git-bug 0.2.4

A rust library for interfacing with git-bug repositories
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
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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

// git-bug-rs - A rust library for interfacing with git-bug repositories
//
// Copyright (C) 2025 Benedikt Peetz <benedikt.peetz@b-peetz.de>
// SPDX-License-Identifier: GPL-3.0-or-later
//
// This file is part of git-bug-rs/git-gub.
//
// You should have received a copy of the License along with this program.
// If not, see <https://www.gnu.org/licenses/agpl.txt>.

//! Issue specific extension to the generic Snapshot type.

use std::collections::HashSet;

use history_step::IssueHistoryStep;
use log::warn;

use super::{
    Issue,
    data::{comment::Comment, label::Label, status::Status},
};
use crate::replica::entity::{
    id::combined_id::CombinedId,
    identity::IdentityStub,
    snapshot::{
        Snapshot,
        timeline::{Timeline, history_step::HistoryStep},
    },
};

pub mod history_step;
pub mod timeline;

impl Snapshot<Issue> {
    /// Returns the Body of the Issue at the time of this snapshot.
    #[must_use]
    // Only expects.
    #[allow(clippy::missing_panics_doc)]
    pub fn body(&self) -> &str {
        &self
            .timeline()
            .body_history()
            .last()
            .expect("This is mandated by the crate op")
            .message
    }

    /// Returns the [`Comments`][`Comment`] at the time of this snapshot.
    #[must_use]
    // Only expects.
    #[allow(clippy::missing_panics_doc)]
    pub fn comments(&self) -> Vec<Comment> {
        let mut output = Vec::with_capacity(self.timeline().comments().count());

        for comment in self.timeline().comments() {
            let first = comment.history.first();

            let last = comment.history.last();

            output.push(Comment {
                combined_id: CombinedId {
                    primary_id: self.id().as_id(),
                    secondary_id: comment.id.as_id(),
                },
                author: first.author,
                message: last.message.clone(),
                files: last.files.clone(),
                timestamp: first.at,
            });
        }

        output
    }

    /// Returns the active [`Label`][`Label`] at the time of this
    /// snapshot.
    #[must_use]
    pub fn labels(&self) -> HashSet<&Label> {
        let mut labels = HashSet::new();

        for label in self.timeline().labels_history() {
            for removed in &label.removed {
                if !labels.remove(removed) {
                    warn!("Label {removed} was removed, but was never added.");
                }
            }
            for added in &label.added {
                if !labels.insert(added) {
                    warn!("Label {added} was added, but was already in the set of labels.");
                }
            }
        }

        labels
    }

    /// Returns the active [`Status`]  at the time of this snapshot.
    #[must_use]
    pub fn status(&self) -> Status {
        if let Some(last) = self.timeline().status_history().last() {
            last.status
        } else {
            // FIXME(@bpeetz): I'm not a fan of this implicit default. But git-bug does this
            // and we need to do it too, if we want to stay compatible.
            // <2025-04-19>
            Status::Open
        }
    }

    /// Returns the Issue's title at the time of this snapshot.
    #[must_use]
    // Only expects.
    #[allow(clippy::missing_panics_doc)]
    pub fn title(&self) -> &str {
        let last = self
            .timeline()
            .title_history()
            .last()
            .expect("This is mandated by the create op");
        &last.title
    }

    /// Return the [`author`][`IdentityStub`] of this [`Issue`][`super::Issue`]
    ///
    /// This is the same as the [`author`][`IdentityStub`] of the
    /// [`Issue`][`super::Issue`], which was used to create this snapshot.
    #[must_use]
    // Only expects
    #[allow(clippy::missing_panics_doc)]
    pub fn author(&self) -> IdentityStub {
        self.timeline()
            .body_history()
            .next()
            .expect("A body item must exist")
            .author
    }

    /// Get an iterator over all the people that actively participated on this
    /// issue.
    pub fn participants(&self) -> impl Iterator<Item = IdentityStub> + use<'_> {
        // TODO(@bpeetz): This should de-duplicate. <2025-04-20>
        self.timeline()
            .history()
            .iter()
            .filter(|item| matches!(item, IssueHistoryStep::Body(_)))
            .map(HistoryStep::author)
    }
}