Bigger refactorings in module layout

src/algorithms/capture.rs

@@ -1,96 +1,6 @@
 use std::convert::Infallible;
 
-use crate::algorithms::hook::DiffHook;
-use crate::DiffOp;
-
-/// Isolate change clusters by eliminating ranges with no changes.
-///
-/// This will leave holes behind in long periods of equal ranges so that
-/// you can build things like unified diffs.
-pub fn group_diff_ops(mut ops: Vec<DiffOp>, n: usize) -> Vec<Vec<DiffOp>> {
-    if ops.is_empty() {
-        return vec![];
-    }
-
-    let mut pending_group = Vec::new();
-    let mut rv = Vec::new();
-
-    if let Some(DiffOp::Equal {
-        old_index,
-        new_index,
-        len,
-    }) = ops.first_mut()
-    {
-        let offset = (*len).saturating_sub(n);
-        *old_index += offset;
-        *new_index += offset;
-        *len -= offset;
-    }
-
-    if let Some(DiffOp::Equal { len, .. }) = ops.last_mut() {
-        *len -= (*len).saturating_sub(n);
-    }
-
-    for op in ops.into_iter() {
-        if let DiffOp::Equal {
-            old_index,
-            new_index,
-            len,
-        } = op
-        {
-            // End the current group and start a new one whenever
-            // there is a large range with no changes.
-            if len > n * 2 {
-                pending_group.push(DiffOp::Equal {
-                    old_index,
-                    new_index,
-                    len: n,
-                });
-                rv.push(pending_group);
-                let offset = len.saturating_sub(n);
-                pending_group = vec![DiffOp::Equal {
-                    old_index: old_index + offset,
-                    new_index: new_index + offset,
-                    len: len - offset,
-                }];
-                continue;
-            }
-        }
-        pending_group.push(op);
-    }
-
-    match &pending_group[..] {
-        &[] | &[DiffOp::Equal { .. }] => {}
-        _ => rv.push(pending_group),
-    }
-
-    rv
-}
-
-/// Return a measure of similarity in the range `0..=1`.
-///
-/// A ratio of `1.0` means the two sequences are a complete match, a
-/// ratio of `0.0` would indicate completely distinct sequences.  The input
-/// is the sequence of diff operations and the length of the old and new
-/// sequence.
-pub fn get_diff_ratio(ops: &[DiffOp], old_len: usize, new_len: usize) -> f32 {
-    let matches = ops
-        .iter()
-        .map(|op| {
-            if let DiffOp::Equal { len, .. } = *op {
-                len
-            } else {
-                0
-            }
-        })
-        .sum::<usize>();
-    let len = old_len + new_len;
-    if len == 0 {
-        1.0
-    } else {
-        2.0 * matches as f32 / len as f32
-    }
-}
+use crate::{group_diff_ops, DiffHook, DiffOp};
 
 /// A [`DiffHook`] that captures all diff operations.
 #[derive(Default, Clone)]