fix: assure differences are handled exhaustively. (#26)

Previously it was possible to have multiple diffs in one crate
distributed over multiple commits to rightfully show up as multiple
hunks of modified and added lines only register the modified lines,
not the new ones (or the deleted ones for that matter).

This would cause updates or removals to be missed.

Now hunks of changes are exhaused properly, fixing this issue.

Author: Byron

src/index/diff/delegate.rs

@@ -75,62 +75,68 @@ impl Delegate {
                                 .iter()
                                 .map(|&line| input.interner[line].as_bstr())
                                 .peekable();
-                            match (lines_before.peek().is_some(), lines_after.peek().is_some()) {
-                                (true, false) => {
-                                    for removed in lines_before {
-                                        match version_from_json_line(removed, location) {
-                                            Ok(version) => {
-                                                self.delete_version_ids.insert(version.id());
-                                            }
-                                            Err(e) => {
-                                                err = Some(e);
-                                                break;
-                                            }
-                                        }
-                                    }
-                                }
-                                (false, true) => {
-                                    for inserted in lines_after {
-                                        match version_from_json_line(inserted, location) {
-                                            Ok(version) => {
-                                                self.changes.push(if version.yanked {
-                                                    Change::Yanked(version)
-                                                } else {
-                                                    Change::Added(version)
-                                                });
-                                            }
-                                            Err(e) => {
-                                                err = Some(e);
-                                                break;
+                            loop {
+                                match (lines_before.peek().is_some(), lines_after.peek().is_some())
+                                {
+                                    (true, false) => {
+                                        for removed in lines_before {
+                                            match version_from_json_line(removed, location) {
+                                                Ok(version) => {
+                                                    self.delete_version_ids.insert(version.id());
+                                                }
+                                                Err(e) => {
+                                                    err = Some(e);
+                                                    break;
+                                                }
                                             }
                                         }
+                                        break;
                                     }
-                                }
-                                (true, true) => {
-                                    for (removed, inserted) in lines_before.zip(lines_after) {
-                                        match version_from_json_line(inserted, location).and_then(
-                                            |inserted| {
-                                                version_from_json_line(removed, location)
-                                                    .map(|removed| (removed, inserted))
-                                            },
-                                        ) {
-                                            Ok((removed, inserted)) => {
-                                                if removed.yanked != inserted.yanked {
-                                                    self.changes.push(if inserted.yanked {
-                                                        Change::Yanked(inserted)
+                                    (false, true) => {
+                                        for inserted in lines_after {
+                                            match version_from_json_line(inserted, location) {
+                                                Ok(version) => {
+                                                    self.changes.push(if version.yanked {
+                                                        Change::Yanked(version)
                                                     } else {
-                                                        Change::Added(inserted)
+                                                        Change::Added(version)
                                                     });
                                                 }
+                                                Err(e) => {
+                                                    err = Some(e);
+                                                    break;
+                                                }
                                             }
-                                            Err(e) => {
-                                                err = Some(e);
-                                                break;
+                                        }
+                                        break;
+                                    }
+                                    (true, true) => {
+                                        for (removed, inserted) in
+                                            lines_before.by_ref().zip(lines_after.by_ref())
+                                        {
+                                            match version_from_json_line(inserted, location)
+                                                .and_then(|inserted| {
+                                                    version_from_json_line(removed, location)
+                                                        .map(|removed| (removed, inserted))
+                                                }) {
+                                                Ok((removed, inserted)) => {
+                                                    if removed.yanked != inserted.yanked {
+                                                        self.changes.push(if inserted.yanked {
+                                                            Change::Yanked(inserted)
+                                                        } else {
+                                                            Change::Added(inserted)
+                                                        });
+                                                    }
+                                                }
+                                                Err(e) => {
+                                                    err = Some(e);
+                                                    break;
+                                                }
                                             }
                                         }
                                     }
+                                    (false, false) => break,
                                 }
-                                (false, false) => {}
                             }
                         },
                     );

tests/index/changes_between_commits.rs

@@ -11,7 +11,6 @@ fn directory_deletions_are_not_picked_up() -> crate::Result {
 }
 
 #[test]
-#[ignore]
 fn updates_before_yanks_are_picked_up() -> crate::Result {
     let index = index_ro()?;
     let repo = index.repository();
@@ -21,9 +20,9 @@ fn updates_before_yanks_are_picked_up() -> crate::Result {
     )?;
 
     assert_eq!(changes.len(), 3, "1 update and 2 yanks");
-    assert_eq!(changes[0].added().expect("first updated").version, "0.3.11");
-    assert_eq!(changes[1].yanked().expect("second yanked").version, "0.3.4");
-    assert_eq!(changes[2].yanked().expect("third yanked").version, "0.3.5");
+    assert_eq!(changes[0].yanked().expect("second yanked").version, "0.3.4");
+    assert_eq!(changes[1].yanked().expect("third yanked").version, "0.3.5");
+    assert_eq!(changes[2].added().expect("first updated").version, "0.3.11");
     Ok(())
 }