From fa11404bcb08225fd5ae0056680d4386a2c1df76 Mon Sep 17 00:00:00 2001 From: Armin Ronacher Date: Sun, 17 Jan 2021 22:59:50 +0100 Subject: [PATCH] Fight bad variable names in replacer --- src/algorithms/hook.rs | 76 ++++++++++++++++---------- src/algorithms/replace.rs | 110 ++++++++++++++++++++++---------------- 2 files changed, 111 insertions(+), 75 deletions(-) diff --git a/src/algorithms/hook.rs b/src/algorithms/hook.rs index 4e38f2c..251ad19 100644 --- a/src/algorithms/hook.rs +++ b/src/algorithms/hook.rs @@ -3,49 +3,59 @@ pub trait DiffHook: Sized { type Error; - /// Called when lines with indices `old` (in the old version) and - /// `new` (in the new version) start an section equal in both + /// Called when lines with indices `old_index` (in the old version) and + /// `new_index` (in the new version) start an section equal in both /// versions, of length `len`. - fn equal(&mut self, old: usize, new: usize, len: usize) -> Result<(), Self::Error> { - let _old = old; - let _new = new; - let _len = len; + fn equal(&mut self, old_index: usize, new_index: usize, len: usize) -> Result<(), Self::Error> { + let _ = old_index; + let _ = new_index; + let _ = len; Ok(()) } - /// Called when a section of length `len`, starting at `old`, + /// Called when a section of length `old_len`, starting at `old_index`, /// needs to be deleted from the old version. - fn delete(&mut self, old: usize, old_len: usize, new: usize) -> Result<(), Self::Error> { - let _old = old; - let _old_len = old_len; - let _new = new; + fn delete( + &mut self, + old_index: usize, + old_len: usize, + new_index: usize, + ) -> Result<(), Self::Error> { + let _ = old_index; + let _ = old_len; + let _ = new_index; Ok(()) } /// Called when a section of the new version, of length `new_len` - /// and starting at `new`, needs to be inserted at position `old'. - fn insert(&mut self, old: usize, new: usize, new_len: usize) -> Result<(), Self::Error> { - let _old = old; - let _new = new; - let _new_len = new_len; + /// and starting at `new_index`, needs to be inserted at position `old_index'. + fn insert( + &mut self, + old_index: usize, + new_index: usize, + new_len: usize, + ) -> Result<(), Self::Error> { + let _ = old_index; + let _ = new_index; + let _ = new_len; Ok(()) } /// Called when a section of the old version, starting at index - /// `old` and of length `old_len`, needs to be replaced with a - /// section of length `new_len`, starting at `new`, of the new + /// `old_index` and of length `old_len`, needs to be replaced with a + /// section of length `new_len`, starting at `new_index`, of the new /// version. /// /// The default implementations invokes `delete` and `insert`. fn replace( &mut self, - old: usize, + old_index: usize, old_len: usize, - new: usize, + new_index: usize, new_len: usize, ) -> Result<(), Self::Error> { - self.delete(old, old_len, new)?; - self.insert(old, new, new_len) + self.delete(old_index, old_len, new_index)?; + self.insert(old_index, new_index, new_len) } /// Always called at the end of the algorithm. @@ -57,16 +67,26 @@ pub trait DiffHook: Sized { impl<'a, D: DiffHook + 'a> DiffHook for &'a mut D { type Error = D::Error; - fn equal(&mut self, old: usize, new: usize, len: usize) -> Result<(), Self::Error> { - (*self).equal(old, new, len) + fn equal(&mut self, old_index: usize, new_index: usize, len: usize) -> Result<(), Self::Error> { + (*self).equal(old_index, new_index, len) } - fn delete(&mut self, old: usize, len: usize, new: usize) -> Result<(), Self::Error> { - (*self).delete(old, len, new) + fn delete( + &mut self, + old_index: usize, + old_len: usize, + new_index: usize, + ) -> Result<(), Self::Error> { + (*self).delete(old_index, old_len, new_index) } - fn insert(&mut self, old: usize, new: usize, new_len: usize) -> Result<(), Self::Error> { - (*self).insert(old, new, new_len) + fn insert( + &mut self, + old_index: usize, + new_index: usize, + new_len: usize, + ) -> Result<(), Self::Error> { + (*self).insert(old_index, new_index, new_len) } fn replace( diff --git a/src/algorithms/replace.rs b/src/algorithms/replace.rs index 996cb7a..06ca560 100644 --- a/src/algorithms/replace.rs +++ b/src/algorithms/replace.rs @@ -10,6 +10,7 @@ pub struct Replace { } impl Replace { + /// Creates a new replace hook wrapping another hook. pub fn new(d: D) -> Self { Replace { d, @@ -18,9 +19,32 @@ impl Replace { eq: None, } } + + /// Extracts the inner hook. pub fn into_inner(self) -> D { self.d } + + fn flush_eq(&mut self) -> Result<(), D::Error> { + if let Some((eq_old_index, eq_new_index, eq_len)) = self.eq.take() { + self.d.equal(eq_old_index, eq_new_index, eq_len)? + } + Ok(()) + } + + fn flush_del_ins(&mut self) -> Result<(), D::Error> { + if let Some((del_old_index, del_old_len, del_new_index)) = self.del.take() { + if let Some((_, ins_new_index, ins_new_len)) = self.ins.take() { + self.d + .replace(del_old_index, del_old_len, ins_new_index, ins_new_len)?; + } else { + self.d.delete(del_old_index, del_old_len, del_new_index)?; + } + } else if let Some((ins_old_index, ins_new_index, ins_new_len)) = self.ins.take() { + self.d.insert(ins_old_index, ins_new_index, ins_new_len)?; + } + Ok(()) + } } impl AsRef for Replace { @@ -37,76 +61,68 @@ impl AsMut for Replace { impl DiffHook for Replace { type Error = D::Error; - fn equal(&mut self, old: usize, new: usize, len: usize) -> Result<(), D::Error> { - if let Some((old0, len0, new0)) = self.del.take() { - if let Some((_, new1, new_len1)) = self.ins.take() { - self.d.replace(old0, len0, new1, new_len1)? - } else { - self.d.delete(old0, len0, new0)? - } - } else if let Some((old0, new0, new_len0)) = self.ins.take() { - self.d.insert(old0, new0, new_len0)? - } - if let Some((a, b, c)) = self.eq.take() { - self.eq = Some((a, b, c + len)) + fn equal(&mut self, old_index: usize, new_index: usize, len: usize) -> Result<(), D::Error> { + self.flush_del_ins()?; + + self.eq = if let Some((eq_old_index, eq_new_index, eq_len)) = self.eq.take() { + Some((eq_old_index, eq_new_index, eq_len + len)) } else { - self.eq = Some((old, new, len)) - } + Some((old_index, new_index, len)) + }; + Ok(()) } - fn delete(&mut self, old: usize, len: usize, new: usize) -> Result<(), D::Error> { + + fn delete( + &mut self, + old_index: usize, + old_len: usize, + new_index: usize, + ) -> Result<(), D::Error> { if let Some((a, b, c)) = self.eq.take() { - self.d.equal(a, b, c)? + self.d.equal(a, b, c)?; } - if let Some((old0, len0, new0)) = self.del.take() { - assert_eq!(old, old0 + len0); - self.del = Some((old0, len0 + len, new0)) + if let Some((del_old_index, del_old_len, del_new_index)) = self.del.take() { + assert_eq!(old_index, del_old_index + del_old_len); + self.del = Some((del_old_index, del_old_len + old_len, del_new_index)); } else { - self.del = Some((old, len, new)) + self.del = Some((old_index, old_len, new_index)); } Ok(()) } - fn insert(&mut self, old: usize, new: usize, new_len: usize) -> Result<(), D::Error> { - if let Some((a, b, c)) = self.eq.take() { - self.d.equal(a, b, c)? - } - if let Some((old1, new1, new_len1)) = self.ins.take() { - assert_eq!(new1 + new_len1, new); - self.ins = Some((old1, new1, new_len + new_len1)) + fn insert( + &mut self, + old_index: usize, + new_index: usize, + new_len: usize, + ) -> Result<(), D::Error> { + self.flush_eq()?; + self.ins = if let Some((ins_old_index, ins_new_index, ins_new_len)) = self.ins.take() { + debug_assert_eq!(ins_new_index + ins_new_len, new_index); + Some((ins_old_index, ins_new_index, new_len + ins_new_len)) } else { - self.ins = Some((old, new, new_len)) - } + Some((old_index, new_index, new_len)) + }; + Ok(()) } fn replace( &mut self, - old: usize, + old_index: usize, old_len: usize, - new: usize, + new_index: usize, new_len: usize, ) -> Result<(), D::Error> { - if let Some((a, b, c)) = self.eq.take() { - self.d.equal(a, b, c)? - } - self.d.replace(old, old_len, new, new_len) + self.flush_eq()?; + self.d.replace(old_index, old_len, new_index, new_len) } fn finish(&mut self) -> Result<(), D::Error> { - if let Some((a, b, c)) = self.eq.take() { - self.d.equal(a, b, c)? - } - if let Some((old0, len0, new0)) = self.del.take() { - if let Some((_, new1, new_len1)) = self.ins.take() { - self.d.replace(old0, len0, new1, new_len1)? - } else { - self.d.delete(old0, len0, new0)? - } - } else if let Some((old0, new0, new_len0)) = self.ins.take() { - self.d.insert(old0, new0, new_len0)? - } + self.flush_eq()?; + self.flush_del_ins()?; self.d.finish() } }