Merge pull request #91 from GuillaumeGomez/cond-evaluation

Add handling of boolean literals to condition evaluation

Author: Kijewski

rinja_derive/src/generator.rs

@@ -372,8 +372,7 @@ impl<'a> Generator<'a> {
         only_contains_is_defined: &mut bool,
     ) -> EvaluatedResult {
         match **expr {
-            Expr::BoolLit(_)
-            | Expr::NumLit(_)
+            Expr::NumLit(_)
             | Expr::StrLit(_)
             | Expr::CharLit(_)
             | Expr::Var(_)
@@ -392,6 +391,8 @@ impl<'a> Generator<'a> {
                 *only_contains_is_defined = false;
                 EvaluatedResult::Unknown
             }
+            Expr::BoolLit(true) => EvaluatedResult::AlwaysTrue,
+            Expr::BoolLit(false) => EvaluatedResult::AlwaysFalse,
             Expr::Unary("!", ref inner) => {
                 match self.evaluate_condition(inner, only_contains_is_defined) {
                     EvaluatedResult::AlwaysTrue => EvaluatedResult::AlwaysFalse,
@@ -1888,8 +1889,12 @@ impl<'a> Generator<'a> {
         DisplayWrap::Wrapped
     }
 
-    fn visit_bool_lit(&mut self, buf: &mut Buffer, s: &str) -> DisplayWrap {
-        buf.write(s);
+    fn visit_bool_lit(&mut self, buf: &mut Buffer, s: bool) -> DisplayWrap {
+        if s {
+            buf.write("true");
+        } else {
+            buf.write("false");
+        }
         DisplayWrap::Unwrapped
     }
 

rinja_derive/src/tests.rs

@@ -334,3 +334,95 @@ writer.write_str("12")?;
         3,
     );
 }
+
+#[test]
+fn check_bool_conditions() {
+    // Checks that it removes conditions if we know at compile-time that they always return false.
+    //
+    // We're forced to add `bla` otherwise `compare` assert fails in weird ways...
+    compare(
+        "{% if false %}{{query}}{% endif %}bla",
+        r#"writer.write_str("bla")?;"#,
+        &[],
+        3,
+    );
+    compare(
+        "{% if false && false %}{{query}}{% endif %}bla",
+        r#"writer.write_str("bla")?;"#,
+        &[],
+        3,
+    );
+    compare(
+        "{% if false && true %}{{query}}{% endif %}bla",
+        r#"writer.write_str("bla")?;"#,
+        &[],
+        3,
+    );
+    compare(
+        "{% if true && false %}{{query}}{% endif %}bla",
+        r#"writer.write_str("bla")?;"#,
+        &[],
+        3,
+    );
+    compare(
+        "{% if false || true %}bli{% endif %}bla",
+        r#"writer.write_str("blibla")?;"#,
+        &[],
+        6,
+    );
+    compare(
+        "{% if true || false %}bli{% endif %}bla",
+        r#"writer.write_str("blibla")?;"#,
+        &[],
+        6,
+    );
+
+    compare(
+        "{% if true || x == 12 %}{{x}}{% endif %}",
+        r#"if *(&(true || self.x == 12) as &bool) {
+    match (
+        &((&&::rinja::filters::AutoEscaper::new(&(self.x), ::rinja::filters::Text)).rinja_auto_escape()?),
+    ) {
+        (expr0,) => {
+            (&&::rinja::filters::Writable(expr0)).rinja_write(writer)?;
+        }
+    }
+}
+"#,
+        &[("x", "u32")],
+        3,
+    );
+    compare(
+        "{% if false || x == 12 %}{{x}}{% endif %}",
+        r#"if *(&(false || self.x == 12) as &bool) {
+    match (
+        &((&&::rinja::filters::AutoEscaper::new(
+            &(self.x),
+            ::rinja::filters::Text,
+        ))
+            .rinja_auto_escape()?),
+    ) {
+        (expr0,) => {
+            (&&::rinja::filters::Writable(expr0)).rinja_write(writer)?;
+        }
+    }
+}
+"#,
+        &[("x", "u32")],
+        3,
+    );
+
+    // Some funny cases.
+    compare(
+        "{% if !(false) %}bla{% endif %}",
+        r#"writer.write_str("bla")?;"#,
+        &[],
+        3,
+    );
+    compare(
+        "{% if !(true) %}{{query}}{% endif %}bla",
+        r#"writer.write_str("bla")?;"#,
+        &[],
+        3,
+    );
+}

rinja_parser/src/expr.rs

@@ -35,7 +35,7 @@ macro_rules! expr_prec_layer {
 
 #[derive(Clone, Debug, PartialEq)]
 pub enum Expr<'a> {
-    BoolLit(&'a str),
+    BoolLit(bool),
     NumLit(&'a str),
     StrLit(&'a str),
     CharLit(&'a str),
@@ -334,8 +334,8 @@ impl<'a> Expr<'a> {
         let start = i;
         map(path_or_identifier, |v| match v {
             PathOrIdentifier::Path(v) => Self::Path(v),
-            PathOrIdentifier::Identifier(v @ "true") => Self::BoolLit(v),
-            PathOrIdentifier::Identifier(v @ "false") => Self::BoolLit(v),
+            PathOrIdentifier::Identifier("true") => Self::BoolLit(true),
+            PathOrIdentifier::Identifier("false") => Self::BoolLit(false),
             PathOrIdentifier::Identifier(v) => Self::Var(v),
         })(i)
         .map(|(i, expr)| (i, WithSpan::new(expr, start)))