[minor] Renamed internal functions

This will be useful to disambiguiate when adding support for 3-way merging of arbitrary types

Author: daladim

src/diff/mod.rs

@@ -96,8 +96,8 @@ impl DiffOptions {
     /// Produce a Patch between two texts based on the configured options
     pub fn create_patch<'a>(&self, original: &'a str, modified: &'a str) -> Patch<'a, str> {
         let mut classifier = Classifier::default();
-        let (old_lines, old_ids) = classifier.classify_lines(original);
-        let (new_lines, new_ids) = classifier.classify_lines(modified);
+        let (old_lines, old_ids) = classifier.classify_text(original);
+        let (new_lines, new_ids) = classifier.classify_text(modified);
 
         let solution = self.diff_slice(&old_ids, &new_ids);
 
@@ -112,8 +112,8 @@ impl DiffOptions {
         modified: &'a [u8],
     ) -> Patch<'a, [u8]> {
         let mut classifier = Classifier::default();
-        let (old_lines, old_ids) = classifier.classify_lines(original);
-        let (new_lines, new_ids) = classifier.classify_lines(modified);
+        let (old_lines, old_ids) = classifier.classify_text(original);
+        let (new_lines, new_ids) = classifier.classify_text(modified);
 
         let solution = self.diff_slice(&old_ids, &new_ids);
 

src/merge/mod.rs

@@ -152,9 +152,9 @@ impl MergeOptions {
         theirs: &'a str,
     ) -> Result<String, String> {
         let mut classifier = Classifier::default();
-        let (ancestor_lines, ancestor_ids) = classifier.classify_lines(ancestor);
-        let (our_lines, our_ids) = classifier.classify_lines(ours);
-        let (their_lines, their_ids) = classifier.classify_lines(theirs);
+        let (ancestor_lines, ancestor_ids) = classifier.classify_text(ancestor);
+        let (our_lines, our_ids) = classifier.classify_text(ours);
+        let (their_lines, their_ids) = classifier.classify_text(theirs);
 
         let opts = DiffOptions::default();
         let our_solution = opts.diff_slice(&ancestor_ids, &our_ids);
@@ -183,9 +183,9 @@ impl MergeOptions {
         theirs: &'a [u8],
     ) -> Result<Vec<u8>, Vec<u8>> {
         let mut classifier = Classifier::default();
-        let (ancestor_lines, ancestor_ids) = classifier.classify_lines(ancestor);
-        let (our_lines, our_ids) = classifier.classify_lines(ours);
-        let (their_lines, their_ids) = classifier.classify_lines(theirs);
+        let (ancestor_lines, ancestor_ids) = classifier.classify_text(ancestor);
+        let (our_lines, our_ids) = classifier.classify_text(ours);
+        let (their_lines, their_ids) = classifier.classify_text(theirs);
 
         let opts = DiffOptions::default();
         let our_solution = opts.diff_slice(&ancestor_ids, &our_ids);

src/utils.rs

@@ -12,7 +12,7 @@ pub struct Classifier<'a, T: ?Sized> {
 }
 
 impl<'a, T: ?Sized + Eq + Hash> Classifier<'a, T> {
-    fn classify(&mut self, record: &'a T) -> u64 {
+    fn classify_item(&mut self, record: &'a T) -> u64 {
         match self.unique_ids.entry(record) {
             Entry::Occupied(o) => *o.get(),
             Entry::Vacant(v) => {
@@ -25,9 +25,9 @@ impl<'a, T: ?Sized + Eq + Hash> Classifier<'a, T> {
 }
 
 impl<'a, T: ?Sized + Text> Classifier<'a, T> {
-    pub fn classify_lines(&mut self, text: &'a T) -> (Vec<&'a T>, Vec<u64>) {
+    pub fn classify_text(&mut self, text: &'a T) -> (Vec<&'a T>, Vec<u64>) {
         LineIter::new(text)
-            .map(|line| (line, self.classify(line)))
+            .map(|line| (line, self.classify_item(line)))
             .unzip()
     }
 }
@@ -227,3 +227,16 @@ fn find_bytes(haystack: &[u8], needle: &[u8]) -> Option<usize> {
 fn find_byte(haystack: &[u8], byte: u8) -> Option<usize> {
     haystack.iter().position(|&b| b == byte)
 }
+
+#[cfg(test)]
+mod test {
+    use super::Classifier;
+
+    #[test]
+    fn classify_string() {
+        let input = "abc\ndef";
+        let mut classifier = Classifier::default();
+        let (lines, _ids) = classifier.classify_text(input);
+        assert_eq!(lines, vec!["abc\n", "def"]);
+    }
+}