hit-0.6.3: Git operations in haskell

LicenseBSD-style
MaintainerVincent Hanquez <vincent@snarc.org>
Stabilityexperimental
Portabilityunix
Safe HaskellNone
LanguageHaskell98

Data.Git

Contents

Description

 

Synopsis

Basic types

data Ref #

represent a git reference (SHA1)

Instances

Eq Ref # 

Methods

(==) :: Ref -> Ref -> Bool #

(/=) :: Ref -> Ref -> Bool #

Data Ref # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ref -> c Ref #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Ref #

toConstr :: Ref -> Constr #

dataTypeOf :: Ref -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Ref) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ref) #

gmapT :: (forall b. Data b => b -> b) -> Ref -> Ref #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ref -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ref -> r #

gmapQ :: (forall d. Data d => d -> u) -> Ref -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Ref -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ref -> m Ref #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ref -> m Ref #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ref -> m Ref #

Ord Ref # 

Methods

compare :: Ref -> Ref -> Ordering #

(<) :: Ref -> Ref -> Bool #

(<=) :: Ref -> Ref -> Bool #

(>) :: Ref -> Ref -> Bool #

(>=) :: Ref -> Ref -> Bool #

max :: Ref -> Ref -> Ref #

min :: Ref -> Ref -> Ref #

Show Ref # 

Methods

showsPrec :: Int -> Ref -> ShowS #

show :: Ref -> String #

showList :: [Ref] -> ShowS #

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)

Instances

Eq Person # 

Methods

(==) :: Person -> Person -> Bool #

(/=) :: Person -> Person -> Bool #

Show Person # 

data Tree #

Represent a root tree with zero to many tree entries.

Constructors

Tree 

Fields

Instances

Eq Tree # 

Methods

(==) :: Tree -> Tree -> Bool #

(/=) :: Tree -> Tree -> Bool #

Show Tree # 

Methods

showsPrec :: Int -> Tree -> ShowS #

show :: Tree -> String #

showList :: [Tree] -> ShowS #

Monoid Tree # 

Methods

mempty :: Tree #

mappend :: Tree -> Tree -> Tree #

mconcat :: [Tree] -> Tree #

Objectable Tree # 

data Blob #

Represent a binary blob.

Constructors

Blob 

Instances

data Tag #

Represent a signed tag.

Instances

Eq Tag # 

Methods

(==) :: Tag -> Tag -> Bool #

(/=) :: Tag -> Tag -> Bool #

Show Tag # 

Methods

showsPrec :: Int -> Tag -> ShowS #

show :: Tag -> String #

showList :: [Tag] -> ShowS #

Objectable Tag # 

data GitTime #

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

newtype ModePerm #

Constructors

ModePerm Word32 

type EntPath = [EntName] #

Helper & type related to ModePerm

data FilePermissions #

traditional unix permission for owner, group and permissions

Constructors

FilePermissions 

Fields

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 # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Revision -> c Revision #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Revision #

toConstr :: Revision -> Constr #

dataTypeOf :: Revision -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Revision) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Revision) #

gmapT :: (forall b. Data b => b -> b) -> Revision -> Revision #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Revision -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Revision -> r #

gmapQ :: (forall d. Data d => d -> u) -> Revision -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Revision -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Revision -> m Revision #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Revision -> m Revision #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Revision -> m Revision #

Show Revision # 
IsString 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

-> EntPath

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.

Work trees

type WorkTree = MVar TreeSt #

data EntType #

Instances

workTreeNew :: IO WorkTree #

Create a new worktree

workTreeFrom :: Ref -> IO WorkTree #

Create a worktree from a tree reference.

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

delete a path from a working tree

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

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

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 #

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 #

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