// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use config::Color;
+use config::{Color, Config, Verbosity};
use diff;
use std::collections::VecDeque;
use std::io;
-use term;
-use utils::use_colored_tty;
+use std::io::Write;
#[derive(Debug, PartialEq)]
pub enum DiffLine {
#[derive(Debug, PartialEq)]
pub struct Mismatch {
+ /// The line number in the formatted version.
pub line_number: u32,
+ /// The line number in the original version.
+ pub line_number_orig: u32,
+ /// The set of lines (context and old/new) in the mismatch.
pub lines: Vec<DiffLine>,
}
impl Mismatch {
- fn new(line_number: u32) -> Mismatch {
+ fn new(line_number: u32, line_number_orig: u32) -> Mismatch {
Mismatch {
- line_number: line_number,
+ line_number,
+ line_number_orig,
lines: Vec::new(),
}
}
// for colorized output and the capabilities of the terminal.
pub fn new(color: Color) -> Self {
if let Some(t) = term::stdout() {
- if use_colored_tty(color) && t.supports_color() {
+ if color.use_colored_tty() && t.supports_color() {
return OutputWriter { terminal: Some(t) };
}
}
// Produces a diff between the expected output and actual output of rustfmt.
pub fn make_diff(expected: &str, actual: &str, context_size: usize) -> Vec<Mismatch> {
let mut line_number = 1;
+ let mut line_number_orig = 1;
let mut context_queue: VecDeque<&str> = VecDeque::with_capacity(context_size);
let mut lines_since_mismatch = context_size + 1;
let mut results = Vec::new();
- let mut mismatch = Mismatch::new(0);
+ let mut mismatch = Mismatch::new(0, 0);
for result in diff::lines(expected, actual) {
match result {
diff::Result::Left(str) => {
if lines_since_mismatch >= context_size && lines_since_mismatch > 0 {
results.push(mismatch);
- mismatch = Mismatch::new(line_number - context_queue.len() as u32);
+ mismatch = Mismatch::new(
+ line_number - context_queue.len() as u32,
+ line_number_orig - context_queue.len() as u32,
+ );
}
while let Some(line) = context_queue.pop_front() {
}
mismatch.lines.push(DiffLine::Resulting(str.to_owned()));
+ line_number_orig += 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);
+ mismatch = Mismatch::new(
+ line_number - context_queue.len() as u32,
+ line_number_orig - context_queue.len() as u32,
+ );
}
while let Some(line) = context_queue.pop_front() {
}
line_number += 1;
+ line_number_orig += 1;
lines_since_mismatch += 1;
}
}
results
}
-pub fn print_diff<F>(diff: Vec<Mismatch>, get_section_title: F, color: Color)
+pub fn print_diff<F>(diff: Vec<Mismatch>, get_section_title: F, config: &Config)
where
F: Fn(u32) -> String,
{
+ let color = config.color();
+ let line_terminator = if config.verbose() == Verbosity::Verbose {
+ "⏎"
+ } else {
+ ""
+ };
+
let mut writer = OutputWriter::new(color);
for mismatch in diff {
let title = get_section_title(mismatch.line_number);
- writer.writeln(&format!("{}", title), None);
+ writer.writeln(&title, None);
for line in mismatch.lines {
match line {
- DiffLine::Context(ref str) => writer.writeln(&format!(" {}⏎", str), None),
- DiffLine::Expected(ref str) => {
- writer.writeln(&format!("+{}⏎", str), Some(term::color::GREEN))
+ DiffLine::Context(ref str) => {
+ writer.writeln(&format!(" {}{}", str, line_terminator), None)
}
- DiffLine::Resulting(ref str) => {
- writer.writeln(&format!("-{}⏎", str), Some(term::color::RED))
+ DiffLine::Expected(ref str) => writer.writeln(
+ &format!("+{}{}", str, line_terminator),
+ Some(term::color::GREEN),
+ ),
+ DiffLine::Resulting(ref str) => writer.writeln(
+ &format!("-{}{}", str, line_terminator),
+ Some(term::color::RED),
+ ),
+ }
+ }
+ }
+}
+
+/// Convert a Mismatch into a serialised form which just includes
+/// enough information to modify the original file.
+/// Each section starts with a line with three integers, space separated:
+/// lineno num_removed num_added
+/// followed by (num_added) lines of added text. The line numbers are
+/// relative to the original file.
+pub fn output_modified<W>(mut out: W, diff: Vec<Mismatch>)
+where
+ W: Write,
+{
+ for mismatch in diff {
+ let (num_removed, num_added) =
+ mismatch
+ .lines
+ .iter()
+ .fold((0, 0), |(rem, add), line| match *line {
+ DiffLine::Context(_) => panic!("No Context expected"),
+ DiffLine::Expected(_) => (rem, add + 1),
+ DiffLine::Resulting(_) => (rem + 1, add),
+ });
+ // Write a header with enough information to separate the modified lines.
+ writeln!(
+ out,
+ "{} {} {}",
+ mismatch.line_number_orig, num_removed, num_added
+ ).unwrap();
+
+ for line in mismatch.lines {
+ match line {
+ DiffLine::Context(_) | DiffLine::Resulting(_) => (),
+ DiffLine::Expected(ref str) => {
+ writeln!(out, "{}", str).unwrap();
}
}
}
#[cfg(test)]
mod test {
- use super::{make_diff, Mismatch};
use super::DiffLine::*;
+ use super::{make_diff, Mismatch};
#[test]
fn diff_simple() {
let diff = make_diff(src, dest, 1);
assert_eq!(
diff,
- vec![
- Mismatch {
- line_number: 2,
- lines: vec![
- Context("two".to_owned()),
- Resulting("three".to_owned()),
- Expected("trois".to_owned()),
- Context("four".to_owned()),
- ],
- },
- ]
+ vec![Mismatch {
+ line_number: 2,
+ line_number_orig: 2,
+ lines: vec![
+ Context("two".to_owned()),
+ Resulting("three".to_owned()),
+ Expected("trois".to_owned()),
+ Context("four".to_owned()),
+ ],
+ }]
);
}
vec![
Mismatch {
line_number: 2,
+ line_number_orig: 2,
lines: vec![
Context("two".to_owned()),
Resulting("three".to_owned()),
},
Mismatch {
line_number: 5,
+ line_number_orig: 5,
lines: vec![
Resulting("five".to_owned()),
Expected("cinq".to_owned()),
let diff = make_diff(src, dest, 0);
assert_eq!(
diff,
- vec![
- Mismatch {
- line_number: 3,
- lines: vec![Resulting("three".to_owned()), Expected("trois".to_owned())],
- },
- ]
+ vec![Mismatch {
+ line_number: 3,
+ line_number_orig: 3,
+ lines: vec![Resulting("three".to_owned()), Expected("trois".to_owned())],
+ }]
);
}
let diff = make_diff(src, dest, 1);
assert_eq!(
diff,
- vec![
- Mismatch {
- line_number: 5,
- lines: vec![Context("five".to_owned()), Expected("".to_owned())],
- },
- ]
+ vec![Mismatch {
+ line_number: 5,
+ line_number_orig: 5,
+ lines: vec![Context("five".to_owned()), Expected("".to_owned())],
+ }]
);
}
}