code_ownership 2.1.2 → 2.1.3

data/ext/cargo-vendor/similar-2.7.0/src/algorithms/replace.rs

@@ -0,0 +1,221 @@
+use crate::algorithms::DiffHook;
+
+/// A [`DiffHook`] that combines deletions and insertions to give blocks
+/// of maximal length, and replacements when appropriate.
+///
+/// It will replace [`DiffHook::insert`] and [`DiffHook::delete`] events when
+/// possible with [`DiffHook::replace`] events.  Note that even though the
+/// text processing in the crate does not use replace events and always resolves
+/// then back to delete and insert, it's useful to always use the replacer to
+/// ensure a consistent order of inserts and deletes.  This is why for instance
+/// the text diffing automatically uses this hook internally.
+pub struct Replace<D: DiffHook> {
+    d: D,
+    del: Option<(usize, usize, usize)>,
+    ins: Option<(usize, usize, usize)>,
+    eq: Option<(usize, usize, usize)>,
+}
+
+impl<D: DiffHook> Replace<D> {
+    /// Creates a new replace hook wrapping another hook.
+    pub fn new(d: D) -> Self {
+        Replace {
+            d,
+            del: None,
+            ins: None,
+            eq: None,
+        }
+    }
+
+    /// Extracts the inner hook.
+    pub fn into_inner(self) -> D {
+        self.d
+    }
+
+    fn flush_eq(&mut self) -> Result<(), D::Error> {
+        if let Some((eq_old_index, eq_new_index, eq_len)) = self.eq.take() {
+            self.d.equal(eq_old_index, eq_new_index, eq_len)?
+        }
+        Ok(())
+    }
+
+    fn flush_del_ins(&mut self) -> Result<(), D::Error> {
+        if let Some((del_old_index, del_old_len, del_new_index)) = self.del.take() {
+            if let Some((_, ins_new_index, ins_new_len)) = self.ins.take() {
+                self.d
+                    .replace(del_old_index, del_old_len, ins_new_index, ins_new_len)?;
+            } else {
+                self.d.delete(del_old_index, del_old_len, del_new_index)?;
+            }
+        } else if let Some((ins_old_index, ins_new_index, ins_new_len)) = self.ins.take() {
+            self.d.insert(ins_old_index, ins_new_index, ins_new_len)?;
+        }
+        Ok(())
+    }
+}
+
+impl<D: DiffHook> AsRef<D> for Replace<D> {
+    fn as_ref(&self) -> &D {
+        &self.d
+    }
+}
+
+impl<D: DiffHook> AsMut<D> for Replace<D> {
+    fn as_mut(&mut self) -> &mut D {
+        &mut self.d
+    }
+}
+
+impl<D: DiffHook> DiffHook for Replace<D> {
+    type Error = D::Error;
+
+    fn equal(&mut self, old_index: usize, new_index: usize, len: usize) -> Result<(), D::Error> {
+        self.flush_del_ins()?;
+
+        self.eq = if let Some((eq_old_index, eq_new_index, eq_len)) = self.eq.take() {
+            Some((eq_old_index, eq_new_index, eq_len + len))
+        } else {
+            Some((old_index, new_index, len))
+        };
+
+        Ok(())
+    }
+
+    fn delete(
+        &mut self,
+        old_index: usize,
+        old_len: usize,
+        new_index: usize,
+    ) -> Result<(), D::Error> {
+        self.flush_eq()?;
+        if let Some((del_old_index, del_old_len, del_new_index)) = self.del.take() {
+            debug_assert_eq!(old_index, del_old_index + del_old_len);
+            self.del = Some((del_old_index, del_old_len + old_len, del_new_index));
+        } else {
+            self.del = Some((old_index, old_len, new_index));
+        }
+        Ok(())
+    }
+
+    fn insert(
+        &mut self,
+        old_index: usize,
+        new_index: usize,
+        new_len: usize,
+    ) -> Result<(), D::Error> {
+        self.flush_eq()?;
+        self.ins = if let Some((ins_old_index, ins_new_index, ins_new_len)) = self.ins.take() {
+            debug_assert_eq!(ins_new_index + ins_new_len, new_index);
+            Some((ins_old_index, ins_new_index, new_len + ins_new_len))
+        } else {
+            Some((old_index, new_index, new_len))
+        };
+
+        Ok(())
+    }
+
+    fn replace(
+        &mut self,
+        old_index: usize,
+        old_len: usize,
+        new_index: usize,
+        new_len: usize,
+    ) -> Result<(), D::Error> {
+        self.flush_eq()?;
+        self.d.replace(old_index, old_len, new_index, new_len)
+    }
+
+    fn finish(&mut self) -> Result<(), D::Error> {
+        self.flush_eq()?;
+        self.flush_del_ins()?;
+        self.d.finish()
+    }
+}
+
+#[test]
+fn test_mayers_replace() {
+    use crate::algorithms::{diff_slices, Algorithm};
+    let a: &[&str] = &[
+        ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n",
+        "a\n",
+        "b\n",
+        "c\n",
+        "================================\n",
+        "d\n",
+        "e\n",
+        "f\n",
+        "<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n",
+    ];
+    let b: &[&str] = &[
+        ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n",
+        "x\n",
+        "b\n",
+        "c\n",
+        "================================\n",
+        "y\n",
+        "e\n",
+        "f\n",
+        "<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n",
+    ];
+
+    let mut d = Replace::new(crate::algorithms::Capture::new());
+    diff_slices(Algorithm::Myers, &mut d, a, b).unwrap();
+
+    insta::assert_debug_snapshot!(&d.into_inner().ops(), @r###"
+    [
+        Equal {
+            old_index: 0,
+            new_index: 0,
+            len: 1,
+        },
+        Replace {
+            old_index: 1,
+            old_len: 1,
+            new_index: 1,
+            new_len: 1,
+        },
+        Equal {
+            old_index: 2,
+            new_index: 2,
+            len: 3,
+        },
+        Replace {
+            old_index: 5,
+            old_len: 1,
+            new_index: 5,
+            new_len: 1,
+        },
+        Equal {
+            old_index: 6,
+            new_index: 6,
+            len: 3,
+        },
+    ]
+    "###);
+}
+
+#[test]
+fn test_replace() {
+    use crate::algorithms::{diff_slices, Algorithm};
+
+    let a: &[usize] = &[0, 1, 2, 3, 4];
+    let b: &[usize] = &[0, 1, 2, 7, 8, 9];
+
+    let mut d = Replace::new(crate::algorithms::Capture::new());
+    diff_slices(Algorithm::Myers, &mut d, a, b).unwrap();
+    insta::assert_debug_snapshot!(d.into_inner().ops(), @r###"
+    [
+        Equal {
+            old_index: 0,
+            new_index: 0,
+            len: 3,
+        },
+        Replace {
+            old_index: 3,
+            old_len: 2,
+            new_index: 3,
+            new_len: 3,
+        },
+    ]
+    "###);
+}

data/ext/cargo-vendor/similar-2.7.0/src/algorithms/snapshots/similar__algorithms__capture__capture_hook_grouping-2.snap

@@ -0,0 +1,60 @@
+---
+source: src/algorithms/capture.rs
+expression: tags
+---
+[
+    [
+        (
+            Equal,
+            7..10,
+            7..10,
+        ),
+        (
+            Replace,
+            10..11,
+            10..11,
+        ),
+        (
+            Equal,
+            11..13,
+            11..13,
+        ),
+        (
+            Replace,
+            13..14,
+            13..14,
+        ),
+        (
+            Equal,
+            14..16,
+            14..16,
+        ),
+        (
+            Replace,
+            16..17,
+            16..17,
+        ),
+        (
+            Equal,
+            17..20,
+            17..20,
+        ),
+    ],
+    [
+        (
+            Equal,
+            31..34,
+            31..34,
+        ),
+        (
+            Replace,
+            34..35,
+            34..35,
+        ),
+        (
+            Equal,
+            35..38,
+            35..38,
+        ),
+    ],
+]

data/ext/cargo-vendor/similar-2.7.0/src/algorithms/snapshots/similar__algorithms__capture__capture_hook_grouping.snap

@@ -0,0 +1,64 @@
+---
+source: src/algorithms/capture.rs
+expression: ops
+---
+[
+    [
+        Equal {
+            old_index: 7,
+            new_index: 7,
+            len: 3,
+        },
+        Replace {
+            old_index: 10,
+            old_len: 1,
+            new_index: 10,
+            new_len: 1,
+        },
+        Equal {
+            old_index: 11,
+            new_index: 11,
+            len: 2,
+        },
+        Replace {
+            old_index: 13,
+            old_len: 1,
+            new_index: 13,
+            new_len: 1,
+        },
+        Equal {
+            old_index: 14,
+            new_index: 14,
+            len: 2,
+        },
+        Replace {
+            old_index: 16,
+            old_len: 1,
+            new_index: 16,
+            new_len: 1,
+        },
+        Equal {
+            old_index: 17,
+            new_index: 17,
+            len: 3,
+        },
+    ],
+    [
+        Equal {
+            old_index: 31,
+            new_index: 31,
+            len: 3,
+        },
+        Replace {
+            old_index: 34,
+            old_len: 1,
+            new_index: 34,
+            new_len: 1,
+        },
+        Equal {
+            old_index: 35,
+            new_index: 35,
+            len: 3,
+        },
+    ],
+]

data/ext/cargo-vendor/similar-2.7.0/src/algorithms/snapshots/similar__algorithms__lcs__contiguous.snap

@@ -0,0 +1,28 @@
+---
+source: src/algorithms/lcs.rs
+expression: d.into_inner().ops()
+---
+[
+    Equal {
+        old_index: 0,
+        new_index: 0,
+        len: 3,
+    },
+    Replace {
+        old_index: 3,
+        old_len: 2,
+        new_index: 3,
+        new_len: 2,
+    },
+    Equal {
+        old_index: 5,
+        new_index: 5,
+        len: 2,
+    },
+    Replace {
+        old_index: 7,
+        old_len: 1,
+        new_index: 7,
+        new_len: 1,
+    },
+]

data/ext/cargo-vendor/similar-2.7.0/src/algorithms/snapshots/similar__algorithms__lcs__diff.snap

@@ -0,0 +1,22 @@
+---
+source: src/algorithms/lcs.rs
+expression: d.into_inner().ops()
+---
+[
+    Equal {
+        old_index: 0,
+        new_index: 0,
+        len: 3,
+    },
+    Replace {
+        old_index: 3,
+        old_len: 1,
+        new_index: 3,
+        new_len: 1,
+    },
+    Equal {
+        old_index: 4,
+        new_index: 4,
+        len: 1,
+    },
+]

data/ext/cargo-vendor/similar-2.7.0/src/algorithms/snapshots/similar__algorithms__lcs__pat.snap

@@ -0,0 +1,31 @@
+---
+source: src/algorithms/lcs.rs
+expression: d.ops()
+---
+[
+    Equal {
+        old_index: 0,
+        new_index: 0,
+        len: 2,
+    },
+    Delete {
+        old_index: 2,
+        old_len: 1,
+        new_index: 2,
+    },
+    Equal {
+        old_index: 3,
+        new_index: 2,
+        len: 1,
+    },
+    Equal {
+        old_index: 4,
+        new_index: 3,
+        len: 1,
+    },
+    Insert {
+        old_index: 5,
+        new_index: 4,
+        new_len: 2,
+    },
+]

data/ext/cargo-vendor/similar-2.7.0/src/algorithms/snapshots/similar__algorithms__lcs__same.snap

@@ -0,0 +1,12 @@
+---
+source: src/algorithms/lcs.rs
+assertion_line: 235
+expression: d.ops()
+---
+[
+    Equal {
+        old_index: 0,
+        new_index: 0,
+        len: 8,
+    },
+]

data/ext/cargo-vendor/similar-2.7.0/src/algorithms/snapshots/similar__algorithms__myers__contiguous.snap

@@ -0,0 +1,28 @@
+---
+source: src/algorithms/myers.rs
+expression: d.into_inner().ops()
+---
+[
+    Equal {
+        old_index: 0,
+        new_index: 0,
+        len: 3,
+    },
+    Replace {
+        old_index: 3,
+        old_len: 1,
+        new_index: 3,
+        new_len: 2,
+    },
+    Equal {
+        old_index: 4,
+        new_index: 5,
+        len: 2,
+    },
+    Replace {
+        old_index: 6,
+        old_len: 2,
+        new_index: 7,
+        new_len: 1,
+    },
+]

data/ext/cargo-vendor/similar-2.7.0/src/algorithms/snapshots/similar__algorithms__myers__deadline_reached.snap

@@ -0,0 +1,22 @@
+---
+source: src/algorithms/myers.rs
+expression: d.into_inner().ops()
+---
+[
+    Equal {
+        old_index: 0,
+        new_index: 0,
+        len: 10,
+    },
+    Replace {
+        old_index: 10,
+        old_len: 41,
+        new_index: 10,
+        new_len: 41,
+    },
+    Equal {
+        old_index: 51,
+        new_index: 51,
+        len: 49,
+    },
+]

data/ext/cargo-vendor/similar-2.7.0/src/algorithms/snapshots/similar__algorithms__myers__diff.snap

@@ -0,0 +1,22 @@
+---
+source: src/algorithms/myers.rs
+expression: d.into_inner().ops()
+---
+[
+    Equal {
+        old_index: 0,
+        new_index: 0,
+        len: 3,
+    },
+    Replace {
+        old_index: 3,
+        old_len: 1,
+        new_index: 3,
+        new_len: 1,
+    },
+    Equal {
+        old_index: 4,
+        new_index: 4,
+        len: 1,
+    },
+]

data/ext/cargo-vendor/similar-2.7.0/src/algorithms/snapshots/similar__algorithms__myers__pat.snap

@@ -0,0 +1,31 @@
+---
+source: src/algorithms/myers.rs
+expression: d.ops()
+---
+[
+    Equal {
+        old_index: 0,
+        new_index: 0,
+        len: 2,
+    },
+    Delete {
+        old_index: 2,
+        old_len: 1,
+        new_index: 2,
+    },
+    Equal {
+        old_index: 3,
+        new_index: 2,
+        len: 2,
+    },
+    Insert {
+        old_index: 5,
+        new_index: 4,
+        new_len: 1,
+    },
+    Insert {
+        old_index: 5,
+        new_index: 5,
+        new_len: 1,
+    },
+]

data/ext/cargo-vendor/similar-2.7.0/src/algorithms/snapshots/similar__algorithms__patience__patience.snap

@@ -0,0 +1,45 @@
+---
+source: src/algorithms/patience.rs
+expression: d.into_inner().ops()
+---
+[
+    Replace {
+        old_index: 0,
+        old_len: 1,
+        new_index: 0,
+        new_len: 1,
+    },
+    Equal {
+        old_index: 1,
+        new_index: 1,
+        len: 3,
+    },
+    Replace {
+        old_index: 4,
+        old_len: 1,
+        new_index: 4,
+        new_len: 2,
+    },
+    Equal {
+        old_index: 5,
+        new_index: 6,
+        len: 2,
+    },
+    Replace {
+        old_index: 7,
+        old_len: 2,
+        new_index: 8,
+        new_len: 1,
+    },
+    Equal {
+        old_index: 9,
+        new_index: 9,
+        len: 1,
+    },
+    Replace {
+        old_index: 10,
+        old_len: 1,
+        new_index: 10,
+        new_len: 1,
+    },
+]

data/ext/cargo-vendor/similar-2.7.0/src/algorithms/snapshots/similar__algorithms__patience__patience_out_of_bounds_bug.snap

@@ -0,0 +1,16 @@
+---
+source: src/algorithms/patience.rs
+expression: d.into_inner().ops()
+---
+[
+    Equal {
+        old_index: 0,
+        new_index: 0,
+        len: 3,
+    },
+    Delete {
+        old_index: 3,
+        old_len: 1,
+        new_index: 3,
+    },
+]