logloom 1.0.0

Parse, validate, and export changelogs with a CLI and Rust library
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

use std::ops::Range;

use crate::{Changelog, Entry, EntryKind, ParseError, Release, Span};

use super::{push_entry, source::Source};

#[derive(Default)]
pub struct Entries {
    pending: Option<(usize, EntryKind)>,
}

impl Entries {
    pub fn line(
        &mut self,
        source: &Source<'_>,
        current: &mut Release,
        span: Span,
        text: &str,
        item: bool,
    ) -> Result<(), ParseError> {
        if text.trim().is_empty() {
            if matches!(self.pending, Some((_, EntryKind::Text))) {
                self.finish(source, current, span.start)?;
            }
        } else {
            if item {
                self.finish(source, current, span.start)?;
            }
            self.pending.get_or_insert((
                span.start,
                if item {
                    EntryKind::ListItem
                } else {
                    EntryKind::Text
                },
            ));
        }
        Ok(())
    }

    pub fn finish(
        &mut self,
        source: &Source<'_>,
        current: &mut Release,
        end: usize,
    ) -> Result<(), ParseError> {
        if let Some((start, kind)) = self.pending.take() {
            push_entry(
                current,
                Entry {
                    markdown: source.text(start..end)?.trim().to_owned(),
                    kind,
                    span: source.span(start..end),
                },
            );
        }
        Ok(())
    }
}

pub fn rebase(
    changelog: &mut Changelog,
    original: &Source<'_>,
    offset: usize,
) -> Result<(), ParseError> {
    let shift = |span: &mut Span| -> Result<(), ParseError> {
        let start = offset.checked_add(span.start);
        let end = offset.checked_add(span.end);
        let range = start
            .zip(end)
            .map(|(start, end)| start..end)
            .ok_or_else(|| {
                crate::ParseError::new(
                    crate::ErrorKind::ResourceLimit,
                    None,
                    "source offset overflow",
                )
            })?;
        original.text(range.clone())?;
        *span = original.span(range);
        Ok(())
    };
    for release in &mut changelog.releases {
        shift(&mut release.span)?;
        if let Some(span) = &mut release.date_span {
            shift(span)?;
        }
        for link in &mut release.links {
            shift(&mut link.span)?;
        }
        for section in &mut release.sections {
            shift(&mut section.span)?;
            for entry in &mut section.entries {
                shift(&mut entry.span)?;
            }
        }
    }
    for link in &mut changelog.links {
        shift(&mut link.span)?;
    }
    original.input.clone_into(&mut changelog.source);
    Ok(())
}

pub fn containing_spans(changelog: &mut Changelog, span: Span) {
    for release in &mut changelog.releases {
        release.span = span;
        if let Some(date_span) = &mut release.date_span {
            *date_span = span;
        }
        for link in &mut release.links {
            link.span = span;
        }
        for section in &mut release.sections {
            section.span = span;
            for entry in &mut section.entries {
                entry.span = span;
            }
        }
    }
    for link in &mut changelog.links {
        link.span = span;
    }
}

pub const fn range(span: Span) -> Range<usize> {
    span.start..span.end
}