sley 0.0.3

Ergonomic facade over the sley engine, a native-Rust reimplementation of Git's plumbing.
Documentation 
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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

//! Repository-level git notes helpers.

use sley_notes::{
    Note, NotesCommitIdentity, NotesIter, NotesRef, iter_notes, list_notes, notes_ref_expected,
    read_note_bytes, read_note_for, resolve_notes_ref, write_notes,
};

use crate::{ObjectId, Repository, Result};

impl Repository {
    /// Resolve the active notes ref (honours `GIT_NOTES_REF` and `core.notesRef`).
    pub fn notes_ref(&self, override_ref: Option<&str>) -> Result<NotesRef> {
        resolve_notes_ref(self.git_dir(), override_ref)
    }

    /// List every note on `notes_ref`.
    pub fn list_notes(&self, notes_ref: &NotesRef) -> Result<Vec<Note>> {
        list_notes(
            self.git_dir(),
            self.object_format(),
            &self.references(),
            notes_ref,
        )
    }

    /// Stream notes from `notes_ref` without loading the full list.
    pub fn iter_notes(&self, notes_ref: &NotesRef) -> Result<NotesIter> {
        iter_notes(
            self.git_dir(),
            self.object_format(),
            &self.references(),
            notes_ref,
        )
    }

    /// Return the note blob oid for `annotated`, if any (fanout-aware lookup).
    pub fn read_note_for(
        &self,
        notes_ref: &NotesRef,
        annotated: &ObjectId,
    ) -> Result<Option<ObjectId>> {
        read_note_for(
            self.git_dir(),
            self.object_format(),
            &self.references(),
            notes_ref,
            annotated,
        )
    }

    /// Return the note blob oid for `annotated`, if any.
    pub fn read_note(
        &self,
        notes_ref: &NotesRef,
        annotated: &ObjectId,
    ) -> Result<Option<ObjectId>> {
        self.read_note_for(notes_ref, annotated)
    }

    /// Return decoded note bytes for `annotated`, if a note exists.
    pub fn read_note_bytes(
        &self,
        notes_ref: &NotesRef,
        annotated: &ObjectId,
    ) -> Result<Option<Vec<u8>>> {
        read_note_bytes(
            self.git_dir(),
            self.object_format(),
            &self.references(),
            notes_ref,
            annotated,
        )
    }

    /// Rewrite the notes tree and advance `notes_ref` to a new commit.
    pub fn write_notes(
        &self,
        notes_ref: &NotesRef,
        notes: &[Note],
        message: &str,
        identity: &NotesCommitIdentity,
    ) -> Result<()> {
        write_notes(
            self.git_dir(),
            self.object_format(),
            &self.references(),
            notes_ref,
            notes,
            message,
            identity,
            notes_ref_expected(&self.references(), notes_ref)?,
        )
    }
}