clankerdiff-core 0.1.1

Renderer-independent diff and code review domain model
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

use super::DiffSide;
use clankerdiff_theme::DiffTone;
use serde::{Deserialize, Serialize};
use std::sync::Arc;

/// A line's semantic patch kind.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum PatchLineKind {
    HunkHeader,
    Context,
    Added,
    Removed,
    Meta,
}

impl PatchLineKind {
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::HunkHeader => "HunkHeader",
            Self::Context => "Context",
            Self::Added => "Added",
            Self::Removed => "Removed",
            Self::Meta => "Meta",
        }
    }

    #[must_use]
    pub const fn sides(self) -> &'static [DiffSide] {
        match self {
            Self::Removed => &[DiffSide::Old],
            Self::Added => &[DiffSide::New],
            _ => &[DiffSide::Old, DiffSide::New],
        }
    }

    /// Semantic tint used when presenting a line of this kind.
    #[must_use]
    pub const fn tone(self) -> DiffTone {
        match self {
            Self::Added => DiffTone::Added,
            Self::Removed => DiffTone::Removed,
            Self::Meta | Self::HunkHeader => DiffTone::Meta,
            Self::Context => DiffTone::Context,
        }
    }
}

/// A line in a hunk, including canonical old/new numbering.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct PatchLine {
    pub kind: PatchLineKind,
    pub text: Arc<str>,
    pub old_line_no: Option<usize>,
    pub new_line_no: Option<usize>,
    pub no_newline: bool,
}

impl PatchLine {
    /// Creates an added line.
    #[must_use]
    pub fn added(text: impl Into<Arc<str>>, new_line_no: usize) -> Self {
        Self {
            kind: PatchLineKind::Added,
            text: text.into(),
            old_line_no: None,
            new_line_no: Some(new_line_no),
            no_newline: false,
        }
    }

    /// Creates a removed line.
    #[must_use]
    pub fn removed(text: impl Into<Arc<str>>, old_line_no: usize) -> Self {
        Self {
            kind: PatchLineKind::Removed,
            text: text.into(),
            old_line_no: Some(old_line_no),
            new_line_no: None,
            no_newline: false,
        }
    }

    /// Creates a context line.
    #[must_use]
    pub fn context(text: impl Into<Arc<str>>, old_line_no: usize, new_line_no: usize) -> Self {
        Self {
            kind: PatchLineKind::Context,
            text: text.into(),
            old_line_no: Some(old_line_no),
            new_line_no: Some(new_line_no),
            no_newline: false,
        }
    }

    /// Marks this line as the final line without a trailing newline.
    #[must_use]
    pub fn without_newline(mut self) -> Self {
        self.no_newline = true;
        self
    }

    /// Returns the number for a side.
    #[must_use]
    pub const fn line_number(&self, side: DiffSide) -> Option<usize> {
        match side {
            DiffSide::Old => self.old_line_no,
            DiffSide::New => self.new_line_no,
        }
    }
}