package git

  1. Overview
  2. Docs
On This Page
  1. Backend Features
Git format and protocol in pure OCaml

Install 

dune-project
 Dependency

github.com Readme Changelog ISC License Edit opam file Versions (8)

Authors

  1. T
    Thomas Gazagnaire

Maintainers

  1. T
    thomas@gazagnaire.org
  2. R
    romain.calascibetta@gmail.com

Sources

git-3.6.0.tbz
sha256=b148810ea65aef76503a0fd5deb351fa7307fd29f06ce93fdf43cc7add5c1b45
sha512=73e0a7ab2bf00102653ac14d47ac62f3dddcdb0e24f7c5e33226801331cf608bcbfba2f058b5cb612ba9313d6ab12b2d01556169239e5fb18ef1c14a9b1c1eaf

doc/git/Git/module-type-S/index.html

Module type Git.SSource

Sourcetype t
Sourcetype hash
Sourcetype error = private [>
  1. | `Not_found of hash
  2. | `Reference_not_found of Reference.t
  3. | `Msg of string
]
Sourceval pp_error : error Fmt.t
Sourcemodule Hash : sig ... end
Sourcemodule Value : Value.S with type hash = hash
Sourcemodule Reference : Reference.S with type hash = hash
Sourceval dotgit : t -> Fpath.t

dotgit state returns the current ".git" path used - eg. the default ?dotgit value of v if the client does not notice a specific value.

Sourceval root : t -> Fpath.t

root state returns the current path of the repository. eg. the default value ?root value of v if the client does not notice a specific value.

Sourceval contents : t -> (hash * Value.t) list Lwt.t

contents state returns an associated list between the hash and its bind git object. This list contains all git objects available in the current git repository state.

Sourceval size : t -> hash -> (int64, error) result Lwt.t

size state hash returns the size of the git object which respects the predicate digest(object) = hash. The size is how many byte(s) are needed to store the serialized (but not deflated) git object in bytes (without the header).

Sourceval read : t -> hash -> (Value.t, error) result Lwt.t

read state hash can retrieve a git object from the current repository state. It de-serializes the git object to an OCaml value.

Sourceval read_exn : t -> hash -> Value.t Lwt.t

read_exn state hash is an alias of read but raise an exception (instead to return a result) if the git object requested does not exist or when we catch any others errors.

Sourceval mem : t -> hash -> bool Lwt.t

mem state hash checks if one object satisfies the predicate digest(object) = hash.

Sourceval list : t -> hash list Lwt.t

list state lists all git objects available in the current git repository state.

Sourceval write : t -> Value.t -> (hash * int, error) result Lwt.t

write state v writes the value v in the git repository state.

Sourceval batch_write : t -> hash -> pck:(unit -> string option Lwt.t) -> idx:(unit -> string option Lwt.t) -> (unit, error) result Lwt.t

batch_write state map pack index writes all objects indexed into index and available into pack in the git repository state.

Sourceval fold : t -> ('acc -> ?name:Fpath.t -> length:int64 -> hash -> Value.t -> 'acc Lwt.t) -> path:Fpath.t -> 'acc -> hash -> 'acc Lwt.t

fold state f ~path acc hash iters on any git objects reachable by the git object hash which located in path (for example, if you iter on a commit, path should be "." - however, if you iter on a tree, path should be the directory path represented by your tree). For each git objects, we notice the path name (derived from path) if the object is a Blob or a Tree, the length or the git object (see size), the hash and the value.

If the hash points to:

  • Value.Blob.t: f is called only one time with the OCaml value of the blob.
  • Value.Tree.t: f is called firstly with the Ocaml value of the pointed tree by the hash hash. Then, we iter (and call f for each iteration) in the list of entries of the tree. Finally, we retrieve recursively all sub-tree objects and do an ascending walk. f is never called more than one time for each hash.
  • Value.Commit.t: f is called firstly with the OCaml value of the pointed commit by the hash hash. Then, it follozs recursively all parents of the current commit, Finallym it starts a fold inside the pointed root tree git object of each commit previously retrieved. f never called more than one time for each hash.
  • Value.Tag.t: f is called firstly with the OCaml value of the pointed tag by the hash hash. Then, it follows the git object pointed by the tag.

Any retrieved error is missed.

Sourceval iter : t -> (hash -> Value.t -> unit Lwt.t) -> hash -> unit Lwt.t
Sourcemodule Ref : sig ... end
Sourceval reset : t -> (unit, error) result Lwt.t

reset t removes all things of the git repository t and ensures it will be empty.

Sourceval read_inflated : t -> hash -> ([ `Commit | `Tag | `Blob | `Tree ] * Cstruct.t) option Lwt.t

read_inflated state hash returns the inflated git object which respect the predicate digest(value) = hash. We return the kind of the object and the inflated value as a Cstruct.t (which the client can take the ownership).

Sourceval write_inflated : t -> kind:[ `Commit | `Tree | `Blob | `Tag ] -> Cstruct.t -> hash Lwt.t

write_inflated state kind raw writes the git object in the git repository state and associates the kind to this object. This function does not verify if the raw data is well-defined (and respects the Git format). Then, this function returns the hash produced from the kind and the inflated raw to let the user to retrieve it.

Sourceval is_shallowed : t -> hash -> bool Lwt.t
Sourceval shallowed : t -> hash list Lwt.t
Sourceval shallow : t -> hash -> unit Lwt.t
Sourceval unshallow : t -> hash -> unit Lwt.t

Backend Features

Sourceval has_global_watches : bool
Sourceval has_global_checkout : bool