Update code to match Stencil changes

djbe · djbe · commit dd5cb8407cca · 2018-08-27T01:15:28.000+02:00
- Add `token` attribute for better errors support - Switches to resolvable where possible - Had to make the `CallableBlock` a non-`NodeType` to avoid rendering during resolvable resolution

t
diff --git a/Sources/CallMacroNodes.swift b/Sources/CallMacroNodes.swift
@@ -6,10 +6,15 @@
 
 import Stencil
 
-struct CallableBlock: NodeType {
+struct CallableBlock {
   let parameters: [String]
   let nodes: [NodeType]
 
+  init(parameters: [String], nodes: [NodeType], token: Token? = nil) {
+    self.parameters = parameters
+    self.nodes = nodes
+  }
+
   func context(_ context: Context, arguments: [Resolvable]) throws -> [String: Any] {
     var result = [String: Any]()
 
@@ -19,16 +24,13 @@ struct CallableBlock: NodeType {
 
     return result
   }
-
-  func render(_ context: Context) throws -> String {
-    throw TemplateSyntaxError("A callable block must be called using the 'call' tag.")
-  }
 }
 
 class MacroNode: NodeType {
   let variableName: String
   let parameters: [String]
   let nodes: [NodeType]
+  let token: Token?
 
   class func parse(_ parser: TokenParser, token: Token) throws -> NodeType {
     let components = token.components()
@@ -43,49 +45,55 @@ class MacroNode: NodeType {
       throw TemplateSyntaxError("`endmacro` was not found.")
     }
 
-    return MacroNode(variableName: variable, parameters: parameters, nodes: setNodes)
+    return MacroNode(variableName: variable, parameters: parameters, nodes: setNodes, token: token)
   }
 
-  init(variableName: String, parameters: [String], nodes: [NodeType]) {
+  init(variableName: String, parameters: [String], nodes: [NodeType], token: Token? = nil) {
     self.variableName = variableName
     self.parameters = parameters
     self.nodes = nodes
+    self.token = token
   }
 
   func render(_ context: Context) throws -> String {
-    let result = CallableBlock(parameters: parameters, nodes: nodes)
+    let result = CallableBlock(parameters: parameters, nodes: nodes, token: token)
     context[variableName] = result
     return ""
   }
 }
 
 class CallNode: NodeType {
-  let variableName: String
+  let variable: Variable
   let arguments: [Resolvable]
+  let token: Token?
 
   class func parse(_ parser: TokenParser, token: Token) throws -> NodeType {
     let components = token.components()
     guard components.count >= 2 else {
       throw TemplateSyntaxError("'call' tag takes at least one argument, the name of the block to call.")
     }
-    let variable = components[1]
-    let arguments = try Array(components.dropFirst(2)).map(parser.compileFilter)
 
-    return CallNode(variableName: variable, arguments: arguments)
+    let variable = Variable(components[1])
+    let arguments = try Array(components.dropFirst(2)).map {
+      try parser.compileResolvable($0, containedIn: token)
+    }
+
+    return CallNode(variable: variable, arguments: arguments, token: token)
   }
 
-  init(variableName: String, arguments: [Resolvable]) {
-    self.variableName = variableName
+  init(variable: Variable, arguments: [Resolvable], token: Token? = nil) {
+    self.variable = variable
     self.arguments = arguments
+    self.token = token
   }
 
   func render(_ context: Context) throws -> String {
-    guard let block = context[variableName] as? CallableBlock else {
-      throw TemplateSyntaxError("Call to undefined block '\(variableName)'.")
+    guard let block = try variable.resolve(context) as? CallableBlock else {
+      throw TemplateSyntaxError("Call to undefined block '\(variable.variable)'.")
     }
     guard block.parameters.count == arguments.count else {
       throw TemplateSyntaxError("""
-        Block '\(variableName)' accepts \(block.parameters.count) parameters, \
+        Block '\(variable.variable)' accepts \(block.parameters.count) parameters, \
         \(arguments.count) given.
         """)
     }
diff --git a/Sources/MapNode.swift b/Sources/MapNode.swift
@@ -8,28 +8,33 @@
 import Stencil
 
 class MapNode: NodeType {
-  let variable: Variable
+  let resolvable: Resolvable
   let resultName: String
   let mapVariable: String?
   let nodes: [NodeType]
+  let token: Token?
 
   class func parse(parser: TokenParser, token: Token) throws -> NodeType {
     let components = token.components()
 
-    guard components.count == 4 && components[2] == "into" ||
-      components.count == 6 && components[2] == "into" && components[4] == "using" else {
+    func hasToken(_ token: String, at index: Int) -> Bool {
+      return components.count > (index + 1) && components[index] == token
+    }
+
+    func endsOrHasToken(_ token: String, at index: Int) -> Bool {
+      return components.count == index || hasToken(token, at: index)
+    }
+
+    guard hasToken("into", at: 2) && endsOrHasToken("using", at: 4) else {
         throw TemplateSyntaxError("""
           'map' statements should use the following 'map {array} into \
-          {varname} [using {element}]' `\(token.contents)`.
+          {varname} [using {element}]'.
           """)
     }
 
-    let variable = components[1]
+    let resolvable = try parser.compileResolvable(components[1], containedIn: token)
     let resultName = components[3]
-    var mapVariable: String? = nil
-    if components.count > 4 {
-      mapVariable = components[5]
-    }
+    let mapVariable = hasToken("using", at: 4) ? components[5] : nil
 
     let mapNodes = try parser.parse(until(["endmap", "empty"]))
 
@@ -41,18 +46,25 @@ class MapNode: NodeType {
       _ = parser.nextToken()
     }
 
-    return MapNode(variable: variable, resultName: resultName, mapVariable: mapVariable, nodes: mapNodes)
+    return MapNode(
+      resolvable: resolvable,
+      resultName: resultName,
+      mapVariable: mapVariable,
+      nodes: mapNodes,
+      token: token
+    )
   }
 
-  init(variable: String, resultName: String, mapVariable: String?, nodes: [NodeType]) {
-    self.variable = Variable(variable)
+  init(resolvable: Resolvable, resultName: String, mapVariable: String?, nodes: [NodeType], token: Token? = nil) {
+    self.resolvable = resolvable
     self.resultName = resultName
     self.mapVariable = mapVariable
     self.nodes = nodes
+    self.token = token
   }
 
   func render(_ context: Context) throws -> String {
-    let values = try variable.resolve(context)
+    let values = try resolvable.resolve(context)
 
     if let values = values as? [Any], !values.isEmpty {
       let mappedValues: [String] = try values.enumerated().map { index, item in
diff --git a/Sources/SetNode.swift b/Sources/SetNode.swift
@@ -14,6 +14,7 @@ class SetNode: NodeType {
 
   let variableName: String
   let content: Content
+  let token: Token?
 
   class func parse(_ parser: TokenParser, token: Token) throws -> NodeType {
     let components = token.components()
@@ -27,8 +28,8 @@ class SetNode: NodeType {
     let variable = components[1]
     if components.count == 3 {
       // we have a value expression, no nodes
-      let value = try parser.compileFilter(components[2])
-      return SetNode(variableName: variable, content: .reference(to: value))
+      let resolvable = try parser.compileResolvable(components[1], containedIn: token)
+      return SetNode(variableName: variable, content: .reference(to: resolvable))
     } else {
       // no value expression, parse until an `endset` node
       let setNodes = try parser.parse(until(["endset"]))
@@ -37,13 +38,14 @@ class SetNode: NodeType {
         throw TemplateSyntaxError("`endset` was not found.")
       }
 
-      return SetNode(variableName: variable, content: .nodes(setNodes))
+      return SetNode(variableName: variable, content: .nodes(setNodes), token: token)
     }
   }
 
-  init(variableName: String, content: Content) {
+  init(variableName: String, content: Content, token: Token? = nil) {
     self.variableName = variableName
     self.content = content
+    self.token = token
   }
 
   func render(_ context: Context) throws -> String {
diff --git a/Tests/StencilSwiftKitTests/CallNodeTests.swift b/Tests/StencilSwiftKitTests/CallNodeTests.swift
@@ -11,7 +11,7 @@ import XCTest
 class CallNodeTests: XCTestCase {
   func testParser() {
     let tokens: [Token] = [
-      .block(value: "call myFunc")
+      .block(value: "call myFunc", at: .unknown)
     ]
 
     let parser = TokenParser(tokens: tokens, environment: stencilSwiftEnvironment())
@@ -21,13 +21,13 @@ class CallNodeTests: XCTestCase {
       return
     }
 
-    XCTAssertEqual(node.variableName, "myFunc")
+    XCTAssertEqual(node.variable.variable, "myFunc")
     XCTAssertEqual(node.arguments.count, 0)
   }
 
   func testParserWithArguments() {
     let tokens: [Token] = [
-      .block(value: "call myFunc a b c")
+      .block(value: "call myFunc a b c", at: .unknown)
     ]
 
     let parser = TokenParser(tokens: tokens, environment: stencilSwiftEnvironment())
@@ -37,15 +37,15 @@ class CallNodeTests: XCTestCase {
       return
     }
 
-    XCTAssertEqual(node.variableName, "myFunc")
+    XCTAssertEqual(node.variable.variable, "myFunc")
     let variables = node.arguments.compactMap { $0 as? FilterExpression }.compactMap { $0.variable }
     XCTAssertEqual(variables, [Variable("a"), Variable("b"), Variable("c")])
   }
 
   func testParserFail() {
     do {
       let tokens: [Token] = [
-        .block(value: "call")
+        .block(value: "call", at: .unknown)
       ]
 
       let parser = TokenParser(tokens: tokens, environment: stencilSwiftEnvironment())
@@ -56,15 +56,15 @@ class CallNodeTests: XCTestCase {
   func testRender() throws {
     let block = CallableBlock(parameters: [], nodes: [TextNode(text: "hello")])
     let context = Context(dictionary: ["myFunc": block])
-    let node = CallNode(variableName: "myFunc", arguments: [])
+    let node = CallNode(variable: Variable("myFunc"), arguments: [])
     let output = try node.render(context)
 
     XCTAssertEqual(output, "hello")
   }
 
   func testRenderFail() {
     let context = Context(dictionary: [:])
-    let node = CallNode(variableName: "myFunc", arguments: [])
+    let node = CallNode(variable: Variable("myFunc"), arguments: [])
 
     XCTAssertThrowsError(try node.render(context))
   }
@@ -77,7 +77,7 @@ class CallNodeTests: XCTestCase {
       VariableNode(variable: "c")
     ])
     let context = Context(dictionary: ["myFunc": block])
-    let node = CallNode(variableName: "myFunc", arguments: [
+    let node = CallNode(variable: Variable("myFunc"), arguments: [
       Variable("\"hello\""),
       Variable("\"world\""),
       Variable("\"test\"")
@@ -98,21 +98,21 @@ class CallNodeTests: XCTestCase {
 
     // must pass arguments
     do {
-      let node = CallNode(variableName: "myFunc", arguments: [])
+      let node = CallNode(variable: Variable("myFunc"), arguments: [])
       XCTAssertThrowsError(try node.render(context))
     }
 
     // not enough arguments
     do {
-      let node = CallNode(variableName: "myFunc", arguments: [
+      let node = CallNode(variable: Variable("myFunc"), arguments: [
         Variable("\"hello\"")
       ])
       XCTAssertThrowsError(try node.render(context))
     }
 
     // too many arguments
     do {
-      let node = CallNode(variableName: "myFunc", arguments: [
+      let node = CallNode(variable: Variable("myFunc"), arguments: [
         Variable("\"hello\""),
         Variable("\"world\""),
         Variable("\"test\""),
diff --git a/Tests/StencilSwiftKitTests/MacroNodeTests.swift b/Tests/StencilSwiftKitTests/MacroNodeTests.swift
@@ -11,9 +11,9 @@ import XCTest
 class MacroNodeTests: XCTestCase {
   func testParser() {
     let tokens: [Token] = [
-      .block(value: "macro myFunc"),
-      .text(value: "hello"),
-      .block(value: "endmacro")
+      .block(value: "macro myFunc", at: .unknown),
+      .text(value: "hello", at: .unknown),
+      .block(value: "endmacro", at: .unknown)
     ]
 
     let parser = TokenParser(tokens: tokens, environment: stencilSwiftEnvironment())
@@ -31,9 +31,9 @@ class MacroNodeTests: XCTestCase {
 
   func testParserWithParameters() {
     let tokens: [Token] = [
-      .block(value: "macro myFunc a b c"),
-      .text(value: "hello"),
-      .block(value: "endmacro")
+      .block(value: "macro myFunc a b c", at: .unknown),
+      .text(value: "hello", at: .unknown),
+      .block(value: "endmacro", at: .unknown)
     ]
 
     let parser = TokenParser(tokens: tokens, environment: stencilSwiftEnvironment())
@@ -52,8 +52,8 @@ class MacroNodeTests: XCTestCase {
   func testParserFail() {
     do {
       let tokens: [Token] = [
-        .block(value: "macro myFunc"),
-        .text(value: "hello")
+        .block(value: "macro myFunc", at: .unknown),
+        .text(value: "hello", at: .unknown)
       ]
 
       let parser = TokenParser(tokens: tokens, environment: stencilSwiftEnvironment())
@@ -62,9 +62,9 @@ class MacroNodeTests: XCTestCase {
 
     do {
       let tokens: [Token] = [
-        .block(value: "macro"),
-        .text(value: "hello"),
-        .block(value: "endmacro")
+        .block(value: "macro", at: .unknown),
+        .text(value: "hello", at: .unknown),
+        .block(value: "endmacro", at: .unknown)
       ]
 
       let parser = TokenParser(tokens: tokens, environment: stencilSwiftEnvironment())
@@ -116,13 +116,6 @@ class MacroNodeTests: XCTestCase {
     XCTAssert(block.nodes.first is TextNode)
   }
 
-  func testCallableBlockRender() {
-    let block = CallableBlock(parameters: [], nodes: [TextNode(text: "hello")])
-    let context = Context(dictionary: [:])
-
-    XCTAssertThrowsError(try block.render(context))
-  }
-
   func testCallableBlockContext() throws {
     let block = CallableBlock(parameters: ["p1", "p2", "p3"], nodes: [TextNode(text: "hello")])
     let arguments = [Variable("a"), Variable("b"), Variable("\"hello\"")]
diff --git a/Tests/StencilSwiftKitTests/MapNodeTests.swift b/Tests/StencilSwiftKitTests/MapNodeTests.swift
diff --git a/Tests/StencilSwiftKitTests/SetNodeTests.swift b/Tests/StencilSwiftKitTests/SetNodeTests.swift
