hit-0.6.3: Git operations in haskell

MaintainerVincent Hanquez <vincent@snarc.org>
Safe HaskellNone






Basic types

data Ref Source

represent a git reference (SHA1)


newtype RefName Source




refNameRaw :: String

data Person Source

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)


data Tree Source

Represent a root tree with zero to many tree entries.




treeGetEnts :: [TreeEnt]

data Blob Source

Represent a binary blob.



data Tag Source

Represent a signed tag.


data GitTime Source

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

newtype ModePerm Source


ModePerm Word32 


Helper & type related to ModePerm

data FilePermissions Source

traditional unix permission for owner, group and permissions




getOwnerPerm :: !Perm
getGroupPerm :: !Perm
getOtherPerm :: !Perm


data Revision Source

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

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

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) Source

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

resolvePath Source


:: Git


-> Ref

commit reference

-> EntPath


-> IO (Maybe Ref) 

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

repo context

data Git Source

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

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

execute a function on the current repository.

check findRepo to see how the git repository is found.

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

execute a function f with a git context.

findRepo :: IO FilePath Source

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 () Source

initialize a new repository at a specific location.

isRepo :: FilePath -> IO Bool Source

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

Context operations

rewrite Source


:: Git


-> (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 Source


:: Git


-> 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 Source

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

getTree :: Git -> Ref -> IO Tree Source

get a specified tree but raise

Set objects

setObject :: Git -> Object -> IO Ref Source

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

Work trees

type WorkTree = MVar TreeSt Source

workTreeNew :: IO WorkTree Source

Create a new worktree

workTreeFrom :: Ref -> IO WorkTree Source

Create a worktree from a tree reference.

workTreeDelete :: Git -> WorkTree -> EntPath -> IO () Source

delete a path from a working tree

if the path doesn't exist, no error is raised

workTreeSet :: Git -> WorkTree -> EntPath -> (EntType, Ref) -> IO () Source

Set a file in this working tree to a specific ref.

The ref should point to a valid blob or tree object, and it's safer to write the referenced tree or blob object first.

workTreeFlush :: Git -> WorkTree -> IO Ref Source

Flush the worktree by creating all the necessary trees in the git store and return the root ref of the work tree.

Named refs

branchWrite Source


:: Git


-> 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) Source

Return the list of branches

tagWrite Source


:: Git


-> 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) Source

Return the list of branches

headSet Source


:: Git


-> 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) Source

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