package git-unix

You can search for identifiers within the package.

in-package search v0.2.0

git-unix
- Git_unix
  - Fs
    
    Dir
    
    File
    
    Mapper
  - Index
    
    ENTRY
    
    Entry
    
    Make
    
    Entry
    
    FS
    
    Dir
    
    File
    
    Mapper
    
    Read
    
    Snapshot
    
    Store
    
    Deflate
    
    Hash
    
    Inflate
    
    Pack
    
    Ref
    
    Reference
    
    A
    
    D
    
    E
    
    M
    
    P
    
    Value
    
    A
    
    D
    
    E
    
    M
    
    MakeMeta
    
    Meta
    
    Option
    
    Write
  - Net
  - Store
    
    Deflate
    
    HDec
    
    IDec
    
    IEnc
    
    Inflate
    
    Loose
    
    D
    
    E
    
    Value
    
    A
    
    D
    
    E
    
    M
    
    MakeMeta
    
    Meta
    
    Option
    
    PDec
    
    PEnc
    
    Delta
    
    Entry
    
    Hunk
    
    PInfo
    
    Pack
    
    Deflate
    
    IDec
    
    IEnc
    
    PEnc
    
    Delta
    
    Entry
    
    Hunk
    
    PInfo
    
    Packed_refs
    
    A
    
    D
    
    E
    
    M
    
    RPDec
    
    Ascendant
    
    Base
    
    Cache
    
    Descendant
    
    Diff
    
    Object
    
    Patch
    
    Ref
    
    Reference
    
    A
    
    D
    
    E
    
    M
    
    P
    
    Value
    
    A
    
    D
    
    E
    
    M
    
    MakeMeta
    
    Meta
    
    Option
  - Sync
    
    Endpoint
    
    G
    
    Deflate
    
    Hash
    
    Inflate
    
    Pack
    
    Ref
    
    Reference
    
    A
    
    D
    
    E
    
    M
    
    P
    
    Value
    
    A
    
    D
    
    E
    
    M
    
    MakeMeta
    
    Meta
    
    Option
    
    Http
    
    Client
    
    Endpoint
    
    Web
    
    HTTP
    
    Headers
    
    Request
    
    Response
    
    Tcp
    
    Endpoint
git-unix.top
- Git_top
  - Graph
    
    K
    
    E
    
    V
    
    Store
    
    Deflate
    
    Hash
    
    Map
    
    Set
    
    Inflate
    
    Pack
    
    Ref
    
    Reference
    
    A
    
    D
    
    E
    
    M
    
    Map
    
    P
    
    Set
    
    Value
    
    A
    
    Blob
    
    A
    
    D
    
    E
    
    M
    
    MakeMeta
    
    Meta
    
    Option
    
    Map
    
    Set
    
    Commit
    
    A
    
    D
    
    E
    
    M
    
    MakeMeta
    
    Meta
    
    Option
    
    Map
    
    Set
    
    D
    
    E
    
    M
    
    MakeMeta
    
    Meta
    
    Option
    
    Map
    
    Set
    
    Tag
    
    A
    
    D
    
    E
    
    M
    
    MakeMeta
    
    Meta
    
    Option
    
    Map
    
    Set
    
    Tree
    
    A
    
    D
    
    E
    
    M
    
    MakeMeta
    
    Meta
    
    Option
    
    Map
    
    Set

Legend:
Library
Module
Module type
Parameter
Class
Class type

include Git.Store.S
  with module Hash = Git.Hash.Make(Digestif.SHA1)
   and module FS := Fs

type t

The type of the git repository.

module Hash = Git.Hash.Make(Digestif.SHA1)

The Digest module used to make the implementation.

module Inflate : sig ... end

The Inflate module used to make the implementation.

module Deflate : sig ... end

The Deflate module used to make the implementation.

module Value : 
  Git.Value.S
    with module Hash := Hash
     and module Inflate := Inflate
     and module Deflate := Deflate
     and module Blob = Git.Blob.Make(Hash)
     and module Commit = Git.Commit.Make(Hash)
     and module Tree = Git.Tree.Make(Hash)
     and module Tag = Git.Tag.Make(Hash)
     and type t = Git.Value.Make(Hash)(Inflate)(Deflate).t

The Value module, which represents the Git object.

module Reference : 
  Git.Reference.IO with module Hash := Hash and module FS := Fs

The Reference module, which represents the Git reference.

module HDec : Git.Unpack.H with module Hash := Hash

module PDec : 
  Git.Unpack.P
    with module Hash := Hash
     and module Inflate := Inflate
     and module Hunk := HDec

module RPDec : 
  Git.Unpack.D
    with module Hash := Hash
     and module Inflate := Inflate
     and module Hunk := HDec
     and module Pack := PDec
     and module Mapper := Fs.Mapper

module PEnc : Git.Pack.P with module Hash := Hash and module Deflate := Deflate

module IDec : Git.Index_pack.LAZY with module Hash := Hash

module IEnc : Git.Index_pack.ENCODER with module Hash := Hash

module PInfo : 
  Git.Pack_info.S
    with module Hash := Hash
     and module Inflate := Inflate
     and module HDec := HDec
     and module PDec := PDec

module Packed_refs : 
  Git.Packed_refs.S with module Hash := Hash and module FS := Fs

type kind = [

| `Commit
| `Tree
| `Tag
| `Blob

]

Kind of the packed Git object.

