Refine compatibility (#56)

Author: casey

Cargo.toml

@@ -36,6 +36,7 @@ missing-errors-doc = "allow"
 missing-panics-doc = "allow"
 needless-pass-by-value = "allow"
 pedantic = { level = "deny", priority = -1 }
+too-many-lines = "allow"
 wildcard-imports = "allow"
 
 [workspace.lints.rust]

crates/boilerplate-parser/src/token.rs

@@ -117,21 +117,28 @@ impl<'src> Token<'src> {
   }
 
   #[must_use]
-  pub fn is_compatible_with(self, other: &Self) -> bool {
+  pub fn is_compatible_with(self, other: Self) -> bool {
     if self.code() != other.code() {
       return false;
     }
 
-    match (self, other) {
-      (Self::Code { .. }, Self::Code { .. })
-      | (Self::Interpolation { .. }, Self::Interpolation { .. })
-      | (Self::Text { .. }, Self::Text { .. }) => true,
-      (Self::CodeLine { closed, .. }, Self::CodeLine { closed: other, .. })
-      | (Self::InterpolationLine { closed, .. }, Self::InterpolationLine { closed: other, .. }) => {
-        closed == *other
+    if self.block() != other.block() {
+      for token in [self, other] {
+        if !matches!(token, Self::Code { .. } | Self::CodeLine { .. }) {
+          return false;
+        }
+      }
+    }
+
+    if let Self::InterpolationLine { closed, .. } = self {
+      if let Self::InterpolationLine { closed: other, .. } = other {
+        if closed != other {
+          return false;
+        }
       }
-      _ => false,
     }
+
+    true
   }
 
   #[must_use]
@@ -148,6 +155,148 @@ impl<'src> Token<'src> {
 mod tests {
   use {super::*, pretty_assertions::assert_eq, Token::*};
 
+  #[test]
+  fn compatibility() {
+    #[track_caller]
+    fn case(a: Token, b: Token) {
+      assert!(a.is_compatible_with(b));
+    }
+    case(
+      Text {
+        contents: "foo",
+        index: 0,
+      },
+      Text {
+        contents: "bar",
+        index: 1,
+      },
+    );
+    case(Code { contents: "foo" }, Code { contents: "foo" });
+    case(Code { contents: " foo" }, Code { contents: "foo" });
+    case(Code { contents: "foo " }, Code { contents: "foo" });
+    case(
+      CodeLine {
+        contents: "foo",
+        closed: true,
+      },
+      CodeLine {
+        contents: "foo",
+        closed: true,
+      },
+    );
+    case(
+      CodeLine {
+        contents: "foo",
+        closed: false,
+      },
+      CodeLine {
+        contents: "foo",
+        closed: false,
+      },
+    );
+    case(
+      CodeLine {
+        contents: "foo",
+        closed: true,
+      },
+      CodeLine {
+        contents: "foo",
+        closed: false,
+      },
+    );
+    case(
+      CodeLine {
+        contents: "foo",
+        closed: false,
+      },
+      CodeLine {
+        contents: "foo",
+        closed: true,
+      },
+    );
+    case(
+      Code { contents: "foo" },
+      CodeLine {
+        contents: "foo",
+        closed: true,
+      },
+    );
+    case(
+      CodeLine {
+        contents: "foo",
+        closed: true,
+      },
+      Code { contents: "foo" },
+    );
+    case(
+      Interpolation { contents: "foo" },
+      Interpolation { contents: "foo" },
+    );
+    case(
+      InterpolationLine {
+        contents: "foo",
+        closed: true,
+      },
+      InterpolationLine {
+        contents: "foo",
+        closed: true,
+      },
+    );
+    case(
+      InterpolationLine {
+        contents: "foo",
+        closed: false,
+      },
+      InterpolationLine {
+        contents: "foo",
+        closed: false,
+      },
+    );
+  }
+
+  #[test]
+  fn incompatibility() {
+    #[track_caller]
+    fn case(a: Token, b: Token) {
+      assert!(!a.is_compatible_with(b));
+    }
+    case(
+      Text {
+        contents: "foo",
+        index: 0,
+      },
+      Code { contents: "bar" },
+    );
+    case(Code { contents: "foo" }, Interpolation { contents: "bar" });
+    case(
+      Interpolation { contents: "foo" },
+      InterpolationLine {
+        contents: "bar",
+        closed: false,
+      },
+    );
+    case(
+      InterpolationLine {
+        contents: "foo",
+        closed: true,
+      },
+      InterpolationLine {
+        contents: "bar",
+        closed: true,
+      },
+    );
+    case(
+      InterpolationLine {
+        contents: "foo",
+        closed: true,
+      },
+      InterpolationLine {
+        contents: "foo",
+        closed: false,
+      },
+    );
+  }
+
   #[track_caller]
   fn assert_parse(expected: &str, expected_tokens: &[Token]) {
     let actual_tokens = Token::parse(expected).unwrap();

src/lib.rs

@@ -451,7 +451,14 @@
 //!     "template blocks are not compatible: {{self.id}} != {{self.first}}",
 //!   );
 //!
-//!   // Try to reload an incompatible template with a different number of code blocks:
+//!   // Text blocks cannot be removed entirely:
+//!   let incompatible_template = "{{ self.first }}";
+//!   assert_eq!(
+//!     context.reload(incompatible_template).err().unwrap().to_string(),
+//!     "new template has 1 blocks but old template has 3 blocks",
+//!   );
+//!
+//!   // Try to reload an incompatible template with a different number of blocks:
 //!   let incompatible_template = "Goodbye, {{self.first}} {{self.last}}!";
 //!   assert_eq!(
 //!     context.reload(incompatible_template).err().unwrap().to_string(),
@@ -610,14 +617,15 @@ pub trait Boilerplate {
   fn reload<'a>(&self, src: &'a str) -> Result<Reload<&Self>, Error<'a>> {
     let tokens = Token::parse(src).map_err(Error::Parse)?;
 
-    let new = tokens.len();
-    let old = Self::TOKENS.len();
-    if new != old {
-      return Err(Error::Length { new, old });
+    if tokens.len() != Self::TOKENS.len() {
+      return Err(Error::Length {
+        new: tokens.len(),
+        old: Self::TOKENS.len(),
+      });
     }
 
-    for (&new, &old) in tokens.iter().zip(Self::TOKENS) {
-      if !new.is_compatible_with(&old) {
+    for (new, old) in tokens.iter().copied().zip(Self::TOKENS.iter().copied()) {
+      if !new.is_compatible_with(old) {
         return Err(Error::Incompatible { new, old });
       }
     }