Added support for brackets in boolean expressions

CHANGELOG.md

@@ -7,6 +7,7 @@
 - Added support for resolving superclass properties for not-NSObject subclasses
 - The `{% for %}` tag can now iterate over tuples, structures and classes via
   their stored properties.
+- You can now use brackets in boolean expressions to change operators precedence
 
 ### Bug Fixes
 

Sources/IfTag.swift

@@ -38,10 +38,11 @@ func findOperator(name: String) -> Operator? {
 }
 
 
-enum IfToken {
+indirect enum IfToken {
   case infix(name: String, bindingPower: Int, op: InfixOperator.Type)
   case prefix(name: String, bindingPower: Int, op: PrefixOperator.Type)
   case variable(Resolvable)
+  case subExpression(Expression)
   case end
 
   var bindingPower: Int {
@@ -52,6 +53,8 @@ enum IfToken {
       return bindingPower
     case .variable(_):
       return 0
+    case .subExpression(_):
+      return 0
     case .end:
         return 0
     }
@@ -66,6 +69,8 @@ enum IfToken {
       return op.init(expression: expression)
     case .variable(let variable):
       return VariableExpression(variable: variable)
+    case .subExpression(let expression):
+      return expression
     case .end:
       throw TemplateSyntaxError("'if' expression error: end")
     }
@@ -80,6 +85,8 @@ enum IfToken {
       throw TemplateSyntaxError("'if' expression error: prefix operator '\(name)' was called with a left hand side")
     case .variable(let variable):
       throw TemplateSyntaxError("'if' expression error: variable '\(variable)' was called with a left hand side")
+    case .subExpression(_):
+      throw TemplateSyntaxError("'if' expression error: sub expression was called with a left hand side")
     case .end:
       throw TemplateSyntaxError("'if' expression error: end")
     }
@@ -100,21 +107,74 @@ final class IfExpressionParser {
   let tokens: [IfToken]
   var position: Int = 0
 
-  init(components: [String], tokenParser: TokenParser) throws {
-    self.tokens = try components.map { component in
-      if let op = findOperator(name: component) {
-        switch op {
-        case .infix(let name, let bindingPower, let cls):
-          return .infix(name: name, bindingPower: bindingPower, op: cls)
-        case .prefix(let name, let bindingPower, let cls):
-          return .prefix(name: name, bindingPower: bindingPower, op: cls)
+  private init(tokens: [IfToken]) {
+    self.tokens = tokens
+  }
+
+  static func parser(components: [String], tokenParser: TokenParser) throws -> IfExpressionParser {
+    try IfExpressionParser.validateBracketsBalance(components: components)
+    return try IfExpressionParser(components: components, tokenParser: tokenParser)
+  }
+
+  static func validateBracketsBalance(components: [String]) throws {
+    guard try components.reduce(0, {
+      var bracketsBalance = $0
+      if $1 == "(" { bracketsBalance += 1 }
+      else if $1 == ")" { bracketsBalance -= 1 }
+      if bracketsBalance < 0 { throw TemplateSyntaxError("unbalanced brackets") }
+      return bracketsBalance
+    }) == 0 else {
+      throw TemplateSyntaxError("unbalanced brackets")
+    }
+  }
+
+  private init(components: [String], tokenParser: TokenParser) throws {
+    var parsedComponents = [String]()
+    self.tokens = try components.enumerated().flatMap { index, component in
+      if component == "(" {
+        let (expression, parsed) = try IfExpressionParser.subExpression(
+          from: index + 1,
+          components: components,
+          tokenParser: tokenParser
+        )
+        parsedComponents.append(contentsOf: parsed)
+        return .subExpression(expression)
+      }
+      else if component == ")" {
+        parsedComponents.append(component)
+        return nil
+      } else if index >= parsedComponents.count {
+        parsedComponents.append(component)
+        if let op = findOperator(name: component) {
+          switch op {
+          case .infix(let name, let bindingPower, let cls):
+            return .infix(name: name, bindingPower: bindingPower, op: cls)
+          case .prefix(let name, let bindingPower, let cls):
+            return .prefix(name: name, bindingPower: bindingPower, op: cls)
+          }
         }
+        return .variable(try tokenParser.compileFilter(component))
+      } else {
+        return nil
       }
-
-      return .variable(try tokenParser.compileFilter(component))
     }
   }
 
+  static func subExpression(from index: Int, components: [String], tokenParser: TokenParser) throws -> (Expression, [String]) {
+    var bracketsBalance = 1
+    let subComponents = Array(components
+      .suffix(from: index)
+      .prefix(while: {
+        if $0 == "(" { bracketsBalance += 1 }
+        else if $0 == ")" { bracketsBalance -= 1 }
+        return bracketsBalance != 0
+      }))
+
+    let expressionParser = try IfExpressionParser(components: subComponents, tokenParser: tokenParser)
+    let expression = try expressionParser.parse()
+    return (expression, ["("] + subComponents + [")"])
+  }
+
   var currentToken: IfToken {
     if tokens.count > position {
       return tokens[position]
@@ -154,13 +214,11 @@ final class IfExpressionParser {
   }
 }
 
-
 func parseExpression(components: [String], tokenParser: TokenParser) throws -> Expression {
-  let parser = try IfExpressionParser(components: components, tokenParser: tokenParser)
+  let parser = try IfExpressionParser.parser(components: components, tokenParser: tokenParser)
   return try parser.parse()
 }
 
-
 /// Represents an if condition and the associated nodes when the condition
 /// evaluates
 final class IfCondition {

Tests/StencilTests/ExpressionSpec.swift

@@ -295,6 +295,35 @@ func testExpressions() {
           try expect(expression.evaluate(context: Context(dictionary: ["lhs": "a", "rhs": "bcd"]))).to.beFalse()
         }
       }
+
+      $0.describe("sub expression") {
+        $0.it("evaluates correctly") {
+          let context = Context(dictionary: ["one": false, "two": false, "three": true])
+
+          let expression = try! parseExpression(components: ["one", "and", "two", "or", "three"], tokenParser: parser)
+          let expressionWithBrackets = try! parseExpression(components: ["one", "and", "(", "two", "or", "three", ")"], tokenParser: parser)
+
+          try expect(expression.evaluate(context: context)).to.beTrue()
+          try expect(expressionWithBrackets.evaluate(context: context)).to.beFalse()
+
+          let notExpression = try! parseExpression(components: ["not", "one", "or", "three"], tokenParser: parser)
+          let notExpressionWithBrackets = try! parseExpression(components: ["not", "(", "one", "or", "three", ")"], tokenParser: parser)
+
+          try expect(notExpression.evaluate(context: context)).to.beTrue()
+          try expect(notExpressionWithBrackets.evaluate(context: context)).to.beFalse()
+        }
+
+        $0.it("fails when brackets are not balanced") {
+          try expect(parseExpression(components: ["(", "lhs", "and", "rhs"], tokenParser: parser)).toThrow()
+          try expect(parseExpression(components: [")", "lhs", "and", "rhs"], tokenParser: parser)).toThrow()
+          try expect(parseExpression(components: ["(", "lhs", "and", "rhs", ")", "("], tokenParser: parser)).toThrow()
+          try expect(parseExpression(components: ["(", "lhs", "and", "rhs", ")", ")"], tokenParser: parser)).toThrow()
+          try expect(parseExpression(components: ["(", "lhs", "and", "rhs", ")", ")"], tokenParser: parser)).toThrow()
+          try expect(parseExpression(components: ["(", "lhs", "and", ")"], tokenParser: parser)).toThrow()
+          try expect(parseExpression(components: ["(", "and", "rhs", ")"], tokenParser: parser)).toThrow()
+        }
+      }
+
     }
   }
 }