type error = [

| `Delta of PEnc.Delta.error
| `Pack_decoder of RPDec.error
| `Pack_encoder of PEnc.error
| `Pack_info of PInfo.error
| `Idx_decoder of IDec.error
| `Idx_encoder of IEnc.error
| `Invalid_hash of Hash.t
| `Invalid_reference of Reference.t
| Git.Error.Decoder.t
| Fs.error Git.Error.FS.t
| Inflate.error Git.Error.Inf.t
| Deflate.error Git.Error.Def.t
| Git.Error.not_found

]

The type error.

val pp_error : error Fmt.t

Pretty-printer of error.

module Loose : 
  Git.Store.LOOSE
    with type t = Value.t
     and type state = t
     and type error = error
     and module Hash := Hash
     and module Inflate := Inflate
     and module Deflate := Deflate
     and module FS := Fs

The Loose module which represents any loose git object available in git repository.

module Pack : 
  Git.Store.PACK
    with type t = RPDec.Object.t
     and type value = Value.t
     and type state = t
     and type error = error
     and module Hash := Hash
     and module FS := Fs
     and module Inflate := Inflate
     and module HDec := HDec
     and module PDec := PDec
     and module RPDec := RPDec

The Pack module which represents any packed git object available in the git repository.

type buffer

The type for buffers.

val default_buffer : unit -> buffer

val buffer : 
  ?ztmp:Cstruct.t ->
  ?dtmp:Cstruct.t ->
  ?raw:Cstruct.t ->
  ?window:Inflate.window ->
  unit ->
  buffer

Build a buffer to read and write a Git object.

window is a buffer used by the Inflate module
ztmp is a buffer used to store the inflated flow
dtmp is a buffer used by the decoder to save the inflated flow (and keep it for an alteration)
raw is a buffer used to store the input flow

If not specified the cstruct are created with a size of 4 MiB.

Store functions can be used in a concurrency context only if the specified buffers are not used by another process. The deserialisation functions does not allocate any buffer and uses only the specified buffers to construct the OCaml value.

val dotgit : t -> Fpath.t

dotgit state is the current ".git" path used.

val root : t -> Fpath.t

root state is the current path of the repository.

val compression : t -> int

compression state is the current level of the compression used to write a git object.

val mem : t -> Hash.t -> bool Lwt.t

mem state hash is true if one object of the current repository state satisfies the predicate digest(object) = hash.

val list : t -> Hash.t list Lwt.t

list state is the list of all git objects available in the current repository state.

val read : t -> Hash.t -> (Value.t, error) Stdlib.result Lwt.t

read state hash is the Git object with hash hash from the current repository state. It de-serializes the git object to an OCaml value. This function needs some buffers, provided t's buffer function.

This function follows the same scheme of allocation of Loose.read if the requested git object is a loose git object or Pack.read if the requested git object is a packed git object. Otherwise, return an error.

val read_exn : t -> Hash.t -> 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 if we catch any other errors.

val write : t -> Value.t -> (Hash.t * int, error) Stdlib.result Lwt.t

write state v writes as a loose git object v in the file-system. It serializes and deflates the value to a new file. which respect the internal structure of a git repository.

This function does not allocate any buffer and uses only the specified buffers to store the OCaml value to the file-system. Then, the OCaml value will be available by read state digest(v). Otherwise, return an error:

FS.File.error when we can not create a new file in the file-system.
Value.E.error when we can not serialize xor deflate the requested git loose object. This kind of error should be never happen.

val size : t -> Hash.t -> (int64, error) Stdlib.result Lwt.t

size state hash is the size of the git object such that digest(object) = hash. The size is how many byte(s) are needed to store the serialized (but not inflated) git object in bytes (without the header).

As read, size can return an error.

val read_inflated : t -> Hash.t -> (kind * Cstruct.t) option Lwt.t

read_inflated state hash is the non-compressed representaton of a Git object in the git repository xsstate. However, this function does not de-serialize the git object and returns the kind of the object and the raw-data inflated. Precisely, it decodes only the header.

This function follows the same scheme of allocation of Loose.read_inflated if the requested git object is a loose git object or Pack.read if the requested git object is a packed git object. Otherwise, return an error.

val write_inflated : t -> kind:kind -> Cstruct.t -> Hash.t 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.

If we retrieve any error error while the I/O operations, we raise 9by Lwt.fail a Failure which describe in a string the error encountered.

val contents : t -> ((Hash.t * Value.t) list, error) Stdlib.result 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.

val fold : 
  t ->
  ('a -> ?name:Git.Path.t -> length:int64 -> Hash.t -> Value.t -> 'a Lwt.t) ->
  path:Git.Path.t ->
  'a ->
  Hash.t ->
  'a 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 skipped.

val iter : t -> (Hash.t -> Value.t -> unit Lwt.t) -> Hash.t -> unit Lwt.t

module Ref : sig ... end

val clear_caches : t -> unit Lwt.t

clear_caches t drops all values stored in the internal caches binded with the git repository t.

val reset : t -> (unit, error) Stdlib.result Lwt.t

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

val has_global_watches : bool

val has_global_checkout : bool

val v : 
  ?dotgit:Fpath.t ->
  ?compression:int ->
  ?buffer:((buffer -> unit Lwt.t) -> unit Lwt.t) ->
  Fpath.t ->
  (t, error) Stdlib.result Lwt.t