Module B0_vcs

module B0_vcs: sig .. end

Version control system (VCS) repositories.


VCS kinds

type kind = 
| Git
| Hg

The type for VCS supported by the module.

val pp_kind : kind B0_std.Fmt.t

pp_kind formats types of VCS.

Version control system repositories

type t 

The type for VCS repositories.

val kind : t -> kind

kind r is r's kind.

val repo_dir : t -> B0_std.Fpath.t

repo_dir r is r's repository directory (not the working directory).

val work_dir : t -> B0_std.Fpath.t

work_dir r is r's working directory.

val cmd : t -> B0_std.Cmd.t

cmd r is the base command to use to act on r. Use only if you need VCS specific functionality not provided by the module.

val pp : t B0_std.Fmt.t

pp formats a repository.

Finding repositories

val find : ?dir:B0_std.Fpath.t -> unit -> (t option, string) Stdlib.result

find ~dir () finds, using VCS functionality, a repository starting in directory dir (if unspecified this is the cwd).

val get : ?dir:B0_std.Fpath.t -> unit -> (t, string) Stdlib.result

get is like B0_vcs.find but errors if no VCS was found.

Commits

type commit_ish = string 

The type for symbols resolving to a commit. Important, the module uses "HEAD" for specifying the commit currently checkout in the working directory; use this symbol even if the underlying VCS is Hg.

type commit_id = string 

The type for commit identifiers. Note that the module sometimes appends the string "-dirty" to these identifiers in which case they are no longer.

val head : commit_ish

head is "HEAD". A symbol to represent the commit currently checked out in the working directory.

val commit_id : t ->
dirty_mark:bool ->
commit_ish -> (commit_id, string) Stdlib.result

commit_id r ~dirty_mark ~commit_ish is the object name (identifier) of commit_ish. If commit_ish is "HEAD" and dirty_mark is true (default) and the working tree of r B0_vcs.is_dirty, a mark gets appended to the commit identifier.

val commit_ptime_s : t -> commit_ish -> (int, string) Stdlib.result

commit_ptime_s t commit_ish is the POSIX time in seconds of commit commit_ish of repository r.

val changes : t ->
after:commit_ish ->
until:commit_ish ->
((commit_id * string) list, string) Stdlib.result

changes r ~after ~until is the list of commits with their one-line synopsis from commit-ish after to commit-ish until.

val tracked_files : t -> tree_ish:string -> (B0_std.Fpath.t list, string) Stdlib.result

tracked_files ~tree_ish r are the files tracked by the tree object tree_ish.

val commit_files : ?msg:string ->
t -> B0_std.Fpath.t list -> (unit, string) Stdlib.result

commit_files r ~msg files commits the file files with message msg (if unspecified the VCS should prompt).

Working directory

val is_dirty : t -> (bool, string) Stdlib.result

is_dirty r is Ok true iff the working directory of r has uncommited changes.

val not_dirty : t -> (unit, string) Stdlib.result

not_dirty is Ok () iff the working directory of r is not dirty and an error that enjoins to stash or commit otherwise.

val file_is_dirty : t -> B0_std.Fpath.t -> (bool, string) Stdlib.result

file_is_dirty r f is Ok true iff f has uncommited changes.

val checkout : ?and_branch:string ->
t -> commit_ish -> (unit, string) Stdlib.result

checkout r ~and_branch commit_ish checks out commit_ish in the working directory of r. Checks out in a new branch and_branch if provided. This fails if the current working directory B0_vcs.is_dirty.

val clone : t -> dir:B0_std.Fpath.t -> (t, string) Stdlib.result

clone r ~dir clones r to a working directory dir and returns a repo to operate on it.

Tags

type tag = string 

The type for VCS tags.

val tags : t -> (tag list, string) Stdlib.result

tags r is the list of tags in the repo r.

val tag : ?msg:string ->
t ->
force:bool ->
sign:bool -> commit_ish -> tag -> (unit, string) Stdlib.result

tag r ~force ~sign ~msg commit_ish t tags commit_ish with t and message msg (if unspecified the VCS should prompt). If sign is true (defaults to false) signs the tag (`Git repos only). If force is true (default to false) doesn't fail if the tag already exists.

val delete_tag : t -> tag -> (unit, string) Stdlib.result

delete_tag r t deletes tag t in repo r.

val describe : t ->
dirty_mark:bool -> commit_ish -> (string, string) Stdlib.result

describe r dirty_mark commit_ish identifies commit_ish (defaults to "HEAD") using tags from the repository r. If commit_ish is "HEAD" and dirty_mark is true (default) and the working tree of r B0_vcs.is_dirty, a mark gets appended to the description.

Git specific operations

module Git: sig .. end

Git specific operations.