Git

Interface for working with Git repositories.

Documentation

data RepositoryFacts

Constructors

RepositoryFacts

Fields

hasSymbolicReferences :: !Bool

Instances

Show RepositoryFacts

type MonadGit m = (Failure GitException m, Applicative m, MonadIO m, MonadBaseControl IO m)

class (Applicative m, Monad m, Failure GitException m, Eq (Oid m), Ord (Oid m), Show (Oid m)) => Repository m where

Repository is the central point of contact between user code and Git data objects. Every object must belong to some repository.

Associated Types

data Oid m

data TreeData m

data Options m

Methods

facts :: m RepositoryFacts

parseOid :: Text -> m (Oid m)

renderOid :: Oid m -> Text

renderObjOid :: Tagged a (Oid m) -> Text

createRef :: Text -> RefTarget m (Commit m) -> m (Reference m (Commit m))

createRef_ :: Text -> RefTarget m (Commit m) -> m ()

lookupRef :: Text -> m (Maybe (Reference m (Commit m)))

updateRef :: Text -> RefTarget m (Commit m) -> m (Reference m (Commit m))

updateRef_ :: Text -> RefTarget m (Commit m) -> m ()

deleteRef :: Text -> m ()

allRefs :: m [Reference m (Commit m)]

allRefNames :: m [Text]

resolveRef :: Text -> m (Maybe (CommitRef m))

lookupCommit :: CommitOid m -> m (Commit m)

lookupTree :: TreeOid m -> m (Tree m)

lookupBlob :: BlobOid m -> m (Blob m)

lookupTag :: TagOid m -> m (Tag m)

lookupObject :: Text -> m (Object m)

existsObject :: Oid m -> m Bool

traverseObjects :: forall a. (Object m -> m a) -> Maybe (CommitName m) -> m [a]

traverseObjects_ :: (Object m -> m ()) -> Maybe (CommitName m) -> m ()

pushCommit :: (MonadTrans t, MonadGit m, MonadGit (t m), Repository m, Repository (t m)) => CommitName m -> Maybe Text -> Text -> t m (CommitRef (t m))

traverseCommits :: forall a. (CommitRef m -> m a) -> CommitName m -> m [a]

traverseCommits_ :: (CommitRef m -> m ()) -> CommitName m -> m ()

missingObjects

Arguments

:: Maybe (CommitName m)

A commit we may already have

-> CommitName m

The commit we need

-> m [Object m]

All the objects in between

newTree :: m (Tree m)

hashContents :: BlobContents m -> m (BlobOid m)

createBlob :: BlobContents m -> m (BlobOid m)

createCommit :: [CommitRef m] -> TreeRef m -> Signature -> Signature -> Text -> Maybe Text -> m (Commit m)

createTag :: CommitOid m -> Signature -> Text -> Text -> m (Tag m)

deleteRepository :: m ()

buildPackFile :: FilePath -> [Either (CommitOid m) (TreeOid m)] -> m FilePath

buildPackIndex :: FilePath -> ByteString -> m (Text, FilePath, FilePath)

writePackFile :: FilePath -> m ()

remoteFetch :: Text -> Text -> m ()

data GitException

There is a separate GitException for each possible failure when interacting with the Git repository.

Constructors

BackendError Text

GitError Text

RepositoryNotExist

RepositoryInvalid

RepositoryCannotAccess Text

BlobCreateFailed

BlobEmptyCreateFailed

BlobEncodingUnknown Text

BlobLookupFailed

PushNotFastForward Text

TranslationException Text

TreeCreateFailed Text

TreeBuilderCreateFailed

TreeBuilderInsertFailed Text

TreeBuilderRemoveFailed Text

TreeBuilderWriteFailed Text

TreeLookupFailed

TreeCannotTraverseBlob

TreeCannotTraverseCommit

TreeEntryLookupFailed FilePath

TreeUpdateFailed

TreeWalkFailed

CommitCreateFailed

CommitLookupFailed Text

ReferenceCreateFailed

ReferenceDeleteFailed Text

RefCannotCreateFromPartialOid

ReferenceListingFailed

ReferenceLookupFailed Text

ObjectLookupFailed Text Int

ObjectRefRequiresFullOid

OidCopyFailed

OidParseFailed Text

QuotaHardLimitExceeded Int Int

Instances

Eq GitException

