notabene 0.2.0

A fast linter for changelogs in Keep a Changelog format
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

//! Owned versions of changelog types.
use super::traits;

pub struct OwnedChangelog {
    pub(crate) title: Option<String>,
    pub(crate) unreleased: Option<OwnedUnreleased>,
    pub(crate) releases: Vec<OwnedRelease>,
}

pub struct OwnedUnreleased {
    pub(crate) url: Option<String>,
    pub(crate) changes: Vec<OwnedChanges>,
}

pub struct OwnedRelease {
    pub(crate) version: String,
    pub(crate) url: Option<String>,
    pub(crate) date: Option<String>,
    pub(crate) yanked: bool,
    pub(crate) changes: Vec<OwnedChanges>,
}

pub struct OwnedChanges {
    pub(crate) kind: String,
    pub(crate) items: Vec<String>,
}

impl traits::Changelog for OwnedChangelog {
    type Unreleased = OwnedUnreleased;
    type Release = OwnedRelease;

    fn title(&self) -> Option<&str> {
        self.title.as_deref()
    }

    fn unreleased(&self) -> Option<&Self::Unreleased> {
        self.unreleased.as_ref()
    }

    fn releases(&self) -> &[Self::Release] {
        &self.releases
    }
}

impl traits::Unreleased for OwnedUnreleased {
    type Changes = OwnedChanges;

    fn url(&self) -> Option<&str> {
        self.url.as_deref()
    }

    fn changes(&self) -> &[Self::Changes] {
        &self.changes
    }
}

impl traits::Release for OwnedRelease {
    type Changes = OwnedChanges;

    fn version(&self) -> &str {
        &self.version
    }

    fn url(&self) -> Option<&str> {
        self.url.as_deref()
    }

    fn date(&self) -> Option<&str> {
        self.date.as_deref()
    }

    fn yanked(&self) -> bool {
        self.yanked
    }

    fn changes(&self) -> &[Self::Changes] {
        &self.changes
    }
}

impl traits::Changes for OwnedChanges {
    fn kind(&self) -> &str {
        &self.kind
    }

    fn items(&self) -> impl Iterator<Item = &str> {
        self.items.iter().map(|s| s.as_str())
    }
}