Bigger refactorings in module layout

src/algorithms/mod.rs

@@ -6,108 +6,33 @@
 //! direct access to these algorithms can be useful in some cases.
 //!
 //! All these algorithms provide a `diff` function which takes two indexable
-//! objects (for instance slices) and a [`DiffHook`].  As the diff is generated
-//! the diff hook is invoked.  Note that the diff hook does not get access to
-//! the actual values but only the indexes.  This is why the diff hook is not
-//! used outside of the raw algorithm implementations as for most situations
-//! access to the values is useful of required.
+//! objects (for instance slices) and a [`DiffHook`](crate::DiffHook).  As the
+//! diff is generated the diff hook is invoked.  Note that the diff hook does
+//! not get access to the actual values but only the indexes.  This is why the
+//! diff hook is not used outside of the raw algorithm implementations as for
+//! most situations access to the values is useful of required.
 //!
-//! Most of the crate operates on the [`Algorithm`] enum which abstracts over
-//! the different algorithms.
+//! A more generic interface for these algorthms is available on the toplevel
+//! module.
 //!
 //! # Example
 //!
 //! This is a simple example that shows how you can calculate the difference
-//! between two sequences and capture the [`DiffOp`]s into a vector.
+//! between two sequences and capture the ops into a vector.
 //!
 //! ```rust
-//! use similar::Algorithm;
-//! use similar::algorithms::capture_diff_slices;
+//! use similar::{Algorithm, capture_diff_slices};
 //!
 //! let a = vec![1, 2, 3, 4, 5];
 //! let b = vec![1, 2, 3, 4, 7];
 //! let ops = capture_diff_slices(Algorithm::Myers, &a, &b);
 //! ```
 
-// general traits and utilities
 mod capture;
-mod hook;
 mod replace;
 
-use std::hash::Hash;
-use std::ops::{Index, Range};
-
-use crate::types::{Algorithm, DiffOp};
-
-pub use capture::{get_diff_ratio, group_diff_ops, Capture};
-pub use hook::DiffHook;
+pub use capture::Capture;
 pub use replace::Replace;
 
-// actual diffing algorithms
 pub mod myers;
 pub mod patience;
-
-/// Creates a diff between old and new with the given algorithm.
-///
-/// Diffs `old`, between indices `old_range` and `new` between indices `new_range`.
-pub fn diff<Old, New, D>(
-    alg: Algorithm,
-    d: &mut D,
-    old: &Old,
-    old_range: Range<usize>,
-    new: &New,
-    new_range: Range<usize>,
-) -> Result<(), D::Error>
-where
-    Old: Index<usize> + ?Sized,
-    New: Index<usize> + ?Sized,
-    D: DiffHook,
-    Old::Output: Hash + Eq + Ord,
-    New::Output: PartialEq<Old::Output> + Hash + Eq + Ord,
-{
-    match alg {
-        Algorithm::Myers => myers::diff(d, old, old_range, new, new_range),
-        Algorithm::Patience => patience::diff(d, old, old_range, new, new_range),
-    }
-}
-
-/// Shortcut for diffing slices with a specific algorithm.
-pub fn diff_slices<D, T>(alg: Algorithm, d: &mut D, old: &[T], new: &[T]) -> Result<(), D::Error>
-where
-    D: DiffHook,
-    T: Eq + Hash + Ord,
-{
-    diff(alg, d, old, 0..old.len(), new, 0..new.len())
-}
-
-/// Creates a diff between old and new with the given algorithm capturing the ops.
-///
-/// This is like [`diff`] but instead of using an arbitrary hook this will
-/// always use [`Replace`] + [`Capture`] and return the captured [`DiffOp`]s.
-pub fn capture_diff<Old, New>(
-    alg: Algorithm,
-    old: &Old,
-    old_range: Range<usize>,
-    new: &New,
-    new_range: Range<usize>,
-) -> Vec<DiffOp>
-where
-    Old: Index<usize> + ?Sized,
-    New: Index<usize> + ?Sized,
-    Old::Output: Hash + Eq + Ord,
-    New::Output: PartialEq<Old::Output> + Hash + Eq + Ord,
-{
-    let mut d = Replace::new(Capture::new());
-    diff(alg, &mut d, old, old_range, new, new_range).unwrap();
-    d.into_inner().into_ops()
-}
-
-/// Creates a diff between old and new with the given algorithm capturing the ops.
-pub fn capture_diff_slices<T>(alg: Algorithm, old: &[T], new: &[T]) -> Vec<DiffOp>
-where
-    T: Eq + Hash + Ord,
-{
-    let mut d = Replace::new(Capture::new());
-    diff_slices(alg, &mut d, old, new).unwrap();
-    d.into_inner().into_ops()
-}