399318488

Build Type

push

github

Committed by Dan Davison

Commit Message

<a href="https://github.com/dandavison/delta/commit/5e5913132">Back to </a><a class="double-link" href="https://github.com/dandavison/delta/commit/462fc56cf">462fc56cf</a>

Run Details

2055 of 2829 relevant lines covered (72.64%)

1.81 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.89

/src/parse.rs

use lazy_static::lazy_static;
use regex::Regex;
use std::borrow::Cow;
use std::path::Path;

use crate::config::Config;
use crate::features;

// https://git-scm.com/docs/git-config#Documentation/git-config.txt-diffmnemonicPrefix
const DIFF_PREFIXES: [&str; 6] = ["a/", "b/", "c/", "i/", "o/", "w/"];

#[allow(clippy::tabs_in_doc_comments)]
/// Given input like
/// "--- one.rs        2019-11-20 06:16:08.000000000 +0100"
/// Return "rs"
pub fn get_file_extension_from_marker_line(line: &str) -> Option<&str> {
    line.split('\t')
        .next()
        .and_then(|column| column.split(' ').nth(1))
        .and_then(|file| file.split('.').last())
}

#[derive(Debug, PartialEq)]
pub enum FileEvent {
    Change,
    Copy,
    Rename,
    NoEvent,
}

pub fn parse_file_meta_line(line: &str, git_diff_name: bool) -> (String, FileEvent) {
    match line {
        line if line.starts_with("--- ") || line.starts_with("+++ ") => {
            let offset = 4;
            let file = match &line[offset..] {
                path if path == "/dev/null" => "/dev/null",
                path if git_diff_name && DIFF_PREFIXES.iter().any(|s| path.starts_with(s)) => {
                    &path[2..]
                }
                path if git_diff_name => &path,
                path => path.split('\t').next().unwrap_or(""),
            }
            .to_string();
            (file, FileEvent::Change)
        }
        line if line.starts_with("rename from ") => {
            (line[12..].to_string(), FileEvent::Rename) // "rename from ".len()
        }
        line if line.starts_with("rename to ") => {
            (line[10..].to_string(), FileEvent::Rename) // "rename to ".len()
        }
        line if line.starts_with("copy from ") => {
            (line[10..].to_string(), FileEvent::Copy) // "copy from ".len()
        }
        line if line.starts_with("copy to ") => {
            (line[8..].to_string(), FileEvent::Copy) // "copy to ".len()
        }
        _ => ("".to_string(), FileEvent::NoEvent),
    }
}

pub fn get_file_extension_from_file_meta_line_file_path(path: &str) -> Option<&str> {
    if path.is_empty() || path == "/dev/null" {
        None
    } else {
        get_extension(&path).map(|ex| ex.trim())
    }
}

pub fn get_file_change_description_from_file_paths(
    minus_file: &str,
    plus_file: &str,
    comparing: bool,
    file_event: &FileEvent,
    config: &Config,
) -> String {
    if comparing {
        format!("comparing: {} ⟶   {}", minus_file, plus_file)
    } else {
        let format_label = |label: &str| {
            if !label.is_empty() {
                format!("{} ", label)
            } else {
                "".to_string()
            }
        };
        let format_file = |file| {
            if config.hyperlinks {
                features::hyperlinks::format_osc8_file_hyperlink(file, None, file, config)
            } else {
                Cow::from(file)
            }
        };
        match (minus_file, plus_file) {
            (minus_file, plus_file) if minus_file == plus_file => format!(
                "{}{}",
                format_label(&config.file_modified_label),
                format_file(minus_file)
            ),
            (minus_file, "/dev/null") => format!(
                "{}{}",
                format_label(&config.file_removed_label),
                format_file(minus_file)
            ),
            ("/dev/null", plus_file) => format!(
                "{}{}",
                format_label(&config.file_added_label),
                format_file(plus_file)
            ),
            (minus_file, plus_file) => format!(
                "{}{} ⟶   {}",
                format_label(match file_event {
                    FileEvent::Rename => &config.file_renamed_label,
                    FileEvent::Copy => &config.file_copied_label,
                    _ => "",
                }),
                format_file(minus_file),
                format_file(plus_file)
            ),
        }
    }
}

