Merging upstream version 1.74.1+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

6 files changed, 1382 insertions, 0 deletions

diff --git a/vendor/prettydiff/src/basic.rs b/vendor/prettydiff/src/basic.rs
new file mode 100644
index 000000000..d35392a7b
--- /dev/null
+++ b/vendor/prettydiff/src/basic.rs
@@ -0,0 +1,169 @@
+//! Basic diff functions
+use crate::lcs;
+use ansi_term::Colour;
+use std::fmt;
+
+/// Single change in original slice needed to get new slice
+#[derive(Debug, PartialEq, Eq)]
+pub enum DiffOp<'a, T: 'a> {
+    /// Appears only in second slice
+    Insert(&'a [T]),
+    /// Appears in both slices, but changed
+    Replace(&'a [T], &'a [T]),
+    /// Appears only in first slice
+    Remove(&'a [T]),
+    /// Appears on both slices
+    Equal(&'a [T]),
+}
+
+/// Diffs any slices which implements PartialEq
+pub fn diff<'a, T: PartialEq>(x: &'a [T], y: &'a [T]) -> Vec<DiffOp<'a, T>> {
+    let mut ops: Vec<DiffOp<T>> = Vec::new();
+    let table = lcs::Table::new(x, y);
+
+    let mut i = 0;
+    let mut j = 0;
+
+    for m in table.matches_zero() {
+        let x_seq = &x[i..m.x];
+        let y_seq = &y[j..m.y];
+
+        if i < m.x && j < m.y {
+            ops.push(DiffOp::Replace(x_seq, y_seq));
+        } else if i < m.x {
+            ops.push(DiffOp::Remove(x_seq));
+        } else if j < m.y {
+            ops.push(DiffOp::Insert(y_seq));
+        }
+
+        i = m.x + m.len;
+        j = m.y + m.len;
+
+        if m.len > 0 {
+            ops.push(DiffOp::Equal(&x[m.x..i]));
+        }
+    }
+    ops
+}
+
+/// Container for slice diff result.  Can be pretty-printed by Display trait.
+#[derive(Debug, PartialEq, Eq)]
+pub struct SliceChangeset<'a, T> {
+    pub diff: Vec<DiffOp<'a, T>>,
+}
+
+impl<'a, T: fmt::Display> SliceChangeset<'a, T> {
+    pub fn format(&self, skip_same: bool) -> String {
+        let mut out: Vec<String> = Vec::with_capacity(self.diff.len());
+        for op in &self.diff {
+            match op {
+                DiffOp::Equal(a) => {
+                    if !skip_same || a.len() == 1 {
+                        for i in a.iter() {
+                            out.push(format!("    {}", i))
+                        }
+                    } else if a.len() > 1 {
+                        out.push(format!("    ... skip({}) ...", a.len()));
+                    }
+                }
+
+                DiffOp::Insert(a) => {
+                    for i in a.iter() {
+                        out.push(Colour::Green.paint(format!("+   {}", i)).to_string());
+                    }
+                }
+
+                DiffOp::Remove(a) => {
+                    for i in a.iter() {
+                        out.push(Colour::Red.paint(format!("-   {}", i)).to_string());
+                    }
+                }
+                DiffOp::Replace(a, b) => {
+                    let min_len = std::cmp::min(a.len(), b.len());
+                    let max_len = std::cmp::max(a.len(), b.len());
+
+                    for i in 0..min_len {
+                        out.push(
+                            Colour::Yellow
+                                .paint(format!("~   {} -> {}", a[i], b[i]))
+                                .to_string(),
+                        );
+                    }
+                    for i in min_len..max_len {
+                        if max_len == a.len() {
+                            out.push(Colour::Red.paint(format!("-   {}", a[i])).to_string());
+                        } else {
+                            out.push(Colour::Green.paint(format!("+   {}", b[i])).to_string());
+                        }
+                    }
+                }
+            }
+        }
+        format!("[\n{}\n]", out.join(",\n"))
+    }
+}
+
+impl<'a, T: fmt::Display> fmt::Display for SliceChangeset<'a, T> {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "{}", self.format(true))
+    }
+}
+
+/// Diff two arbitary slices with elements that support Display trait
+pub fn diff_slice<'a, T: PartialEq + std::fmt::Display>(
+    x: &'a [T],
+    y: &'a [T],
+) -> SliceChangeset<'a, T> {
+    let diff = diff(x, y);
+    SliceChangeset { diff }
+}
+
+#[test]
+fn test_basic() {
+    assert_eq!(
+        diff(&[1, 2, 3, 4, 5, 6], &[2, 3, 5, 7]),
+        vec![
+            DiffOp::Remove(&[1]),
+            DiffOp::Equal(&[2, 3]),
+            DiffOp::Remove(&[4]),
+            DiffOp::Equal(&[5]),
+            DiffOp::Replace(&[6], &[7]),
+        ]
+    );
+
+    assert_eq!(
+        diff_slice(
+            &["q", "a", "b", "x", "c", "d"],
+            &["a", "b", "y", "c", "d", "f"],
+        )
+        .diff,
+        vec![
+            DiffOp::Remove(&["q"]),
+            DiffOp::Equal(&["a", "b"]),
+            DiffOp::Replace(&["x"], &["y"]),
+            DiffOp::Equal(&["c", "d"]),
+            DiffOp::Insert(&["f"]),
+        ]
+    );
+
+    assert_eq!(
+        diff(&["a", "c", "d", "b"], &["a", "e", "b"]),
+        vec![
+            DiffOp::Equal(&["a"]),
+            DiffOp::Replace(&["c", "d"], &["e"]),
+            DiffOp::Equal(&["b"]),
+        ]
+    );
+    println!("Diff: {}", diff_slice(&[1, 2, 3, 4, 5, 6], &[2, 3, 5, 7]));
+    println!(
+        "Diff: {}",
+        diff_slice(
+            &["q", "a", "b", "x", "c", "d"],
+            &["a", "b", "y", "c", "d", "f"]
+        )
+    );
+    println!(
+        "Diff: {}",
+        diff_slice(&["a", "c", "d", "b"], &["a", "e", "b"])
+    );
+}
diff --git a/vendor/prettydiff/src/format_table.rs b/vendor/prettydiff/src/format_table.rs
new file mode 100644
index 000000000..7293faefd
--- /dev/null
+++ b/vendor/prettydiff/src/format_table.rs
@@ -0,0 +1,38 @@
+//! Setup unicode-formatted table for prettytable
+//!
+//! TODO: Move to separate crate
+
+use prettytable::format;
+use prettytable::Table;
+
+fn format_table(table: &mut Table) {
+    table.set_format(
+        format::FormatBuilder::new()
+            .column_separator('│')
+            .borders('│')
+            .separators(
+                &[format::LinePosition::Top],
+                format::LineSeparator::new('─', '┬', '┌', '┐'),
+            )
+            .separators(
+                &[format::LinePosition::Title],
+                format::LineSeparator::new('─', '┼', '├', '┤'),
+            )
+            .separators(
+                &[format::LinePosition::Intern],
+                format::LineSeparator::new('─', '┼', '├', '┤'),
+            )
+            .separators(
+                &[format::LinePosition::Bottom],
+                format::LineSeparator::new('─', '┴', '└', '┘'),
+            )
+            .padding(1, 1)
+            .build(),
+    );
+}
+/// Returns Table with unicode formatter
+pub fn new() -> Table {
+    let mut table = Table::new();
+    format_table(&mut table);
+    table
+}
diff --git a/vendor/prettydiff/src/lcs.rs b/vendor/prettydiff/src/lcs.rs
new file mode 100644
index 000000000..fc57edc77
--- /dev/null
+++ b/vendor/prettydiff/src/lcs.rs
@@ -0,0 +1,227 @@
+//! Common functions for [Longest common subsequences](https://en.wikipedia.org/wiki/Longest_common_subsequence_problem)
+//! on slice.
+
+cfg_prettytable! {
+    use crate::format_table;
+    use prettytable::{Cell, Row};
+}
+use std::cmp::max;
+
+#[derive(Debug)]
+pub struct Table<'a, T: 'a> {
+    x: &'a [T],
+    y: &'a [T],
+    table: Vec<Vec<usize>>,
+}
+
+/// Implements Longest Common Subsequences Table
+/// Memory requirement: O(N^2)
+///
+/// Based on [Wikipedia article](https://en.wikipedia.org/wiki/Longest_common_subsequence_problem)
+impl<'a, T> Table<'a, T>
+where
+    T: PartialEq,
+{
+    /// Creates new table for search common subsequences in x and y
+    pub fn new(x: &'a [T], y: &'a [T]) -> Table<'a, T> {
+        let x_len = x.len() + 1;
+        let y_len = y.len() + 1;
+        let mut table = vec![vec![0; y_len]; x_len];
+
+        for i in 1..x_len {
+            for j in 1..y_len {
+                table[i][j] = if x[i - 1] == y[j - 1] {
+                    table[i - 1][j - 1] + 1
+                } else {
+                    max(table[i][j - 1], table[i - 1][j])
+                };
+            }
+        }
+
+        Table { x, y, table }
+    }
+
+    fn seq_iter(&self) -> TableIter<T> {
+        TableIter {
+            x: self.x.len(),
+            y: self.y.len(),
+            table: self,
+        }
+    }
+    fn get_match(&self, x: usize, y: usize, len: usize) -> Match<T> {
+        Match {
+            x,
+            y,
+            len,
+            table: self,
+        }
+    }
+
+    /// Returns matches between X and Y
+    pub fn matches(&self) -> Vec<Match<T>> {
+        let mut matches: Vec<Match<T>> = Vec::new();
+        for (x, y) in self.seq_iter() {
+            if let Some(last) = matches.last_mut() {
+                if last.x == x + 1 && last.y == y + 1 {
+                    last.x = x;
+                    last.y = y;
+                    last.len += 1;
+                    continue;
+                }
+            }
+            matches.push(self.get_match(x, y, 1));
+        }
+        matches.reverse();
+        matches
+    }
+
+    /// Returns matches between X and Y with zero-len match at the end
+    pub fn matches_zero(&self) -> Vec<Match<T>> {
+        let mut matches = self.matches();
+        matches.push(self.get_match(self.x.len(), self.y.len(), 0));
+        matches
+    }
+
+    /// Find longest sequence
+    pub fn longest_seq(&self) -> Vec<&T> {
+        self.matches();
+        let mut common: Vec<_> = self.seq_iter().map(|(x, _y)| &self.x[x]).collect();
+        common.reverse();
+        common
+    }
+}
+
+#[cfg(feature = "prettytable-rs")]
+/// Prints pretty-table for LCS
+impl<'a, T> std::fmt::Display for Table<'a, T>
+where
+    T: std::fmt::Display,
+{
+    fn fmt(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        let mut table = format_table::new();
+        let mut header = vec!["".to_string(), "Ø".to_string()];
+        for i in self.x {
+            header.push(format!("{}", i));
+        }
+
+        table.set_titles(Row::new(
+            header.into_iter().map(|i| Cell::new(&i)).collect(),
+        ));
+        for j in 0..=self.y.len() {
+            let mut row = vec![if j == 0 {
+                "Ø".to_string()
+            } else {
+                format!("{}", self.y[j - 1])
+            }];
+            for i in 0..=self.x.len() {
+                row.push(format!("{}", self.table[i][j]));
+            }
+            table.add_row(row.into_iter().map(|i| Cell::new(&i)).collect());
+        }
+        write!(formatter, "\n{}", table)
+    }
+}
+
+struct TableIter<'a, T: 'a> {
+    x: usize,
+    y: usize,
+    table: &'a Table<'a, T>,
+}
+
+impl<'a, T> Iterator for TableIter<'a, T> {
+    type Item = (usize, usize);
+    fn next(&mut self) -> Option<Self::Item> {
+        let table = &self.table.table;
+
+        while self.x != 0 && self.y != 0 {
+            let cur = table[self.x][self.y];
+
+            if cur == table[self.x - 1][self.y] {
+                self.x -= 1;
+                continue;
+            }
+            self.y -= 1;
+            if cur == table[self.x][self.y] {
+                continue;
+            }
+            self.x -= 1;
+            return Some((self.x, self.y));
+        }
+        None
+    }
+}
+
+pub struct Match<'a, T: 'a> {
+    pub x: usize,
+    pub y: usize,
+    pub len: usize,
+    table: &'a Table<'a, T>,
+}
+
+impl<'a, T> Match<'a, T> {
+    /// Returns matched sequence
+    pub fn seq(&self) -> &[T] {
+        &self.table.x[self.x..(self.x + self.len)]
+    }
+}
+
+#[test]
+fn test_table() {
+    let x = vec!["A", "G", "C", "A", "T"];
+    let y = vec!["G", "A", "C"];
+
+    let table = Table::new(&x, &y);
+    assert_eq!(
+        format!("{}", table),
+        r#"
+┌───┬───┬───┬───┬───┬───┬───┐
+│   │ Ø │ A │ G │ C │ A │ T │
+├───┼───┼───┼───┼───┼───┼───┤
+│ Ø │ 0 │ 0 │ 0 │ 0 │ 0 │ 0 │
+├───┼───┼───┼───┼───┼───┼───┤
+│ G │ 0 │ 0 │ 1 │ 1 │ 1 │ 1 │
+├───┼───┼───┼───┼───┼───┼───┤
+│ A │ 0 │ 1 │ 1 │ 1 │ 2 │ 2 │
+├───┼───┼───┼───┼───┼───┼───┤
+│ C │ 0 │ 1 │ 1 │ 2 │ 2 │ 2 │
+└───┴───┴───┴───┴───┴───┴───┘
+"#
+    );
+    assert_eq!(table.longest_seq(), vec![&"A", &"C"]);
+}
+
+#[test]
+
+fn test_table_match() {
+    let test_v = vec![
+        (
+            "The quick brown fox jumps over the lazy dog",
+            "The quick brown dog leaps over the lazy cat",
+            "The quick brown o ps over the lazy ",
+            vec!["The quick brown ", "o", " ", "ps over the lazy "],
+        ),
+        ("ab:c", "ba:b:c", "ab:c", vec!["a", "b:c"]),
+        (
+            "The red brown fox jumped over the rolling log",
+            "The brown spotted fox leaped over the rolling log",
+            "The brown fox ped over the rolling log",
+            vec!["The ", "brown ", "fox ", "ped over the rolling log"],
+        ),
+    ];
+    for (x_str, y_str, exp_str, match_exp) in test_v {
+        let x: Vec<_> = x_str.split("").collect();
+        let y: Vec<_> = y_str.split("").collect();
+
+        // Trim empty elements
+        let table = Table::new(&x[1..(x.len() - 1)], &y[1..(y.len() - 1)]);
+        let seq = table
+            .longest_seq()
+            .iter()
+            .map(|i| i.to_string())
+            .collect::<Vec<String>>()
+            .join("");
+        assert_eq!(seq, exp_str);
+        let matches: Vec<_> = table.matches().iter().map(|m| m.seq().join("")).collect();
+        assert_eq!(matches, match_exp);
+    }
+}
diff --git a/vendor/prettydiff/src/lib.rs b/vendor/prettydiff/src/lib.rs
new file mode 100644
index 000000000..ff9dae6ce
--- /dev/null
+++ b/vendor/prettydiff/src/lib.rs
@@ -0,0 +1,20 @@
+macro_rules! cfg_prettytable {( $($item:item)* ) => (
+    $(
+        #[cfg(feature = "prettytable-rs")]
+        $item
+    )*
+)}
+
+#[cfg(feature = "prettytable-rs")]
+#[macro_use]
+extern crate prettytable;
+
+pub mod basic;
+cfg_prettytable! {
+    pub mod format_table;
+}
+pub mod lcs;
+pub mod text;
+
+pub use crate::basic::diff_slice;
+pub use crate::text::{diff_chars, diff_lines, diff_words};
diff --git a/vendor/prettydiff/src/main.rs b/vendor/prettydiff/src/main.rs
new file mode 100644
index 000000000..9b6a59bbd
--- /dev/null
+++ b/vendor/prettydiff/src/main.rs
@@ -0,0 +1,51 @@
+use std::fs::File;
+use std::io::prelude::*;
+use std::path::PathBuf;
+use structopt::StructOpt;
+
+/// Side-by-side diff for two files
+#[derive(StructOpt, Debug)]
+#[structopt(name = "prettydiff")]
+struct Opt {
+    /// Left file
+    #[structopt(name = "LEFT", parse(from_os_str))]
+    left: PathBuf,
+    /// Right file
+    #[structopt(name = "RIGHT", parse(from_os_str))]
+    right: PathBuf,
+    /// Don't show lines numbers
+    #[structopt(long = "disable_lines")]
+    disable_lines: bool,
+    /// Show non-changed blocks
+    #[structopt(long = "show_same")]
+    show_same: bool,
+    /// Align new lines inside change block
+    #[structopt(long = "disable_align")]
+    disable_align: bool,
+}
+
+fn read_file(path: &PathBuf) -> std::io::Result<String> {
+    let mut file = File::open(path)?;
+    let mut contents = String::new();
+    file.read_to_string(&mut contents)?;
+    Ok(contents)
+}
+
+fn main() -> std::io::Result<()> {
+    let opt = Opt::from_args();
+
+    let left_data = read_file(&opt.left)?;
+    let left_name = opt.left.into_os_string().into_string().unwrap();
+
+    let right_data = read_file(&opt.right)?;
+    let right_name = opt.right.into_os_string().into_string().unwrap();
+
+    prettydiff::diff_lines(&left_data, &right_data)
+        .names(&left_name, &right_name)
+        .set_show_lines(!opt.disable_lines)
+        .set_diff_only(!opt.show_same)
+        .set_align_new_lines(!opt.disable_align)
+        .prettytable();
+
+    Ok(())
+}
diff --git a/vendor/prettydiff/src/text.rs b/vendor/prettydiff/src/text.rs
new file mode 100644
index 000000000..0d5fc03c3
--- /dev/null
+++ b/vendor/prettydiff/src/text.rs
@@ -0,0 +1,877 @@
+//! Utils for diff text
+pub use ansi_term::Style;
+
+use crate::basic;
+cfg_prettytable! {
+    use crate::format_table;
+    use prettytable::{Cell, Row};
+}
+use ansi_term::Colour;
+use pad::{Alignment, PadStr};
+use std::{
+    cmp::{max, min},
+    fmt,
+};
+
+pub struct StringSplitIter<'a, F>
+where
+    F: Fn(char) -> bool,
+{
+    last: usize,
+    text: &'a str,
+    matched: Option<&'a str>,
+    iter: std::str::MatchIndices<'a, F>,
+}
+
+impl<'a, F> Iterator for StringSplitIter<'a, F>
+where
+    F: Fn(char) -> bool,
+{
+    type Item = &'a str;
+    fn next(&mut self) -> Option<Self::Item> {
+        if let Some(m) = self.matched {
+            self.matched = None;
+            Some(m)
+        } else if let Some((idx, matched)) = self.iter.next() {
+            let res = if self.last != idx {
+                self.matched = Some(matched);
+                &self.text[self.last..idx]
+            } else {
+                matched
+            };
+            self.last = idx + matched.len();
+            Some(res)
+        } else if self.last < self.text.len() {
+            let res = &self.text[self.last..];
+            self.last = self.text.len();
+            Some(res)
+        } else {
+            None
+        }
+    }
+}
+
+pub fn collect_strings<T: ToString>(it: impl Iterator<Item = T>) -> Vec<String> {
+    it.map(|s| s.to_string()).collect::<Vec<String>>()
+}
+
+/// Split string by clousure (Fn(char)->bool) keeping delemiters
+pub fn split_by_char_fn<F>(text: &'_ str, pat: F) -> StringSplitIter<'_, F>
+where
+    F: Fn(char) -> bool,
+{
+    StringSplitIter {
+        last: 0,
+        text,
+        matched: None,
+        iter: text.match_indices(pat),
+    }
+}
+
+/// Split string by non-alphanumeric characters keeping delemiters
+pub fn split_words(text: &str) -> impl Iterator<Item = &str> {
+    split_by_char_fn(text, |c: char| !c.is_alphanumeric())
+}
+
+/// Container for inline text diff result. Can be pretty-printed by Display trait.
+#[derive(Debug, PartialEq)]
+pub struct InlineChangeset<'a> {
+    old: Vec<&'a str>,
+    new: Vec<&'a str>,
+    separator: &'a str,
+    highlight_whitespace: bool,
+    insert_style: Style,
+    insert_whitespace_style: Style,
+    remove_style: Style,
+    remove_whitespace_style: Style,
+}
+
+impl<'a> InlineChangeset<'a> {
+    pub fn new(old: Vec<&'a str>, new: Vec<&'a str>) -> InlineChangeset<'a> {
+        InlineChangeset {
+            old,
+            new,
+            separator: "",
+            highlight_whitespace: true,
+            insert_style: Colour::Green.normal(),
+            insert_whitespace_style: Colour::White.on(Colour::Green),
+            remove_style: Colour::Red.strikethrough(),
+            remove_whitespace_style: Colour::White.on(Colour::Red),
+        }
+    }
+    /// Highlight whitespaces in case of insert/remove?
+    pub fn set_highlight_whitespace(mut self, val: bool) -> Self {
+        self.highlight_whitespace = val;
+        self
+    }
+
+    /// Style of inserted text
+    pub fn set_insert_style(mut self, val: Style) -> Self {
+        self.insert_style = val;
+        self
+    }
+
+    /// Style of inserted whitespace
+    pub fn set_insert_whitespace_style(mut self, val: Style) -> Self {
+        self.insert_whitespace_style = val;
+        self
+    }
+
+    /// Style of removed text
+    pub fn set_remove_style(mut self, val: Style) -> Self {
+        self.remove_style = val;
+        self
+    }
+
+    /// Style of removed whitespace
+    pub fn set_remove_whitespace_style(mut self, val: Style) -> Self {
+        self.remove_whitespace_style = val;
+        self
+    }
+
+    /// Set output separator
+    pub fn set_separator(mut self, val: &'a str) -> Self {
+        self.separator = val;
+        self
+    }
+
+    /// Returns Vec of changes
+    pub fn diff(&self) -> Vec<basic::DiffOp<'a, &str>> {
+        basic::diff(&self.old, &self.new)
+    }
+
+    fn apply_style(&self, style: Style, whitespace_style: Style, a: &[&str]) -> String {
+        let s = a.join(self.separator);
+        if self.highlight_whitespace {
+            collect_strings(split_by_char_fn(&s, |c| c.is_whitespace()).map(|s| {
+                let style = if s
+                    .chars()
+                    .next()
+                    .map_or_else(|| false, |c| c.is_whitespace())
+                {
+                    whitespace_style
+                } else {
+                    style
+                };
+                style.paint(s)
+            }))
+            .join("")
+        } else {
+            style.paint(s).to_string()
+        }
+    }
+
+    fn remove_color(&self, a: &[&str]) -> String {
+        self.apply_style(self.remove_style, self.remove_whitespace_style, a)
+    }
+
+    fn insert_color(&self, a: &[&str]) -> String {
+        self.apply_style(self.insert_style, self.insert_whitespace_style, a)
+    }
+    /// Returns formatted string with colors
+    pub fn format(&self) -> String {
+        let diff = self.diff();
+        let mut out: Vec<String> = Vec::with_capacity(diff.len());
+        for op in diff {
+            match op {
+                basic::DiffOp::Equal(a) => out.push(a.join(self.separator)),
+                basic::DiffOp::Insert(a) => out.push(self.insert_color(a)),
+                basic::DiffOp::Remove(a) => out.push(self.remove_color(a)),
+                basic::DiffOp::Replace(a, b) => {
+                    out.push(self.remove_color(a));
+                    out.push(self.insert_color(b));
+                }
+            }
+        }
+        out.join(self.separator)
+    }
+}
+
+impl<'a> fmt::Display for InlineChangeset<'a> {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "{}", self.format())
+    }
+}
+
+pub fn diff_chars<'a>(old: &'a str, new: &'a str) -> InlineChangeset<'a> {
+    let old: Vec<&str> = old.split("").filter(|&i| i != "").collect();
+    let new: Vec<&str> = new.split("").filter(|&i| i != "").collect();
+
+    InlineChangeset::new(old, new)
+}
+
+/// Diff two strings by words (contiguous)
+pub fn diff_words<'a>(old: &'a str, new: &'a str) -> InlineChangeset<'a> {
+    InlineChangeset::new(split_words(old).collect(), split_words(new).collect())
+}
+
+#[cfg(feature = "prettytable-rs")]
+fn color_multilines(color: Colour, s: &str) -> String {
+    collect_strings(s.split('\n').map(|i| color.paint(i))).join("\n")
+}
+
+#[derive(Debug)]
+pub struct ContextConfig<'a> {
+    pub context_size: usize,
+    pub skipping_marker: &'a str,
+}
+
+/// Container for line-by-line text diff result. Can be pretty-printed by Display trait.
+#[derive(Debug, PartialEq, Eq)]
+pub struct LineChangeset<'a> {
+    old: Vec<&'a str>,
+    new: Vec<&'a str>,
+
+    names: Option<(&'a str, &'a str)>,
+    diff_only: bool,
+    show_lines: bool,
+    trim_new_lines: bool,
+    aling_new_lines: bool,
+}
+
+impl<'a> LineChangeset<'a> {
+    pub fn new(old: Vec<&'a str>, new: Vec<&'a str>) -> LineChangeset<'a> {
+        LineChangeset {
+            old,
+            new,
+            names: None,
+            diff_only: false,
+            show_lines: true,
+            trim_new_lines: true,
+            aling_new_lines: false,
+        }
+    }
+
+    /// Sets names for side-by-side diff
+    pub fn names(mut self, old: &'a str, new: &'a str) -> Self {
+        self.names = Some((old, new));
+        self
+    }
+    /// Show only differences for side-by-side diff
+    pub fn set_diff_only(mut self, val: bool) -> Self {
+        self.diff_only = val;
+        self
+    }
+    /// Show lines in side-by-side diff
+    pub fn set_show_lines(mut self, val: bool) -> Self {
+        self.show_lines = val;
+        self
+    }
+    /// Trim new lines in side-by-side diff
+    pub fn set_trim_new_lines(mut self, val: bool) -> Self {
+        self.trim_new_lines = val;
+        self
+    }
+    /// Align new lines inside diff
+    pub fn set_align_new_lines(mut self, val: bool) -> Self {
+        self.aling_new_lines = val;
+        self
+    }
+    /// Returns Vec of changes
+    pub fn diff(&self) -> Vec<basic::DiffOp<'a, &str>> {
+        basic::diff(&self.old, &self.new)
+    }
+
+    #[cfg(feature = "prettytable-rs")]
+    fn prettytable_process(&self, a: &[&str], color: Option<Colour>) -> (String, usize) {
+        let mut start = 0;
+        let mut stop = a.len();
+        if self.trim_new_lines {
+            for (index, element) in a.iter().enumerate() {
+                if *element != "" {
+                    break;
+                }
+                start = index + 1;
+            }
+            for (index, element) in a.iter().enumerate().rev() {
+                if *element != "" {
+                    stop = index + 1;
+                    break;
+                }
+            }
+        }
+        let out = &a[start..stop];
+        if let Some(color) = color {
+            (
+                collect_strings(out.iter().map(|i| color.paint(*i).to_string()))
+                    .join("\n")
+                    .replace("\t", "    "),
+                start,
+            )
+        } else {
+            (out.join("\n").replace("\t", "    "), start)
+        }
+    }
+
+    #[cfg(feature = "prettytable-rs")]
+    fn prettytable_process_replace(
+        &self,
+        old: &[&str],
+        new: &[&str],
+    ) -> ((String, String), (usize, usize)) {
+        let (old, old_offset) = self.prettytable_process(old, None);
+        let (new, new_offset) = self.prettytable_process(new, None);
+
+        let mut old_out = String::new();
+        let mut new_out = String::new();
+
+        for op in diff_words(&old, &new).diff() {
+            match op {
+                basic::DiffOp::Equal(a) => {
+                    old_out.push_str(&a.join(""));
+                    new_out.push_str(&a.join(""));
+                }
+                basic::DiffOp::Insert(a) => {
+                    new_out.push_str(&color_multilines(Colour::Green, &a.join("")));
+                }
+                basic::DiffOp::Remove(a) => {
+                    old_out.push_str(&color_multilines(Colour::Red, &a.join("")));
+                }
+                basic::DiffOp::Replace(a, b) => {
+                    old_out.push_str(&color_multilines(Colour::Red, &a.join("")));
+                    new_out.push_str(&color_multilines(Colour::Green, &b.join("")));
+                }
+            }
+        }
+
+        ((old_out, new_out), (old_offset, new_offset))
+    }
+
+    #[cfg(feature = "prettytable-rs")]
+    /// Prints side-by-side diff in table
+    pub fn prettytable(&self) {
+        let mut table = format_table::new();
+        if let Some((old, new)) = &self.names {
+            let mut header = vec![];
+            if self.show_lines {
+                header.push(Cell::new(""));
+            }
+            header.push(Cell::new(&Colour::Cyan.paint(old.to_string()).to_string()));
+            if self.show_lines {
+                header.push(Cell::new(""));
+            }
+            header.push(Cell::new(&Colour::Cyan.paint(new.to_string()).to_string()));
+            table.set_titles(Row::new(header));
+        }
+        let mut old_lines = 1;
+        let mut new_lines = 1;
+        let mut out: Vec<(usize, String, usize, String)> = Vec::new();
+        for op in &self.diff() {
+            match op {
+                basic::DiffOp::Equal(a) => {
+                    let (old, offset) = self.prettytable_process(a, None);
+                    if !self.diff_only {
+                        out.push((old_lines + offset, old.clone(), new_lines + offset, old));
+                    }
+                    old_lines += a.len();
+                    new_lines += a.len();
+                }
+                basic::DiffOp::Insert(a) => {
+                    let (new, offset) = self.prettytable_process(a, Some(Colour::Green));
+                    out.push((old_lines, "".to_string(), new_lines + offset, new));
+                    new_lines += a.len();
+                }
+                basic::DiffOp::Remove(a) => {
+                    let (old, offset) = self.prettytable_process(a, Some(Colour::Red));
+                    out.push((old_lines + offset, old, new_lines, "".to_string()));
+                    old_lines += a.len();
+                }
+                basic::DiffOp::Replace(a, b) => {
+                    let ((old, new), (old_offset, new_offset)) =
+                        self.prettytable_process_replace(a, b);
+                    out.push((old_lines + old_offset, old, new_lines + new_offset, new));
+                    old_lines += a.len();
+                    new_lines += b.len();
+                }
+            };
+        }
+        for (old_lines, old, new_lines, new) in out {
+            if self.trim_new_lines && old.trim() == "" && new.trim() == "" {
+                continue;
+            }
+            if self.show_lines {
+                table.add_row(row![old_lines, old, new_lines, new]);
+            } else {
+                table.add_row(row![old, new]);
+            }
+        }
+        table.printstd();
+    }
+
+    fn remove_color(&self, a: &str) -> String {
+        Colour::Red.strikethrough().paint(a).to_string()
+    }
+
+    fn insert_color(&self, a: &str) -> String {
+        Colour::Green.paint(a).to_string()
+    }
+
+    /// Returns formatted string with colors
+    pub fn format(&self) -> String {
+        self.format_with_context(None, false)
+    }
+
+    /// Formats lines in DiffOp::Equal
+    fn format_equal(
+        &self,
+        lines: &[&str],
+        display_line_numbers: bool,
+        prefix_size: usize,
+        line_counter: &mut usize,
+    ) -> Option<String> {
+        lines
+            .iter()
+            .map(|line| {
+                let res = if display_line_numbers {
+                    format!("{} ", *line_counter)
+                        .pad_to_width_with_alignment(prefix_size, Alignment::Right)
+                        + line
+                } else {
+                    "".pad_to_width(prefix_size) + line
+                };
+                *line_counter += 1;
+                res
+            })
+            .reduce(|acc, line| acc + "\n" + &line)
+    }
+
+    /// Formats lines in DiffOp::Remove
+    fn format_remove(
+        &self,
+        lines: &[&str],
+        display_line_numbers: bool,
+        prefix_size: usize,
+        line_counter: &mut usize,
+    ) -> String {
+        lines
+            .iter()
+            .map(|line| {
+                let res = if display_line_numbers {
+                    format!("{} ", *line_counter)
+                        .pad_to_width_with_alignment(prefix_size, Alignment::Right)
+                        + &self.remove_color(line)
+                } else {
+                    "".pad_to_width(prefix_size) + &self.remove_color(line)
+                };
+                *line_counter += 1;
+                res
+            })
+            .reduce(|acc, line| acc + "\n" + &line)
+            .unwrap()
+    }
+
+    /// Formats lines in DiffOp::Insert
+    fn format_insert(&self, lines: &[&str], prefix_size: usize) -> String {
+        lines
+            .iter()
+            .map(|line| "".pad_to_width(prefix_size) + &self.insert_color(line))
+            .reduce(|acc, line| acc + "\n" + &line)
+            .unwrap()
+    }
+
+    /// Returns formatted string with colors.
+    /// May omit identical lines, if `context_size` is `Some(k)`.
+    /// In this case, only print identical lines if they are within `k` lines
+    /// of a changed line (as in `diff -C`).
+    pub fn format_with_context(
+        &self,
+        context_config: Option<ContextConfig>,
+        display_line_numbers: bool,
+    ) -> String {
+        let line_number_size = if display_line_numbers {
+            (self.old.len() as f64).log10().ceil() as usize
+        } else {
+            0
+        };
+        let skipping_marker_size = if let Some(ContextConfig {
+            skipping_marker, ..
+        }) = context_config
+        {
+            skipping_marker.len()
+        } else {
+            0
+        };
+        let prefix_size = max(line_number_size, skipping_marker_size) + 1;
+
+        let mut next_line = 1;
+
+        let mut diff = self.diff().into_iter().peekable();
+        let mut out: Vec<String> = Vec::with_capacity(diff.len());
+        let mut at_beginning = true;
+        while let Some(op) = diff.next() {
+            match op {
+                basic::DiffOp::Equal(a) => match context_config {
+                    None => out.push(a.join("\n")),
+                    Some(ContextConfig {
+                        context_size,
+                        skipping_marker,
+                    }) => {
+                        let mut lines = a;
+                        if !at_beginning {
+                            let upper_bound = min(context_size, lines.len());
+                            if let Some(newlines) = self.format_equal(
+                                &lines[..upper_bound],
+                                display_line_numbers,
+                                prefix_size,
+                                &mut next_line,
+                            ) {
+                                out.push(newlines)
+                            }
+                            lines = &lines[upper_bound..];
+                        }
+                        if lines.len() == 0 {
+                            continue;
+                        }
+                        let lower_bound = if lines.len() > context_size {
+                            lines.len() - context_size
+                        } else {
+                            0
+                        };
+                        if lower_bound > 0 {
+                            out.push(skipping_marker.to_string());
+                            next_line += lower_bound
+                        }
+                        if diff.peek().is_none() {
+                            continue;
+                        }
+                        if let Some(newlines) = self.format_equal(
+                            &lines[lower_bound..],
+                            display_line_numbers,
+                            prefix_size,
+                            &mut next_line,
+                        ) {
+                            out.push(newlines)
+                        }
+                    }
+                },
+                basic::DiffOp::Insert(a) => out.push(self.format_insert(a, prefix_size)),
+                basic::DiffOp::Remove(a) => out.push(self.format_remove(
+                    a,
+                    display_line_numbers,
+                    prefix_size,
+                    &mut next_line,
+                )),
+                basic::DiffOp::Replace(a, b) => {
+                    out.push(self.format_remove(
+                        a,
+                        display_line_numbers,
+                        prefix_size,
+                        &mut next_line,
+                    ));
+                    out.push(self.format_insert(b, prefix_size));
+                }
+            }
+            at_beginning = false;
+        }
+        out.join("\n")
+    }
+}
+
+impl<'a> fmt::Display for LineChangeset<'a> {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "{}", self.format())
+    }
+}
+
+pub fn diff_lines<'a>(old: &'a str, new: &'a str) -> LineChangeset<'a> {
+    let old: Vec<&str> = old.lines().collect();
+    let new: Vec<&str> = new.lines().collect();
+
+    LineChangeset::new(old, new)
+}
+
+fn _test_splitter_basic(text: &str, exp: &[&str]) {
+    let res = collect_strings(
+        split_by_char_fn(&text, |c: char| c.is_whitespace()).map(|s| s.to_string()),
+    );
+    assert_eq!(res, exp)
+}
+
+#[test]
+fn test_splitter() {
+    _test_splitter_basic(
+        "  blah test2 test3  ",
+        &[" ", " ", "blah", " ", "test2", " ", "test3", " ", " "],
+    );
+    _test_splitter_basic(
+        "\tblah test2 test3  ",
+        &["\t", "blah", " ", "test2", " ", "test3", " ", " "],
+    );
+    _test_splitter_basic(
+        "\tblah test2 test3  t",
+        &["\t", "blah", " ", "test2", " ", "test3", " ", " ", "t"],
+    );
+    _test_splitter_basic(
+        "\tblah test2 test3  tt",
+        &["\t", "blah", " ", "test2", " ", "test3", " ", " ", "tt"],
+    );
+}
+
+#[test]
+fn test_basic() {
+    println!("diff_chars: {}", diff_chars("abefcd", "zadqwc"));
+    println!(
+        "diff_chars: {}",
+        diff_chars(
+            "The quick brown fox jumps over the lazy dog",
+            "The quick brown dog leaps over the lazy cat"
+        )
+    );
+    println!(
+        "diff_chars: {}",
+        diff_chars(
+            "The red brown fox jumped over the rolling log",
+            "The brown spotted fox leaped over the rolling log"
+        )
+    );
+    println!(
+        "diff_chars: {}",
+        diff_chars(
+            "The red    brown fox jumped over the rolling log",
+            "The brown spotted fox leaped over the rolling log"
+        )
+        .set_highlight_whitespace(true)
+    );
+    println!(
+        "diff_words: {}",
+        diff_words(
+            "The red brown fox jumped over the rolling log",
+            "The brown spotted fox leaped over the rolling log"
+        )
+    );
+    println!(
+        "diff_words: {}",
+        diff_words(
+            "The quick brown fox jumps over the lazy dog",
+            "The quick, brown dog leaps over the lazy cat"
+        )
+    );
+}
+
+#[test]
+fn test_split_words() {
+    assert_eq!(
+        collect_strings(split_words("Hello World")),
+        ["Hello", " ", "World"]
+    );
+    assert_eq!(
+        collect_strings(split_words("Hello😋World")),
+        ["Hello", "😋", "World"]
+    );
+    assert_eq!(
+        collect_strings(split_words(
+            "The red brown fox\tjumped, over the rolling log"
+        )),
+        [
+            "The", " ", "red", " ", "brown", " ", "fox", "\t", "jumped", ",", " ", "over", " ",
+            "the", " ", "rolling", " ", "log"
+        ]
+    );
+}
+
+#[test]
+fn test_diff_lines() {
+    let code1_a = r#"
+void func1() {
+    x += 1
+}
+
+void func2() {
+    x += 2
+}
+    "#;
+    let code1_b = r#"
+void func1(a: u32) {
+    x += 1
+}
+
+void functhreehalves() {
+    x += 1.5
+}
+
+void func2() {
+    x += 2
+}
+
+void func3(){}
+"#;
+    println!("diff_lines:");
+    println!("{}", diff_lines(code1_a, code1_b));
+    println!("====");
+    diff_lines(code1_a, code1_b)
+        .names("left", "right")
+        .set_align_new_lines(true)
+        .prettytable();
+}
+
+fn _test_colors(changeset: &InlineChangeset, exp: &[(Option<Style>, &str)]) {
+    let color_s: String = collect_strings(exp.iter().map(|(style_opt, s)| {
+        if let Some(style) = style_opt {
+            style.paint(s.to_string()).to_string()
+        } else {
+            s.to_string()
+        }
+    }))
+    .join("");
+    assert_eq!(format!("{}", changeset), color_s);
+}
+
+#[test]
+fn test_diff_words_issue_1() {
+    let insert_style = Colour::Green.normal();
+    let insert_whitespace_style = Colour::White.on(Colour::Green);
+    let remove_style = Colour::Red.strikethrough();
+    let remove_whitespace_style = Colour::White.on(Colour::Red);
+    let d1 = diff_words(
+        "und meine Unschuld beweisen!",
+        "und ich werde meine Unschuld beweisen!",
+    )
+    .set_insert_style(insert_style)
+    .set_insert_whitespace_style(insert_whitespace_style)
+    .set_remove_style(remove_style)
+    .set_remove_whitespace_style(remove_whitespace_style);
+
+    println!("diff_words: {} {:?}", d1, d1.diff());
+
+    _test_colors(
+        &d1,
+        &[
+            (None, "und "),
+            (Some(insert_style), "ich"),
+            (Some(insert_whitespace_style), " "),
+            (Some(insert_style), "werde"),
+            (Some(insert_whitespace_style), " "),
+            (None, "meine Unschuld beweisen!"),
+        ],
+    );
+    _test_colors(
+        &d1.set_highlight_whitespace(false),
+        &[
+            (None, "und "),
+            (Some(insert_style), "ich werde "),
+            (None, "meine Unschuld beweisen!"),
+        ],
+    );
+    let d2 = diff_words(
+        "Campaignings aus dem Ausland gegen meine Person ausfindig",
+        "Campaignings ausfindig",
+    );
+    println!("diff_words: {} {:?}", d2, d2.diff());
+    _test_colors(
+        &d2,
+        &[
+            (None, "Campaignings "),
+            (Some(remove_style), "aus"),
+            (Some(remove_whitespace_style), " "),
+            (Some(remove_style), "dem"),
+            (Some(remove_whitespace_style), " "),
+            (Some(remove_style), "Ausland"),
+            (Some(remove_whitespace_style), " "),
+            (Some(remove_style), "gegen"),
+            (Some(remove_whitespace_style), " "),
+            (Some(remove_style), "meine"),
+            (Some(remove_whitespace_style), " "),
+            (Some(remove_style), "Person"),
+            (Some(remove_whitespace_style), " "),
+            (None, "ausfindig"),
+        ],
+    );
+    let d3 = diff_words("des kriminellen Videos", "des kriminell erstellten Videos");
+    println!("diff_words: {} {:?}", d3, d3.diff());
+    _test_colors(
+        &d3,
+        &[
+            (None, "des "),
+            (Some(remove_style), "kriminellen"),
+            (Some(insert_style), "kriminell"),
+            (None, " "),
+            (Some(insert_style), "erstellten"),
+            (Some(insert_whitespace_style), " "),
+            (None, "Videos"),
+        ],
+    );
+}
+
+#[test]
+fn test_prettytable_process() {
+    let d1 = diff_lines(
+        r#"line1
+        line2
+        line3
+        "#,
+        r#"line1
+        line2
+        line2.5
+        line3
+        "#,
+    );
+
+    println!("diff_lines: {} {:?}", d1, d1.diff());
+    assert_eq!(d1.prettytable_process(&["a", "b", "c"], None), (String::from("a\nb\nc"), 0));
+    assert_eq!(d1.prettytable_process(&["a", "b", "c", ""], None), (String::from("a\nb\nc"), 0));
+    assert_eq!(d1.prettytable_process(&["", "a", "b", "c"], None), (String::from("a\nb\nc"), 1));
+    assert_eq!(d1.prettytable_process(&["", "a", "b", "c", ""], None), (String::from("a\nb\nc"), 1));
+}
+
+#[test]
+fn test_format_with_context() {
+    let d = diff_lines(
+        r#"line1
+        line2
+        line3
+        line4
+        line5
+        line6
+        line7
+        line8
+        line9
+        line10
+        line11
+        line12"#,
+        r#"line1
+        line2
+        line4
+        line5
+        line6.5
+        line7
+        line8
+        line9
+        line10
+        line11.5
+        line12"#,
+    );
+    let context = |n| ContextConfig {
+        context_size: n,
+        skipping_marker: "...",
+    };
+    println!(
+        "diff_lines:\n{}\n{:?}",
+        d.format_with_context(Some(context(0)), true),
+        d.diff()
+    );
+    let formatted_none = d.format_with_context(None, true);
+    let formatted_some_0 = d.format_with_context(Some(context(0)), true);
+    let formatted_some_1 = d.format_with_context(Some(context(1)), true);
+    let formatted_some_2 = d.format_with_context(Some(context(2)), true);
+    // With a context of size 2, every line is present
+    assert_eq!(
+        formatted_none.lines().count(),
+        formatted_some_2.lines().count()
+    );
+    // with a context of size 1:
+    // * line 1 is replaced by '...' (-0 lines)
+    // * line 8-9 are replaced by '...' (-1 line)
+    assert_eq!(
+        formatted_none.lines().count() - 1,
+        formatted_some_1.lines().count()
+    );
+    // with a context of size 0:
+    // * lines 1-2 are replaced by '...' (-1 line)
+    // * lines 4-5 are replaced by '...' (-1 line)
+    // * lines 7-10 are replaced by '...' (-3 lines)
+    // * line 12 is replaced by '...' (-0 lines)
+    assert_eq!(
+        formatted_none.lines().count() - 5,
+        formatted_some_0.lines().count()
+    );
+}