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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use crate::{bstr::BStr, Commit, DetachedObject, Tree};

mod error {
    use crate::object;

    #[derive(Debug, thiserror::Error)]
    #[allow(missing_docs)]
    pub enum Error {
        #[error(transparent)]
        FindExistingObject(#[from] object::find::existing::OdbError),
        #[error("The commit could not be decoded fully or partially")]
        Decode(#[from] git_object::decode::Error),
        #[error("Expected object of type {}, but got {}", .expected, .actual)]
        ObjectKind {
            expected: git_object::Kind,
            actual: git_object::Kind,
        },
    }
}

use crate::id::Ancestors;

pub use error::Error;

impl<'repo> Commit<'repo> {
    /// Create an owned instance of this object, copying our data in the process.
    pub fn detached(&self) -> DetachedObject {
        DetachedObject {
            id: self.id,
            kind: git_object::Kind::Commit,
            data: self.data.clone(),
        }
    }

    /// Sever the connection to the `Repository` and turn this instance into a standalone object.
    pub fn detach(self) -> DetachedObject {
        self.into()
    }
}

impl<'repo> Commit<'repo> {
    /// Turn this objects id into a shortened id with a length in hex as configured by `core.abbrev`.
    pub fn short_id(&self) -> Result<git_hash::Prefix, crate::id::shorten::Error> {
        use crate::ext::ObjectIdExt;
        self.id.attach(self.repo).shorten()
    }

    /// Parse the commits message into a [`MessageRef`][git_object::commit::MessageRef]
    pub fn message(&self) -> Result<git_object::commit::MessageRef<'_>, git_object::decode::Error> {
        Ok(git_object::commit::MessageRef::from_bytes(self.message_raw()?))
    }
    /// Decode the entire commit object in full and return the raw message bytes.
    pub fn message_raw(&self) -> Result<&'_ BStr, git_object::decode::Error> {
        git_object::CommitRefIter::from_bytes(&self.data).message()
    }
    /// Decode the commit and obtain the time at which the commit was created.
    ///
    /// For the time at which it was authored, refer to `.decode()?.author.time`.
    pub fn time(&self) -> Result<git_actor::Time, Error> {
        Ok(self.committer()?.time)
    }

    /// Decode the entire commit object and return it for accessing all commit information.
    ///
    /// It will allocate only if there are more than 2 parents.
    ///
    /// Note that the returned commit object does make lookup easy and should be
    /// used for successive calls to string-ish information to avoid decoding the object
    /// more than once.
    pub fn decode(&self) -> Result<git_object::CommitRef<'_>, git_object::decode::Error> {
        git_object::CommitRef::from_bytes(&self.data)
    }

    /// Return an iterator over tokens, representing this commit piece by piece.
    pub fn iter(&self) -> git_object::CommitRefIter<'_> {
        git_object::CommitRefIter::from_bytes(&self.data)
    }

    /// Return the commits author, with surrounding whitespace trimmed.
    pub fn author(&self) -> Result<git_actor::SignatureRef<'_>, git_object::decode::Error> {
        git_object::CommitRefIter::from_bytes(&self.data)
            .author()
            .map(|s| s.trim())
    }

    /// Return the commits committer. with surrounding whitespace trimmed.
    pub fn committer(&self) -> Result<git_actor::SignatureRef<'_>, git_object::decode::Error> {
        git_object::CommitRefIter::from_bytes(&self.data)
            .committer()
            .map(|s| s.trim())
    }

    /// Decode this commits parent ids on the fly without allocating.
    // TODO: tests
    pub fn parent_ids(&self) -> impl Iterator<Item = crate::Id<'repo>> + '_ {
        use crate::ext::ObjectIdExt;
        let repo = self.repo;
        git_object::CommitRefIter::from_bytes(&self.data)
            .parent_ids()
            .map(move |id| id.attach(repo))
    }

    /// Parse the commit and return the the tree object it points to.
    pub fn tree(&self) -> Result<Tree<'repo>, Error> {
        let tree_id = self.tree_id()?;
        match self.repo.find_object(tree_id)?.try_into_tree() {
            Ok(tree) => Ok(tree),
            Err(crate::object::try_into::Error { actual, expected, .. }) => Err(Error::ObjectKind { actual, expected }),
        }
    }

    /// Parse the commit and return the the tree id it points to.
    pub fn tree_id(&self) -> Result<git_hash::ObjectId, git_object::decode::Error> {
        git_object::CommitRefIter::from_bytes(&self.data).tree_id()
    }

    /// Return our id own id with connection to this repository.
    pub fn id(&self) -> crate::Id<'repo> {
        use crate::ext::ObjectIdExt;
        self.id.attach(self.repo)
    }

    /// Obtain a platform for traversing ancestors of this commit.
    pub fn ancestors(&self) -> Ancestors<'repo> {
        self.id().ancestors()
    }
}

impl<'r> std::fmt::Debug for Commit<'r> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "Commit({})", self.id)
    }
}