diff --git a/src/algorithms/myers.rs b/src/algorithms/myers.rs index 1d97130..f67aa93 100644 --- a/src/algorithms/myers.rs +++ b/src/algorithms/myers.rs @@ -55,11 +55,11 @@ where pub(crate) fn diff_offsets( diff: &mut D, old: &Old, - i: usize, - i_: usize, + old_current: usize, + old_end: usize, new: &New, - j: usize, - j_: usize, + new_current: usize, + new_end: usize, ) -> Result<(), D::Error> where D: DiffHook + ?Sized, @@ -67,9 +67,9 @@ where New: Index + ?Sized, New::Output: PartialEq, { - if i_ > i && j_ > j { - let n = i_ - i; - let m = j_ - j; + if old_end > old_current && new_end > new_current { + let n = old_end - old_current; + let m = new_end - new_current; let l = (n + m) as isize; let z = (2 * min(n, m) + 2) as usize; let w = n as isize - m as isize; @@ -102,7 +102,7 @@ where } else { (n - a - 1, m - b - 1) }; - new[j + f_i] == old[i + e_i] + new[new_current + f_i] == old[old_current + e_i] } { a += 1; b += 1; @@ -120,19 +120,35 @@ where (n - a, m - b, n - s, m - t) }; if h + bound > 1 || (x != u && y != v) { - diff_offsets(diff, old, i, i + x, new, j, j + y)?; + diff_offsets( + diff, + old, + old_current, + old_current + x, + new, + new_current, + new_current + y, + )?; if x != u { - diff.equal(i + x, j + y, u - x)?; + diff.equal(old_current + x, new_current + y, u - x)?; } - diff_offsets(diff, old, i + u, i_, new, j + v, j_)?; + diff_offsets( + diff, + old, + old_current + u, + old_end, + new, + new_current + v, + new_end, + )?; return Ok(()); } else if m > n { - diff.equal(i, j, n)?; - diff.insert(i + n, j + n, m - n)?; + diff.equal(old_current, new_current, n)?; + diff.insert(old_current + n, new_current + n, m - n)?; return Ok(()); } else if m < n { - diff.equal(i, j, m)?; - diff.delete(i + m, n - m, j + m)?; + diff.equal(old_current, new_current, m)?; + diff.delete(old_current + m, n - m, new_current + m)?; return Ok(()); } else { return Ok(()); @@ -141,10 +157,10 @@ where } } } - } else if i_ > i { - diff.delete(i, i_ - i, j)? - } else if j_ > j { - diff.insert(i, j, j_ - j)? + } else if old_end > old_current { + diff.delete(old_current, old_end - old_current, new_current)? + } else if new_end > new_current { + diff.insert(old_current, new_current, new_end - new_current)? } Ok(()) } diff --git a/src/algorithms/patience.rs b/src/algorithms/patience.rs index 8eb0a2d..2cc5fd8 100644 --- a/src/algorithms/patience.rs +++ b/src/algorithms/patience.rs @@ -68,13 +68,13 @@ where struct Patience<'old, 'new, 'd, Old: ?Sized, New: ?Sized, D> { d: &'d mut D, old: &'old Old, + old_current: usize, + old_end: usize, + old_indexes: &'old [Indexable<'old, Old>], new: &'new New, - current_old: usize, - end_old: usize, - current_new: usize, - end_new: usize, - indexes_old: &'old [Indexable<'old, Old>], - indexes_new: &'new [Indexable<'new, New>], + new_current: usize, + new_end: usize, + new_indexes: &'new [Indexable<'new, New>], } impl<'old, 'new, 'd, Old, New, D> DiffHook for Patience<'old, 'new, 'd, Old, New, D> @@ -87,29 +87,29 @@ where type Error = D::Error; fn equal(&mut self, old: usize, new: usize, len: usize) -> Result<(), D::Error> { for (old, new) in (old..old + len).zip(new..new + len) { - let a0 = self.current_old; - let b0 = self.current_new; - while self.current_old < self.indexes_old[old].index - && self.current_new < self.indexes_new[new].index - && self.new[self.current_new] == self.old[self.current_old] + let a0 = self.old_current; + let b0 = self.new_current; + while self.old_current < self.old_indexes[old].index + && self.new_current < self.new_indexes[new].index + && self.new[self.new_current] == self.old[self.old_current] { - self.current_old += 1; - self.current_new += 1; + self.old_current += 1; + self.new_current += 1; } - if self.current_old > a0 { - self.d.equal(a0, b0, self.current_old - a0)? + if self.old_current > a0 { + self.d.equal(a0, b0, self.old_current - a0)? } myers::diff_offsets( self.d, self.old, - self.current_old, - self.indexes_old[old].index, + self.old_current, + self.old_indexes[old].index, self.new, - self.current_new, - self.indexes_new[new].index, + self.new_current, + self.new_indexes[new].index, )?; - self.current_old = self.indexes_old[old].index; - self.current_new = self.indexes_new[new].index; + self.old_current = self.old_indexes[old].index; + self.new_current = self.new_indexes[new].index; } Ok(()) } @@ -118,9 +118,9 @@ where myers::diff( self.d, self.old, - self.current_old..self.end_old, + self.old_current..self.old_end, self.new, - self.current_new..self.end_new, + self.new_current..self.new_end, ) } } @@ -142,26 +142,26 @@ where New::Output: PartialEq + Hash + Eq, D: DiffHook, { - let indexes_old = unique(old, old_range.start, old_range.end); - let indexes_new = unique(new, old_range.start, old_range.end); + let old_indexes = unique(old, old_range.start, old_range.end); + let new_indexes = unique(new, old_range.start, old_range.end); let mut d = Replace::new(Patience { d, old, + old_current: old_range.start, + old_end: old_range.end, + old_indexes: &old_indexes, new, - current_old: old_range.start, - end_old: old_range.end, - current_new: new_range.start, - end_new: new_range.end, - indexes_old: &indexes_old, - indexes_new: &indexes_new, + new_current: new_range.start, + new_end: new_range.end, + new_indexes: &new_indexes, }); myers::diff( &mut d, - &indexes_old, - 0..indexes_old.len(), - &indexes_new, - 0..indexes_new.len(), + &old_indexes, + 0..old_indexes.len(), + &new_indexes, + 0..new_indexes.len(), )?; Ok(()) }