Git

Interface for working with Git repositories.

Documentation

data RepositoryFacts

Constructors

RepositoryFacts

Fields

hasSymbolicReferences :: !Bool

Instances

Show RepositoryFacts

class (Applicative m, Monad m, Failure GitException m, IsOid (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

type Oid m :: *

data Tree m :: *

data Options m :: *

Methods

facts :: m RepositoryFacts

parseOid :: Text -> m (Oid m)

parseObjOid :: forall o. Text -> m (Tagged o (Oid m))

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

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

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

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

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

deleteReference :: Text -> m ()

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

allReferenceNames :: m [Text]

resolveReference :: 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

newTreeBuilder :: Maybe (Tree m) -> m (TreeBuilder m)

treeOid :: Tree m -> TreeOid m

getTreeEntry :: Tree m -> FilePath -> m (Maybe (TreeEntry m))

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

traverseEntries_ :: (FilePath -> TreeEntry m -> m a) -> Tree m -> 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 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 ()

data RepositoryOptions

Constructors

RepositoryOptions

Fields

repoPath :: !FilePath

repoIsBare :: !Bool

repoAutoCreate :: !Bool

Instances

Default RepositoryOptions

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 -> FilePath -> t m a -> m a

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

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

class (Eq o, Ord o, Show o) => IsOid o where

Methods

renderOid :: o -> Text

renderObjOid :: Tagged a o -> Text

Instances

IsOid SHA

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

data Object m

Constructors

BlobObj !(BlobRef m)

TreeObj !(TreeRef m)

CommitObj !(CommitRef m)

TagObj !(TagRef m)

data ObjRef m a

Constructors

ByOid !(Tagged a (Oid m))

Known !a

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

newtype SHA

Constructors

SHA ByteString

Instances

Eq SHA

Ord SHA

Read SHA

Show SHA

Binary SHA

Hashable SHA

IsOid SHA

textToSha :: Monad m => Text -> m SHA

shaToText :: SHA -> Text

data Blob m

Constructors

Blob

Fields

blobOid :: !(BlobOid m)

blobContents :: !(BlobContents m)

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

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

type ByteSource m = Producer m ByteString

type BlobRef m = ObjRef m (Blob m)

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

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

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

createBlobUtf8 :: Repository m => Text -> m (BlobOid m)

catBlob :: Repository m => Text -> m ByteString

catBlobUtf8 :: Repository m => Text -> m Text

copyBlob :: (Repository m, Repository (t m), MonadTrans t) => BlobRef m -> HashSet Text -> t m (BlobOid (t m), HashSet Text)

blobContentsToByteString :: Repository m => BlobContents m -> m ByteString

blobToByteString :: Repository m => Blob m -> m ByteString

data TreeT m a

Instances

MonadTrans TreeT

Monad m => Monad (TreeT m)

Functor m => Functor (TreeT m)

MonadFix m => MonadFix (TreeT m)

MonadPlus m => MonadPlus (TreeT m)

(Functor m, Monad m) => Applicative (TreeT m)

(Functor m, MonadPlus m) => Alternative (TreeT m)

MonadIO m => MonadIO (TreeT m)

data TreeBuilder m

Constructors

TreeBuilder

Fields

mtbBaseTreeRef :: Maybe (TreeRef m)

mtbPendingUpdates :: HashMap Text (TreeBuilder m)

mtbNewBuilder :: Maybe (Tree m) -> m (TreeBuilder m)

mtbWriteContents :: TreeBuilder m -> m (ModifiedBuilder m, TreeRef m)

mtbLookupEntry :: Text -> m (Maybe (TreeEntry m))

mtbEntryCount :: m Int

mtbPutEntry :: TreeBuilder m -> Text -> TreeEntry m -> m (ModifiedBuilder m)

mtbDropEntry :: TreeBuilder m -> Text -> m (ModifiedBuilder m)

Instances

Monad m => Monoid (TreeBuilder m)

data ModifiedBuilder m

Constructors

ModifiedBuilder (TreeBuilder m)

BuilderUnchanged (TreeBuilder m)

Instances

Monoid (ModifiedBuilder m)

data TreeEntry m

Constructors

BlobEntry

Fields

blobEntryOid :: !(BlobOid m)

blobEntryKind :: !BlobKind

TreeEntry

Fields

treeEntryOid :: !(TreeOid m)

CommitEntry

Fields

commitEntryOid :: !(CommitOid m)

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

type TreeRef m = ObjRef m (Tree m)

createTree :: Repository m => TreeT m a -> m (TreeRef m)

withNewTree :: Repository m => TreeT m a -> m (a, TreeRef m)

mutateTree :: Repository m => Tree m -> TreeT m a -> m (TreeRef m)

mutateTreeRef :: Repository m => TreeRef m -> TreeT m a -> m (TreeRef m)

currentTree :: Repository m => TreeT m (Tree m)

currentTreeRef :: Repository m => TreeT m (TreeRef m)

withTree :: Repository m => Tree m -> TreeT m a -> m (a, TreeRef m)

withTreeRef :: Repository m => TreeRef m -> TreeT m a -> m (a, TreeRef m)

dropEntry :: Repository m => FilePath -> TreeT m ()

getEntry :: Repository m => FilePath -> TreeT m (Maybe (TreeEntry m))

putBlob :: Repository m => FilePath -> BlobOid m -> TreeT m ()

putBlob' :: Repository m => FilePath -> BlobOid m -> BlobKind -> TreeT m ()

putCommit :: Repository m => FilePath -> CommitOid m -> TreeT m ()

putEntry :: Repository m => FilePath -> TreeEntry m -> TreeT m ()

putTree :: Repository m => FilePath -> TreeOid m -> TreeT m ()

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

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

getTreeEntryOid :: Repository m => TreeEntry m -> Oid m

treeRef :: Tree m -> TreeRef m

A Tree is anything that is treeish.

treeRefOid :: Repository m => TreeRef m -> TreeOid 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

emptyTreeId :: Text

treeBlobEntries :: Repository m => Tree m -> m [(FilePath, TreeEntry m)]

copyTreeEntry :: (Repository m, Repository (t m), MonadTrans t) => TreeEntry m -> HashSet Text -> t m (TreeEntry (t m), HashSet Text)

copyTree :: (Repository m, Repository (t m), MonadTrans t) => TreeRef m -> HashSet Text -> t m (TreeRef (t m), HashSet Text)

data Commit m

Constructors

Commit

Fields

commitOid :: !(CommitOid m)

commitParents :: ![CommitRef m]

commitTree :: !(TreeRef m)

commitAuthor :: !Signature

commitCommitter :: !Signature

commitLog :: !Text

commitEncoding :: !Text

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

data CommitName m

Constructors

CommitObjectId !(CommitOid m)

CommitRefName !Text

CommitReference !(Reference m (Commit m))

Instances

Repository m => Show (CommitName m)

type CommitRef m = ObjRef m (Commit m)

data Signature

Constructors

Signature

Fields

signatureName :: !Text

signatureEmail :: !Text

signatureWhen :: !ZonedTime

Instances

Show Signature

Default Signature

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

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

commitRef :: Commit m -> CommitRef m

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

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

getCommitParents :: Repository m => Commit m -> m [Commit m]

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

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

nameOfCommit :: Commit m -> CommitName m

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

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

commitTreeEntry :: Repository m => Commit m -> FilePath -> m (Maybe (TreeEntry m))

copyCommit :: (Repository m, Repository (t m), MonadTrans t) => CommitRef m -> Maybe Text -> HashSet Text -> t m (CommitRef (t m), HashSet Text)

genericPushCommit :: (Repository m, Repository (t m), MonadTrans t) => CommitName m -> Text -> t m (CommitRef (t m))

Fast-forward push a reference between repositories using a recursive copy. This can be extremely slow, but always works.

data PinnedEntry m

Constructors

PinnedEntry

Fields

pinnedOid :: Oid m

pinnedCommit :: Commit m

pinnedEntry :: TreeEntry m

commitHistoryFirstParent :: Repository m => Commit m -> m [Commit m]

commitEntryHistory :: Repository m => Commit m -> FilePath -> m [PinnedEntry m]

identifyEntry :: Repository m => Commit m -> TreeEntry m -> m (PinnedEntry m)

data Tag m

Constructors

Tag

Fields

tagOid :: !(TagOid m)

tagCommit :: !(CommitRef m)

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

type TagRef m = ObjRef m (Tag m)

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

data RefTarget m a

Constructors

RefObj !(ObjRef m a)

RefSymbolic !Text

data Reference m a

Constructors

Reference

Fields

referenceName :: !Text

referenceTarget :: !(RefTarget m a)

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

resolveReferenceTree :: Repository m => Text -> m (Maybe (Tree 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

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

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)

mergeStatus :: ModificationKind -> ModificationKind -> MergeStatus

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

allMissingObjects :: Repository m => [Object m] -> m [Object m]

Given a list of objects (commit and top-level trees) return by missingObjects, expand it to include all subtrees and blobs as well. Ordering is preserved.

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

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