Data.Git

Basic types

data Ref

represent a git reference (SHA1)

Instances

Eq Ref

Data Ref

Ord Ref

Show Ref

Typeable * Ref

newtype RefName

Constructors

RefName

Fields

refNameRaw :: String

Instances

Eq RefName

Ord RefName

Show RefName

IsString RefName

data Commit

Represent a commit object.

Constructors

Commit

Fields

commitTreeish :: Ref

commitParents :: [Ref]

commitAuthor :: Person

commitCommitter :: Person

commitEncoding :: Maybe ByteString

commitExtras :: [CommitExtra]

commitMessage :: ByteString

Instances

Eq Commit

Show Commit

Objectable Commit

data Person

an author or committer line has the format: name email time timezone FIXME: should be a string, but I don't know if the data is stored consistantly in one encoding (UTF8)

Constructors

Person

Fields

personName :: ByteString

personEmail :: ByteString

personTime :: GitTime

Instances

Eq Person

Show Person

data CommitExtra

Constructors

CommitExtra

Fields

commitExtraKey :: ByteString

commitExtraValue :: ByteString

Instances

Eq CommitExtra

Show CommitExtra

data Tree

Represent a root tree with zero to many tree entries.

Constructors

Tree

Fields

treeGetEnts :: [TreeEnt]

Instances

Eq Tree

Show Tree

Monoid Tree

Objectable Tree

data Blob

Represent a binary blob.

Constructors

Blob

Fields

blobGetContent :: ByteString

Instances

Eq Blob

Show Blob

Objectable Blob

data Tag

Represent a signed tag.

Constructors

Tag

Fields

tagRef :: Ref

tagObjectType :: ObjectType

tagBlob :: ByteString

tagName :: Person

tagS :: ByteString

Instances

Eq Tag

Show Tag

Objectable Tag

data GitTime

Git time is number of seconds since unix epoch in the UTC zone with the current timezone associated

Instances

Eq GitTime

Show GitTime

Timeable GitTime

Time GitTime

newtype ModePerm

Constructors

ModePerm Word32

Instances

Eq ModePerm

Show ModePerm

Helper & type related to ModePerm

data ObjectFileType

Git object file type

Constructors

FileTypeDirectory

FileTypeRegularFile

FileTypeSymbolicLink

FileTypeGitLink

Instances

Eq ObjectFileType

Show ObjectFileType

data FilePermissions

traditional unix permission for owner, group and permissions

Constructors

FilePermissions

Fields

getOwnerPerm :: !Perm

getGroupPerm :: !Perm

getOtherPerm :: !Perm

Instances

Eq FilePermissions

Show FilePermissions

getPermission :: ModePerm -> FilePermissions

getFiletype :: ModePerm -> ObjectFileType

Revision

data Revision

A git revision. this can be many things: * a shorten ref * a ref * a named branch or tag followed by optional modifiers RevModifier that can represent: * parenting * type * date

Instances

Eq Revision

Data Revision

Show Revision

IsString Revision

Typeable * Revision

resolveRevision :: Git -> Revision -> IO (Maybe Ref)

try to resolve a string to a specific commit ref for example: HEAD, HEAD^, master~3, shortRef

Object resolution

resolveTreeish :: Git -> Ref -> IO (Maybe Tree)

returns a tree from a ref that might be either a commit, a tree or a tag.

resolvePath

Arguments

:: Git

repository

-> Ref

commit reference

-> [ByteString]

paths

-> IO (Maybe Ref)

resolve the ref (tree or blob) related to a path at a specific commit ref

repo context

data Git

represent a git repo, with possibly already opened filereaders for indexes and packs

withCurrentRepo :: (Git -> IO a) -> IO a

execute a function on the current repository.

check findRepo to see how the git repository is found.

withRepo :: FilePath -> (Git -> IO c) -> IO c

execute a function f with a git context.

findRepo :: IO FilePath

Find the git repository from the current directory.

If the environment variable GIT_DIR is set then it's used, otherwise iterate from current directory, up to 128 parents for a .git directory

Repository queries and creation

initRepo :: FilePath -> IO ()

initialize a new repository at a specific location.

isRepo :: FilePath -> IO Bool

basic checks to see if a specific path looks like a git repo.

Context operations

rewrite

Arguments

:: Git

Repository

-> (Commit -> IO Commit)

Mapping function

-> Revision

revision to start from

-> Int

the number of parents to map

-> IO Ref

return the new head REF

Rewrite a set of commits from a revision and returns the new ref.

If during revision traversal (diving) there's a commit with zero or multiple parents then the traversal will stop regardless of the amount of parent requested.

calling "rewrite f 2 (revisionOf d)" on the following tree:

a <-- b <-- c <-- d

result in the following tree after mapping with f:

a <-- f(b) <-- f(c) <-- f(d)

Get objects

getObject

Arguments

:: Git

repository

-> Ref

the object's reference to

-> Bool

whether to resolve deltas if found

-> IO (Maybe Object)

returned object if found

get an object from repository using a ref.

getCommit :: Git -> Ref -> IO Commit

get a specified commit but raises an exception if doesn't exists or type is not appropriate

getTree :: Git -> Ref -> IO Tree

get a specified tree but raise

Set objects

setObject :: Git -> Object -> IO Ref

set an object in the store and returns the new ref this is always going to create a loose object.

toObject :: Objectable a => a -> Object

Named refs

branchWrite

Arguments

:: Git

repository

-> RefName

the name of the branch to write

-> Ref

the reference to set

-> IO ()

Write a branch to point to a specific reference

branchList :: Git -> IO (Set RefName)

Return the list of branches

tagWrite

Arguments

:: Git

repository

-> RefName

the name of the tag to write

-> Ref

the reference to set

-> IO ()

Write a tag to point to a specific reference

tagList :: Git -> IO (Set RefName)

Return the list of branches

headSet

Arguments

:: Git

repository

-> Either Ref RefName

either a raw reference or a branch name

-> IO ()

Set head to point to either a reference or a branch name.

headGet :: Git -> IO (Either Ref RefName)

Get what the head is pointing to, or the reference otherwise