lazy_static! {
    static ref HUNK_HEADER_REGEX: Regex = Regex::new(r"@+ ([^@]+)@+(.*\s?)").unwrap();
}

// Parse unified diff hunk header format. See
// https://www.gnu.org/software/diffutils/manual/html_node/Detailed-Unified.html
// https://www.artima.com/weblogs/viewpost.jsp?thread=164293
lazy_static! {
    static ref HUNK_HEADER_FILE_COORDINATE_REGEX: Regex = Regex::new(
        r"(?x)
[-+]
(\d+)            # 1. Hunk start line number
(?:              # Start optional hunk length section (non-capturing)
  ,              #   Literal comma
  (\d+)          #   2. Optional hunk length (defaults to 1)
)?"
    )
    .unwrap();
}

/// Given input like
/// "@@ -74,15 +74,14 @@ pub fn delta("
/// Return " pub fn delta(" and a vector of (line_number, hunk_length) tuples.
pub fn parse_hunk_header(line: &str) -> (String, Vec<(usize, usize)>) {
    let caps = HUNK_HEADER_REGEX.captures(line).unwrap();
    let file_coordinates = &caps[1];
    let line_numbers_and_hunk_lengths = HUNK_HEADER_FILE_COORDINATE_REGEX
        .captures_iter(file_coordinates)
        .map(|caps| {
            (
                caps[1].parse::<usize>().unwrap(),
                caps.get(2)
                    .map(|m| m.as_str())
                    // Per the specs linked above, if the hunk length is absent then it is 1.
                    .unwrap_or("1")
                    .parse::<usize>()
                    .unwrap(),
            )
        })
        .collect();
    let code_fragment = &caps[2];
    (code_fragment.to_string(), line_numbers_and_hunk_lengths)
}

