Factor out a myers_diff module

src/line_parser.rs

@@ -8,6 +8,7 @@ use rustc_hash::FxHashMap;
 
 use crate::{
     lines::NewlinePositions,
+    myers_diff,
     syntax::{split_words, AtomKind, MatchKind, MatchedPos, TokenKind},
 };
 
@@ -109,25 +110,15 @@ fn diff_slice_by_hash<'a, T: Eq + Hash>(lhs: &'a [T], rhs: &'a [T]) -> Vec<diff:
         rhs_ids.push(id);
     }
 
-    wu_diff::diff(&lhs_ids[..], &rhs_ids[..])
+    myers_diff::slice(&lhs_ids[..], &rhs_ids[..])
         .into_iter()
         .map(|result| match result {
-            wu_diff::DiffResult::Removed(r) => {
-                let id = lhs_ids[r.old_index.unwrap()];
-                diff::Result::Left(*id_values.get(&id).unwrap())
-            }
-            wu_diff::DiffResult::Common(c) => {
-                let lhs_id = lhs_ids[c.old_index.unwrap()];
-                let rhs_id = rhs_ids[c.new_index.unwrap()];
-                diff::Result::Both(
-                    *id_values.get(&lhs_id).unwrap(),
-                    *id_values.get(&rhs_id).unwrap(),
-                )
-            }
-            wu_diff::DiffResult::Added(a) => {
-                let id = rhs_ids[a.new_index.unwrap()];
-                diff::Result::Right(*id_values.get(&id).unwrap())
-            }
+            myers_diff::DiffResult::Left(id) => diff::Result::Left(*id_values.get(id).unwrap()),
+            myers_diff::DiffResult::Both(lhs_id, rhs_id) => diff::Result::Both(
+                *id_values.get(lhs_id).unwrap(),
+                *id_values.get(rhs_id).unwrap(),
+            ),
+            myers_diff::DiffResult::Right(id) => diff::Result::Right(*id_values.get(id).unwrap()),
         })
         .collect::<Vec<diff::Result<&'a T>>>()
 }

src/main.rs

@@ -26,6 +26,7 @@ mod summary;
 mod syntax;
 mod tree_sitter_parser;
 mod unchanged;
+mod myers_diff;
 
 #[macro_use]
 extern crate log;

src/myers_diff.rs

@@ -0,0 +1,21 @@
+#[derive(Debug)]
+pub enum DiffResult<T> {
+    Left(T),
+    Both(T, T),
+    Right(T),
+}
+
+pub fn slice<'a, T: PartialEq + Clone>(lhs: &'a [T], rhs: &'a [T]) -> Vec<DiffResult<&'a T>> {
+    wu_diff::diff(lhs, rhs)
+        .into_iter()
+        .map(|result| match result {
+            wu_diff::DiffResult::Removed(r) => DiffResult::Left(&lhs[r.old_index.unwrap()]),
+            wu_diff::DiffResult::Common(c) => {
+                let lhs_id = c.old_index.unwrap();
+                let rhs_id = c.new_index.unwrap();
+                DiffResult::Both(&lhs[lhs_id], &rhs[rhs_id])
+            }
+            wu_diff::DiffResult::Added(a) => DiffResult::Right(&rhs[a.new_index.unwrap()]),
+        })
+        .collect::<Vec<_>>()
+}