Show GitException

Typeable GitException

Exception GitException

type BlobOid m = Tagged (Blob m) (Oid m)

type TreeOid m = Tagged (Tree m) (Oid m)

type CommitOid m = Tagged (Commit m) (Oid m)

type TagOid m = Tagged (Tag m) (Oid m)

data RefTarget m a

Constructors

RefObj !(ObjRef m a)

RefSymbolic !Text

data Reference m a

Constructors

Reference

Fields

refName :: !Text

refTarget :: !(RefTarget m a)

data CommitName m

Constructors

CommitObjectId !(CommitOid m)

CommitRefName !Text

CommitReference !(Reference m (Commit m))

Instances

Repository m => Show (CommitName m)

nameOfCommit :: Commit m -> CommitName m

commitNameToRef :: Repository m => CommitName m -> m (Maybe (CommitRef m))

renderCommitName :: Repository m => CommitName m -> Text

copyOid :: (Repository m, MonadGit m, Repository n, MonadGit n) => Oid m -> n (Oid n)

copyCommitOid :: (Repository m, MonadGit m, Repository n, MonadGit n) => CommitOid m -> n (CommitOid n)

copyCommitName :: (Repository m, MonadGit m, Repository n, MonadGit n) => CommitName m -> n (Maybe (CommitName n))

data ObjRef m a

Constructors

ByOid !(Tagged a (Oid m))

Known !a

type BlobRef m = ObjRef m (Blob m)

type TreeRef m = ObjRef m (Tree m)

type CommitRef m = ObjRef m (Commit m)

type TagRef m = ObjRef m (Tag m)

data Object m

Constructors

BlobObj !(BlobRef m)

TreeObj !(TreeRef m)

CommitObj !(CommitRef m)

TagObj !(TagRef m)

objectOid :: Repository m => Object m -> m (Oid m)

data Blob m

Constructors

Blob

Fields

blobOid :: !(BlobOid m)

blobContents :: !(BlobContents m)

blobRefOid :: Repository m => BlobRef m -> BlobOid m

resolveBlobRef :: Repository m => BlobRef m -> m (Blob m)

type ByteSource m = Producer m ByteString

data BlobContents m

Constructors

BlobString !ByteString

BlobStream !(ByteSource m)

BlobSizedStream !(ByteSource m) !Int

Instances

Eq (BlobContents m)

data BlobKind

Constructors

PlainBlob

ExecutableBlob

SymlinkBlob

UnknownBlob

Instances

Enum BlobKind

Eq BlobKind

Show BlobKind

data TreeEntry m

Constructors

BlobEntry

Fields

blobEntryOid :: !(BlobOid m)

blobEntryKind :: !BlobKind

TreeEntry

Fields

treeEntryRef :: !(TreeRef m)

CommitEntry

Fields

commitEntryRef :: !(CommitOid m)

treeEntryOid :: Repository m => TreeEntry m -> m (Oid m)

blobEntry :: Repository m => BlobOid m -> BlobKind -> TreeEntry m

treeEntry :: Repository m => Tree m -> TreeEntry m

commitEntry :: Repository m => Commit m -> TreeEntry m

data ModifyTreeResult m

Constructors

TreeEntryNotFound

TreeEntryDeleted

TreeEntryPersistent (TreeEntry m)

TreeEntryMutated (TreeEntry m)

fromModifyTreeResult :: ModifyTreeResult m -> Maybe (TreeEntry m)

toModifyTreeResult :: (TreeEntry m -> ModifyTreeResult m) -> Maybe (TreeEntry m) -> ModifyTreeResult m

data Tree m

A Tree is anything that is treeish.

Minimal complete definition: modifyTree. Note that for some treeish things, like Tags, it should always be an error to attempt to modify the tree in any way.

Constructors

Tree

Fields

modifyTree :: FilePath -> Bool -> (Maybe (TreeEntry m) -> m (ModifyTreeResult m)) -> m (Maybe (TreeEntry m))

lookupEntry :: FilePath -> m (Maybe (TreeEntry m))

putTreeEntry :: FilePath -> TreeEntry m -> m ()

putBlob' :: FilePath -> BlobOid m -> BlobKind -> m ()

putBlob :: FilePath -> BlobOid m -> m ()

putTree :: FilePath -> TreeRef m -> m ()

