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

type TreeKind m :: *

type Tree m :: * -> *

data Options m

Methods

facts :: m RepositoryFacts

parseOid :: Text -> m (Oid m)

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

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 (RepositoryTree 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 (RepositoryTree m)

cloneTree :: RepositoryTree m -> m (RepositoryTree m)

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

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

writeTree :: RepositoryTree m -> m (TreeOid m)

unsafeUpdateTree :: RepositoryTree m -> FilePath -> Bool -> (Maybe (TreeEntry m) -> ModifyTreeResult m) -> m (RepositoryTree m, Maybe (TreeEntry 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

copyOid :: (Repository m, MonadGit m, Repository n, MonadGit 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)

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)

data TreeT t m a

Instances

MonadTrans (TreeT t)

Monad m => Monad (TreeT t m)

Functor m => Functor (TreeT t m)

MonadFix m => MonadFix (TreeT t m)

MonadPlus m => MonadPlus (TreeT t m)

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

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

MonadIO m => MonadIO (TreeT t m)

type RepositoryTree m = Tree m (TreeKind m)

type RepositoryTreeT m a = TreeT (RepositoryTree m) m a

data MutableTree

type MutableTreeT m a = TreeT (Tree m MutableTree) m a

data PersistentTree

type PersistentTreeT m a = TreeT (Tree m PersistentTree) m a

data TreeEntry m

Constructors

BlobEntry

Fields

blobEntryOid :: !(BlobOid m)

blobEntryKind :: !BlobKind

TreeEntry

Fields

treeEntryRef :: !(TreeRef m)

CommitEntry

Fields

commitEntryRef :: !(CommitOid m)

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

type TreeRef m = ObjRef m (RepositoryTree m)

createTree :: Repository m => RepositoryTreeT m a -> m (RepositoryTree m)

withNewTree :: Repository m => RepositoryTreeT m a -> m (a, RepositoryTree m)

mutateTree :: Repository m => RepositoryTree m -> RepositoryTreeT m a -> m (RepositoryTree m)

withTree :: Repository m => RepositoryTree m -> RepositoryTreeT m a -> m (a, RepositoryTree m)

unsafeMutateTree :: Repository m => Tree m MutableTree -> MutableTreeT m a -> m (Tree m MutableTree)

unsafeMutateTree_ :: Repository m => Tree m MutableTree -> MutableTreeT m a -> m ()

unsafeWithTree :: Repository m => Tree m MutableTree -> MutableTreeT m a -> m (a, Tree m MutableTree)

unsafeGetTree :: Monad m => RepositoryTreeT m (RepositoryTree m)

unsafePutTree :: Monad m => RepositoryTree m -> RepositoryTreeT m ()

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

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

getTreeEntry :: Repository m => RepositoryTree m -> FilePath -> m (Maybe (TreeEntry m))

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

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

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

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

putTree :: Repository m => FilePath -> TreeRef m -> RepositoryTreeT m ()

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

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

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

treeRef :: RepositoryTree m -> TreeRef m

A Tree is anything that is treeish.

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

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)

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)

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

refName :: !Text

refTarget :: !(RefTarget m a)

referenceToRef :: Repository m => Maybe Text -> Maybe (Reference m (Commit m)) -> m (Maybe (CommitRef 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)