summaryrefslogtreecommitdiff
path: root/lib/git_presenters.ml
blob: feff7ac8eed2484a00fb6c41087b5174e7ffa226 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
(* -*- mode: tuareg; -*- *)

module Store = Git_unix.Store
open Lwt_result.Syntax
open Config

let full_path path = Filename.concat config.git_project_root path

let store repo =
  let path = Fpath.v @@ full_path repo in
  Store.v ~dotgit:path path

let repo_description repo =
  let description_path = Filename.concat (full_path repo) "description" in
  In_channel.with_open_text description_path In_channel.input_all

type user = Git.User.t

(* let all_authors store = *)
(*   let* store = store repo in *)

type commit = {
  hash : string;
  short_hash : string;
  parents : string list;
  author : user;
  message : string option;
}

let to_commit store h =
  let* v = Store.read store h in
  match v with
  | Git.Value.Commit c ->
      let hash = Store.Hash.to_hex h in
      Lwt_result.return
        {
          hash;
          short_hash = String.sub hash 0 8;
          parents = Store.Value.Commit.parents c |> List.map Store.Hash.to_hex;
          author = Store.Value.Commit.author c;
          message = Store.Value.Commit.message c;
        }
  | _ -> Lwt_result.fail @@ `Msg "value is not a commit"

let recent_commits repo n =
  let* store = store repo in
  let* head = Store.Ref.resolve store Git.Reference.head in
  let rec walk acc hash count =
    if count = 0 then Lwt_result.return (List.rev acc)
    else
      let* commit = to_commit store hash in
      match commit.parents with
      | parent :: _ ->
          walk (commit :: acc) (Store.Hash.of_hex parent) (count - 1)
      | [] -> Lwt_result.return (List.rev (commit :: acc))
  in
  walk [] head n

let of_id repo id =
  let* store = store repo in
  let id = Store.Hash.of_hex id in
  to_commit store id

type branch = { name : string }

let all_branches repo =
  let* store = store repo in
  let open Lwt.Syntax in
  let* refs = Store.Ref.list store in
  let branches =
    List.map (fun (ref, _) -> { name = Git.Reference.to_string ref }) refs
  in
  Lwt_result.return branches
Copyright 2019--2025 Marius PETER