putCommit :: FilePath -> CommitOid m -> m ()

dropFromTree :: FilePath -> m ()

writeTree :: m (TreeOid m)

traverseEntries :: forall a. (FilePath -> TreeEntry m -> m a) -> m [a]

traverseEntries_ :: (FilePath -> TreeEntry m -> m ()) -> m ()

getTreeData :: !(TreeData m)

mkTree :: Repository m => (Tree m -> FilePath -> Bool -> (Maybe (TreeEntry m) -> m (ModifyTreeResult m)) -> m (Maybe (TreeEntry m))) -> (Tree m -> m (TreeOid m)) -> (forall a. Tree m -> (FilePath -> TreeEntry m -> m a) -> m [a]) -> TreeData m -> Tree m

treeRef :: Tree m -> TreeRef m

treeRefOid :: Repository m => TreeRef m -> m (TreeOid m)

resolveTreeRef :: Repository m => TreeRef m -> m (Tree m)

data Signature

Constructors

Signature

Fields

signatureName :: !Text

signatureEmail :: !Text

signatureWhen :: !ZonedTime

Instances

Show Signature

Default Signature

data Commit m

Constructors

Commit

Fields

commitOid :: !(CommitOid m)

commitParents :: ![CommitRef m]

commitTree :: !(TreeRef m)

commitAuthor :: !Signature

commitCommitter :: !Signature

commitLog :: !Text

commitEncoding :: !Text

commitRef :: Commit m -> CommitRef m

commitRefTarget :: Commit c -> RefTarget m (Commit c)

commitRefOid :: Repository m => CommitRef m -> CommitOid m

resolveCommitRef :: Repository m => CommitRef m -> m (Commit m)

referenceToRef :: Repository m => Maybe Text -> Maybe (Reference m (Commit m)) -> m (Maybe (CommitRef m))

data Tag m

Constructors

Tag

Fields

tagOid :: !(TagOid m)

tagCommit :: !(CommitRef m)

tagRefOid :: Repository m => TagRef m -> TagOid m

data ModificationKind

Constructors

Unchanged

Modified

Added

Deleted

TypeChanged

Instances

Enum ModificationKind

Eq ModificationKind

Ord ModificationKind

Read ModificationKind

Show ModificationKind

data MergeStatus

Constructors

NoConflict

BothModified

LeftModifiedRightDeleted

LeftDeletedRightModified

BothAdded

LeftModifiedRightTypeChanged

LeftTypeChangedRightModified

LeftDeletedRightTypeChanged

LeftTypeChangedRightDeleted

BothTypeChanged

Instances

Enum MergeStatus

Eq MergeStatus

Ord MergeStatus

Read MergeStatus

Show MergeStatus

mergeStatus :: ModificationKind -> ModificationKind -> MergeStatus

data MergeResult m

Constructors

MergeSuccess

Fields

mergeCommit :: CommitOid m

MergeConflicted

Fields

mergeCommit :: CommitOid m

mergeHeadLeft :: CommitOid m

mergeHeadRight :: CommitOid m

mergeConflicts :: Map FilePath (ModificationKind, ModificationKind)

Instances

Repository m => Show (MergeResult m)

copyConflict :: (Repository m, MonadGit m, Repository n, MonadGit n) => MergeResult m -> n (MergeResult n)

data RepositoryOptions

Constructors

RepositoryOptions

Fields

repoPath :: !FilePath

repoIsBare :: !Bool

repoAutoCreate :: !Bool

Instances

Default RepositoryOptions

data RepositoryFactory t m c

Constructors

RepositoryFactory

Fields

openRepository :: RepositoryOptions -> m c

runRepository :: forall a. c -> t m a -> m a

closeRepository :: c -> m ()

getRepository :: t m c

defaultOptions :: !RepositoryOptions

startupBackend :: m ()

shutdownBackend :: m ()

withBackendDo :: (MonadIO m, MonadBaseControl IO m) => RepositoryFactory t m a -> m b -> m b

withRepository' :: (Repository (t m), MonadTrans t, MonadBaseControl IO m, MonadIO m) => RepositoryFactory t m c -> RepositoryOptions -> t m a -> m a

withRepository :: (Repository (t m), MonadTrans t, MonadBaseControl IO m, MonadIO m) => RepositoryFactory t m c -> FilePath -> t m a -> m a