Data.Git.Repository

Documentation

data Git hash

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

Config

configGetAll :: Git hash -> IO [Config]

Read the Config

configGet

Arguments

:: Git hash

Git context

-> String

section name

-> String

key name

-> IO (Maybe String)

The resulting value if it exists

Get a configuration element from the config file, starting from the local repository config file, then the global config file.

for example the equivalent to git config user.name is:

configGet git "user" "name"

newtype Config

Constructors

Config [Section]

Instances

Eq Config

Methods

(==) :: Config -> Config -> Bool

(/=) :: Config -> Config -> Bool

Show Config

Methods

showsPrec :: Int -> Config -> ShowS

show :: Config -> String

showList :: [Config] -> ShowS

data Section

Constructors

Section

Fields

• sectionName :: String
• sectionKVs :: [(String, String)]

Instances

Eq Section

Methods

(==) :: Section -> Section -> Bool

(/=) :: Section -> Section -> Bool

Show Section

Methods

showsPrec :: Int -> Section -> ShowS

show :: Section -> String

showList :: [Section] -> ShowS

Trees

type HTree hash = [(ModePerm, EntName, HTreeEnt hash)]

data HTreeEnt hash

hierarchy tree, either a reference to a blob (file) or a tree (directory).

Constructors

TreeDir (Ref hash) (HTree hash)

TreeFile (Ref hash)

newtype RefName

Constructors

RefName

Fields

• refNameRaw :: String

Instances

Eq RefName

Methods

(==) :: RefName -> RefName -> Bool

(/=) :: RefName -> RefName -> Bool

Ord RefName

Methods

compare :: RefName -> RefName -> Ordering

(<) :: RefName -> RefName -> Bool

(<=) :: RefName -> RefName -> Bool

(>) :: RefName -> RefName -> Bool

(>=) :: RefName -> RefName -> Bool

max :: RefName -> RefName -> RefName

min :: RefName -> RefName -> RefName

Show RefName

Methods

showsPrec :: Int -> RefName -> ShowS

show :: RefName -> String

showList :: [RefName] -> ShowS

IsString RefName

Methods

fromString :: String -> RefName

Resolvable RefName

Methods

resolve :: GitMonad m => RefName -> m (Maybe (Ref SHA1))

getCommitMaybe :: HashAlgorithm hash => Git hash -> Ref hash -> IO (Maybe (Commit hash))

get a specified commit

getCommit :: (Typeable hash, HashAlgorithm hash) => Git hash -> Ref hash -> IO (Commit hash)

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

getTreeMaybe :: HashAlgorithm hash => Git hash -> Ref hash -> IO (Maybe (Tree hash))

get a specified tree

getTree :: (Typeable hash, HashAlgorithm hash) => Git hash -> Ref hash -> IO (Tree hash)

get a specified tree but raise

rewrite

Arguments

:: (Typeable hash, HashAlgorithm hash)

=> Git hash

Repository

-> (Commit hash -> IO (Commit hash))

Mapping function

-> Revision

revision to start from

-> Int

the number of parents to map

-> IO (Ref hash)

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)

buildHTree :: (Typeable hash, HashAlgorithm hash) => Git hash -> Tree hash -> IO (HTree hash)

build a hierarchy tree from a tree object

resolvePath

Arguments

:: (Typeable hash, HashAlgorithm hash)

=> Git hash

repository

-> Ref hash

commit reference

-> EntPath

paths

-> IO (Maybe (Ref hash))

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

resolveTreeish :: HashAlgorithm hash => Git hash -> Ref hash -> IO (Maybe (Tree hash))

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

resolveRevision :: (Typeable hash, HashAlgorithm hash) => Git hash -> Revision -> IO (Maybe (Ref hash))

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

initRepo :: LocalPath -> IO ()

initialize a new repository at a specific location.

isRepo :: LocalPath -> IO Bool

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

named refs manipulation

branchWrite

Arguments

:: Git hash

repository

-> RefName

the name of the branch to write

-> Ref hash

the reference to set

-> IO ()

Write a branch to point to a specific reference

branchList :: Git hash -> IO (Set RefName)

Return the list of branches

tagWrite

Arguments

:: Git hash

repository

-> RefName

the name of the tag to write

-> Ref hash

the reference to set

-> IO ()

Write a tag to point to a specific reference

tagList :: Git hash -> IO (Set RefName)

Return the list of branches

headSet

Arguments

:: Git hash

repository

-> Either (Ref hash) RefName

either a raw reference or a branch name

-> IO ()

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

headGet :: HashAlgorithm hash => Git hash -> IO (Either (Ref hash) RefName)

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