/// Attempt to parse input as a file path and return extension as a &str.
fn get_extension(s: &str) -> Option<&str> {
    let path = Path::new(s);
    path.extension()
        .and_then(|e| e.to_str())
        // E.g. 'Makefile' is the file name and also the extension
        .or_else(|| path.file_name().and_then(|s| s.to_str()))
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_get_file_extension_from_marker_line() {
        assert_eq!(
            get_file_extension_from_marker_line(
                "--- src/one.rs        2019-11-20 06:47:56.000000000 +0100"
            ),
            Some("rs")
        );
    }

    #[test]
    fn test_get_file_extension_from_file_meta_line() {
        assert_eq!(
            get_file_extension_from_file_meta_line_file_path("a/src/parse.rs"),
            Some("rs")
        );
        assert_eq!(
            get_file_extension_from_file_meta_line_file_path("b/src/pa rse.rs"),
            Some("rs")
        );
        assert_eq!(
            get_file_extension_from_file_meta_line_file_path("src/pa rse.rs"),
            Some("rs")
        );
        assert_eq!(
            get_file_extension_from_file_meta_line_file_path("wat hello.rs"),
            Some("rs")
        );
        assert_eq!(
            get_file_extension_from_file_meta_line_file_path("/dev/null"),
            None
        );
        assert_eq!(
            get_file_extension_from_file_meta_line_file_path("Dockerfile"),
            Some("Dockerfile")
        );
        assert_eq!(
            get_file_extension_from_file_meta_line_file_path("Makefile"),
            Some("Makefile")
        );
        assert_eq!(
            get_file_extension_from_file_meta_line_file_path("a/src/Makefile"),
            Some("Makefile")
        );
        assert_eq!(
            get_file_extension_from_file_meta_line_file_path("src/Makefile"),
            Some("Makefile")
        );
    }

    // We should only strip the prefixes if they are "a/" or "b/". This will be correct except for
    // the case of a user with `diff.noprefix = true` who has directories named "a" or "b", which
    // is an irresolvable ambiguity. Ideally one would only strip the prefixes if we have confirmed
    // that we are looking at something like
    //
    // --- a/src/parse.rs
    // +++ b/src/parse.rs
    //
    // as opposed to something like
    //
    // --- a/src/parse.rs
    // +++ sibling_of_a/src/parse.rs
    //
    // but we don't attempt that currently.
    #[test]
    fn test_get_file_path_from_git_file_meta_line() {
        assert_eq!(
            parse_file_meta_line("--- /dev/null", true),
            ("/dev/null".to_string(), FileEvent::Change)
        );
        for prefix in &DIFF_PREFIXES {
            assert_eq!(
                parse_file_meta_line(&format!("--- {}src/delta.rs", prefix), true),
                ("src/delta.rs".to_string(), FileEvent::Change)
            );
        }
        assert_eq!(
            parse_file_meta_line("--- src/delta.rs", true),
            ("src/delta.rs".to_string(), FileEvent::Change)
        );
        assert_eq!(
            parse_file_meta_line("+++ src/delta.rs", true),
            ("src/delta.rs".to_string(), FileEvent::Change)
        );
    }

    #[test]
    fn test_get_file_path_from_git_file_meta_line_containing_spaces() {
        assert_eq!(
            parse_file_meta_line("+++ a/my src/delta.rs", true),
            ("my src/delta.rs".to_string(), FileEvent::Change)
        );
        assert_eq!(
            parse_file_meta_line("+++ my src/delta.rs", true),
            ("my src/delta.rs".to_string(), FileEvent::Change)
        );
        assert_eq!(
            parse_file_meta_line("+++ a/src/my delta.rs", true),
            ("src/my delta.rs".to_string(), FileEvent::Change)
        );
        assert_eq!(
            parse_file_meta_line("+++ a/my src/my delta.rs", true),
            ("my src/my delta.rs".to_string(), FileEvent::Change)
        );
        assert_eq!(
            parse_file_meta_line("+++ b/my src/my enough/my delta.rs", true),
            (
                "my src/my enough/my delta.rs".to_string(),
                FileEvent::Change
            )
        );
    }

    #[test]
    fn test_get_file_path_from_git_file_meta_line_rename() {
        assert_eq!(
            parse_file_meta_line("rename from nospace/file2.el", true),
            ("nospace/file2.el".to_string(), FileEvent::Rename)
        );
    }

    #[test]
    fn test_get_file_path_from_git_file_meta_line_rename_containing_spaces() {
        assert_eq!(
            parse_file_meta_line("rename from with space/file1.el", true),
            ("with space/file1.el".to_string(), FileEvent::Rename)
        );
    }

    #[test]
    fn test_parse_file_meta_line() {
        assert_eq!(
            parse_file_meta_line("--- src/delta.rs", false),
            ("src/delta.rs".to_string(), FileEvent::Change)
        );
        assert_eq!(
            parse_file_meta_line("+++ src/delta.rs", false),
            ("src/delta.rs".to_string(), FileEvent::Change)
        );
    }

    #[test]
    fn test_parse_hunk_header() {
        let parsed = parse_hunk_header("@@ -74,15 +75,14 @@ pub fn delta(\n");
        let code_fragment = parsed.0;
        let line_numbers_and_hunk_lengths = parsed.1;
        assert_eq!(code_fragment, " pub fn delta(\n");
        assert_eq!(line_numbers_and_hunk_lengths[0], (74, 15),);
        assert_eq!(line_numbers_and_hunk_lengths[1], (75, 14),);
    }

    #[test]
    fn test_parse_hunk_header_with_omitted_hunk_lengths() {
        let parsed = parse_hunk_header("@@ -74 +75,2 @@ pub fn delta(\n");
        let code_fragment = parsed.0;
        let line_numbers_and_hunk_lengths = parsed.1;
        assert_eq!(code_fragment, " pub fn delta(\n");
        assert_eq!(line_numbers_and_hunk_lengths[0], (74, 1),);
        assert_eq!(line_numbers_and_hunk_lengths[1], (75, 2),);
    }

    #[test]
    fn test_parse_hunk_header_added_file() {
        let parsed = parse_hunk_header("@@ -1,22 +0,0 @@");
        let code_fragment = parsed.0;
        let line_numbers_and_hunk_lengths = parsed.1;
        assert_eq!(code_fragment, "",);
        assert_eq!(line_numbers_and_hunk_lengths[0], (1, 22),);
        assert_eq!(line_numbers_and_hunk_lengths[1], (0, 0),);
    }

    #[test]
    fn test_parse_hunk_header_deleted_file() {
        let parsed = parse_hunk_header("@@ -0,0 +1,3 @@");
        let code_fragment = parsed.0;
        let line_numbers_and_hunk_lengths = parsed.1;
        assert_eq!(code_fragment, "",);
        assert_eq!(line_numbers_and_hunk_lengths[0], (0, 0),);
        assert_eq!(line_numbers_and_hunk_lengths[1], (1, 3),);
    }

    #[test]
    fn test_parse_hunk_header_merge() {
        let parsed = parse_hunk_header("@@@ -293,11 -358,15 +358,16 @@@ dependencies =");
        let code_fragment = parsed.0;
        let line_numbers_and_hunk_lengths = parsed.1;
        assert_eq!(code_fragment, " dependencies =");
        assert_eq!(line_numbers_and_hunk_lengths[0], (293, 11),);
        assert_eq!(line_numbers_and_hunk_lengths[1], (358, 15),);
        assert_eq!(line_numbers_and_hunk_lengths[2], (358, 16),);
    }
}

