Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
65 changes: 36 additions & 29 deletions src/context_diff.rs
Original file line number Diff line number Diff line change
Expand Up @@ -7,7 +7,7 @@ use std::collections::VecDeque;
use std::io::Write;

use crate::params::Params;
use crate::utils::{do_write_line, line_prefix};
use crate::utils::{diff_lines, do_write_line, line_prefix};
use crate::utils::{
get_modification_time, is_posix_locale, write_file_header, FunctionLineFinder, TimestampStyle,
};
Expand Down Expand Up @@ -100,30 +100,31 @@ fn make_diff(
actual: &[u8],
context_size: usize,
stop_early: bool,
ignore_case: bool,
) -> Vec<Mismatch> {
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 context_queue: VecDeque<(&[u8], &[u8])> = VecDeque::with_capacity(context_size);
// Like GNU diff, keep changes in one hunk while at most twice the context
// size of unchanged lines separates them.
let max_gap = 2 * context_size;
let mut lines_since_mismatch = max_gap + 1;
let mut results = Vec::new();
let mut mismatch = Mismatch::new(0, 0);

let mut expected_lines: Vec<&[u8]> = expected.split(|&c| c == b'\n').collect();
let mut actual_lines: Vec<&[u8]> = actual.split(|&c| c == b'\n').collect();
let mut expected_lines = diff_lines(expected, ignore_case);
let mut actual_lines = diff_lines(actual, ignore_case);

debug_assert_eq!(b"".split(|&c| c == b'\n').count(), 1);
// ^ means that underflow here is impossible
let expected_lines_count = expected_lines.len() - 1;
let actual_lines_count = actual_lines.len() - 1;

if expected_lines.last() == Some(&&b""[..]) {
if expected_lines.last().is_some_and(|l| l.raw.is_empty()) {
expected_lines.pop();
}

if actual_lines.last() == Some(&&b""[..]) {
if actual_lines.last().is_some_and(|l| l.raw.is_empty()) {
actual_lines.pop();
}

Expand All @@ -140,9 +141,9 @@ fn make_diff(
);
}

while let Some(line) = context_queue.pop_front() {
mismatch.expected.push(DiffLine::Context(line.to_vec()));
mismatch.actual.push(DiffLine::Context(line.to_vec()));
while let Some((exp_line, act_line)) = context_queue.pop_front() {
mismatch.expected.push(DiffLine::Context(exp_line.to_vec()));
mismatch.actual.push(DiffLine::Context(act_line.to_vec()));
}

ChangeBlock::mark(&mut block, &mismatch, true, false);
Expand All @@ -162,9 +163,9 @@ fn make_diff(
);
}

while let Some(line) = context_queue.pop_front() {
mismatch.expected.push(DiffLine::Context(line.to_vec()));
mismatch.actual.push(DiffLine::Context(line.to_vec()));
while let Some((exp_line, act_line)) = context_queue.pop_front() {
mismatch.expected.push(DiffLine::Context(exp_line.to_vec()));
mismatch.actual.push(DiffLine::Context(act_line.to_vec()));
}

ChangeBlock::mark(&mut block, &mismatch, false, true);
Expand All @@ -175,7 +176,7 @@ fn make_diff(
line_number_actual += 1;
lines_since_mismatch = 0;
}
diff::Result::Both(str, _) => {
diff::Result::Both(str1, str2) => {
// if one of them is missing a newline and the other isn't, then they don't actually match
if (line_number_actual > actual_lines_count)
&& (line_number_expected > expected_lines_count)
Expand All @@ -184,8 +185,8 @@ fn make_diff(
// this is the last line: lines still in the queue are past
// the trailing context and there is no next hunk to lead into
if lines_since_mismatch < context_size {
mismatch.expected.push(DiffLine::Context(str.to_vec()));
mismatch.actual.push(DiffLine::Context(str.to_vec()));
mismatch.expected.push(DiffLine::Context(str1.to_vec()));
mismatch.actual.push(DiffLine::Context(str2.to_vec()));
mismatch.expected_missing_nl = true;
mismatch.actual_missing_nl = true;
}
Expand All @@ -197,13 +198,13 @@ fn make_diff(
line_number_actual - context_queue.len(),
);
}
while let Some(line) = context_queue.pop_front() {
mismatch.expected.push(DiffLine::Context(line.to_vec()));
mismatch.actual.push(DiffLine::Context(line.to_vec()));
while let Some((exp_line, act_line)) = context_queue.pop_front() {
mismatch.expected.push(DiffLine::Context(exp_line.to_vec()));
mismatch.actual.push(DiffLine::Context(act_line.to_vec()));
}
ChangeBlock::mark(&mut block, &mismatch, true, true);
mismatch.expected.push(DiffLine::Change(str.to_vec()));
mismatch.actual.push(DiffLine::Change(str.to_vec()));
mismatch.expected.push(DiffLine::Change(str1.to_vec()));
mismatch.actual.push(DiffLine::Change(str2.to_vec()));
mismatch.actual_missing_nl = true;
lines_since_mismatch = 0;
} else if line_number_expected > expected_lines_count {
Expand All @@ -214,14 +215,14 @@ fn make_diff(
line_number_actual - context_queue.len(),
);
}
while let Some(line) = context_queue.pop_front() {
mismatch.expected.push(DiffLine::Context(line.to_vec()));
mismatch.actual.push(DiffLine::Context(line.to_vec()));
while let Some((exp_line, act_line)) = context_queue.pop_front() {
mismatch.expected.push(DiffLine::Context(exp_line.to_vec()));
mismatch.actual.push(DiffLine::Context(act_line.to_vec()));
}
ChangeBlock::mark(&mut block, &mismatch, true, true);
mismatch.expected.push(DiffLine::Change(str.to_vec()));
mismatch.expected.push(DiffLine::Change(str1.to_vec()));
mismatch.expected_missing_nl = true;
mismatch.actual.push(DiffLine::Change(str.to_vec()));
mismatch.actual.push(DiffLine::Change(str2.to_vec()));
lines_since_mismatch = 0;
} else {
ChangeBlock::close(&mut block, &mut mismatch);
Expand All @@ -230,10 +231,10 @@ fn make_diff(
let _ = context_queue.pop_front();
}
if lines_since_mismatch < context_size {
mismatch.expected.push(DiffLine::Context(str.to_vec()));
mismatch.actual.push(DiffLine::Context(str.to_vec()));
mismatch.expected.push(DiffLine::Context(str1.to_vec()));
mismatch.actual.push(DiffLine::Context(str2.to_vec()));
} else if context_size > 0 {
context_queue.push_back(str);
context_queue.push_back((str1.raw, str2.raw));
}
lines_since_mismatch += 1;
}
Expand Down Expand Up @@ -337,7 +338,13 @@ pub fn diff(expected: &[u8], actual: &[u8], params: &Params) -> Vec<u8> {
params.to_label.as_deref(),
&to_modified_time,
);
let diff_results = make_diff(expected, actual, params.context_count, params.brief);
let diff_results = make_diff(
expected,
actual,
params.context_count,
params.brief,
params.ignore_case,
);
if diff_results.is_empty() {
return Vec::new();
}
Expand Down
19 changes: 12 additions & 7 deletions src/ed_diff.rs
Original file line number Diff line number Diff line change
Expand Up @@ -6,7 +6,7 @@
use std::io::Write;

use crate::params::Params;
use crate::utils::do_write_line;
use crate::utils::{diff_lines, do_write_line};

#[derive(Debug, PartialEq)]
struct Mismatch {
Expand Down Expand Up @@ -45,27 +45,32 @@ impl Mismatch {
}

// Produces a diff between the expected output and actual output.
fn make_diff(expected: &[u8], actual: &[u8], stop_early: bool) -> Result<Vec<Mismatch>, DiffError> {
fn make_diff(
expected: &[u8],
actual: &[u8],
stop_early: bool,
ignore_case: bool,
) -> Result<Vec<Mismatch>, DiffError> {
let mut line_number_expected = 1;
let mut line_number_actual = 1;
let mut results = Vec::new();
let mut mismatch = Mismatch::new(line_number_expected, line_number_actual);

let mut expected_lines: Vec<&[u8]> = expected.split(|&c| c == b'\n').collect();
let mut actual_lines: Vec<&[u8]> = actual.split(|&c| c == b'\n').collect();
let mut expected_lines = diff_lines(expected, ignore_case);
let mut actual_lines = diff_lines(actual, ignore_case);

debug_assert_eq!(b"".split(|&c| c == b'\n').count(), 1);
// ^ means that underflow here is impossible
let _expected_lines_count = expected_lines.len() - 1;
let _actual_lines_count = actual_lines.len() - 1;

if expected_lines.last() == Some(&&b""[..]) {
if expected_lines.last().is_some_and(|l| l.raw.is_empty()) {
expected_lines.pop();
} else {
return Err(DiffError::MissingNL);
}

if actual_lines.last() == Some(&&b""[..]) {
if actual_lines.last().is_some_and(|l| l.raw.is_empty()) {
actual_lines.pop();
} else {
return Err(DiffError::MissingNL);
Expand Down Expand Up @@ -112,7 +117,7 @@ fn make_diff(expected: &[u8], actual: &[u8], stop_early: bool) -> Result<Vec<Mis

pub fn diff(expected: &[u8], actual: &[u8], params: &Params) -> Result<Vec<u8>, DiffError> {
let mut output = Vec::new();
let diff_results = make_diff(expected, actual, params.brief)?;
let diff_results = make_diff(expected, actual, params.brief, params.ignore_case)?;
if params.brief && !diff_results.is_empty() {
write!(&mut output, "\0").unwrap();
return Ok(output);
Expand Down
42 changes: 30 additions & 12 deletions src/normal_diff.rs
Original file line number Diff line number Diff line change
Expand Up @@ -6,7 +6,7 @@
use std::io::Write;

use crate::params::Params;
use crate::utils::{do_write_line, line_prefix};
use crate::utils::{diff_lines, do_write_line, line_prefix};

#[derive(Debug, PartialEq)]
struct Mismatch {
Expand All @@ -32,25 +32,25 @@ impl Mismatch {
}

// Produces a diff between the expected output and actual output.
fn make_diff(expected: &[u8], actual: &[u8], stop_early: bool) -> Vec<Mismatch> {
fn make_diff(expected: &[u8], actual: &[u8], stop_early: bool, ignore_case: bool) -> Vec<Mismatch> {
let mut line_number_expected = 1;
let mut line_number_actual = 1;
let mut results = Vec::new();
let mut mismatch = Mismatch::new(line_number_expected, line_number_actual);

let mut expected_lines: Vec<&[u8]> = expected.split(|&c| c == b'\n').collect();
let mut actual_lines: Vec<&[u8]> = actual.split(|&c| c == b'\n').collect();
let mut expected_lines = diff_lines(expected, ignore_case);
let mut actual_lines = diff_lines(actual, ignore_case);

debug_assert_eq!(b"".split(|&c| c == b'\n').count(), 1);
// ^ means that underflow here is impossible
let expected_lines_count = expected_lines.len() - 1;
let actual_lines_count = actual_lines.len() - 1;

if expected_lines.last() == Some(&&b""[..]) {
if expected_lines.last().is_some_and(|l| l.raw.is_empty()) {
expected_lines.pop();
}

if actual_lines.last() == Some(&&b""[..]) {
if actual_lines.last().is_some_and(|l| l.raw.is_empty()) {
actual_lines.pop();
}

Expand All @@ -70,24 +70,24 @@ fn make_diff(expected: &[u8], actual: &[u8], stop_early: bool) -> Vec<Mismatch>
mismatch.actual_missing_nl = line_number_actual > actual_lines_count;
line_number_actual += 1;
}
diff::Result::Both(str, _) => {
diff::Result::Both(str1, str2) => {
match (
line_number_expected > expected_lines_count,
line_number_actual > actual_lines_count,
) {
(true, false) => {
line_number_expected += 1;
line_number_actual += 1;
mismatch.expected.push(str.to_vec());
mismatch.expected.push(str1.to_vec());
mismatch.expected_missing_nl = true;
mismatch.actual.push(str.to_vec());
mismatch.actual.push(str2.to_vec());
}
(false, true) => {
line_number_expected += 1;
line_number_actual += 1;
mismatch.actual.push(str.to_vec());
mismatch.actual.push(str2.to_vec());
mismatch.actual_missing_nl = true;
mismatch.expected.push(str.to_vec());
mismatch.expected.push(str1.to_vec());
}
(true, true) | (false, false) => {
line_number_expected += 1;
Expand Down Expand Up @@ -121,7 +121,7 @@ pub fn diff(expected: &[u8], actual: &[u8], params: &Params) -> Vec<u8> {
// See https://www.gnu.org/software/diffutils/manual/html_node/Detailed-Normal.html
// for details on the syntax of the normal format.
let mut output = Vec::new();
let diff_results = make_diff(expected, actual, params.brief);
let diff_results = make_diff(expected, actual, params.brief, params.ignore_case);
if params.brief && !diff_results.is_empty() {
write!(&mut output, "\0").unwrap();
return output;
Expand Down Expand Up @@ -618,4 +618,22 @@ mod tests {
);
assert!(nodiff_brief.is_empty());
}

#[test]
fn test_ignore_case() {
let from = b"Hello World\nLine 2\n";
let to = b"hello world\nline 2\n";
let res = diff(
from,
to,
&Params {
ignore_case: true,
..Default::default()
},
);
assert!(res.is_empty());

let res_diff = diff(from, to, &Params::default());
assert!(!res_diff.is_empty());
}
}
28 changes: 28 additions & 0 deletions src/params.rs
Original file line number Diff line number Diff line change
Expand Up @@ -63,6 +63,7 @@ pub struct Params {
/// The name from which to start comparing the top-level directories
/// (`-S`).
pub starting_file: Option<OsString>,
pub ignore_case: bool,
pub ignore_file_name_case: bool,
pub no_dereference: bool,
/// Set when `from` did not exist and was compared as an empty file.
Expand Down Expand Up @@ -109,6 +110,7 @@ impl Default for Params {
function_line_patterns: Vec::new(),
recursive: false,
starting_file: None,
ignore_case: false,
ignore_file_name_case: false,
no_dereference: false,
from_missing: false,
Expand Down Expand Up @@ -253,6 +255,14 @@ pub fn parse_params<I: Iterator<Item = OsString>>(
params.no_dereference = true;
continue;
}
if param == "-i" || param == "--ignore-case" {
params.ignore_case = true;
continue;
}
if param == "--no-ignore-case" {
params.ignore_case = false;
continue;
}
if param == "--ignore-file-name-case" {
params.ignore_file_name_case = true;
continue;
Expand Down Expand Up @@ -1487,6 +1497,24 @@ mod tests {
)
.is_err());
}
#[test]
fn ignore_case() {
for (args, expected) in [
(&[][..], false),
(&["-i"], true),
(&["--ignore-case"], true),
(&["--no-ignore-case"], false),
(&["-i", "--no-ignore-case"], false),
(&["--no-ignore-case", "-i"], true),
] {
let args = std::iter::once("diff")
.chain(args.iter().copied())
.chain(["foo", "bar"]);
let params = parse_params(args.map(os).peekable()).unwrap();
assert_eq!(params.ignore_case, expected);
}
}

#[test]
fn ignore_file_name_case() {
// The last of --ignore-file-name-case and --no-ignore-file-name-case
Expand Down
Loading