From fe5ec139922c117baf8d284c67a0ea156cd1c657 Mon Sep 17 00:00:00 2001 From: Michael Howell Date: Wed, 24 Feb 2021 00:23:38 -0700 Subject: [PATCH] Clean up language for more consistency --- src/lib.rs | 110 ++++++++++++++++++++++++++++------------------------- 1 file changed, 58 insertions(+), 52 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index 1dae5bb..6a8a2b1 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -5,22 +5,22 @@ use std::io::Write; pub enum DiffLine { Context(Vec), Expected(Vec), - Resulting(Vec), + Actual(Vec), MissingNL, } #[derive(Debug, PartialEq)] struct Mismatch { - pub line_number: u32, - pub line_number_resulting: u32, + pub line_number_expected: u32, + pub line_number_actual: u32, pub lines: Vec, } impl Mismatch { - fn new(line_number: u32, line_number_resulting: u32) -> Mismatch { + fn new(line_number_expected: u32, line_number_actual: u32) -> Mismatch { Mismatch { - line_number, - line_number_resulting, + line_number_expected, + line_number_actual, lines: Vec::new(), } } @@ -28,8 +28,8 @@ impl Mismatch { // Produces a diff between the expected output and actual output. fn make_diff(expected: &[u8], actual: &[u8], context_size: usize) -> Vec { - let mut line_number = 1; - let mut line_number_resulting = 1; + let mut line_number_expected = 1; + let mut line_number_actual = 1; let mut context_queue: VecDeque<&[u8]> = VecDeque::with_capacity(context_size); let mut lines_since_mismatch = context_size + 1; let mut results = Vec::new(); @@ -57,8 +57,8 @@ fn make_diff(expected: &[u8], actual: &[u8], context_size: usize) -> Vec= context_size && lines_since_mismatch > 0 { results.push(mismatch); mismatch = Mismatch::new( - line_number - context_queue.len() as u32, - line_number_resulting - context_queue.len() as u32, + line_number_expected - context_queue.len() as u32, + line_number_actual - context_queue.len() as u32, ); } @@ -69,33 +69,33 @@ fn make_diff(expected: &[u8], actual: &[u8], context_size: usize) -> Vec { - // We have to make sure that Resulting (the + lines) + Some(DiffLine::Actual(res)) => { + // We have to make sure that Actual (the + lines) // always come after Expected (the - lines) mismatch.lines.push(DiffLine::Expected(str.to_vec())); - if line_number > expected_lines_count { + if line_number_expected > expected_lines_count { mismatch.lines.push(DiffLine::MissingNL) } - mismatch.lines.push(DiffLine::Resulting(res)); + mismatch.lines.push(DiffLine::Actual(res)); mismatch.lines.push(DiffLine::MissingNL); } _ => unreachable!("unterminated Left and Common lines shouldn't be followed by more Left lines"), } } else { mismatch.lines.push(DiffLine::Expected(str.to_vec())); - if line_number > expected_lines_count { + if line_number_expected > expected_lines_count { mismatch.lines.push(DiffLine::MissingNL) } } - line_number += 1; + line_number_expected += 1; lines_since_mismatch = 0; } diff::Result::Right(str) => { if lines_since_mismatch >= context_size && lines_since_mismatch > 0 { results.push(mismatch); mismatch = Mismatch::new( - line_number - context_queue.len() as u32, - line_number_resulting - context_queue.len() as u32, + line_number_expected - context_queue.len() as u32, + line_number_actual - context_queue.len() as u32, ); } @@ -104,27 +104,27 @@ fn make_diff(expected: &[u8], actual: &[u8], context_size: usize) -> Vec actual_lines_count { + mismatch.lines.push(DiffLine::Actual(str.to_vec())); + if line_number_actual > actual_lines_count { mismatch.lines.push(DiffLine::MissingNL) } - line_number_resulting += 1; + line_number_actual += 1; lines_since_mismatch = 0; } diff::Result::Both(str, _) => { - if (line_number_resulting > actual_lines_count) - || (line_number > expected_lines_count) + if (line_number_actual > actual_lines_count) + || (line_number_expected > expected_lines_count) { // if one of them is missing a newline and the other isn't, then they don't actually match if lines_since_mismatch >= context_size && lines_since_mismatch > 0 - && (line_number_resulting > actual_lines_count) - != (line_number > expected_lines_count) + && (line_number_actual > actual_lines_count) + != (line_number_expected > expected_lines_count) { results.push(mismatch); mismatch = Mismatch::new( - line_number - context_queue.len() as u32, - line_number_resulting - context_queue.len() as u32, + line_number_expected - context_queue.len() as u32, + line_number_actual - context_queue.len() as u32, ); } while let Some(line) = context_queue.pop_front() { @@ -132,18 +132,18 @@ fn make_diff(expected: &[u8], actual: &[u8], context_size: usize) -> Vec actual_lines_count - && line_number > expected_lines_count + if line_number_actual > actual_lines_count + && line_number_expected > expected_lines_count { mismatch.lines.push(DiffLine::Context(str.to_vec())); mismatch.lines.push(DiffLine::MissingNL); - } else if line_number > expected_lines_count { + } else if line_number_expected > expected_lines_count { mismatch.lines.push(DiffLine::Expected(str.to_vec())); mismatch.lines.push(DiffLine::MissingNL); - mismatch.lines.push(DiffLine::Resulting(str.to_vec())); - } else if line_number_resulting > actual_lines_count { + mismatch.lines.push(DiffLine::Actual(str.to_vec())); + } else if line_number_actual > actual_lines_count { mismatch.lines.push(DiffLine::Expected(str.to_vec())); - mismatch.lines.push(DiffLine::Resulting(str.to_vec())); + mismatch.lines.push(DiffLine::Actual(str.to_vec())); mismatch.lines.push(DiffLine::MissingNL); } } else { @@ -158,8 +158,8 @@ fn make_diff(expected: &[u8], actual: &[u8], context_size: usize) -> Vec Vec Vec { @@ -225,10 +231,10 @@ pub fn diff( } DiffLine::Context(_) => { expected_count += 1; - resulting_count += 1; + actual_count += 1; } - DiffLine::Resulting(_) => { - resulting_count += 1; + DiffLine::Actual(_) => { + actual_count += 1; } DiffLine::MissingNL => {} } @@ -236,7 +242,7 @@ pub fn diff( writeln!( output, "@@ -{},{} +{},{} @@", - line_number, expected_count, line_number_resulting, resulting_count + line_number_expected, expected_count, line_number_actual, actual_count ) .expect("write to Vec is infallible"); for line in result.lines { @@ -251,7 +257,7 @@ pub fn diff( output.write_all(&c).expect("write to Vec is infallible"); writeln!(output).unwrap(); } - DiffLine::Resulting(r) => { + DiffLine::Actual(r) => { write!(output, "+",).expect("write to Vec is infallible"); output.write_all(&r).expect("write to Vec is infallible"); writeln!(output).unwrap();