1	use lazy_static::lazy_static;
2	use regex::Regex;
3	use std::borrow::Cow;
4	use std::path::Path;
5
6	use crate::config::Config;
7	use crate::features;
8
9	// https://git-scm.com/docs/git-config#Documentation/git-config.txt-diffmnemonicPrefix
10	const DIFF_PREFIXES: [&str; 6] = ["a/", "b/", "c/", "i/", "o/", "w/"];
11
12	#[allow(clippy::tabs_in_doc_comments)]
13	/// Given input like
14	/// "--- one.rs 2019-11-20 06:16:08.000000000 +0100"
15	/// Return "rs"
16	pub fn get_file_extension_from_marker_line(line: &str) -> Option<&str> {	1✔
17	line.split('\t')	1✔
18	.next()
19	.and_then(\|column\| column.split(' ').nth(1))	2✔
20	.and_then(\|file\| file.split('.').last())	2✔
21	}
22
23	#[derive(Debug, PartialEq)]
24	pub enum FileEvent {
25	Change,
26	Copy,
27	Rename,
28	NoEvent,
29	}
30
31	pub fn parse_file_meta_line(line: &str, git_diff_name: bool) -> (String, FileEvent) {	2✔
32	match line {	6✔
33	line if line.starts_with("--- ") \|\| line.starts_with("+++ ") => {	2✔
34	let offset = 4;	2✔
35	let file = match &line[offset..] {	10✔
36	path if path == "/dev/null" => "/dev/null",	2✔
37	path if git_diff_name && DIFF_PREFIXES.iter().any(\|s\| path.starts_with(s)) => {	6✔
38	&path[2..]	4✔
39	}
40	path if git_diff_name => &path,	2✔
41	path => path.split('\t').next().unwrap_or(""),	1✔
42	}
43	.to_string();
44	(file, FileEvent::Change)	2✔
45	}
46	line if line.starts_with("rename from ") => {	2✔
47	(line[12..].to_string(), FileEvent::Rename) // "rename from ".len()	2✔
48	}
49	line if line.starts_with("rename to ") => {	2✔
50	(line[10..].to_string(), FileEvent::Rename) // "rename to ".len()	2✔
51	}
52	line if line.starts_with("copy from ") => {	2✔
53	(line[10..].to_string(), FileEvent::Copy) // "copy from ".len()	2✔
54	}
55	line if line.starts_with("copy to ") => {	2✔
56	(line[8..].to_string(), FileEvent::Copy) // "copy to ".len()	2✔
57	}
58	_ => ("".to_string(), FileEvent::NoEvent),	×
59	}
60	}
61
62	pub fn get_file_extension_from_file_meta_line_file_path(path: &str) -> Option<&str> {	2✔
63	if path.is_empty() \|\| path == "/dev/null" {	5✔
64	None	1✔
65	} else {
66	get_extension(&path).map(\|ex\| ex.trim())	8✔
67	}
68	}
69
70	pub fn get_file_change_description_from_file_paths(	1✔
71	minus_file: &str,
72	plus_file: &str,
73	comparing: bool,
74	file_event: &FileEvent,
75	config: &Config,
76	) -> String {
77	if comparing {	3✔
78	format!("comparing: {} ⟶ {}", minus_file, plus_file)	1✔
79	} else {
80	let format_label = \|label: &str\| {	1✔
81	if !label.is_empty() {	2✔
82	format!("{} ", label)	1✔
83	} else {
84	"".to_string()	1✔
85	}
86	};
87	let format_file = \|file\| {	2✔
88	if config.hyperlinks {	1✔
89	features::hyperlinks::format_osc8_file_hyperlink(file, None, file, config)	×
90	} else {
91	Cow::from(file)	1✔
92	}
93	};
94	match (minus_file, plus_file) {	4✔
95	(minus_file, plus_file) if minus_file == plus_file => format!(	3✔
96	"{}{}",
97	format_label(&config.file_modified_label),	2✔
98	format_file(minus_file)	1✔
99	),
100	(minus_file, "/dev/null") => format!(	4✔
101	"{}{}",
102	format_label(&config.file_removed_label),	1✔
103	format_file(minus_file)	1✔
104	),
105	("/dev/null", plus_file) => format!(	3✔
106	"{}{}",
107	format_label(&config.file_added_label),	1✔
108	format_file(plus_file)	1✔
109	),
110	(minus_file, plus_file) => format!(	1✔
111	"{}{} ⟶ {}",
112	format_label(match file_event {	3✔
113	FileEvent::Rename => &config.file_renamed_label,	2✔
114	FileEvent::Copy => &config.file_copied_label,	2✔
115	_ => "",	×
116	}),
117	format_file(minus_file),	1✔
118	format_file(plus_file)	1✔
119	),
120	}
121	}
122	}
123
124	lazy_static! {
125	static ref HUNK_HEADER_REGEX: Regex = Regex::new(r"@+ ([^@]+)@+(.*\s?)").unwrap();	1✔
126	}
127
128	// Parse unified diff hunk header format. See
129	// https://www.gnu.org/software/diffutils/manual/html_node/Detailed-Unified.html
130	// https://www.artima.com/weblogs/viewpost.jsp?thread=164293
131	lazy_static! {
132	static ref HUNK_HEADER_FILE_COORDINATE_REGEX: Regex = Regex::new(	1✔
133	r"(?x)
134	[-+]
135	(\d+) # 1. Hunk start line number
136	(?: # Start optional hunk length section (non-capturing)
137	, # Literal comma
138	(\d+) # 2. Optional hunk length (defaults to 1)
139	)?"
140	)
141	.unwrap();
142	}
143
144	/// Given input like
145	/// "@@ -74,15 +74,14 @@ pub fn delta("
146	/// Return " pub fn delta(" and a vector of (line_number, hunk_length) tuples.
147	pub fn parse_hunk_header(line: &str) -> (String, Vec<(usize, usize)>) {	1✔
148	let caps = HUNK_HEADER_REGEX.captures(line).unwrap();	2✔
149	let file_coordinates = &caps[1];	1✔
150	let line_numbers_and_hunk_lengths = HUNK_HEADER_FILE_COORDINATE_REGEX	2✔
151	.captures_iter(file_coordinates)
152	.map(\|caps\| {	1✔
153	(
154	caps[1].parse::<usize>().unwrap(),	3✔
155	caps.get(2)	1✔
156	.map(\|m\| m.as_str())	2✔
157	// Per the specs linked above, if the hunk length is absent then it is 1.
158	.unwrap_or("1")
159	.parse::<usize>()
160	.unwrap(),
161	)
162	})
163	.collect();
164	let code_fragment = &caps[2];	1✔
165	(code_fragment.to_string(), line_numbers_and_hunk_lengths)	2✔
166	}
167
168	/// Attempt to parse input as a file path and return extension as a &str.
169	fn get_extension(s: &str) -> Option<&str> {	2✔
170	let path = Path::new(s);	2✔
171	path.extension()	4✔
172	.and_then(\|e\| e.to_str())	4✔
173	// E.g. 'Makefile' is the file name and also the extension
174	.or_else(\|\| path.file_name().and_then(\|s\| s.to_str()))	6✔
175	}
176
177	#[cfg(test)]
178	mod tests {
179	use super::*;
180
181	#[test]
182	fn test_get_file_extension_from_marker_line() {
183	assert_eq!(
184	get_file_extension_from_marker_line(
185	"--- src/one.rs 2019-11-20 06:47:56.000000000 +0100"
186	),
187	Some("rs")
188	);
189	}
190
191	#[test]
192	fn test_get_file_extension_from_file_meta_line() {
193	assert_eq!(
194	get_file_extension_from_file_meta_line_file_path("a/src/parse.rs"),
195	Some("rs")
196	);
197	assert_eq!(
198	get_file_extension_from_file_meta_line_file_path("b/src/pa rse.rs"),
199	Some("rs")
200	);
201	assert_eq!(
202	get_file_extension_from_file_meta_line_file_path("src/pa rse.rs"),
203	Some("rs")
204	);
205	assert_eq!(
206	get_file_extension_from_file_meta_line_file_path("wat hello.rs"),
207	Some("rs")
208	);
209	assert_eq!(
210	get_file_extension_from_file_meta_line_file_path("/dev/null"),
211	None
212	);
213	assert_eq!(
214	get_file_extension_from_file_meta_line_file_path("Dockerfile"),
215	Some("Dockerfile")
216	);
217	assert_eq!(
218	get_file_extension_from_file_meta_line_file_path("Makefile"),
219	Some("Makefile")
220	);
221	assert_eq!(
222	get_file_extension_from_file_meta_line_file_path("a/src/Makefile"),
223	Some("Makefile")
224	);
225	assert_eq!(
226	get_file_extension_from_file_meta_line_file_path("src/Makefile"),
227	Some("Makefile")
228	);
229	}
230
231	// We should only strip the prefixes if they are "a/" or "b/". This will be correct except for
232	// the case of a user with `diff.noprefix = true` who has directories named "a" or "b", which
233	// is an irresolvable ambiguity. Ideally one would only strip the prefixes if we have confirmed
234	// that we are looking at something like
235	//
236	// --- a/src/parse.rs
237	// +++ b/src/parse.rs
238	//
239	// as opposed to something like
240	//
241	// --- a/src/parse.rs
242	// +++ sibling_of_a/src/parse.rs
243	//
244	// but we don't attempt that currently.
245	#[test]
246	fn test_get_file_path_from_git_file_meta_line() {
247	assert_eq!(
248	parse_file_meta_line("--- /dev/null", true),
249	("/dev/null".to_string(), FileEvent::Change)
250	);
251	for prefix in &DIFF_PREFIXES {
252	assert_eq!(
253	parse_file_meta_line(&format!("--- {}src/delta.rs", prefix), true),
254	("src/delta.rs".to_string(), FileEvent::Change)
255	);
256	}
257	assert_eq!(
258	parse_file_meta_line("--- src/delta.rs", true),
259	("src/delta.rs".to_string(), FileEvent::Change)
260	);
261	assert_eq!(
262	parse_file_meta_line("+++ src/delta.rs", true),
263	("src/delta.rs".to_string(), FileEvent::Change)
264	);
265	}
266
267	#[test]
268	fn test_get_file_path_from_git_file_meta_line_containing_spaces() {
269	assert_eq!(
270	parse_file_meta_line("+++ a/my src/delta.rs", true),
271	("my src/delta.rs".to_string(), FileEvent::Change)
272	);
273	assert_eq!(
274	parse_file_meta_line("+++ my src/delta.rs", true),
275	("my src/delta.rs".to_string(), FileEvent::Change)
276	);
277	assert_eq!(
278	parse_file_meta_line("+++ a/src/my delta.rs", true),
279	("src/my delta.rs".to_string(), FileEvent::Change)
280	);
281	assert_eq!(
282	parse_file_meta_line("+++ a/my src/my delta.rs", true),
283	("my src/my delta.rs".to_string(), FileEvent::Change)
284	);
285	assert_eq!(
286	parse_file_meta_line("+++ b/my src/my enough/my delta.rs", true),
287	(
288	"my src/my enough/my delta.rs".to_string(),
289	FileEvent::Change
290	)
291	);
292	}
293
294	#[test]
295	fn test_get_file_path_from_git_file_meta_line_rename() {
296	assert_eq!(
297	parse_file_meta_line("rename from nospace/file2.el", true),
298	("nospace/file2.el".to_string(), FileEvent::Rename)
299	);
300	}
301
302	#[test]
303	fn test_get_file_path_from_git_file_meta_line_rename_containing_spaces() {
304	assert_eq!(
305	parse_file_meta_line("rename from with space/file1.el", true),
306	("with space/file1.el".to_string(), FileEvent::Rename)
307	);
308	}
309
310	#[test]
311	fn test_parse_file_meta_line() {
312	assert_eq!(
313	parse_file_meta_line("--- src/delta.rs", false),
314	("src/delta.rs".to_string(), FileEvent::Change)
315	);
316	assert_eq!(
317	parse_file_meta_line("+++ src/delta.rs", false),
318	("src/delta.rs".to_string(), FileEvent::Change)
319	);
320	}
321
322	#[test]
323	fn test_parse_hunk_header() {
324	let parsed = parse_hunk_header("@@ -74,15 +75,14 @@ pub fn delta(\n");
325	let code_fragment = parsed.0;
326	let line_numbers_and_hunk_lengths = parsed.1;
327	assert_eq!(code_fragment, " pub fn delta(\n");
328	assert_eq!(line_numbers_and_hunk_lengths[0], (74, 15),);
329	assert_eq!(line_numbers_and_hunk_lengths[1], (75, 14),);
330	}
331
332	#[test]
333	fn test_parse_hunk_header_with_omitted_hunk_lengths() {
334	let parsed = parse_hunk_header("@@ -74 +75,2 @@ pub fn delta(\n");
335	let code_fragment = parsed.0;
336	let line_numbers_and_hunk_lengths = parsed.1;
337	assert_eq!(code_fragment, " pub fn delta(\n");
338	assert_eq!(line_numbers_and_hunk_lengths[0], (74, 1),);
339	assert_eq!(line_numbers_and_hunk_lengths[1], (75, 2),);
340	}
341
342	#[test]
343	fn test_parse_hunk_header_added_file() {
344	let parsed = parse_hunk_header("@@ -1,22 +0,0 @@");
345	let code_fragment = parsed.0;
346	let line_numbers_and_hunk_lengths = parsed.1;
347	assert_eq!(code_fragment, "",);
348	assert_eq!(line_numbers_and_hunk_lengths[0], (1, 22),);
349	assert_eq!(line_numbers_and_hunk_lengths[1], (0, 0),);
350	}
351
352	#[test]
353	fn test_parse_hunk_header_deleted_file() {
354	let parsed = parse_hunk_header("@@ -0,0 +1,3 @@");
355	let code_fragment = parsed.0;
356	let line_numbers_and_hunk_lengths = parsed.1;
357	assert_eq!(code_fragment, "",);
358	assert_eq!(line_numbers_and_hunk_lengths[0], (0, 0),);
359	assert_eq!(line_numbers_and_hunk_lengths[1], (1, 3),);
360	}
361
362	#[test]
363	fn test_parse_hunk_header_merge() {
364	let parsed = parse_hunk_header("@@@ -293,11 -358,15 +358,16 @@@ dependencies =");
365	let code_fragment = parsed.0;
366	let line_numbers_and_hunk_lengths = parsed.1;
367	assert_eq!(code_fragment, " dependencies =");
368	assert_eq!(line_numbers_and_hunk_lengths[0], (293, 11),);
369	assert_eq!(line_numbers_and_hunk_lengths[1], (358, 15),);
370	assert_eq!(line_numbers_and_hunk_lengths[2], (358, 16),);
371	}
372	}

dandavison / delta / 399318488

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous