Fix issues in Tests

t

Tests/StencilTests/ContextSpec.swift

@@ -1,14 +1,11 @@
-import XCTest
 import Spectre
 @testable import Stencil
+import XCTest
 
-
+final class ContextTests: XCTestCase {
-class ContextTests: XCTestCase {
+  func testContextSubscripting() {
-  
+    describe("Context Subscripting") {
-  func testContext() {
+      var context = Context()
-    describe("Context") {
-      var context: Context!
-
       $0.before {
         context = Context(dictionary: ["name": "Kyle"])
       }
@@ -41,6 +38,15 @@ class ContextTests: XCTestCase {
           try expect(context["name"] as? String) == "Katie"
         }
       }
+    }
+  }
+
+  func testContextRestoration() {
+    describe("Context Restoration") {
+      var context = Context()
+      $0.before {
+        context = Context(dictionary: ["name": "Kyle"])
+      }
 
       $0.it("allows you to pop to restore previous state") {
         context.push {

Tests/StencilTests/EnvironmentSpec.swift

@@ -1,224 +1,223 @@
-import XCTest
-import Spectre
 import PathKit
+import Spectre
 @testable import Stencil
+import XCTest
 
-class EnvironmentTests: XCTestCase {
+final class EnvironmentTests: XCTestCase {
-  func testEnvironment() {
+  var environment = Environment(loader: ExampleLoader())
-    describe("Environment") {
+  var template: Template = ""
-      var environment: Environment!
+
-      var template: Template!
+  override func setUp() {
+    super.setUp()
+
+    let errorExtension = Extension()
+    errorExtension.registerFilter("throw") { (_: Any?) in
+      throw TemplateSyntaxError("filter error")
+    }
+    errorExtension.registerSimpleTag("simpletag") { _ in
+      throw TemplateSyntaxError("simpletag error")
+    }
+    errorExtension.registerTag("customtag") { _, token in
+      ErrorNode(token: token)
+    }
 
-      $0.before {
     environment = Environment(loader: ExampleLoader())
-        template = nil
+    environment.extensions += [errorExtension]
+    template = ""
   }
 
-      $0.it("can load a template from a name") {
+  func testLoading() {
-        let template = try environment.loadTemplate(name: "example.html")
+    it("can load a template from a name") {
+      let template = try self.environment.loadTemplate(name: "example.html")
       try expect(template.name) == "example.html"
     }
 
-      $0.it("can load a template from a names") {
+    it("can load a template from a names") {
-        let template = try environment.loadTemplate(names: ["first.html", "example.html"])
+      let template = try self.environment.loadTemplate(names: ["first.html", "example.html"])
       try expect(template.name) == "example.html"
     }
+  }
 
-      $0.it("can render a template from a string") {
+  func testRendering() {
-        let result = try environment.renderTemplate(string: "Hello World")
+    it("can render a template from a string") {
+      let result = try self.environment.renderTemplate(string: "Hello World")
       try expect(result) == "Hello World"
     }
 
-      $0.it("can render a template from a file") {
+    it("can render a template from a file") {
-        let result = try environment.renderTemplate(name: "example.html")
+      let result = try self.environment.renderTemplate(name: "example.html")
       try expect(result) == "Hello World!"
     }
 
-      $0.it("allows you to provide a custom template class") {
+    it("allows you to provide a custom template class") {
       let environment = Environment(loader: ExampleLoader(), templateClass: CustomTemplate.self)
       let result = try environment.renderTemplate(string: "Hello World")
 
       try expect(result) == "here"
     }
-
-      func expectedSyntaxError(token: String, template: Template, description: String) -> TemplateSyntaxError {
-        guard let range = template.templateString.range(of: token) else {
-          fatalError("Can't find '\(token)' in '\(template)'")
-        }
-        let lexer = Lexer(templateString: template.templateString)
-        let location = lexer.rangeLocation(range)
-        let sourceMap = SourceMap(filename: template.name, location: location)
-        let token = Token.block(value: token, at: sourceMap)
-        return TemplateSyntaxError(reason: description, token: token, stackTrace: [])
   }
 
-      func expectError(reason: String, token: String,
+  func testSyntaxError() {
-                       file: String = #file, line: Int = #line, function: String = #function) throws {
+    it("reports syntax error on invalid for tag syntax") {
+      self.template = "Hello {% for name in %}{{ name }}, {% endfor %}!"
+      try self.expectError(
+        reason: "'for' statements should use the syntax: `for <x> in <y> [where <condition>]`.",
+        token: "for name in"
+      )
+    }
+
+    it("reports syntax error on missing endfor") {
+      self.template = "{% for name in names %}{{ name }}"
+      try self.expectError(reason: "`endfor` was not found.", token: "for name in names")
+    }
+
+    it("reports syntax error on unknown tag") {
+      self.template = "{% for name in names %}{{ name }}{% end %}"
+      try self.expectError(reason: "Unknown template tag 'end'", token: "end")
+    }
+  }
+
+  func testUnknownFilter() {
+    it("reports syntax error in for tag") {
+      self.template = "{% for name in names|unknown %}{{ name }}{% endfor %}"
+      try self.expectError(
+        reason: "Unknown filter 'unknown'. Found similar filters: 'uppercase'.",
+        token: "names|unknown"
+      )
+    }
+
+    it("reports syntax error in for-where tag") {
+      self.template = "{% for name in names where name|unknown %}{{ name }}{% endfor %}"
+      try self.expectError(
+        reason: "Unknown filter 'unknown'. Found similar filters: 'uppercase'.",
+        token: "name|unknown"
+      )
+    }
+
+    it("reports syntax error in if tag") {
+      self.template = "{% if name|unknown %}{{ name }}{% endif %}"
+      try self.expectError(
+        reason: "Unknown filter 'unknown'. Found similar filters: 'uppercase'.",
+        token: "name|unknown"
+      )
+    }
+
+    it("reports syntax error in elif tag") {
+      self.template = "{% if name %}{{ name }}{% elif name|unknown %}{% endif %}"
+      try self.expectError(
+        reason: "Unknown filter 'unknown'. Found similar filters: 'uppercase'.",
+        token: "name|unknown"
+      )
+    }
+
+    it("reports syntax error in ifnot tag") {
+      self.template = "{% ifnot name|unknown %}{{ name }}{% endif %}"
+      try self.expectError(
+        reason: "Unknown filter 'unknown'. Found similar filters: 'uppercase'.",
+        token: "name|unknown"
+      )
+    }
+
+    it("reports syntax error in filter tag") {
+      self.template = "{% filter unknown %}Text{% endfilter %}"
+      try self.expectError(
+        reason: "Unknown filter 'unknown'. Found similar filters: 'uppercase'.",
+        token: "filter unknown"
+      )
+    }
+
+    it("reports syntax error in variable tag") {
+      self.template = "{{ name|unknown }}"
+      try self.expectError(
+        reason: "Unknown filter 'unknown'. Found similar filters: 'uppercase'.",
+        token: "name|unknown"
+      )
+    }
+  }
+
+  func testRenderingError() {
+    it("reports rendering error in variable filter") {
+      self.template = Template(templateString: "{{ name|throw }}", environment: self.environment)
+      try self.expectError(reason: "filter error", token: "name|throw")
+    }
+
+    it("reports rendering error in filter tag") {
+      self.template = Template(templateString: "{% filter throw %}Test{% endfilter %}", environment: self.environment)
+      try self.expectError(reason: "filter error", token: "filter throw")
+    }
+
+    it("reports rendering error in simple tag") {
+      self.template = Template(templateString: "{% simpletag %}", environment: self.environment)
+      try self.expectError(reason: "simpletag error", token: "simpletag")
+    }
+
+    it("reports passing argument to simple filter") {
+      self.template = "{{ name|uppercase:5 }}"
+      try self.expectError(reason: "cannot invoke filter with an argument", token: "name|uppercase:5")
+    }
+
+    it("reports rendering error in custom tag") {
+      self.template = Template(templateString: "{% customtag %}", environment: self.environment)
+      try self.expectError(reason: "Custom Error", token: "customtag")
+    }
+
+    it("reports rendering error in for body") {
+      self.template = Template(templateString: """
+        {% for name in names %}{% customtag %}{% endfor %}
+        """, environment: self.environment)
+      try self.expectError(reason: "Custom Error", token: "customtag")
+    }
+
+    it("reports rendering error in block") {
+      self.template = Template(
+        templateString: "{% block some %}{% customtag %}{% endblock %}",
+        environment: self.environment
+      )
+      try self.expectError(reason: "Custom Error", token: "customtag")
+    }
+  }
+
+  private func expectError(
+    reason: String,
+    token: String,
+    file: String = #file,
+    line: Int = #line,
+    function: String = #function
+  ) throws {
     let expectedError = expectedSyntaxError(token: token, template: template, description: reason)
 
-        let error = try expect(environment.render(template: template, context: ["names": ["Bob", "Alice"], "name": "Bob"]),
+    let error = try expect(
-                               file: file, line: line, function: function).toThrow() as TemplateSyntaxError
+      self.environment.render(template: self.template, context: ["names": ["Bob", "Alice"], "name": "Bob"]),
+      file: file,
+      line: line,
+      function: function
+    ).toThrow() as TemplateSyntaxError
     let reporter = SimpleErrorReporter()
-        try expect(reporter.renderError(error), file: file, line: line, function: function) == reporter.renderError(expectedError)
+    try expect(
-      }
+      reporter.renderError(error),
-
+      file: file,
-      $0.context("given syntax error") {
+      line: line,
-
+      function: function
-        $0.it("reports syntax error on invalid for tag syntax") {
+    ) == reporter.renderError(expectedError)
-          template = "Hello {% for name in %}{{ name }}, {% endfor %}!"
-          try expectError(reason: "'for' statements should use the syntax: `for <x> in <y> [where <condition>]`.", token: "for name in")
-        }
-
-        $0.it("reports syntax error on missing endfor") {
-          template = "{% for name in names %}{{ name }}"
-          try expectError(reason: "`endfor` was not found.", token: "for name in names")
-        }
-
-        $0.it("reports syntax error on unknown tag") {
-          template = "{% for name in names %}{{ name }}{% end %}"
-          try expectError(reason: "Unknown template tag 'end'", token: "end")
-        }
-
-      }
-
-      $0.context("given unknown filter") {
-
-        $0.it("reports syntax error in for tag") {
-          template = "{% for name in names|unknown %}{{ name }}{% endfor %}"
-          try expectError(reason: "Unknown filter 'unknown'. Found similar filters: 'uppercase'.", token: "names|unknown")
-        }
-
-        $0.it("reports syntax error in for-where tag") {
-          template = "{% for name in names where name|unknown %}{{ name }}{% endfor %}"
-          try expectError(reason: "Unknown filter 'unknown'. Found similar filters: 'uppercase'.", token: "name|unknown")
-        }
-
-        $0.it("reports syntax error in if tag") {
-          template = "{% if name|unknown %}{{ name }}{% endif %}"
-          try expectError(reason: "Unknown filter 'unknown'. Found similar filters: 'uppercase'.", token: "name|unknown")
-        }
-
-        $0.it("reports syntax error in elif tag") {
-          template = "{% if name %}{{ name }}{% elif name|unknown %}{% endif %}"
-          try expectError(reason: "Unknown filter 'unknown'. Found similar filters: 'uppercase'.", token: "name|unknown")
-        }
-
-        $0.it("reports syntax error in ifnot tag") {
-          template = "{% ifnot name|unknown %}{{ name }}{% endif %}"
-          try expectError(reason: "Unknown filter 'unknown'. Found similar filters: 'uppercase'.", token: "name|unknown")
-        }
-
-        $0.it("reports syntax error in filter tag") {
-          template = "{% filter unknown %}Text{% endfilter %}"
-          try expectError(reason: "Unknown filter 'unknown'. Found similar filters: 'uppercase'.", token: "filter unknown")
-        }
-
-        $0.it("reports syntax error in variable tag") {
-          template = "{{ name|unknown }}"
-          try expectError(reason: "Unknown filter 'unknown'. Found similar filters: 'uppercase'.", token: "name|unknown")
-        }
-
-      }
-
-      $0.context("given rendering error") {
-
-        $0.it("reports rendering error in variable filter") {
-          let filterExtension = Extension()
-          filterExtension.registerFilter("throw") { (value: Any?) in
-            throw TemplateSyntaxError("filter error")
-          }
-          environment.extensions += [filterExtension]
-
-          template = Template(templateString: "{{ name|throw }}", environment: environment)
-          try expectError(reason: "filter error", token: "name|throw")
-        }
-
-        $0.it("reports rendering error in filter tag") {
-          let filterExtension = Extension()
-          filterExtension.registerFilter("throw") { (value: Any?) in
-            throw TemplateSyntaxError("filter error")
-          }
-          environment.extensions += [filterExtension]
-
-          template = Template(templateString: "{% filter throw %}Test{% endfilter %}", environment: environment)
-          try expectError(reason: "filter error", token: "filter throw")
-        }
-
-        $0.it("reports rendering error in simple tag") {
-          let tagExtension = Extension()
-          tagExtension.registerSimpleTag("simpletag") { context in
-            throw TemplateSyntaxError("simpletag error")
-          }
-          environment.extensions += [tagExtension]
-
-          template = Template(templateString: "{% simpletag %}", environment: environment)
-          try expectError(reason: "simpletag error", token: "simpletag")
-        }
-
-        $0.it("reporsts passing argument to simple filter") {
-          template = "{{ name|uppercase:5 }}"
-          try expectError(reason: "cannot invoke filter with an argument", token: "name|uppercase:5")
-        }
-
-        $0.it("reports rendering error in custom tag") {
-          let tagExtension = Extension()
-          tagExtension.registerTag("customtag") { parser, token in
-            return ErrorNode(token: token)
-          }
-          environment.extensions += [tagExtension]
-
-          template = Template(templateString: "{% customtag %}", environment: environment)
-          try expectError(reason: "Custom Error", token: "customtag")
-        }
-
-        $0.it("reports rendering error in for body") {
-          let tagExtension = Extension()
-          tagExtension.registerTag("customtag") { parser, token in
-            return ErrorNode(token: token)
-          }
-          environment.extensions += [tagExtension]
-
-          template = Template(templateString: "{% for name in names %}{% customtag %}{% endfor %}", environment: environment)
-          try expectError(reason: "Custom Error", token: "customtag")
-        }
-
-        $0.it("reports rendering error in block") {
-          let tagExtension = Extension()
-          tagExtension.registerTag("customtag") { parser, token in
-            return ErrorNode(token: token)
-          }
-          environment.extensions += [tagExtension]
-
-          template = Template(templateString: "{% block some %}{% customtag %}{% endblock %}", environment: environment)
-          try expectError(reason: "Custom Error", token: "customtag")
   }
 }
 
-      $0.context("given included template") {
+final class EnvironmentIncludeTemplateTests: XCTestCase {
+  var environment = Environment(loader: ExampleLoader())
+  var template: Template = ""
+  var includedTemplate: Template = ""
+
+  override func setUp() {
+    super.setUp()
+
     let path = Path(#file) + ".." + "fixtures"
     let loader = FileSystemLoader(paths: [path])
-        var environment = Environment(loader: loader)
-        var template: Template!
-        var includedTemplate: Template!
-
-        $0.before {
     environment = Environment(loader: loader)
-          template = nil
+    template = ""
-          includedTemplate = nil
+    includedTemplate = ""
   }
 
-        func expectError(reason: String, token: String, includedToken: String,
+  func testSyntaxError() throws {
-                         file: String = #file, line: Int = #line, function: String = #function) throws {
-          var expectedError = expectedSyntaxError(token: token, template: template, description: reason)
-          expectedError.stackTrace = [expectedSyntaxError(token: includedToken, template: includedTemplate, description: reason).token!]
-
-          let error = try expect(environment.render(template: template, context: ["target": "World"]),
-                                 file: file, line: line, function: function).toThrow() as TemplateSyntaxError
-          let reporter = SimpleErrorReporter()
-          try expect(reporter.renderError(error), file: file, line: line, function: function) == reporter.renderError(expectedError)
-        }
-
-        $0.it("reports syntax error in included template") {
     template = Template(templateString: """
       {% include "invalid-include.html" %}
       """, environment: environment)
@@ -231,11 +230,11 @@ class EnvironmentTests: XCTestCase {
                     includedToken: "target|unknown")
   }
 
-        $0.it("reports runtime error in included template") {
+  func testRuntimeError() throws {
     let filterExtension = Extension()
-          filterExtension.registerFilter("unknown", filter: {  (_: Any?) in
+    filterExtension.registerFilter("unknown") {  (_: Any?) in
       throw TemplateSyntaxError("filter error")
-          })
+    }
     environment.extensions += [filterExtension]
 
     template = Template(templateString: """
@@ -248,34 +247,53 @@ class EnvironmentTests: XCTestCase {
                     includedToken: "target|unknown")
   }
 
+  private func expectError(
+    reason: String,
+    token: String,
+    includedToken: String,
+    file: String = #file,
+    line: Int = #line,
+    function: String = #function
+  ) throws {
+    var expectedError = expectedSyntaxError(token: token, template: template, description: reason)
+    expectedError.stackTrace = [expectedSyntaxError(
+      token: includedToken,
+      template: includedTemplate,
+      description: reason
+      ).token].compactMap { $0 }
+
+    let error = try expect(
+      self.environment.render(template: self.template, context: ["target": "World"]),
+      file: file,
+      line: line,
+      function: function
+    ).toThrow() as TemplateSyntaxError
+    let reporter = SimpleErrorReporter()
+    try expect(
+      reporter.renderError(error),
+      file: file,
+      line: line,
+      function: function
+    ) == reporter.renderError(expectedError)
+  }
 }
 
-      $0.context("given base and child templates") {
+final class EnvironmentBaseAndChildTemplateTests: XCTestCase {
+  var environment = Environment(loader: ExampleLoader())
+  var childTemplate: Template = ""
+  var baseTemplate: Template = ""
+
+  override func setUp() {
+    super.setUp()
+
     let path = Path(#file) + ".." + "fixtures"
     let loader = FileSystemLoader(paths: [path])
-        var environment: Environment!
-        var childTemplate: Template!
-        var baseTemplate: Template!
-
-        $0.before {
     environment = Environment(loader: loader)
-          childTemplate = nil
+    childTemplate = ""
-          baseTemplate = nil
+    baseTemplate = ""
   }
 
-        func expectError(reason: String, childToken: String, baseToken: String?,
+  func testSyntaxErrorInBaseTemplate() throws {
-                         file: String = #file, line: Int = #line, function: String = #function) throws {
-          var expectedError = expectedSyntaxError(token: childToken, template: childTemplate, description: reason)
-          if let baseToken = baseToken {
-            expectedError.stackTrace = [expectedSyntaxError(token: baseToken, template: baseTemplate, description: reason).token!]
-          }
-          let error = try expect(environment.render(template: childTemplate, context: ["target": "World"]),
-                                 file: file, line: line, function: function).toThrow() as TemplateSyntaxError
-          let reporter = SimpleErrorReporter()
-          try expect(reporter.renderError(error), file: file, line: line, function: function) == reporter.renderError(expectedError)
-        }
-
-        $0.it("reports syntax error in base template") {
     childTemplate = try environment.loadTemplate(name: "invalid-child-super.html")
     baseTemplate = try environment.loadTemplate(name: "invalid-base.html")
 
@@ -284,11 +302,11 @@ class EnvironmentTests: XCTestCase {
                     baseToken: "target|unknown")
   }
 
-        $0.it("reports runtime error in base template") {
+  func testRuntimeErrorInBaseTemplate() throws {
     let filterExtension = Extension()
-          filterExtension.registerFilter("unknown", filter: {  (_: Any?) in
+    filterExtension.registerFilter("unknown") {  (_: Any?) in
       throw TemplateSyntaxError("filter error")
-          })
+    }
     environment.extensions += [filterExtension]
 
     childTemplate = try environment.loadTemplate(name: "invalid-child-super.html")
@@ -299,44 +317,78 @@ class EnvironmentTests: XCTestCase {
                     baseToken: "target|unknown")
   }
 
-        $0.it("reports syntax error in child template") {
+  func testSyntaxErrorInChildTemplate() throws {
-          childTemplate = Template(templateString: """
+    childTemplate = Template(
+      templateString: """
       {% extends "base.html" %}
       {% block body %}Child {{ target|unknown }}{% endblock %}
-          """, environment: environment, name: nil)
+      """,
+      environment: environment,
+      name: nil
+    )
 
     try expectError(reason: "Unknown filter 'unknown'. Found similar filters: 'uppercase'.",
                     childToken: "target|unknown",
                     baseToken: nil)
   }
 
-        $0.it("reports runtime error in child template") {
+  func testRuntimeErrorInChildTemplate() throws {
     let filterExtension = Extension()
-          filterExtension.registerFilter("unknown", filter: {  (_: Any?) in
+    filterExtension.registerFilter("unknown") {  (_: Any?) in
       throw TemplateSyntaxError("filter error")
-          })
+    }
     environment.extensions += [filterExtension]
 
-          childTemplate = Template(templateString: """
+    childTemplate = Template(
+      templateString: """
       {% extends "base.html" %}
       {% block body %}Child {{ target|unknown }}{% endblock %}
-          """, environment: environment, name: nil)
+      """,
+      environment: environment,
+      name: nil
+    )
 
     try expectError(reason: "filter error",
                     childToken: "target|unknown",
                     baseToken: nil)
   }
 
+  private func expectError(
+    reason: String,
+    childToken: String,
+    baseToken: String?,
+    file: String = #file,
+    line: Int = #line,
+    function: String = #function
+  ) throws {
+    var expectedError = expectedSyntaxError(token: childToken, template: childTemplate, description: reason)
+    if let baseToken = baseToken {
+      expectedError.stackTrace = [expectedSyntaxError(
+        token: baseToken,
+        template: baseTemplate,
+        description: reason
+        ).token].compactMap { $0 }
     }
-
+    let error = try expect(
-    }
+      self.environment.render(template: self.childTemplate, context: ["target": "World"]),
+      file: file,
+      line: line,
+      function: function
+    ).toThrow() as TemplateSyntaxError
+    let reporter = SimpleErrorReporter()
+    try expect(
+      reporter.renderError(error),
+      file: file,
+      line: line,
+      function: function
+    ) == reporter.renderError(expectedError)
   }
 }
 
 extension Expectation {
   @discardableResult
   func toThrow<T: Error>() throws -> T {
-    var thrownError: Error? = nil
+    var thrownError: Error?
 
     do {
       _ = try expression()
@@ -356,7 +408,20 @@ extension Expectation {
   }
 }
 
-fileprivate class ExampleLoader: Loader {
+extension XCTestCase {
+  func expectedSyntaxError(token: String, template: Template, description: String) -> TemplateSyntaxError {
+    guard let range = template.templateString.range(of: token) else {
+      fatalError("Can't find '\(token)' in '\(template)'")
+    }
+    let lexer = Lexer(templateString: template.templateString)
+    let location = lexer.rangeLocation(range)
+    let sourceMap = SourceMap(filename: template.name, location: location)
+    let token = Token.block(value: token, at: sourceMap)
+    return TemplateSyntaxError(reason: description, token: token, stackTrace: [])
+  }
+}
+
+private class ExampleLoader: Loader {
   func loadTemplate(name: String, environment: Environment) throws -> Template {
     if name == "example.html" {
       return Template(templateString: "Hello World!", environment: environment, name: name)
@@ -366,8 +431,8 @@ fileprivate class ExampleLoader: Loader {
   }
 }
 
-
+private class CustomTemplate: Template {
-class CustomTemplate: Template {
+  // swiftlint:disable discouraged_optional_collection
   override func render(_ dictionary: [String: Any]? = nil) throws -> String {
     return "here"
   }

Tests/StencilTests/ExpressionSpec.swift

@@ -1,345 +1,355 @@
-import XCTest
 import Spectre
 @testable import Stencil
+import XCTest
 
-class ExpressionsTests: XCTestCase {
+final class ExpressionsTests: XCTestCase {
-  func testExpressions() {
+  let parser = TokenParser(tokens: [], environment: Environment())
-    describe("Expression") {
 
-      func parseExpression(components: [String]) throws -> Expression {
+  private func makeExpression(_ components: [String]) -> Expression {
-        let parser = try IfExpressionParser.parser(components: components, environment: Environment(), token: .text(value: "", at: .unknown))
+    do {
+      let parser = try IfExpressionParser.parser(
+        components: components,
+        environment: Environment(),
+        token: .text(value: "", at: .unknown)
+      )
       return try parser.parse()
+    } catch {
+      fatalError(error.localizedDescription)
+    }
   }
 
-      $0.describe("VariableExpression") {
+  func testTrueExpressions() {
     let expression = VariableExpression(variable: Variable("value"))
 
-        $0.it("evaluates to true when value is not nil") {
+    it("evaluates to true when value is not nil") {
       let context = Context(dictionary: ["value": "known"])
       try expect(try expression.evaluate(context: context)).to.beTrue()
     }
 
-        $0.it("evaluates to false when value is unset") {
+    it("evaluates to true when array variable is not empty") {
-          let context = Context()
+      let items: [[String: Any]] = [["key": "key1", "value": 42], ["key": "key2", "value": 1_337]]
-          try expect(try expression.evaluate(context: context)).to.beFalse()
-        }
-
-        $0.it("evaluates to true when array variable is not empty") {
-          let items: [[String: Any]] = [["key":"key1","value":42],["key":"key2","value":1337]]
       let context = Context(dictionary: ["value": [items]])
       try expect(try expression.evaluate(context: context)).to.beTrue()
     }
 
-        $0.it("evaluates to false when array value is empty") {
+    it("evaluates to false when dictionary value is empty") {
-          let emptyItems = [[String: Any]]()
-          let context = Context(dictionary: ["value": emptyItems])
-          try expect(try expression.evaluate(context: context)).to.beFalse()
-        }
-
-        $0.it("evaluates to false when dictionary value is empty") {
       let emptyItems = [String: Any]()
       let context = Context(dictionary: ["value": emptyItems])
       try expect(try expression.evaluate(context: context)).to.beFalse()
     }
 
-        $0.it("evaluates to false when Array<Any> value is empty") {
+    it("evaluates to true when integer value is above 0") {
-          let context = Context(dictionary: ["value": ([] as [Any])])
-          try expect(try expression.evaluate(context: context)).to.beFalse()
-        }
-
-        $0.it("evaluates to true when integer value is above 0") {
       let context = Context(dictionary: ["value": 1])
       try expect(try expression.evaluate(context: context)).to.beTrue()
     }
 
-        $0.it("evaluates to true with string") {
+    it("evaluates to true with string") {
       let context = Context(dictionary: ["value": "test"])
       try expect(try expression.evaluate(context: context)).to.beTrue()
     }
 
-        $0.it("evaluates to false when empty string") {
+    it("evaluates to true when float value is above 0") {
-          let context = Context(dictionary: ["value": ""])
-          try expect(try expression.evaluate(context: context)).to.beFalse()
-        }
-
-        $0.it("evaluates to false when integer value is below 0 or below") {
-          let context = Context(dictionary: ["value": 0])
-          try expect(try expression.evaluate(context: context)).to.beFalse()
-
-          let negativeContext = Context(dictionary: ["value": 0])
-          try expect(try expression.evaluate(context: negativeContext)).to.beFalse()
-        }
-
-        $0.it("evaluates to true when float value is above 0") {
       let context = Context(dictionary: ["value": Float(0.5)])
       try expect(try expression.evaluate(context: context)).to.beTrue()
     }
 
-        $0.it("evaluates to false when float is 0 or below") {
+    it("evaluates to true when double value is above 0") {
+      let context = Context(dictionary: ["value": Double(0.5)])
+      try expect(try expression.evaluate(context: context)).to.beTrue()
+    }
+  }
+
+  func testFalseExpressions() {
+    let expression = VariableExpression(variable: Variable("value"))
+
+    it("evaluates to false when value is unset") {
+      let context = Context()
+      try expect(try expression.evaluate(context: context)).to.beFalse()
+    }
+
+    it("evaluates to false when array value is empty") {
+      let emptyItems = [[String: Any]]()
+      let context = Context(dictionary: ["value": emptyItems])
+      try expect(try expression.evaluate(context: context)).to.beFalse()
+    }
+
+    it("evaluates to false when dictionary value is empty") {
+      let emptyItems = [String: Any]()
+      let context = Context(dictionary: ["value": emptyItems])
+      try expect(try expression.evaluate(context: context)).to.beFalse()
+    }
+
+    it("evaluates to false when Array<Any> value is empty") {
+      let context = Context(dictionary: ["value": ([] as [Any])])
+      try expect(try expression.evaluate(context: context)).to.beFalse()
+    }
+
+    it("evaluates to false when empty string") {
+      let context = Context(dictionary: ["value": ""])
+      try expect(try expression.evaluate(context: context)).to.beFalse()
+    }
+
+    it("evaluates to false when integer value is below 0 or below") {
+      let context = Context(dictionary: ["value": 0])
+      try expect(try expression.evaluate(context: context)).to.beFalse()
+
+      let negativeContext = Context(dictionary: ["value": -1])
+      try expect(try expression.evaluate(context: negativeContext)).to.beFalse()
+    }
+
+    it("evaluates to false when float is 0 or below") {
       let context = Context(dictionary: ["value": Float(0)])
       try expect(try expression.evaluate(context: context)).to.beFalse()
     }
 
-        $0.it("evaluates to true when double value is above 0") {
+    it("evaluates to false when double is 0 or below") {
-          let context = Context(dictionary: ["value": Double(0.5)])
-          try expect(try expression.evaluate(context: context)).to.beTrue()
-        }
-
-        $0.it("evaluates to false when double is 0 or below") {
       let context = Context(dictionary: ["value": Double(0)])
       try expect(try expression.evaluate(context: context)).to.beFalse()
     }
 
-        $0.it("evaluates to false when uint is 0") {
+    it("evaluates to false when uint is 0") {
       let context = Context(dictionary: ["value": UInt(0)])
       try expect(try expression.evaluate(context: context)).to.beFalse()
     }
   }
 
-      $0.describe("NotExpression") {
+  func testNotExpression() {
-        $0.it("returns truthy for positive expressions") {
+    it("returns truthy for positive expressions") {
       let expression = NotExpression(expression: StaticExpression(value: true))
       try expect(expression.evaluate(context: Context())).to.beFalse()
     }
 
-        $0.it("returns falsy for negative expressions") {
+    it("returns falsy for negative expressions") {
       let expression = NotExpression(expression: StaticExpression(value: false))
       try expect(expression.evaluate(context: Context())).to.beTrue()
     }
   }
 
-      $0.describe("expression parsing") {
+  func testExpressionParsing() {
-        $0.it("can parse a variable expression") {
+    it("can parse a variable expression") {
-          let expression = try parseExpression(components: ["value"])
+      let expression = self.makeExpression(["value"])
       try expect(expression.evaluate(context: Context())).to.beFalse()
       try expect(expression.evaluate(context: Context(dictionary: ["value": true]))).to.beTrue()
     }
 
-        $0.it("can parse a not expression") {
+    it("can parse a not expression") {
-          let expression = try parseExpression(components: ["not", "value"])
+      let expression = self.makeExpression(["not", "value"])
       try expect(expression.evaluate(context: Context())).to.beTrue()
       try expect(expression.evaluate(context: Context(dictionary: ["value": true]))).to.beFalse()
     }
+  }
 
-        $0.describe("and expression") {
+  func testAndExpression() {
-          let expression = try! parseExpression(components: ["lhs", "and", "rhs"])
+    let expression = makeExpression(["lhs", "and", "rhs"])
 
-          $0.it("evaluates to false with lhs false") {
+    it("evaluates to false with lhs false") {
       try expect(expression.evaluate(context: Context(dictionary: ["lhs": false, "rhs": true]))).to.beFalse()
     }
 
-          $0.it("evaluates to false with rhs false") {
+    it("evaluates to false with rhs false") {
       try expect(expression.evaluate(context: Context(dictionary: ["lhs": true, "rhs": false]))).to.beFalse()
     }
 
-          $0.it("evaluates to false with lhs and rhs false") {
+    it("evaluates to false with lhs and rhs false") {
       try expect(expression.evaluate(context: Context(dictionary: ["lhs": false, "rhs": false]))).to.beFalse()
     }
 
-          $0.it("evaluates to true with lhs and rhs true") {
+    it("evaluates to true with lhs and rhs true") {
       try expect(expression.evaluate(context: Context(dictionary: ["lhs": true, "rhs": true]))).to.beTrue()
     }
   }
 
-        $0.describe("or expression") {
+  func testOrExpression() {
-          let expression = try! parseExpression(components: ["lhs", "or", "rhs"])
+    let expression = makeExpression(["lhs", "or", "rhs"])
 
-          $0.it("evaluates to true with lhs true") {
+    it("evaluates to true with lhs true") {
       try expect(expression.evaluate(context: Context(dictionary: ["lhs": true, "rhs": false]))).to.beTrue()
     }
 
-          $0.it("evaluates to true with rhs true") {
+    it("evaluates to true with rhs true") {
       try expect(expression.evaluate(context: Context(dictionary: ["lhs": false, "rhs": true]))).to.beTrue()
     }
 
-          $0.it("evaluates to true with lhs and rhs true") {
+    it("evaluates to true with lhs and rhs true") {
       try expect(expression.evaluate(context: Context(dictionary: ["lhs": true, "rhs": true]))).to.beTrue()
     }
 
-          $0.it("evaluates to false with lhs and rhs false") {
+    it("evaluates to false with lhs and rhs false") {
       try expect(expression.evaluate(context: Context(dictionary: ["lhs": false, "rhs": false]))).to.beFalse()
     }
   }
 
-        $0.describe("equality expression") {
+  func testEqualityExpression() {
-          let expression = try! parseExpression(components: ["lhs", "==", "rhs"])
+    let expression = makeExpression(["lhs", "==", "rhs"])
 
-          $0.it("evaluates to true with equal lhs/rhs") {
+    it("evaluates to true with equal lhs/rhs") {
       try expect(expression.evaluate(context: Context(dictionary: ["lhs": "a", "rhs": "a"]))).to.beTrue()
     }
 
-          $0.it("evaluates to false with non equal lhs/rhs") {
+    it("evaluates to false with non equal lhs/rhs") {
       try expect(expression.evaluate(context: Context(dictionary: ["lhs": "a", "rhs": "b"]))).to.beFalse()
     }
 
-          $0.it("evaluates to true with nils") {
+    it("evaluates to true with nils") {
       try expect(expression.evaluate(context: Context(dictionary: [:]))).to.beTrue()
     }
 
-          $0.it("evaluates to true with numbers") {
+    it("evaluates to true with numbers") {
       try expect(expression.evaluate(context: Context(dictionary: ["lhs": 1, "rhs": 1.0]))).to.beTrue()
     }
 
-          $0.it("evaluates to false with non equal numbers") {
+    it("evaluates to false with non equal numbers") {
       try expect(expression.evaluate(context: Context(dictionary: ["lhs": 1, "rhs": 1.1]))).to.beFalse()
     }
 
-          $0.it("evaluates to true with booleans") {
+    it("evaluates to true with booleans") {
       try expect(expression.evaluate(context: Context(dictionary: ["lhs": true, "rhs": true]))).to.beTrue()
     }
 
-          $0.it("evaluates to false with falsy booleans") {
+    it("evaluates to false with falsy booleans") {
       try expect(expression.evaluate(context: Context(dictionary: ["lhs": true, "rhs": false]))).to.beFalse()
     }
 
-          $0.it("evaluates to false with different types") {
+    it("evaluates to false with different types") {
       try expect(expression.evaluate(context: Context(dictionary: ["lhs": true, "rhs": 1]))).to.beFalse()
     }
   }
 
-        $0.describe("inequality expression") {
+  func testInequalityExpression() {
-          let expression = try! parseExpression(components: ["lhs", "!=", "rhs"])
+    let expression = makeExpression(["lhs", "!=", "rhs"])
 
-          $0.it("evaluates to true with inequal lhs/rhs") {
+    it("evaluates to true with inequal lhs/rhs") {
       try expect(expression.evaluate(context: Context(dictionary: ["lhs": "a", "rhs": "b"]))).to.beTrue()
     }
 
-          $0.it("evaluates to false with equal lhs/rhs") {
+    it("evaluates to false with equal lhs/rhs") {
       try expect(expression.evaluate(context: Context(dictionary: ["lhs": "b", "rhs": "b"]))).to.beFalse()
     }
   }
 
-        $0.describe("more than expression") {
+  func testMoreThanExpression() {
-          let expression = try! parseExpression(components: ["lhs", ">", "rhs"])
+    let expression = makeExpression(["lhs", ">", "rhs"])
 
-          $0.it("evaluates to true with lhs > rhs") {
+    it("evaluates to true with lhs > rhs") {
       try expect(expression.evaluate(context: Context(dictionary: ["lhs": 5.0, "rhs": 4]))).to.beTrue()
     }
 
-          $0.it("evaluates to false with lhs == rhs") {
+    it("evaluates to false with lhs == rhs") {
       try expect(expression.evaluate(context: Context(dictionary: ["lhs": 5.0, "rhs": 5.0]))).to.beFalse()
     }
   }
 
-        $0.describe("more than equal expression") {
+  func testMoreThanEqualExpression() {
-          let expression = try! parseExpression(components: ["lhs", ">=", "rhs"])
+    let expression = makeExpression(["lhs", ">=", "rhs"])
 
-          $0.it("evaluates to true with lhs == rhs") {
+    it("evaluates to true with lhs == rhs") {
       try expect(expression.evaluate(context: Context(dictionary: ["lhs": 5.0, "rhs": 5]))).to.beTrue()
     }
 
-          $0.it("evaluates to false with lhs < rhs") {
+    it("evaluates to false with lhs < rhs") {
       try expect(expression.evaluate(context: Context(dictionary: ["lhs": 5.0, "rhs": 5.1]))).to.beFalse()
     }
   }
 
-        $0.describe("less than expression") {
+  func testLessThanExpression() {
-          let expression = try! parseExpression(components: ["lhs", "<", "rhs"])
+    let expression = makeExpression(["lhs", "<", "rhs"])
 
-          $0.it("evaluates to true with lhs < rhs") {
+    it("evaluates to true with lhs < rhs") {
       try expect(expression.evaluate(context: Context(dictionary: ["lhs": 4, "rhs": 4.5]))).to.beTrue()
     }
 
-          $0.it("evaluates to false with lhs == rhs") {
+    it("evaluates to false with lhs == rhs") {
       try expect(expression.evaluate(context: Context(dictionary: ["lhs": 5.0, "rhs": 5.0]))).to.beFalse()
     }
   }
 
-        $0.describe("less than equal expression") {
+  func testLessThanEqualExpression() {
-          let expression = try! parseExpression(components: ["lhs", "<=", "rhs"])
+    let expression = makeExpression(["lhs", "<=", "rhs"])
 
-          $0.it("evaluates to true with lhs == rhs") {
+    it("evaluates to true with lhs == rhs") {
       try expect(expression.evaluate(context: Context(dictionary: ["lhs": 5.0, "rhs": 5]))).to.beTrue()
     }
 
-          $0.it("evaluates to false with lhs > rhs") {
+    it("evaluates to false with lhs > rhs") {
       try expect(expression.evaluate(context: Context(dictionary: ["lhs": 5.1, "rhs": 5.0]))).to.beFalse()
     }
   }
 
-        $0.describe("multiple expression") {
+  func testMultipleExpressions() {
-          let expression = try! parseExpression(components: ["one", "or", "two", "and", "not", "three"])
+    let expression = makeExpression(["one", "or", "two", "and", "not", "three"])
 
-          $0.it("evaluates to true with one") {
+    it("evaluates to true with one") {
       try expect(expression.evaluate(context: Context(dictionary: ["one": true]))).to.beTrue()
     }
 
-          $0.it("evaluates to true with one and three") {
+    it("evaluates to true with one and three") {
       try expect(expression.evaluate(context: Context(dictionary: ["one": true, "three": true]))).to.beTrue()
     }
 
-          $0.it("evaluates to true with two") {
+    it("evaluates to true with two") {
       try expect(expression.evaluate(context: Context(dictionary: ["two": true]))).to.beTrue()
     }
 
-          $0.it("evaluates to false with two and three") {
+    it("evaluates to false with two and three") {
       try expect(expression.evaluate(context: Context(dictionary: ["two": true, "three": true]))).to.beFalse()
     }
 
-          $0.it("evaluates to false with two and three") {
+    it("evaluates to false with two and three") {
       try expect(expression.evaluate(context: Context(dictionary: ["two": true, "three": true]))).to.beFalse()
     }
 
-          $0.it("evaluates to false with nothing") {
+    it("evaluates to false with nothing") {
       try expect(expression.evaluate(context: Context())).to.beFalse()
     }
   }
 
-        $0.describe("in expression") {
+  func testTrueInExpression() throws {
-          let expression = try! parseExpression(components: ["lhs", "in", "rhs"])
+    let expression = makeExpression(["lhs", "in", "rhs"])
 
-          $0.it("evaluates to true when rhs contains lhs") {
+    try expect(expression.evaluate(context: Context(dictionary: [
-            try expect(expression.evaluate(context: Context(dictionary: ["lhs": 1, "rhs": [1, 2, 3]]))).to.beTrue()
+      "lhs": 1,
-            try expect(expression.evaluate(context: Context(dictionary: ["lhs": "a", "rhs": ["a", "b", "c"]]))).to.beTrue()
+      "rhs": [1, 2, 3]
-            try expect(expression.evaluate(context: Context(dictionary: ["lhs": "a", "rhs": "abc"]))).to.beTrue()
+    ]))).to.beTrue()
-            try expect(expression.evaluate(context: Context(dictionary: ["lhs": 1, "rhs": 1...3]))).to.beTrue()
+    try expect(expression.evaluate(context: Context(dictionary: [
-            try expect(expression.evaluate(context: Context(dictionary: ["lhs": 1, "rhs": 1..<3]))).to.beTrue()
+      "lhs": "a",
+      "rhs": ["a", "b", "c"]
+    ]))).to.beTrue()
+    try expect(expression.evaluate(context: Context(dictionary: [
+      "lhs": "a",
+      "rhs": "abc"
+    ]))).to.beTrue()
+    try expect(expression.evaluate(context: Context(dictionary: [
+      "lhs": 1,
+      "rhs": 1...3
+    ]))).to.beTrue()
+    try expect(expression.evaluate(context: Context(dictionary: [
+      "lhs": 1,
+      "rhs": 1..<3
+    ]))).to.beTrue()
   }
 
-          $0.it("evaluates to false when rhs does not contain lhs") {
+  func testFalseInExpression() throws {
-            try expect(expression.evaluate(context: Context(dictionary: ["lhs": 1, "rhs": [2, 3, 4]]))).to.beFalse()
+    let expression = makeExpression(["lhs", "in", "rhs"])
-            try expect(expression.evaluate(context: Context(dictionary: ["lhs": "a", "rhs": ["b", "c", "d"]]))).to.beFalse()
-            try expect(expression.evaluate(context: Context(dictionary: ["lhs": "a", "rhs": "bcd"]))).to.beFalse()
-            try expect(expression.evaluate(context: Context(dictionary: ["lhs": 4, "rhs": 1...3]))).to.beFalse()
-            try expect(expression.evaluate(context: Context(dictionary: ["lhs": 3, "rhs": 1..<3]))).to.beFalse()
-          }
-        }
 
-        $0.describe("sub expression") {
+    try expect(expression.evaluate(context: Context(dictionary: [
-          $0.it("evaluates correctly") {
+      "lhs": 1,
-            let context = Context(dictionary: ["one": false, "two": false, "three": true, "four": true])
+      "rhs": [2, 3, 4]
-
+    ]))).to.beFalse()
-            let expression = try! parseExpression(components: ["one", "and", "two", "or", "three", "and", "four"])
+    try expect(expression.evaluate(context: Context(dictionary: [
-            let expressionWithBrackets = try! parseExpression(components: ["one", "and", "(", "(", "two", ")", "or", "(", "three", "and", "four", ")", ")"])
+      "lhs": "a",
-
+      "rhs": ["b", "c", "d"]
-            try expect(expression.evaluate(context: context)).to.beTrue()
+    ]))).to.beFalse()
-            try expect(expressionWithBrackets.evaluate(context: context)).to.beFalse()
+    try expect(expression.evaluate(context: Context(dictionary: [
-
+      "lhs": "a",
-            let notExpression = try! parseExpression(components: ["not", "one", "or", "three"])
+      "rhs": "bcd"
-            let notExpressionWithBrackets = try! parseExpression(components: ["not", "(", "one", "or", "three", ")"])
+    ]))).to.beFalse()
-
+    try expect(expression.evaluate(context: Context(dictionary: [
-            try expect(notExpression.evaluate(context: context)).to.beTrue()
+      "lhs": 4,
-            try expect(notExpressionWithBrackets.evaluate(context: context)).to.beFalse()
+      "rhs": 1...3
-          }
+    ]))).to.beFalse()
-
+    try expect(expression.evaluate(context: Context(dictionary: [
-          $0.it("fails when brackets are not balanced") {
+      "lhs": 3,
-            try expect(parseExpression(components: ["(", "lhs", "and", "rhs"]))
+      "rhs": 1..<3
-              .toThrow(TemplateSyntaxError("'if' expression error: missing closing bracket"))
+    ]))).to.beFalse()
-            try expect(parseExpression(components: [")", "lhs", "and", "rhs"]))
-              .toThrow(TemplateSyntaxError("'if' expression error: missing opening bracket"))
-            try expect(parseExpression(components: ["lhs", "and", "rhs", ")"]))
-              .toThrow(TemplateSyntaxError("'if' expression error: missing opening bracket"))
-            try expect(parseExpression(components: ["(", "lhs", "and", "rhs", ")", "("]))
-              .toThrow(TemplateSyntaxError("'if' expression error: missing closing bracket"))
-            try expect(parseExpression(components: ["(", "lhs", "and", "rhs", ")", ")"]))
-              .toThrow(TemplateSyntaxError("'if' expression error: missing opening bracket"))
-            try expect(parseExpression(components: ["(", "lhs", "and", ")"]))
-              .toThrow(TemplateSyntaxError("'if' expression error: end"))
-            try expect(parseExpression(components: ["(", "and", "rhs", ")"]))
-              .toThrow(TemplateSyntaxError("'if' expression error: infix operator 'and' doesn't have a left hand side"))
-          }
-        }
-      }
-    }
   }
 }

Tests/StencilTests/FilterSpec.swift

@@ -1,13 +1,12 @@
-import XCTest
 import Spectre
 @testable import Stencil
+import XCTest
 
-class FilterTests: XCTestCase {
+final class FilterTests: XCTestCase {
-  func testFilter() {
+  func testRegistration() {
-    describe("template filters") {
     let context: [String: Any] = ["name": "Kyle"]
 
-      $0.it("allows you to register a custom filter") {
+    it("allows you to register a custom filter") {
       let template = Template(templateString: "{{ name|repeat }}")
 
       let repeatExtension = Extension()
@@ -19,11 +18,14 @@ class FilterTests: XCTestCase {
         return nil
       }
 
-        let result = try template.render(Context(dictionary: context, environment: Environment(extensions: [repeatExtension])))
+      let result = try template.render(Context(
+        dictionary: context,
+        environment: Environment(extensions: [repeatExtension])
+      ))
       try expect(result) == "Kyle Kyle"
     }
 
-      $0.it("allows you to register boolean filters") {
+    it("allows you to register boolean filters") {
       let repeatExtension = Extension()
       repeatExtension.registerFilter(name: "isPositive", negativeFilterName: "isNotPositive") { (value: Any?) in
         if let value = value as? Int {
@@ -41,106 +43,117 @@ class FilterTests: XCTestCase {
       try expect(negativeResult) == "true"
     }
 
-      $0.it("allows you to register a custom filter which accepts single argument") {
+    it("allows you to register a custom which throws") {
+      let template = Template(templateString: "{{ name|repeat }}")
+      let repeatExtension = Extension()
+      repeatExtension.registerFilter("repeat") { (_: Any?) in
+        throw TemplateSyntaxError("No Repeat")
+      }
+
+      let context = Context(dictionary: context, environment: Environment(extensions: [repeatExtension]))
+      try expect(try template.render(context))
+        .toThrow(TemplateSyntaxError(reason: "No Repeat", token: template.tokens.first))
+    }
+
+    it("throws when you pass arguments to simple filter") {
+      let template = Template(templateString: "{{ name|uppercase:5 }}")
+      try expect(try template.render(Context(dictionary: ["name": "kyle"]))).toThrow()
+    }
+  }
+
+  func testRegistrationOverrideDefault() throws {
+    let template = Template(templateString: "{{ name|join }}")
+    let context: [String: Any] = ["name": "Kyle"]
+
+    let repeatExtension = Extension()
+    repeatExtension.registerFilter("join") { (_: Any?) in
+      "joined"
+    }
+
+    let result = try template.render(Context(
+      dictionary: context,
+      environment: Environment(extensions: [repeatExtension])
+    ))
+    try expect(result) == "joined"
+  }
+
+  func testRegistrationWithArguments() {
+    let context: [String: Any] = ["name": "Kyle"]
+
+    it("allows you to register a custom filter which accepts single argument") {
       let template = Template(templateString: """
         {{ name|repeat:'value1, "value2"' }}
         """)
 
       let repeatExtension = Extension()
       repeatExtension.registerFilter("repeat") { value, arguments in
-          if !arguments.isEmpty {
+        guard let value = value,
-            return "\(value!) \(value!) with args \(arguments.first!!)"
+          let argument = arguments.first else { return nil }
+
+        return "\(value) \(value) with args \(argument ?? "")"
       }
 
-          return nil
+      let result = try template.render(Context(
-        }
+        dictionary: context,
-
+        environment: Environment(extensions: [repeatExtension])
-        let result = try template.render(Context(dictionary: context, environment: Environment(extensions: [repeatExtension])))
+      ))
       try expect(result) == """
         Kyle Kyle with args value1, "value2"
         """
     }
 
-      $0.it("allows you to register a custom filter which accepts several arguments") {
+    it("allows you to register a custom filter which accepts several arguments") {
         let template = Template(templateString: """
           {{ name|repeat:'value"1"',"value'2'",'(key, value)' }}
           """)
 
         let repeatExtension = Extension()
         repeatExtension.registerFilter("repeat") { value, arguments in
-              if !arguments.isEmpty {
+          guard let value = value else { return nil }
-                  return "\(value!) \(value!) with args 0: \(arguments[0]!), 1: \(arguments[1]!), 2: \(arguments[2]!)"
+          let args = arguments.compactMap { $0 }
+          return "\(value) \(value) with args 0: \(args[0]), 1: \(args[1]), 2: \(args[2])"
         }
 
-              return nil
+        let result = try template.render(Context(
-          }
+          dictionary: context,
-
+          environment: Environment(extensions: [repeatExtension])
-          let result = try template.render(Context(dictionary: context, environment: Environment(extensions: [repeatExtension])))
+        ))
         try expect(result) == """
           Kyle Kyle with args 0: value"1", 1: value'2', 2: (key, value)
           """
     }
 
-      $0.it("allows you to register a custom which throws") {
+    it("allows whitespace in expression") {
-        let template = Template(templateString: "{{ name|repeat }}")
-        let repeatExtension = Extension()
-        repeatExtension.registerFilter("repeat") { (value: Any?) in
-          throw TemplateSyntaxError("No Repeat")
-        }
-
-        let context = Context(dictionary: context, environment: Environment(extensions: [repeatExtension]))
-        try expect(try template.render(context)).toThrow(TemplateSyntaxError(reason: "No Repeat", token: template.tokens.first))
-      }
-
-      $0.it("allows you to override a default filter") {
-        let template = Template(templateString: "{{ name|join }}")
-
-        let repeatExtension = Extension()
-        repeatExtension.registerFilter("join") { (value: Any?) in
-          return "joined"
-        }
-
-        let result = try template.render(Context(dictionary: context, environment: Environment(extensions: [repeatExtension])))
-        try expect(result) == "joined"
-      }
-
-      $0.it("allows whitespace in expression") {
       let template = Template(templateString: """
           {{ value | join : ", " }}
           """)
       let result = try template.render(Context(dictionary: ["value": ["One", "Two"]]))
       try expect(result) == "One, Two"
     }
-
-      $0.it("throws when you pass arguments to simple filter") {
-        let template = Template(templateString: "{{ name|uppercase:5 }}")
-        try expect(try template.render(Context(dictionary: ["name": "kyle"]))).toThrow()
-      }
   }
 
-    describe("string filters") {
+  func testStringFilters() {
-      $0.context("given string") {
+    it("transforms a string to be capitalized") {
-        $0.it("transforms a string to be capitalized") {
       let template = Template(templateString: "{{ name|capitalize }}")
       let result = try template.render(Context(dictionary: ["name": "kyle"]))
       try expect(result) == "Kyle"
     }
 
-        $0.it("transforms a string to be uppercase") {
+    it("transforms a string to be uppercase") {
       let template = Template(templateString: "{{ name|uppercase }}")
       let result = try template.render(Context(dictionary: ["name": "kyle"]))
       try expect(result) == "KYLE"
     }
 
-        $0.it("transforms a string to be lowercase") {
+    it("transforms a string to be lowercase") {
       let template = Template(templateString: "{{ name|lowercase }}")
       let result = try template.render(Context(dictionary: ["name": "Kyle"]))
       try expect(result) == "kyle"
     }
   }
 
-      $0.context("given array of strings") {
+  func testStringFiltersWithArrays() {
-        $0.it("transforms a string to be capitalized") {
+    it("transforms a string to be capitalized") {
       let template = Template(templateString: "{{ names|capitalize }}")
       let result = try template.render(Context(dictionary: ["names": ["kyle", "kyle"]]))
       try expect(result) == """
@@ -148,7 +161,7 @@ class FilterTests: XCTestCase {
         """
     }
 
-        $0.it("transforms a string to be uppercase") {
+    it("transforms a string to be uppercase") {
       let template = Template(templateString: "{{ names|uppercase }}")
       let result = try template.render(Context(dictionary: ["names": ["kyle", "kyle"]]))
       try expect(result) == """
@@ -156,7 +169,7 @@ class FilterTests: XCTestCase {
         """
     }
 
-        $0.it("transforms a string to be lowercase") {
+    it("transforms a string to be lowercase") {
       let template = Template(templateString: "{{ names|lowercase }}")
       let result = try template.render(Context(dictionary: ["names": ["Kyle", "Kyle"]]))
       try expect(result) == """
@@ -164,24 +177,23 @@ class FilterTests: XCTestCase {
         """
     }
   }
-    }
 
-    describe("default filter") {
+  func testDefaultFilter() {
     let template = Template(templateString: """
       Hello {{ name|default:"World" }}
       """)
 
-      $0.it("shows the variable value") {
+    it("shows the variable value") {
       let result = try template.render(Context(dictionary: ["name": "Kyle"]))
       try expect(result) == "Hello Kyle"
     }
 
-      $0.it("shows the default value") {
+    it("shows the default value") {
       let result = try template.render(Context(dictionary: [:]))
       try expect(result) == "Hello World"
     }
 
-      $0.it("supports multiple defaults") {
+    it("supports multiple defaults") {
       let template = Template(templateString: """
         Hello {{ name|default:a,b,c,"World" }}
         """)
@@ -189,19 +201,19 @@ class FilterTests: XCTestCase {
       try expect(result) == "Hello World"
     }
 
-      $0.it("can use int as default") {
+    it("can use int as default") {
       let template = Template(templateString: "{{ value|default:1 }}")
       let result = try template.render(Context(dictionary: [:]))
       try expect(result) == "1"
     }
 
-      $0.it("can use float as default") {
+    it("can use float as default") {
       let template = Template(templateString: "{{ value|default:1.5 }}")
       let result = try template.render(Context(dictionary: [:]))
       try expect(result) == "1.5"
     }
 
-      $0.it("checks for underlying nil value correctly") {
+    it("checks for underlying nil value correctly") {
       let template = Template(templateString: """
         Hello {{ user.name|default:"anonymous" }}
         """)
@@ -212,22 +224,22 @@ class FilterTests: XCTestCase {
     }
   }
 
-    describe("join filter") {
+  func testJoinFilter() {
     let template = Template(templateString: """
       {{ value|join:", " }}
       """)
 
-      $0.it("joins a collection of strings") {
+    it("joins a collection of strings") {
       let result = try template.render(Context(dictionary: ["value": ["One", "Two"]]))
       try expect(result) == "One, Two"
     }
 
-      $0.it("joins a mixed-type collection") {
+    it("joins a mixed-type collection") {
       let result = try template.render(Context(dictionary: ["value": ["One", 2, true, 10.5, "Five"]]))
       try expect(result) == "One, 2, true, 10.5, Five"
     }
 
-      $0.it("can join by non string") {
+    it("can join by non string") {
       let template = Template(templateString: """
         {{ value|join:separator }}
         """)
@@ -235,7 +247,7 @@ class FilterTests: XCTestCase {
       try expect(result) == "OnetrueTwo"
     }
 
-      $0.it("can join without arguments") {
+    it("can join without arguments") {
       let template = Template(templateString: """
         {{ value|join }}
         """)
@@ -244,19 +256,19 @@ class FilterTests: XCTestCase {
     }
   }
 
-    describe("split filter") {
+  func testSplitFilter() {
     let template = Template(templateString: """
       {{ value|split:", " }}
       """)
 
-      $0.it("split a string into array") {
+    it("split a string into array") {
       let result = try template.render(Context(dictionary: ["value": "One, Two"]))
       try expect(result) == """
         ["One", "Two"]
         """
     }
 
-      $0.it("can split without arguments") {
+    it("can split without arguments") {
       let template = Template(templateString: """
         {{ value|split }}
         """)
@@ -267,62 +279,49 @@ class FilterTests: XCTestCase {
     }
   }
 
-
+  func testFilterSuggestion() {
-    describe("filter suggestion") {
+    it("made for unknown filter") {
-      var template: Template!
+      let template = Template(templateString: "{{ value|unknownFilter }}")
-      var filterExtension: Extension!
+      let filterExtension = Extension()
-
-      func expectedSyntaxError(token: String, template: Template, description: String) -> TemplateSyntaxError {
-        guard let range = template.templateString.range(of: token) else {
-          fatalError("Can't find '\(token)' in '\(template)'")
-        }
-        let lexer = Lexer(templateString: template.templateString)
-        let location = lexer.rangeLocation(range)
-        let sourceMap = SourceMap(filename: template.name, location: location)
-        let token = Token.block(value: token, at: sourceMap)
-        return TemplateSyntaxError(reason: description, token: token, stackTrace: [])
-      }
-
-      func expectError(reason: String, token: String,
-                       file: String = #file, line: Int = #line, function: String = #function) throws {
-        let expectedError = expectedSyntaxError(token: token, template: template, description: reason)
-        let environment = Environment(extensions: [filterExtension])
-
-        let error = try expect(environment.render(template: template, context: [:]),
-                               file: file, line: line, function: function).toThrow() as TemplateSyntaxError
-        let reporter = SimpleErrorReporter()
-        try expect(reporter.renderError(error), file: file, line: line, function: function) == reporter.renderError(expectedError)
-      }
-
-      $0.it("made for unknown filter") {
-        template = Template(templateString: "{{ value|unknownFilter }}")
-
-        filterExtension = Extension()
       filterExtension.registerFilter("knownFilter") { value, _ in value }
 
-        try expectError(reason: "Unknown filter 'unknownFilter'. Found similar filters: 'knownFilter'.", token: "value|unknownFilter")
+      try self.expectError(
+        reason: "Unknown filter 'unknownFilter'. Found similar filters: 'knownFilter'.",
+        token: "value|unknownFilter",
+        template: template,
+        extension: filterExtension
+      )
     }
 
-      $0.it("made for multiple similar filters") {
+    it("made for multiple similar filters") {
-        template = Template(templateString: "{{ value|lowerFirst }}")
+      let template = Template(templateString: "{{ value|lowerFirst }}")
-
+      let filterExtension = Extension()
-        filterExtension = Extension()
       filterExtension.registerFilter("lowerFirstWord") { value, _ in value }
       filterExtension.registerFilter("lowerFirstLetter") { value, _ in value }
 
-        try expectError(reason: "Unknown filter 'lowerFirst'. Found similar filters: 'lowerFirstWord', 'lowercase'.", token: "value|lowerFirst")
+      try self.expectError(
+        reason: "Unknown filter 'lowerFirst'. Found similar filters: 'lowerFirstWord', 'lowercase'.",
+        token: "value|lowerFirst",
+        template: template,
+        extension: filterExtension
+      )
     }
 
-      $0.it("not made when can't find similar filter") {
+    it("not made when can't find similar filter") {
-        template = Template(templateString: "{{ value|unknownFilter }}")
+      let template = Template(templateString: "{{ value|unknownFilter }}")
-        try expectError(reason: "Unknown filter 'unknownFilter'. Found similar filters: 'lowerFirstWord'.", token: "value|unknownFilter")
+      let filterExtension = Extension()
+      filterExtension.registerFilter("lowerFirstWord") { value, _ in value }
+
+      try self.expectError(
+        reason: "Unknown filter 'unknownFilter'. Found similar filters: 'lowerFirstWord'.",
+        token: "value|unknownFilter",
+        template: template,
+        extension: filterExtension
+      )
+    }
   }
 
-    }
+  func testIndentContent() throws {
-
-
-    describe("indent filter") {
-      $0.it("indents content") {
     let template = Template(templateString: """
       {{ value|indent:2 }}
       """)
@@ -336,7 +335,7 @@ class FilterTests: XCTestCase {
       """
   }
 
-      $0.it("can indent with arbitrary character") {
+  func testIndentWithArbitraryCharacter() throws {
     let template = Template(templateString: """
       {{ value|indent:2,"\t" }}
       """)
@@ -350,7 +349,7 @@ class FilterTests: XCTestCase {
       """
   }
 
-      $0.it("can indent first line") {
+  func testIndentFirstLine() throws {
     let template = Template(templateString: """
       {{ value|indent:2," ",true }}
       """)
@@ -364,7 +363,7 @@ class FilterTests: XCTestCase {
       """
   }
 
-      $0.it("does not indent empty lines") {
+  func testIndentNotEmptyLines() throws {
     let template = Template(templateString: """
       {{ value|indent }}
       """)
@@ -385,29 +384,62 @@ class FilterTests: XCTestCase {
 
       """
   }
-    }
 
-    describe("dynamic filter") {
+  func testDynamicFilters() throws {
-      
+    it("can apply dynamic filter") {
-      $0.it("can apply dynamic filter") {
       let template = Template(templateString: "{{ name|filter:somefilter }}")
       let result = try template.render(Context(dictionary: ["name": "Jhon", "somefilter": "uppercase"]))
       try expect(result) == "JHON"
     }
 
-      $0.it("can apply dynamic filter on array") {
+    it("can apply dynamic filter on array") {
       let template = Template(templateString: "{{ values|filter:joinfilter }}")
       let result = try template.render(Context(dictionary: ["values": [1, 2, 3], "joinfilter": "join:\", \""]))
       try expect(result) == "1, 2, 3"
     }
 
-      $0.it("throws on unknown dynamic filter") {
+    it("throws on unknown dynamic filter") {
       let template = Template(templateString: "{{ values|filter:unknown }}")
       let context = Context(dictionary: ["values": [1, 2, 3], "unknown": "absurd"])
       try expect(try template.render(context)).toThrow()
     }
-      
   }
 
+  private func expectError(
+    reason: String,
+    token: String,
+    template: Template,
+    extension: Extension,
+    file: String = #file,
+    line: Int = #line,
+    function: String = #function
+  ) throws {
+    guard let range = template.templateString.range(of: token) else {
+      fatalError("Can't find '\(token)' in '\(template)'")
+    }
+
+    let environment = Environment(extensions: [`extension`])
+    let expectedError: Error = {
+      let lexer = Lexer(templateString: template.templateString)
+      let location = lexer.rangeLocation(range)
+      let sourceMap = SourceMap(filename: template.name, location: location)
+      let token = Token.block(value: token, at: sourceMap)
+      return TemplateSyntaxError(reason: reason, token: token, stackTrace: [])
+    }()
+
+    let error = try expect(
+      environment.render(template: template, context: [:]),
+      file: file,
+      line: line,
+      function: function
+    ).toThrow() as TemplateSyntaxError
+    let reporter = SimpleErrorReporter()
+
+    try expect(
+      reporter.renderError(error),
+      file: file,
+      line: line,
+      function: function
+    ) == reporter.renderError(expectedError)
   }
 }

Tests/StencilTests/FilterTagSpec.swift

@@ -1,32 +1,33 @@
-import XCTest
 import Spectre
 import Stencil
+import XCTest
 
-class FilterTagTests: XCTestCase {
+final class FilterTagTests: XCTestCase {
   func testFilterTag() {
-    describe("Filter Tag") {
+    it("allows you to use a filter") {
-      $0.it("allows you to use a filter") {
       let template = Template(templateString: "{% filter uppercase %}Test{% endfilter %}")
       let result = try template.render()
       try expect(result) == "TEST"
     }
 
-      $0.it("allows you to chain filters") {
+    it("allows you to chain filters") {
       let template = Template(templateString: "{% filter lowercase|capitalize %}TEST{% endfilter %}")
       let result = try template.render()
       try expect(result) == "Test"
     }
 
-      $0.it("errors without a filter") {
+    it("errors without a filter") {
       let template = Template(templateString: "Some {% filter %}Test{% endfilter %}")
       try expect(try template.render()).toThrow()
     }
 
-      $0.it("can render filters with arguments") {
+    it("can render filters with arguments") {
       let ext = Extension()
-        ext.registerFilter("split", filter: {
+      ext.registerFilter("split") {
-          return ($0 as! String).components(separatedBy: $1[0] as! String)
+        guard let value = $0 as? String,
-        })
+          let argument = $1.first as? String else { return $0 }
+        return value.components(separatedBy: argument)
+      }
       let env = Environment(extensions: [ext])
       let result = try env.renderTemplate(string: """
         {% filter split:","|join:";"  %}{{ items|join:"," }}{% endfilter %}
@@ -34,12 +35,15 @@ class FilterTagTests: XCTestCase {
       try expect(result) == "1;2"
     }
 
-      $0.it("can render filters with quote as an argument") {
+    it("can render filters with quote as an argument") {
       let ext = Extension()
-        ext.registerFilter("replace", filter: {
+      ext.registerFilter("replace") {
-          print($1[0] as! String)
+        guard let value = $0 as? String,
-          return ($0 as! String).replacingOccurrences(of: $1[0] as! String, with: $1[1] as! String)
+          $1.count == 2,
-        })
+          let search = $1.first as? String,
+          let replacement = $1.last as? String else { return $0 }
+        return value.replacingOccurrences(of: search, with: replacement)
+      }
       let env = Environment(extensions: [ext])
       let result = try env.renderTemplate(string: """
         {% filter replace:'"',"" %}{{ items|join:"," }}{% endfilter %}
@@ -48,4 +52,3 @@ class FilterTagTests: XCTestCase {
     }
   }
 }
-}

Tests/StencilTests/ForNodeSpec.swift

@@ -1,134 +1,63 @@
-import XCTest
 import Spectre
 @testable import Stencil
-import Foundation
+import XCTest
 
-class ForNodeTests: XCTestCase {
+final class ForNodeTests: XCTestCase {
-  func testForNode() {
-    describe("ForNode") {
   let context = Context(dictionary: [
     "items": [1, 2, 3],
+    "anyItems": [1, 2, 3] as [Any],
+    "nsItems": NSArray(array: [1, 2, 3]),
     "emptyItems": [Int](),
     "dict": [
       "one": "I",
-          "two": "II",
+      "two": "II"
     ],
     "tuples": [(1, 2, 3), (4, 5, 6)]
   ])
 
-      $0.it("renders the given nodes for each item") {
+  func testForNode() {
+    it("renders the given nodes for each item") {
       let nodes: [NodeType] = [VariableNode(variable: "item")]
       let node = ForNode(resolvable: Variable("items"), loopVariables: ["item"], nodes: nodes, emptyNodes: [])
-        try expect(try node.render(context)) == "123"
+      try expect(try node.render(self.context)) == "123"
     }
 
-      $0.it("renders the given empty nodes when no items found item") {
+    it("renders the given empty nodes when no items found item") {
-        let nodes: [NodeType] = [VariableNode(variable: "item")]
+      let node = ForNode(
-        let emptyNodes: [NodeType] = [TextNode(text: "empty")]
+        resolvable: Variable("emptyItems"),
-        let node = ForNode(resolvable: Variable("emptyItems"), loopVariables: ["item"], nodes: nodes, emptyNodes: emptyNodes)
+        loopVariables: ["item"],
-        try expect(try node.render(context)) == "empty"
+        nodes: [VariableNode(variable: "item")],
+        emptyNodes: [TextNode(text: "empty")]
+      )
+      try expect(try node.render(self.context)) == "empty"
     }
 
-      $0.it("renders a context variable of type Array<Any>") {
+    it("renders a context variable of type Array<Any>") {
-        let any_context = Context(dictionary: [
-          "items": ([1, 2, 3] as [Any])
-          ])
-
       let nodes: [NodeType] = [VariableNode(variable: "item")]
-        let node = ForNode(resolvable: Variable("items"), loopVariables: ["item"], nodes: nodes, emptyNodes: [])
+      let node = ForNode(resolvable: Variable("anyItems"), loopVariables: ["item"], nodes: nodes, emptyNodes: [])
-        try expect(try node.render(any_context)) == "123"
+      try expect(try node.render(self.context)) == "123"
-      }
-
-      $0.it("renders a context variable of type CountableClosedRange<Int>") {
-        let context = Context(dictionary: ["range": 1...3])
-        let nodes: [NodeType] = [VariableNode(variable: "item")]
-        let node = ForNode(resolvable: Variable("range"), loopVariables: ["item"], nodes: nodes, emptyNodes: [])
-
-        try expect(try node.render(context)) == "123"
-      }
-
-      $0.it("renders a context variable of type CountableRange<Int>") {
-        let context = Context(dictionary: ["range": 1..<4])
-        let nodes: [NodeType] = [VariableNode(variable: "item")]
-        let node = ForNode(resolvable: Variable("range"), loopVariables: ["item"], nodes: nodes, emptyNodes: [])
-
-        try expect(try node.render(context)) == "123"
     }
 
     #if os(OSX)
-      $0.it("renders a context variable of type NSArray") {
+    it("renders a context variable of type NSArray") {
-        let nsarray_context = Context(dictionary: [
-          "items": NSArray(array: [1, 2, 3])
-          ])
-
       let nodes: [NodeType] = [VariableNode(variable: "item")]
-        let node = ForNode(resolvable: Variable("items"), loopVariables: ["item"], nodes: nodes, emptyNodes: [])
+      let node = ForNode(resolvable: Variable("nsItems"), loopVariables: ["item"], nodes: nodes, emptyNodes: [])
-        try expect(try node.render(nsarray_context)) == "123"
+      try expect(try node.render(self.context)) == "123"
     }
     #endif
 
-      $0.it("renders the given nodes while providing if the item is first in the context") {
+    it("can render a filter with spaces") {
-        let nodes: [NodeType] = [VariableNode(variable: "item"), VariableNode(variable: "forloop.first")]
+      let template = Template(templateString: """
-        let node = ForNode(resolvable: Variable("items"), loopVariables: ["item"], nodes: nodes, emptyNodes: [])
-        try expect(try node.render(context)) == "1true2false3false"
-      }
-
-      $0.it("renders the given nodes while providing if the item is last in the context") {
-        let nodes: [NodeType] = [VariableNode(variable: "item"), VariableNode(variable: "forloop.last")]
-        let node = ForNode(resolvable: Variable("items"), loopVariables: ["item"], nodes: nodes, emptyNodes: [])
-        try expect(try node.render(context)) == "1false2false3true"
-      }
-
-      $0.it("renders the given nodes while providing item counter") {
-        let nodes: [NodeType] = [VariableNode(variable: "item"), VariableNode(variable: "forloop.counter")]
-        let node = ForNode(resolvable: Variable("items"), loopVariables: ["item"], nodes: nodes, emptyNodes: [])
-        try expect(try node.render(context)) == "112233"
-      }
-
-      $0.it("renders the given nodes while providing item counter") {
-        let nodes: [NodeType] = [VariableNode(variable: "item"), VariableNode(variable: "forloop.counter0")]
-        let node = ForNode(resolvable: Variable("items"), loopVariables: ["item"], nodes: nodes, emptyNodes: [])
-        try expect(try node.render(context)) == "102132"
-      }
-
-      $0.it("renders the given nodes while providing loop length") {
-        let nodes: [NodeType] = [VariableNode(variable: "item"), VariableNode(variable: "forloop.length")]
-        let node = ForNode(resolvable: Variable("items"), loopVariables: ["item"], nodes: nodes, emptyNodes: [])
-        try expect(try node.render(context)) == "132333"
-      }
-
-      $0.it("renders the given nodes while filtering items using where expression") {
-        let nodes: [NodeType] = [VariableNode(variable: "item"), VariableNode(variable: "forloop.counter")]
-        let parser = TokenParser(tokens: [], environment: Environment())
-        let `where` = try parser.compileExpression(components: ["item", ">", "1"], token: .text(value: "", at: .unknown))
-        let node = ForNode(resolvable: Variable("items"), loopVariables: ["item"], nodes: nodes, emptyNodes: [], where: `where`)
-        try expect(try node.render(context)) == "2132"
-      }
-
-      $0.it("renders the given empty nodes when all items filtered out with where expression") {
-        let nodes: [NodeType] = [VariableNode(variable: "item")]
-        let emptyNodes: [NodeType] = [TextNode(text: "empty")]
-        let parser = TokenParser(tokens: [], environment: Environment())
-        let `where` = try parser.compileExpression(components: ["item", "==", "0"], token: .text(value: "", at: .unknown))
-        let node = ForNode(resolvable: Variable("emptyItems"), loopVariables: ["item"], nodes: nodes, emptyNodes: emptyNodes, where: `where`)
-        try expect(try node.render(context)) == "empty"
-      }
-
-      $0.it("can render a filter with spaces") {
-        let templateString = """
         {% for article in ars | default: a, b , articles %}\
         - {{ article.title }} by {{ article.author }}.
         {% endfor %}
-        """
+        """)
-
       let context = Context(dictionary: [
         "articles": [
           Article(title: "Migrating from OCUnit to XCTest", author: "Kyle Fuller"),
-            Article(title: "Memory Management with ARC", author: "Kyle Fuller"),
+          Article(title: "Memory Management with ARC", author: "Kyle Fuller")
         ]
       ])
-
-        let template = Template(templateString: templateString)
       let result = try template.render(context)
 
       try expect(result) == """
@@ -137,173 +66,264 @@ class ForNodeTests: XCTestCase {
 
         """
     }
+  }
 
-      $0.context("given array of tuples") {
+  func testLoopMetadata() {
-        $0.it("can iterate over all tuple values") {
+    it("renders the given nodes while providing if the item is first in the context") {
-          let templateString = """
+      let nodes: [NodeType] = [VariableNode(variable: "item"), VariableNode(variable: "forloop.first")]
+      let node = ForNode(resolvable: Variable("items"), loopVariables: ["item"], nodes: nodes, emptyNodes: [])
+      try expect(try node.render(self.context)) == "1true2false3false"
+    }
+
+    it("renders the given nodes while providing if the item is last in the context") {
+      let nodes: [NodeType] = [VariableNode(variable: "item"), VariableNode(variable: "forloop.last")]
+      let node = ForNode(resolvable: Variable("items"), loopVariables: ["item"], nodes: nodes, emptyNodes: [])
+      try expect(try node.render(self.context)) == "1false2false3true"
+    }
+
+    it("renders the given nodes while providing item counter") {
+      let nodes: [NodeType] = [VariableNode(variable: "item"), VariableNode(variable: "forloop.counter")]
+      let node = ForNode(resolvable: Variable("items"), loopVariables: ["item"], nodes: nodes, emptyNodes: [])
+      try expect(try node.render(self.context)) == "112233"
+    }
+
+    it("renders the given nodes while providing item counter") {
+      let nodes: [NodeType] = [VariableNode(variable: "item"), VariableNode(variable: "forloop.counter0")]
+      let node = ForNode(resolvable: Variable("items"), loopVariables: ["item"], nodes: nodes, emptyNodes: [])
+      try expect(try node.render(self.context)) == "102132"
+    }
+
+    it("renders the given nodes while providing loop length") {
+      let nodes: [NodeType] = [VariableNode(variable: "item"), VariableNode(variable: "forloop.length")]
+      let node = ForNode(resolvable: Variable("items"), loopVariables: ["item"], nodes: nodes, emptyNodes: [])
+      try expect(try node.render(self.context)) == "132333"
+    }
+  }
+
+  func testWhereExpression() {
+    it("renders the given nodes while filtering items using where expression") {
+      let nodes: [NodeType] = [VariableNode(variable: "item"), VariableNode(variable: "forloop.counter")]
+      let parser = TokenParser(tokens: [], environment: Environment())
+      let `where` = try parser.compileExpression(components: ["item", ">", "1"], token: .text(value: "", at: .unknown))
+      let node = ForNode(
+        resolvable: Variable("items"),
+        loopVariables: ["item"],
+        nodes: nodes,
+        emptyNodes: [],
+        where: `where`
+      )
+      try expect(try node.render(self.context)) == "2132"
+    }
+
+    it("renders the given empty nodes when all items filtered out with where expression") {
+      let nodes: [NodeType] = [VariableNode(variable: "item")]
+      let emptyNodes: [NodeType] = [TextNode(text: "empty")]
+      let parser = TokenParser(tokens: [], environment: Environment())
+      let `where` = try parser.compileExpression(components: ["item", "==", "0"], token: .text(value: "", at: .unknown))
+      let node = ForNode(
+        resolvable: Variable("emptyItems"),
+        loopVariables: ["item"],
+        nodes: nodes,
+        emptyNodes: emptyNodes,
+        where: `where`
+      )
+      try expect(try node.render(self.context)) == "empty"
+    }
+  }
+
+  func testArrayOfTuples() {
+    it("can iterate over all tuple values") {
+      let template = Template(templateString: """
         {% for first,second,third in tuples %}\
         {{ first }}, {{ second }}, {{ third }}
         {% endfor %}
-          """
+        """)
-
+      try expect(template.render(self.context)) == """
-          let template = Template(templateString: templateString)
-          let result = try template.render(context)
-
-          try expect(result) == """
         1, 2, 3
         4, 5, 6
 
         """
     }
 
-        $0.it("can iterate with less number of variables") {
+    it("can iterate with less number of variables") {
-          let templateString = """
+      let template = Template(templateString: """
         {% for first,second in tuples %}\
         {{ first }}, {{ second }}
         {% endfor %}
-          """
+        """)
-
+      try expect(template.render(self.context)) == """
-          let template = Template(templateString: templateString)
-          let result = try template.render(context)
-
-          try expect(result) == """
         1, 2
         4, 5
 
         """
     }
 
-        $0.it("can use _ to skip variables") {
+    it("can use _ to skip variables") {
-          let templateString = """
+      let template = Template(templateString: """
         {% for first,_,third in tuples %}\
         {{ first }}, {{ third }}
         {% endfor %}
-          """
+        """)
-
+      try expect(template.render(self.context)) == """
-          let template = Template(templateString: templateString)
-          let result = try template.render(context)
-
-          try expect(result) == """
         1, 3
         4, 6
 
         """
     }
 
-        $0.it("throws when number of variables is more than number of tuple values") {
+    it("throws when number of variables is more than number of tuple values") {
-          let templateString = """
+      let template = Template(templateString: """
-          {% for key,value,smth in dict %}
+        {% for key,value,smth in dict %}{% endfor %}
-          {% endfor %}
+        """)
-          """
+      try expect(template.render(self.context)).toThrow()
-
+    }
-          let template = Template(templateString: templateString)
-          try expect(template.render(context)).toThrow()
   }
 
-      }
+  func testIterateDictionary() {
-
+    it("can iterate over dictionary") {
-      $0.it("can iterate over dictionary") {
+      let template = Template(templateString: """
-        let templateString = """
         {% for key, value in dict %}\
         {{ key }}: {{ value }},\
         {% endfor %}
-        """
+        """)
-
+      try expect(template.render(self.context)) == """
-        let template = Template(templateString: templateString)
-        let result = try template.render(context)
-
-        try expect(result) == """
         one: I,two: II,
         """
     }
 
-      $0.it("renders supports iterating over dictionary") {
+    it("renders supports iterating over dictionary") {
       let nodes: [NodeType] = [
         VariableNode(variable: "key"),
-          TextNode(text: ","),
+        TextNode(text: ",")
       ]
       let emptyNodes: [NodeType] = [TextNode(text: "empty")]
-        let node = ForNode(resolvable: Variable("dict"), loopVariables: ["key"], nodes: nodes, emptyNodes: emptyNodes, where: nil)
+      let node = ForNode(
-        let result = try node.render(context)
+        resolvable: Variable("dict"),
+        loopVariables: ["key"],
+        nodes: nodes,
+        emptyNodes: emptyNodes
+      )
 
-        try expect(result) == """
+      try expect(node.render(self.context)) == """
         one,two,
         """
     }
 
-      $0.it("renders supports iterating over dictionary") {
+    it("renders supports iterating over dictionary with values") {
       let nodes: [NodeType] = [
         VariableNode(variable: "key"),
         TextNode(text: "="),
         VariableNode(variable: "value"),
-          TextNode(text: ","),
+        TextNode(text: ",")
       ]
       let emptyNodes: [NodeType] = [TextNode(text: "empty")]
-        let node = ForNode(resolvable: Variable("dict"), loopVariables: ["key", "value"], nodes: nodes, emptyNodes: emptyNodes, where: nil)
+      let node = ForNode(
-        let result = try node.render(context)
+        resolvable: Variable("dict"),
+        loopVariables: ["key", "value"],
+        nodes: nodes,
+        emptyNodes: emptyNodes
+      )
 
-        try expect(result) == """
+      try expect(node.render(self.context)) == """
         one=I,two=II,
         """
     }
-
-      $0.it("handles invalid input") {
-        let token = Token.block(value: "for i", at: .unknown)
-        let parser = TokenParser(tokens: [token], environment: Environment())
-        let error = TemplateSyntaxError(reason: "'for' statements should use the syntax: `for <x> in <y> [where <condition>]`.", token: token)
-        try expect(try parser.parse()).toThrow(error)
   }
 
-      $0.it("can iterate over struct properties") {
+  func testIterateUsingMirroring() {
-        struct MyStruct {
-          let string: String
-          let number: Int
-        }
-
-        let context = Context(dictionary: [
-          "struct": MyStruct(string: "abc", number: 123)
-          ])
-
     let nodes: [NodeType] = [
-          VariableNode(variable: "property"),
+      VariableNode(variable: "label"),
       TextNode(text: "="),
       VariableNode(variable: "value"),
-          TextNode(text: "\n"),
+      TextNode(text: "\n")
     ]
-        let node = ForNode(resolvable: Variable("struct"), loopVariables: ["property", "value"], nodes: nodes, emptyNodes: [])
+    let node = ForNode(
-        let result = try node.render(context)
+      resolvable: Variable("item"),
+      loopVariables: ["label", "value"],
+      nodes: nodes,
+      emptyNodes: []
+    )
 
-        try expect(result) == """
+    it("can iterate over struct properties") {
+      let context = Context(dictionary: [
+        "item": MyStruct(string: "abc", number: 123)
+      ])
+      try expect(node.render(context)) == """
         string=abc
         number=123
 
         """
     }
 
-      $0.it("can iterate tuple items") {
+    it("can iterate tuple items") {
       let context = Context(dictionary: [
-          "tuple": (one: 1, two: "dva"),
+        "item": (one: 1, two: "dva")
       ])
-
+      try expect(node.render(context)) == """
-        let nodes: [NodeType] = [
-          VariableNode(variable: "label"),
-          TextNode(text: "="),
-          VariableNode(variable: "value"),
-          TextNode(text: "\n"),
-          ]
-
-        let node = ForNode(resolvable: Variable("tuple"), loopVariables: ["label", "value"], nodes: nodes, emptyNodes: [])
-        let result = try node.render(context)
-
-        try expect(result) == """
         one=1
         two=dva
 
         """
     }
 
-      $0.it("can iterate over class properties") {
+    it("can iterate over class properties") {
-        class MyClass {
+      let context = Context(dictionary: [
+        "item": MySubclass("child", "base", 1)
+      ])
+      try expect(node.render(context)) == """
+        childString=child
+        baseString=base
+        baseInt=1
+
+        """
+    }
+  }
+
+  func testIterateRange() {
+    it("renders a context variable of type CountableClosedRange<Int>") {
+      let context = Context(dictionary: ["range": 1...3])
+      let nodes: [NodeType] = [VariableNode(variable: "item")]
+      let node = ForNode(resolvable: Variable("range"), loopVariables: ["item"], nodes: nodes, emptyNodes: [])
+
+      try expect(try node.render(context)) == "123"
+    }
+
+    it("renders a context variable of type CountableRange<Int>") {
+      let context = Context(dictionary: ["range": 1..<4])
+      let nodes: [NodeType] = [VariableNode(variable: "item")]
+      let node = ForNode(resolvable: Variable("range"), loopVariables: ["item"], nodes: nodes, emptyNodes: [])
+
+      try expect(try node.render(context)) == "123"
+    }
+
+    it("can iterate in range of variables") {
+      let template: Template = "{% for i in 1...j %}{{ i }}{% endfor %}"
+      try expect(try template.render(Context(dictionary: ["j": 3]))) == "123"
+    }
+  }
+
+  func testHandleInvalidInput() throws {
+    let token = Token.block(value: "for i", at: .unknown)
+    let parser = TokenParser(tokens: [token], environment: Environment())
+    let error = TemplateSyntaxError(
+      reason: "'for' statements should use the syntax: `for <x> in <y> [where <condition>]`.",
+      token: token
+    )
+    try expect(try parser.parse()).toThrow(error)
+  }
+}
+
+private struct MyStruct {
+  let string: String
+  let number: Int
+}
+
+private struct Article {
+  let title: String
+  let author: String
+}
+
+private class MyClass {
   var baseString: String
   var baseInt: Int
   init(_ string: String, _ int: Int) {
@@ -312,47 +332,10 @@ class ForNodeTests: XCTestCase {
   }
 }
 
-        class MySubclass: MyClass {
+private class MySubclass: MyClass {
   var childString: String
   init(_ childString: String, _ string: String, _ int: Int) {
     self.childString = childString
     super.init(string, int)
   }
 }
-
-        let context = Context(dictionary: [
-          "class": MySubclass("child", "base", 1)
-          ])
-
-        let nodes: [NodeType] = [
-          VariableNode(variable: "label"),
-          TextNode(text: "="),
-          VariableNode(variable: "value"),
-          TextNode(text: "\n"),
-          ]
-
-        let node = ForNode(resolvable: Variable("class"), loopVariables: ["label", "value"], nodes: nodes, emptyNodes: [])
-        let result = try node.render(context)
-
-        try expect(result) == """
-        childString=child
-        baseString=base
-        baseInt=1
-
-        """
-      }
-
-      $0.it("can iterate in range of variables") {
-        let template: Template = "{% for i in 1...j %}{{ i }}{% endfor %}"
-        try expect(try template.render(Context(dictionary: ["j": 3]))) == "123"
-      }
-
-    }
-
-  }
-}
-
-fileprivate struct Article {
-  let title: String
-  let author: String
-}

Tests/StencilTests/IfNodeSpec.swift

@@ -1,12 +1,14 @@
-import XCTest
 import Spectre
 @testable import Stencil
+import XCTest
 
-class IfNodeTests: XCTestCase {
+private struct SomeType {
-  func testIfNode() {
+  let value: String? = nil
-    describe("IfNode") {
+}
-      $0.describe("parsing") {
+
-        $0.it("can parse an if block") {
+final class IfNodeTests: XCTestCase {
+  func testParseIf() {
+    it("can parse an if block") {
       let tokens: [Token] = [
         .block(value: "if value", at: .unknown),
         .text(value: "true", at: .unknown),
@@ -24,7 +26,22 @@ class IfNodeTests: XCTestCase {
       try expect(trueNode?.text) == "true"
     }
 
-        $0.it("can parse an if with else block") {
+    it("can parse an if with complex expression") {
+      let tokens: [Token] = [
+        .block(value: """
+          if value == \"test\" and (not name or not (name and surname) or( some )and other )
+          """, at: .unknown),
+        .text(value: "true", at: .unknown),
+        .block(value: "endif", at: .unknown)
+      ]
+
+      let parser = TokenParser(tokens: tokens, environment: Environment())
+      let nodes = try parser.parse()
+      try expect(nodes.first is IfNode).beTrue()
+    }
+  }
+
+  func testParseIfWithElse() throws {
     let tokens: [Token] = [
       .block(value: "if value", at: .unknown),
       .text(value: "true", at: .unknown),
@@ -49,7 +66,7 @@ class IfNodeTests: XCTestCase {
     try expect(falseNode?.text) == "false"
   }
 
-        $0.it("can parse an if with elif block") {
+  func testParseIfWithElif() throws {
     let tokens: [Token] = [
       .block(value: "if value", at: .unknown),
       .text(value: "true", at: .unknown),
@@ -80,7 +97,7 @@ class IfNodeTests: XCTestCase {
     try expect(falseNode?.text) == "false"
   }
 
-        $0.it("can parse an if with elif block without else") {
+  func testParseIfWithElifWithoutElse() throws {
     let tokens: [Token] = [
       .block(value: "if value", at: .unknown),
       .text(value: "true", at: .unknown),
@@ -105,7 +122,7 @@ class IfNodeTests: XCTestCase {
     try expect(elifNode?.text) == "some"
   }
 
-        $0.it("can parse an if with multiple elif block") {
+  func testParseMultipleElif() throws {
     let tokens: [Token] = [
       .block(value: "if value", at: .unknown),
       .text(value: "true", at: .unknown),
@@ -142,20 +159,7 @@ class IfNodeTests: XCTestCase {
     try expect(falseNode?.text) == "false"
   }
 
-
+  func testParseIfnot() throws {
-        $0.it("can parse an if with complex expression") {
-          let tokens: [Token] = [
-            .block(value: "if value == \"test\" and (not name or not (name and surname) or( some )and other )", at: .unknown),
-            .text(value: "true", at: .unknown),
-            .block(value: "endif", at: .unknown)
-          ]
-
-          let parser = TokenParser(tokens: tokens, environment: Environment())
-          let nodes = try parser.parse()
-          try expect(nodes.first is IfNode).beTrue()
-        }
-
-        $0.it("can parse an ifnot block") {
     let tokens: [Token] = [
       .block(value: "ifnot value", at: .unknown),
       .text(value: "false", at: .unknown),
@@ -179,7 +183,8 @@ class IfNodeTests: XCTestCase {
     try expect(falseNode?.text) == "false"
   }
 
-        $0.it("throws an error when parsing an if block without an endif") {
+  func testParsingErrors() {
+    it("throws an error when parsing an if block without an endif") {
       let tokens: [Token] = [.block(value: "if value", at: .unknown)]
 
       let parser = TokenParser(tokens: tokens, environment: Environment())
@@ -187,7 +192,7 @@ class IfNodeTests: XCTestCase {
       try expect(try parser.parse()).toThrow(error)
     }
 
-        $0.it("throws an error when parsing an ifnot without an endif") {
+    it("throws an error when parsing an ifnot without an endif") {
       let tokens: [Token] = [.block(value: "ifnot value", at: .unknown)]
 
       let parser = TokenParser(tokens: tokens, environment: Environment())
@@ -196,48 +201,48 @@ class IfNodeTests: XCTestCase {
     }
   }
 
-      $0.describe("rendering") {
+  func testRendering() {
-        $0.it("renders a true expression") {
+    it("renders a true expression") {
       let node = IfNode(conditions: [
         IfCondition(expression: StaticExpression(value: true), nodes: [TextNode(text: "1")]),
         IfCondition(expression: StaticExpression(value: true), nodes: [TextNode(text: "2")]),
-            IfCondition(expression: nil, nodes: [TextNode(text: "3")]),
+        IfCondition(expression: nil, nodes: [TextNode(text: "3")])
       ])
 
       try expect(try node.render(Context())) == "1"
     }
 
-        $0.it("renders the first true expression") {
+    it("renders the first true expression") {
       let node = IfNode(conditions: [
         IfCondition(expression: StaticExpression(value: false), nodes: [TextNode(text: "1")]),
         IfCondition(expression: StaticExpression(value: true), nodes: [TextNode(text: "2")]),
-            IfCondition(expression: nil, nodes: [TextNode(text: "3")]),
+        IfCondition(expression: nil, nodes: [TextNode(text: "3")])
       ])
 
       try expect(try node.render(Context())) == "2"
     }
 
-        $0.it("renders the empty expression when other conditions are falsy") {
+    it("renders the empty expression when other conditions are falsy") {
       let node = IfNode(conditions: [
         IfCondition(expression: StaticExpression(value: false), nodes: [TextNode(text: "1")]),
         IfCondition(expression: StaticExpression(value: false), nodes: [TextNode(text: "2")]),
-            IfCondition(expression: nil, nodes: [TextNode(text: "3")]),
+        IfCondition(expression: nil, nodes: [TextNode(text: "3")])
       ])
 
       try expect(try node.render(Context())) == "3"
     }
 
-        $0.it("renders empty when no truthy conditions") {
+    it("renders empty when no truthy conditions") {
       let node = IfNode(conditions: [
         IfCondition(expression: StaticExpression(value: false), nodes: [TextNode(text: "1")]),
-            IfCondition(expression: StaticExpression(value: false), nodes: [TextNode(text: "2")]),
+        IfCondition(expression: StaticExpression(value: false), nodes: [TextNode(text: "2")])
       ])
 
       try expect(try node.render(Context())) == ""
     }
   }
 
-      $0.it("supports variable filters in the if expression") {
+  func testSupportVariableFilters() throws {
     let tokens: [Token] = [
       .block(value: "if value|uppercase == \"TEST\"", at: .unknown),
       .text(value: "true", at: .unknown),
@@ -251,7 +256,7 @@ class IfNodeTests: XCTestCase {
     try expect(result) == "true"
   }
 
-      $0.it("evaluates nil properties as false") {
+  func testEvaluatesNilAsFalse() throws {
     let tokens: [Token] = [
       .block(value: "if instance.value", at: .unknown),
       .text(value: "true", at: .unknown),
@@ -261,14 +266,11 @@ class IfNodeTests: XCTestCase {
     let parser = TokenParser(tokens: tokens, environment: Environment())
     let nodes = try parser.parse()
 
-        struct SomeType {
-          let value: String? = nil
-        }
     let result = try renderNodes(nodes, Context(dictionary: ["instance": SomeType()]))
     try expect(result) == ""
   }
 
-      $0.it("supports closed range variables") {
+  func testSupportsRangeVariables() throws {
     let tokens: [Token] = [
       .block(value: "if value in 1...3", at: .unknown),
       .text(value: "true", at: .unknown),
@@ -283,7 +285,4 @@ class IfNodeTests: XCTestCase {
     try expect(renderNodes(nodes, Context(dictionary: ["value": 3]))) == "true"
     try expect(renderNodes(nodes, Context(dictionary: ["value": 4]))) == "false"
   }
-
-    }
-  }
 }

Tests/StencilTests/IncludeSpec.swift

@@ -1,25 +1,27 @@
-import XCTest
+import PathKit
 import Spectre
 @testable import Stencil
-import PathKit
+import XCTest
 
-class IncludeTests: XCTestCase {
+final class IncludeTests: XCTestCase {
-  func testInclude() {
-    describe("Include") {
   let path = Path(#file) + ".." + "fixtures"
-      let loader = FileSystemLoader(paths: [path])
+  lazy var loader = FileSystemLoader(paths: [path])
-      let environment = Environment(loader: loader)
+  lazy var environment = Environment(loader: loader)
 
-      $0.describe("parsing") {
+  func testParsing() {
-        $0.it("throws an error when no template is given") {
+    it("throws an error when no template is given") {
       let tokens: [Token] = [ .block(value: "include", at: .unknown) ]
       let parser = TokenParser(tokens: tokens, environment: Environment())
 
-          let error = TemplateSyntaxError(reason: "'include' tag requires one argument, the template file to be included. A second optional argument can be used to specify the context that will be passed to the included file", token: tokens.first)
+      let error = TemplateSyntaxError(reason: """
+        'include' tag requires one argument, the template file to be included. \
+        A second optional argument can be used to specify the context that will \
+        be passed to the included file
+        """, token: tokens.first)
       try expect(try parser.parse()).toThrow(error)
     }
 
-        $0.it("can parse a valid include block") {
+    it("can parse a valid include block") {
       let tokens: [Token] = [ .block(value: "include \"test.html\"", at: .unknown) ]
       let parser = TokenParser(tokens: tokens, environment: Environment())
 
@@ -30,8 +32,8 @@ class IncludeTests: XCTestCase {
     }
   }
 
-      $0.describe("rendering") {
+  func testRendering() {
-        $0.it("throws an error when rendering without a loader") {
+    it("throws an error when rendering without a loader") {
       let node = IncludeNode(templateName: Variable("\"test.html\""), token: .block(value: "", at: .unknown))
 
       do {
@@ -41,32 +43,30 @@ class IncludeTests: XCTestCase {
       }
     }
 
-        $0.it("throws an error when it cannot find the included template") {
+    it("throws an error when it cannot find the included template") {
       let node = IncludeNode(templateName: Variable("\"unknown.html\""), token: .block(value: "", at: .unknown))
 
       do {
-            _ = try node.render(Context(environment: environment))
+        _ = try node.render(Context(environment: self.environment))
       } catch {
         try expect("\(error)".hasPrefix("Template named `unknown.html` does not exist in loader")).to.beTrue()
       }
     }
 
-        $0.it("successfully renders a found included template") {
+    it("successfully renders a found included template") {
       let node = IncludeNode(templateName: Variable("\"test.html\""), token: .block(value: "", at: .unknown))
-          let context = Context(dictionary: ["target": "World"], environment: environment)
+      let context = Context(dictionary: ["target": "World"], environment: self.environment)
       let value = try node.render(context)
       try expect(value) == "Hello World!"
     }
 
-        $0.it("successfully passes context") {
+    it("successfully passes context") {
       let template = Template(templateString: """
         {% include "test.html" child %}
         """)
-          let context = Context(dictionary: ["child": ["target": "World"]], environment: environment)
+      let context = Context(dictionary: ["child": ["target": "World"]], environment: self.environment)
       let value = try template.render(context)
       try expect(value) == "Hello World!"
     }
   }
 }
-  }
-}

Tests/StencilTests/InheritenceSpec.swift

@@ -1,33 +1,32 @@
-import XCTest
+import PathKit
 import Spectre
 import Stencil
-import PathKit
+import XCTest
 
-class InheritenceTests: XCTestCase {
+final class InheritanceTests: XCTestCase {
-  func testInheritence() {
-    describe("Inheritence") {
   let path = Path(#file) + ".." + "fixtures"
-      let loader = FileSystemLoader(paths: [path])
+  lazy var loader = FileSystemLoader(paths: [path])
-      let environment = Environment(loader: loader)
+  lazy var environment = Environment(loader: loader)
 
-      $0.it("can inherit from another template") {
+  func testInheritance() {
-        let template = try environment.loadTemplate(name: "child.html")
+    it("can inherit from another template") {
+      let template = try self.environment.loadTemplate(name: "child.html")
       try expect(try template.render()) == """
         Super_Header Child_Header
         Child_Body
         """
     }
 
-      $0.it("can inherit from another template inheriting from another template") {
+    it("can inherit from another template inheriting from another template") {
-        let template = try environment.loadTemplate(name: "child-child.html")
+      let template = try self.environment.loadTemplate(name: "child-child.html")
       try expect(try template.render()) == """
         Super_Header Child_Header Child_Child_Header
         Child_Body
         """
     }
 
-      $0.it("can inherit from a template that calls a super block") {
+    it("can inherit from a template that calls a super block") {
-        let template = try environment.loadTemplate(name: "child-super.html")
+      let template = try self.environment.loadTemplate(name: "child-super.html")
       try expect(try template.render()) == """
         Header
         Child_Body
@@ -35,4 +34,3 @@ class InheritenceTests: XCTestCase {
     }
   }
 }
-}

Tests/StencilTests/LexerSpec.swift

@@ -3,15 +3,8 @@ import Spectre
 @testable import Stencil
 import XCTest
 
-class LexerTests: XCTestCase {
+final class LexerTests: XCTestCase {
-  func testLexer() {
+  func testText() throws {
-    describe("Lexer") {
-      func makeSourceMap(_ token: String, for lexer: Lexer, options: String.CompareOptions = []) -> SourceMap {
-        guard let range = lexer.templateString.range(of: token, options: options) else { fatalError("Token not found") }
-        return SourceMap(location: lexer.rangeLocation(range))
-      }
-
-      $0.it("can tokenize text") {
     let lexer = Lexer(templateString: "Hello World")
     let tokens = lexer.tokenize()
 
@@ -19,7 +12,7 @@ class LexerTests: XCTestCase {
     try expect(tokens.first) == .text(value: "Hello World", at: makeSourceMap("Hello World", for: lexer))
   }
 
-      $0.it("can tokenize a comment") {
+  func testComment() throws {
     let lexer = Lexer(templateString: "{# Comment #}")
     let tokens = lexer.tokenize()
 
@@ -27,7 +20,7 @@ class LexerTests: XCTestCase {
     try expect(tokens.first) == .comment(value: "Comment", at: makeSourceMap("Comment", for: lexer))
   }
 
-      $0.it("can tokenize a variable") {
+  func testVariable() throws {
     let lexer = Lexer(templateString: "{{ Variable }}")
     let tokens = lexer.tokenize()
 
@@ -35,7 +28,7 @@ class LexerTests: XCTestCase {
     try expect(tokens.first) == .variable(value: "Variable", at: makeSourceMap("Variable", for: lexer))
   }
 
-      $0.it("can tokenize a token without spaces") {
+  func testTokenWithoutSpaces() throws {
     let lexer = Lexer(templateString: "{{Variable}}")
     let tokens = lexer.tokenize()
 
@@ -43,7 +36,7 @@ class LexerTests: XCTestCase {
     try expect(tokens.first) == .variable(value: "Variable", at: makeSourceMap("Variable", for: lexer))
   }
 
-      $0.it("can tokenize unclosed tag by ignoring it") {
+  func testUnclosedTag() throws {
     let templateString = "{{ thing"
     let lexer = Lexer(templateString: templateString)
     let tokens = lexer.tokenize()
@@ -52,7 +45,7 @@ class LexerTests: XCTestCase {
     try expect(tokens.first) == .text(value: "", at: makeSourceMap("{{ thing", for: lexer))
   }
 
-      $0.it("can tokenize a mixture of content") {
+  func testContentMixture() throws {
     let templateString = "My name is {{ myname }}."
     let lexer = Lexer(templateString: templateString)
     let tokens = lexer.tokenize()
@@ -63,7 +56,7 @@ class LexerTests: XCTestCase {
     try expect(tokens[2]) == Token.text(value: ".", at: makeSourceMap(".", for: lexer))
   }
 
-      $0.it("can tokenize two variables without being greedy") {
+  func testVariablesWithoutBeingGreedy() throws {
     let templateString = "{{ thing }}{{ name }}"
     let lexer = Lexer(templateString: templateString)
     let tokens = lexer.tokenize()
@@ -73,22 +66,22 @@ class LexerTests: XCTestCase {
     try expect(tokens[1]) == Token.variable(value: "name", at: makeSourceMap("name", for: lexer))
   }
 
-      $0.it("can tokenize an unclosed block") {
+  func testUnclosedBlock() throws {
     let lexer = Lexer(templateString: "{%}")
     _ = lexer.tokenize()
   }
 
-      $0.it("can tokenize incorrect syntax without crashing") {
+  func testTokenizeIncorrectSyntaxWithoutCrashing() throws {
     let lexer = Lexer(templateString: "func some() {{% if %}")
     _ = lexer.tokenize()
   }
 
-      $0.it("can tokenize an empty variable") {
+  func testEmptyVariable() throws {
     let lexer = Lexer(templateString: "{{}}")
     _ = lexer.tokenize()
   }
 
-      $0.it("can tokenize with new lines") {
+  func testNewlines() throws {
     let templateString = """
       My name is {%
           if name
@@ -110,7 +103,7 @@ class LexerTests: XCTestCase {
     try expect(tokens[4]) == Token.text(value: ".", at: makeSourceMap(".", for: lexer))
   }
 
-      $0.it("can tokenize escape sequences") {
+  func testEscapeSequence() throws {
     let templateString = "class Some {{ '{' }}{% if true %}{{ stuff }}{% endif %}"
     let lexer = Lexer(templateString: templateString)
     let tokens = lexer.tokenize()
@@ -122,8 +115,6 @@ class LexerTests: XCTestCase {
     try expect(tokens[3]) == Token.variable(value: "stuff", at: makeSourceMap("stuff", for: lexer))
     try expect(tokens[4]) == Token.block(value: "endif", at: makeSourceMap("endif", for: lexer))
   }
-    }
-  }
 
   func testPerformance() throws {
     let path = Path(#file) + ".."  + "fixtures" + "huge.html"
@@ -134,4 +125,9 @@ class LexerTests: XCTestCase {
       _ = lexer.tokenize()
     }
   }
+
+  private func makeSourceMap(_ token: String, for lexer: Lexer, options: String.CompareOptions = []) -> SourceMap {
+    guard let range = lexer.templateString.range(of: token, options: options) else { fatalError("Token not found") }
+    return SourceMap(location: lexer.rangeLocation(range))
+  }
 }

Tests/StencilTests/LoaderSpec.swift

@@ -1,57 +1,55 @@
-import XCTest
+import PathKit
 import Spectre
 import Stencil
-import PathKit
+import XCTest
 
-class TemplateLoaderTests: XCTestCase {
+final class TemplateLoaderTests: XCTestCase {
-  func testTemplateLoader() {
+  func testFileSystemLoader() {
-    describe("FileSystemLoader") {
     let path = Path(#file) + ".."  + "fixtures"
     let loader = FileSystemLoader(paths: [path])
     let environment = Environment(loader: loader)
 
-      $0.it("errors when a template cannot be found") {
+    it("errors when a template cannot be found") {
       try expect(try environment.loadTemplate(name: "unknown.html")).toThrow()
     }
 
-      $0.it("errors when an array of templates cannot be found") {
+    it("errors when an array of templates cannot be found") {
       try expect(try environment.loadTemplate(names: ["unknown.html", "unknown2.html"])).toThrow()
     }
 
-      $0.it("can load a template from a file") {
+    it("can load a template from a file") {
       _ = try environment.loadTemplate(name: "test.html")
     }
 
-      $0.it("errors when loading absolute file outside of the selected path") {
+    it("errors when loading absolute file outside of the selected path") {
       try expect(try environment.loadTemplate(name: "/etc/hosts")).toThrow()
     }
 
-      $0.it("errors when loading relative file outside of the selected path") {
+    it("errors when loading relative file outside of the selected path") {
       try expect(try environment.loadTemplate(name: "../LoaderSpec.swift")).toThrow()
     }
   }
 
-    describe("DictionaryLoader") {
+  func testDictionaryLoader() {
     let loader = DictionaryLoader(templates: [
         "index.html": "Hello World"
     ])
     let environment = Environment(loader: loader)
 
-      $0.it("errors when a template cannot be found") {
+    it("errors when a template cannot be found") {
       try expect(try environment.loadTemplate(name: "unknown.html")).toThrow()
     }
 
-      $0.it("errors when an array of templates cannot be found") {
+    it("errors when an array of templates cannot be found") {
       try expect(try environment.loadTemplate(names: ["unknown.html", "unknown2.html"])).toThrow()
     }
 
-      $0.it("can load a template from a known templates") {
+    it("can load a template from a known templates") {
       _ = try environment.loadTemplate(name: "index.html")
     }
 
-      $0.it("can load a known template from a collection of templates") {
+    it("can load a known template from a collection of templates") {
       _ = try environment.loadTemplate(names: ["unknown.html", "index.html"])
     }
   }
 }
-}

Tests/StencilTests/NodeSpec.swift

@@ -1,6 +1,6 @@
-import XCTest
 import Spectre
 @testable import Stencil
+import XCTest
 
 class ErrorNode: NodeType {
   let token: Token?
@@ -13,54 +13,50 @@ class ErrorNode : NodeType {
   }
 }
 
-class NodeTests: XCTestCase {
+final class NodeTests: XCTestCase {
-  func testNode() {
-    describe("Node") {
   let context = Context(dictionary: [
     "name": "Kyle",
     "age": 27,
-        "items": [1, 2, 3],
+    "items": [1, 2, 3]
   ])
 
-      $0.describe("TextNode") {
+  func testTextNode() {
-        $0.it("renders the given text") {
+    it("renders the given text") {
       let node = TextNode(text: "Hello World")
-          try expect(try node.render(context)) == "Hello World"
+      try expect(try node.render(self.context)) == "Hello World"
     }
   }
 
-      $0.describe("VariableNode") {
+  func testVariableNode() {
-        $0.it("resolves and renders the variable") {
+    it("resolves and renders the variable") {
       let node = VariableNode(variable: Variable("name"))
-          try expect(try node.render(context)) == "Kyle"
+      try expect(try node.render(self.context)) == "Kyle"
     }
 
-        $0.it("resolves and renders a non string variable") {
+    it("resolves and renders a non string variable") {
       let node = VariableNode(variable: Variable("age"))
-          try expect(try node.render(context)) == "27"
+      try expect(try node.render(self.context)) == "27"
     }
   }
 
-      $0.describe("rendering nodes") {
+  func testRendering() {
-        $0.it("renders the nodes") {
+    it("renders the nodes") {
+      let nodes: [NodeType] = [
+        TextNode(text: "Hello "),
+        VariableNode(variable: "name")
+      ]
+
+      try expect(try renderNodes(nodes, self.context)) == "Hello Kyle"
+    }
+
+    it("correctly throws a nodes failure") {
       let nodes: [NodeType] = [
         TextNode(text: "Hello "),
         VariableNode(variable: "name"),
+        ErrorNode()
       ]
 
-          try expect(try renderNodes(nodes, context)) == "Hello Kyle"
+      try expect(try renderNodes(nodes, self.context)).toThrow(TemplateSyntaxError("Custom Error"))
-        }
-
-        $0.it("correctly throws a nodes failure") {
-          let nodes: [NodeType] = [
-            TextNode(text:"Hello "),
-            VariableNode(variable: "name"),
-            ErrorNode(),
-            ]
-
-          try expect(try renderNodes(nodes, context)).toThrow(TemplateSyntaxError("Custom Error"))
-        }
-      }
     }
   }
 }

Tests/StencilTests/NowNodeSpec.swift

@@ -1,15 +1,13 @@
-import XCTest
-import Foundation
 import Spectre
 @testable import Stencil
+import XCTest
 
-
+final class NowNodeTests: XCTestCase {
-class NowNodeTests: XCTestCase {
+  func testParsing() {
-  func testNowNode() {
+    it("parses default format without any now arguments") {
-    #if !os(Linux)
+#if os(Linux)
-    describe("NowNode") {
+      throw skip()
-      $0.describe("parsing") {
+#else
-        $0.it("parses default format without any now arguments") {
       let tokens: [Token] = [ .block(value: "now", at: .unknown) ]
       let parser = TokenParser(tokens: tokens, environment: Environment())
 
@@ -17,20 +15,28 @@ class NowNodeTests: XCTestCase {
       let node = nodes.first as? NowNode
       try expect(nodes.count) == 1
       try expect(node?.format.variable) == "\"yyyy-MM-dd 'at' HH:mm\""
+#endif
     }
 
-        $0.it("parses now with a format") {
+    it("parses now with a format") {
+#if os(Linux)
+      throw skip()
+#else
       let tokens: [Token] = [ .block(value: "now \"HH:mm\"", at: .unknown) ]
       let parser = TokenParser(tokens: tokens, environment: Environment())
       let nodes = try parser.parse()
       let node = nodes.first as? NowNode
       try expect(nodes.count) == 1
       try expect(node?.format.variable) == "\"HH:mm\""
+#endif
     }
   }
 
-      $0.describe("rendering") {
+  func testRendering() {
-        $0.it("renders the date") {
+    it("renders the date") {
+#if os(Linux)
+      throw skip()
+#else
       let node = NowNode(format: Variable("\"yyyy-MM-dd\""))
 
       let formatter = DateFormatter()
@@ -38,9 +44,7 @@ class NowNodeTests: XCTestCase {
       let date = formatter.string(from: NSDate() as Date)
 
       try expect(try node.render(Context())) == date
-        }
-      }
-    }
 #endif
     }
   }
+}

Tests/StencilTests/ParserSpec.swift

@@ -1,11 +1,10 @@
-import XCTest
 import Spectre
 @testable import Stencil
+import XCTest
 
-class TokenParserTests: XCTestCase {
+final class TokenParserTests: XCTestCase {
   func testTokenParser() {
-    describe("TokenParser") {
+    it("can parse a text token") {
-      $0.it("can parse a text token") {
       let parser = TokenParser(tokens: [
         .text(value: "Hello World", at: .unknown)
       ], environment: Environment())
@@ -17,7 +16,7 @@ class TokenParserTests: XCTestCase {
       try expect(node?.text) == "Hello World"
     }
 
-      $0.it("can parse a variable token") {
+    it("can parse a variable token") {
       let parser = TokenParser(tokens: [
         .variable(value: "'name'", at: .unknown)
       ], environment: Environment())
@@ -29,7 +28,7 @@ class TokenParserTests: XCTestCase {
       try expect(result) == "name"
     }
 
-      $0.it("can parse a comment token") {
+    it("can parse a comment token") {
       let parser = TokenParser(tokens: [
         .comment(value: "Secret stuff!", at: .unknown)
       ], environment: Environment())
@@ -38,26 +37,28 @@ class TokenParserTests: XCTestCase {
       try expect(nodes.count) == 0
     }
 
-      $0.it("can parse a tag token") {
+    it("can parse a tag token") {
       let simpleExtension = Extension()
       simpleExtension.registerSimpleTag("known") { _ in
-          return ""
+        ""
       }
 
       let parser = TokenParser(tokens: [
-          .block(value: "known", at: .unknown),
+        .block(value: "known", at: .unknown)
       ], environment: Environment(extensions: [simpleExtension]))
 
       let nodes = try parser.parse()
       try expect(nodes.count) == 1
     }
 
-      $0.it("errors when parsing an unknown tag") {
+    it("errors when parsing an unknown tag") {
       let tokens: [Token] = [.block(value: "unknown", at: .unknown)]
       let parser = TokenParser(tokens: tokens, environment: Environment())
 
-        try expect(try parser.parse()).toThrow(TemplateSyntaxError(reason: "Unknown template tag 'unknown'", token: tokens.first))
+      try expect(try parser.parse()).toThrow(TemplateSyntaxError(
-      }
+        reason: "Unknown template tag 'unknown'",
+        token: tokens.first)
+      )
     }
   }
 }

Tests/StencilTests/StencilSpec.swift

@@ -1,36 +1,33 @@
-import XCTest
 import Spectre
 import Stencil
+import XCTest
 
-fileprivate struct CustomNode : NodeType {
+private struct CustomNode: NodeType {
   let token: Token?
   func render(_ context: Context) throws -> String {
     return "Hello World"
   }
 }
 
-fileprivate struct Article {
+private struct Article {
   let title: String
   let author: String
 }
 
-class StencilTests: XCTestCase {
+final class StencilTests: XCTestCase {
-  func testStencil() {
+  lazy var environment: Environment = {
-    describe("Stencil") {
     let exampleExtension = Extension()
-
+    exampleExtension.registerSimpleTag("simpletag") { _ in
-      exampleExtension.registerSimpleTag("simpletag") { context in
+      "Hello World"
-        return "Hello World"
     }
-
+    exampleExtension.registerTag("customtag") { _, token in
-      exampleExtension.registerTag("customtag") { parser, token in
+      CustomNode(token: token)
-        return CustomNode(token: token)
     }
+    return Environment(extensions: [exampleExtension])
+  }()
 
-      let environment = Environment(extensions: [exampleExtension])
+  func testStencil() {
-
+    it("can render the README example") {
-      $0.it("can render the README example") {
-
       let templateString = """
         There are {{ articles.count }} articles.
 
@@ -42,7 +39,7 @@ class StencilTests: XCTestCase {
       let context = [
         "articles": [
           Article(title: "Migrating from OCUnit to XCTest", author: "Kyle Fuller"),
-            Article(title: "Memory Management with ARC", author: "Kyle Fuller"),
+          Article(title: "Memory Management with ARC", author: "Kyle Fuller")
         ]
       ]
 
@@ -58,15 +55,14 @@ class StencilTests: XCTestCase {
         """
     }
 
-      $0.it("can render a custom template tag") {
+    it("can render a custom template tag") {
-        let result = try environment.renderTemplate(string: "{% customtag %}")
+      let result = try self.environment.renderTemplate(string: "{% customtag %}")
       try expect(result) == "Hello World"
     }
 
-      $0.it("can render a simple custom tag") {
+    it("can render a simple custom tag") {
-        let result = try environment.renderTemplate(string: "{% simpletag %}")
+      let result = try self.environment.renderTemplate(string: "{% simpletag %}")
       try expect(result) == "Hello World"
     }
   }
 }
-}

Tests/StencilTests/TemplateSpec.swift

@@ -1,22 +1,19 @@
-import XCTest
 import Spectre
 @testable import Stencil
+import XCTest
 
-class TemplateTests: XCTestCase {
+final class TemplateTests: XCTestCase {
   func testTemplate() {
-    describe("Template") {
+    it("can render a template from a string") {
-      $0.it("can render a template from a string") {
       let template = Template(templateString: "Hello World")
       let result = try template.render([ "name": "Kyle" ])
       try expect(result) == "Hello World"
     }
 
-      $0.it("can render a template from a string literal") {
+    it("can render a template from a string literal") {
         let template: Template = "Hello World"
         let result = try template.render([ "name": "Kyle" ])
         try expect(result) == "Hello World"
     }
-
-    }
   }
 }

Tests/StencilTests/TokenSpec.swift

@@ -1,11 +1,10 @@
-import XCTest
 import Spectre
 @testable import Stencil
+import XCTest
 
-class TokenTests: XCTestCase {
+final class TokenTests: XCTestCase {
   func testToken() {
-    describe("Token") {
+    it("can split the contents into components") {
-      $0.it("can split the contents into components") {
       let token = Token.text(value: "hello world", at: .unknown)
       let components = token.components
 
@@ -14,7 +13,7 @@ class TokenTests: XCTestCase {
       try expect(components[1]) == "world"
     }
 
-      $0.it("can split the contents into components with single quoted strings") {
+    it("can split the contents into components with single quoted strings") {
       let token = Token.text(value: "hello 'kyle fuller'", at: .unknown)
       let components = token.components
 
@@ -23,7 +22,7 @@ class TokenTests: XCTestCase {
       try expect(components[1]) == "'kyle fuller'"
     }
 
-      $0.it("can split the contents into components with double quoted strings") {
+    it("can split the contents into components with double quoted strings") {
       let token = Token.text(value: "hello \"kyle fuller\"", at: .unknown)
       let components = token.components
 
@@ -33,4 +32,3 @@ class TokenTests: XCTestCase {
     }
   }
 }
-}

Tests/StencilTests/VariableSpec.swift

@@ -1,232 +1,215 @@
-import XCTest
-import Foundation
 import Spectre
 @testable import Stencil
-
+import XCTest
 
 #if os(OSX)
-@objc class Superclass: NSObject {
+@objc
+class Superclass: NSObject {
   @objc let name = "Foo"
 }
-@objc class Object : Superclass {
+@objc
+class Object: Superclass {
   @objc let title = "Hello World"
 }
 #endif
 
-fileprivate struct Person {
+private struct Person {
   let name: String
 }
 
-fileprivate struct Article {
+private struct Article {
   let author: Person
 }
 
-fileprivate class WebSite {
+private class WebSite {
   let url: String = "blog.com"
 }
 
-fileprivate class Blog: WebSite {
+private class Blog: WebSite {
   let articles: [Article] = [Article(author: Person(name: "Kyle"))]
   let featuring: Article? = Article(author: Person(name: "Jhon"))
 }
 
-class VariableTests: XCTestCase {
+final class VariableTests: XCTestCase {
-  func testVariable() {
+  let context: Context = {
-    describe("Variable") {
+    let ext = Extension()
-      let context = Context(dictionary: [
+    ext.registerFilter("incr") { arg in
+      (arg.flatMap { toNumber(value: $0) } ?? 0) + 1
+    }
+    let environment = Environment(extensions: [ext])
+
+    var context = Context(dictionary: [
       "name": "Kyle",
       "contacts": ["Katie", "Carlton"],
       "profiles": [
-          "github": "kylef",
+        "github": "kylef"
       ],
       "counter": [
-          "count": "kylef",
+        "count": "kylef"
       ],
       "article": Article(author: Person(name: "Kyle")),
+      "blog": Blog(),
       "tuple": (one: 1, two: 2)
-      ])
+    ], environment: environment)
-
 #if os(OSX)
     context["object"] = Object()
 #endif
-      context["blog"] = Blog()
+    return context
+  }()
 
-      $0.it("can resolve a string literal with double quotes") {
+  func testLiterals() {
+    it("can resolve a string literal with double quotes") {
       let variable = Variable("\"name\"")
-        let result = try variable.resolve(context) as? String
+      let result = try variable.resolve(self.context) as? String
       try expect(result) == "name"
     }
 
-      $0.it("can resolve a string literal with single quotes") {
+    it("can resolve a string literal with single quotes") {
       let variable = Variable("'name'")
-        let result = try variable.resolve(context) as? String
+      let result = try variable.resolve(self.context) as? String
       try expect(result) == "name"
     }
 
-      $0.it("can resolve an integer literal") {
+    it("can resolve an integer literal") {
       let variable = Variable("5")
-        let result = try variable.resolve(context) as? Int
+      let result = try variable.resolve(self.context) as? Int
       try expect(result) == 5
     }
 
-      $0.it("can resolve an float literal") {
+    it("can resolve an float literal") {
       let variable = Variable("3.14")
-        let result = try variable.resolve(context) as? Number
+      let result = try variable.resolve(self.context) as? Number
       try expect(result) == 3.14
     }
 
-      $0.it("can resolve boolean literal") {
+    it("can resolve boolean literal") {
-        try expect(Variable("true").resolve(context) as? Bool) == true
+      try expect(Variable("true").resolve(self.context) as? Bool) == true
-        try expect(Variable("false").resolve(context) as? Bool) == false
+      try expect(Variable("false").resolve(self.context) as? Bool) == false
-        try expect(Variable("0").resolve(context) as? Int) == 0
+      try expect(Variable("0").resolve(self.context) as? Int) == 0
-        try expect(Variable("1").resolve(context) as? Int) == 1
+      try expect(Variable("1").resolve(self.context) as? Int) == 1
+    }
   }
 
-      $0.it("can resolve a string variable") {
+  func testVariable() {
+    it("can resolve a string variable") {
       let variable = Variable("name")
-        let result = try variable.resolve(context) as? String
+      let result = try variable.resolve(self.context) as? String
       try expect(result) == "Kyle"
     }
-
-      $0.context("given string") {
-        $0.it("can resolve an item via it's index") {
-          let variable = Variable("name.0")
-          let result = try variable.resolve(context) as? Character
-          try expect(result) == "K"
-
-          let variable1 = Variable("name.1")
-          let result1 = try variable1.resolve(context) as? Character
-          try expect(result1) == "y"
   }
 
-        $0.it("can resolve an item via unknown index") {
+  func testDictionary() {
-          let variable = Variable("name.5")
+    it("can resolve an item from a dictionary") {
-          let result = try variable.resolve(context) as? Character
-          try expect(result).to.beNil()
-
-          let variable1 = Variable("name.-5")
-          let result1 = try variable1.resolve(context) as? Character
-          try expect(result1).to.beNil()
-        }
-
-        $0.it("can resolve the first item") {
-          let variable = Variable("name.first")
-          let result = try variable.resolve(context) as? Character
-          try expect(result) == "K"
-        }
-
-        $0.it("can resolve the last item") {
-          let variable = Variable("name.last")
-          let result = try variable.resolve(context) as? Character
-          try expect(result) == "e"
-        }
-
-        $0.it("can get the characters count") {
-          let variable = Variable("name.count")
-          let result = try variable.resolve(context) as? Int
-          try expect(result) == 4
-        }
-      }
-
-      $0.context("given dictionary") {
-        $0.it("can resolve an item") {
       let variable = Variable("profiles.github")
-          let result = try variable.resolve(context) as? String
+      let result = try variable.resolve(self.context) as? String
       try expect(result) == "kylef"
     }
 
-        $0.it("can get the count") {
+    it("can get the count of a dictionary") {
       let variable = Variable("profiles.count")
-          let result = try variable.resolve(context) as? Int
+      let result = try variable.resolve(self.context) as? Int
       try expect(result) == 1
     }
   }
 
-      $0.context("given array") {
+  func testArray() {
-        $0.it("can resolve an item via it's index") {
+    it("can resolve an item from an array via it's index") {
       let variable = Variable("contacts.0")
-          let result = try variable.resolve(context) as? String
+      let result = try variable.resolve(self.context) as? String
       try expect(result) == "Katie"
 
         let variable1 = Variable("contacts.1")
-          let result1 = try variable1.resolve(context) as? String
+        let result1 = try variable1.resolve(self.context) as? String
         try expect(result1) == "Carlton"
     }
 
-        $0.it("can resolve an item via unknown index") {
+    it("can resolve an item from an array via unknown index") {
       let variable = Variable("contacts.5")
-          let result = try variable.resolve(context) as? String
+      let result = try variable.resolve(self.context) as? String
       try expect(result).to.beNil()
 
       let variable1 = Variable("contacts.-5")
-          let result1 = try variable1.resolve(context) as? String
+      let result1 = try variable1.resolve(self.context) as? String
       try expect(result1).to.beNil()
     }
 
-        $0.it("can resolve the first item") {
+    it("can resolve the first item from an array") {
       let variable = Variable("contacts.first")
-          let result = try variable.resolve(context) as? String
+      let result = try variable.resolve(self.context) as? String
       try expect(result) == "Katie"
     }
 
-        $0.it("can resolve the last item") {
+    it("can resolve the last item from an array") {
       let variable = Variable("contacts.last")
-          let result = try variable.resolve(context) as? String
+      let result = try variable.resolve(self.context) as? String
       try expect(result) == "Carlton"
     }
+  }
 
-        $0.it("can get the count") {
+  func testReflection() {
-          let variable = Variable("contacts.count")
+    it("can resolve a property with reflection") {
-          let result = try variable.resolve(context) as? Int
+      let variable = Variable("article.author.name")
+      let result = try variable.resolve(self.context) as? String
+      try expect(result) == "Kyle"
+    }
+
+    it("can resolve a value via reflection") {
+      let variable = Variable("blog.articles.0.author.name")
+      let result = try variable.resolve(self.context) as? String
+      try expect(result) == "Kyle"
+    }
+
+    it("can resolve a superclass value via reflection") {
+      let variable = Variable("blog.url")
+      let result = try variable.resolve(self.context) as? String
+      try expect(result) == "blog.com"
+    }
+
+    it("can resolve optional variable property using reflection") {
+      let variable = Variable("blog.featuring.author.name")
+      let result = try variable.resolve(self.context) as? String
+      try expect(result) == "Jhon"
+    }
+  }
+
+  func testKVO() {
+#if os(OSX)
+    it("can resolve a value via KVO") {
+      let variable = Variable("object.title")
+      let result = try variable.resolve(self.context) as? String
+      try expect(result) == "Hello World"
+    }
+
+    it("can resolve a superclass value via KVO") {
+      let variable = Variable("object.name")
+      let result = try variable.resolve(self.context) as? String
+      try expect(result) == "Foo"
+    }
+
+    it("does not crash on KVO") {
+      let variable = Variable("object.fullname")
+      let result = try variable.resolve(self.context) as? String
+      try expect(result).to.beNil()
+    }
+#endif
+  }
+
+  func testTuple() {
+    it("can resolve tuple by index") {
+      let variable = Variable("tuple.0")
+      let result = try variable.resolve(self.context) as? Int
+      try expect(result) == 1
+    }
+
+    it("can resolve tuple by label") {
+      let variable = Variable("tuple.two")
+      let result = try variable.resolve(self.context) as? Int
       try expect(result) == 2
     }
   }
 
-      $0.it("can resolve a property with reflection") {
+  func testOptional() {
-        let variable = Variable("article.author.name")
+    it("does not render Optional") {
-        let result = try variable.resolve(context) as? String
-        try expect(result) == "Kyle"
-      }
-
-  #if os(OSX)
-      $0.it("can resolve a value via KVO") {
-        let variable = Variable("object.title")
-        let result = try variable.resolve(context) as? String
-        try expect(result) == "Hello World"
-      }
-
-      $0.it("can resolve a superclass value via KVO") {
-        let variable = Variable("object.name")
-        let result = try variable.resolve(context) as? String
-        try expect(result) == "Foo"
-      }
-
-      $0.it("does not crash on KVO") {
-        let variable = Variable("object.fullname")
-        let result = try variable.resolve(context) as? String
-        try expect(result).to.beNil()
-      }
-  #endif
-
-      $0.it("can resolve a value via reflection") {
-        let variable = Variable("blog.articles.0.author.name")
-        let result = try variable.resolve(context) as? String
-        try expect(result) == "Kyle"
-      }
-
-      $0.it("can resolve a superclass value via reflection") {
-        let variable = Variable("blog.url")
-        let result = try variable.resolve(context) as? String
-        try expect(result) == "blog.com"
-      }
-
-      $0.it("can resolve optional variable property using reflection") {
-        let variable = Variable("blog.featuring.author.name")
-        let result = try variable.resolve(context) as? String
-        try expect(result) == "Jhon"
-      }
-
-      $0.it("does not render Optional") {
       var array: [Any?] = [1, nil]
       array.append(array)
       let context = Context(dictionary: ["values": array])
@@ -234,87 +217,78 @@ class VariableTests: XCTestCase {
       try expect(VariableNode(variable: "values").render(context)) == "[1, nil, [1, nil]]"
       try expect(VariableNode(variable: "values.1").render(context)) == ""
     }
-
-      $0.it("can subscript tuple by index") {
-        let variable = Variable("tuple.0")
-        let result = try variable.resolve(context) as? Int
-        try expect(result) == 1
   }
 
-      $0.it("can subscript tuple by label") {
+  func testSubscripting() {
-        let variable = Variable("tuple.two")
+    it("can resolve a property subscript via reflection") {
-        let result = try variable.resolve(context) as? Int
+      try self.context.push(dictionary: ["property": "name"]) {
-        try expect(result) == 2
-      }
-
-      $0.describe("Subscripting") {
-        $0.it("can resolve a property subscript via reflection") {
-          try context.push(dictionary: ["property": "name"]) {
         let variable = Variable("article.author[property]")
-            let result = try variable.resolve(context) as? String
+        let result = try variable.resolve(self.context) as? String
         try expect(result) == "Kyle"
       }
     }
 
-        $0.it("can subscript an array with a valid index") {
+    it("can subscript an array with a valid index") {
-          try context.push(dictionary: ["property": 0]) {
+      try self.context.push(dictionary: ["property": 0]) {
         let variable = Variable("contacts[property]")
-            let result = try variable.resolve(context) as? String
+        let result = try variable.resolve(self.context) as? String
         try expect(result) == "Katie"
       }
     }
 
-        $0.it("can subscript an array with an unknown index") {
+    it("can subscript an array with an unknown index") {
-          try context.push(dictionary: ["property": 5]) {
+      try self.context.push(dictionary: ["property": 5]) {
         let variable = Variable("contacts[property]")
-            let result = try variable.resolve(context) as? String
+        let result = try variable.resolve(self.context) as? String
         try expect(result).to.beNil()
       }
     }
 
 #if os(OSX)
-        $0.it("can resolve a subscript via KVO") {
+    it("can resolve a subscript via KVO") {
-          try context.push(dictionary: ["property": "name"]) {
+      try self.context.push(dictionary: ["property": "name"]) {
         let variable = Variable("object[property]")
-            let result = try variable.resolve(context) as? String
+        let result = try variable.resolve(self.context) as? String
         try expect(result) == "Foo"
       }
     }
 #endif
 
-        $0.it("can resolve an optional subscript via reflection") {
+    it("can resolve an optional subscript via reflection") {
-          try context.push(dictionary: ["property": "featuring"]) {
+      try self.context.push(dictionary: ["property": "featuring"]) {
         let variable = Variable("blog[property].author.name")
-            let result = try variable.resolve(context) as? String
+        let result = try variable.resolve(self.context) as? String
         try expect(result) == "Jhon"
       }
     }
+  }
 
-        $0.it("can resolve multiple subscripts") {
+  func testMultipleSubscripting() {
-          try context.push(dictionary: [
+    it("can resolve multiple subscripts") {
+      try self.context.push(dictionary: [
         "prop1": "articles",
         "prop2": 0,
         "prop3": "name"
       ]) {
         let variable = Variable("blog[prop1][prop2].author[prop3]")
-            let result = try variable.resolve(context) as? String
+        let result = try variable.resolve(self.context) as? String
         try expect(result) == "Kyle"
       }
     }
 
-        $0.it("can resolve nested subscripts") {
+    it("can resolve nested subscripts") {
-          try context.push(dictionary: [
+      try self.context.push(dictionary: [
         "prop1": "prop2",
         "ref": ["prop2": "name"]
       ]) {
         let variable = Variable("article.author[ref[prop1]]")
-            let result = try variable.resolve(context) as? String
+        let result = try variable.resolve(self.context) as? String
         try expect(result) == "Kyle"
       }
     }
 
-        $0.it("throws for invalid keypath syntax") {
+    it("throws for invalid keypath syntax") {
-          try context.push(dictionary: ["prop": "name"]) {
+      try self.context.push(dictionary: ["prop": "name"]) {
         let samples = [
           ".",
           "..",
@@ -333,79 +307,49 @@ class VariableTests: XCTestCase {
 
         for lookup in samples {
           let variable = Variable(lookup)
-              try expect(variable.resolve(context)).toThrow()
+          try expect(variable.resolve(self.context)).toThrow()
-            }
         }
       }
     }
   }
 
-    describe("RangeVariable") {
+  func testRangeVariable() {
-
-      let context: Context = {
-        let ext = Extension()
-        ext.registerFilter("incr", filter: { (arg: Any?) in toNumber(value: arg!)! + 1 })
-        let environment = Environment(extensions: [ext])
-        return Context(dictionary: [:], environment: environment)
-      }()
-
     func makeVariable(_ token: String) throws -> RangeVariable? {
       let token = Token.variable(value: token, at: .unknown)
       return try RangeVariable(token.contents, environment: context.environment, containedIn: token)
     }
 
-      $0.it("can resolve closed range as array") {
+    it("can resolve closed range as array") {
-        let result = try makeVariable("1...3")?.resolve(context) as? [Int]
+      let result = try makeVariable("1...3")?.resolve(self.context) as? [Int]
       try expect(result) == [1, 2, 3]
     }
 
-      $0.it("can resolve decreasing closed range as reversed array") {
+    it("can resolve decreasing closed range as reversed array") {
-        let result = try makeVariable("3...1")?.resolve(context) as? [Int]
+      let result = try makeVariable("3...1")?.resolve(self.context) as? [Int]
       try expect(result) == [3, 2, 1]
     }
 
-      $0.it("can use filter on range variables") {
+    it("can use filter on range variables") {
-        let result = try makeVariable("1|incr...3|incr")?.resolve(context) as? [Int]
+      let result = try makeVariable("1|incr...3|incr")?.resolve(self.context) as? [Int]
       try expect(result) == [2, 3, 4]
     }
 
-      $0.it("throws when left value is not int") {
+    it("throws when left value is not int") {
       let template: Template = "{% for i in k...j %}{{ i }}{% endfor %}"
       try expect(try template.render(Context(dictionary: ["j": 3, "k": "1"]))).toThrow()
     }
 
-      $0.it("throws when right value is not int") {
+    it("throws when right value is not int") {
       let variable = try makeVariable("k...j")
       try expect(try variable?.resolve(Context(dictionary: ["j": "3", "k": 1]))).toThrow()
     }
 
-      $0.it("throws is left range value is missing") {
+    it("throws is left range value is missing") {
       try expect(makeVariable("...1")).toThrow()
     }
 
-      $0.it("throws is right range value is missing") {
+    it("throws is right range value is missing") {
       try expect(makeVariable("1...")).toThrow()
     }
-
-    }
-
-    describe("inline if expression") {
-
-      $0.it("can conditionally render variable") {
-        let template: Template = "{{ variable if variable|uppercase == \"A\" }}"
-        try expect(template.render(Context(dictionary: ["variable": "a"]))) == "a"
-        try expect(template.render(Context(dictionary: ["variable": "b"]))) == ""
-      }
-
-      $0.it("can render with else expression") {
-        let template: Template = "{{ variable if variable|uppercase == \"A\" else fallback|uppercase }}"
-        try expect(template.render(Context(dictionary: ["variable": "b", "fallback": "c"]))) == "C"
-      }
-
-      $0.it("throws when used invalid condition") {
-        let template: Template = "{{ variable if variable \"A\" }}"
-        try expect(template.render(Context(dictionary: ["variable": "a"]))).toThrow()
-      }
-    }
   }
 }

Tests/StencilTests/XCTestManifests.swift

@@ -2,19 +2,54 @@ import XCTest
 
 extension ContextTests {
     static let __allTests = [
-        ("testContext", testContext),
+        ("testContextRestoration", testContextRestoration),
+        ("testContextSubscripting", testContextSubscripting),
+    ]
+}
+
+extension EnvironmentBaseAndChildTemplateTests {
+    static let __allTests = [
+        ("testRuntimeErrorInBaseTemplate", testRuntimeErrorInBaseTemplate),
+        ("testRuntimeErrorInChildTemplate", testRuntimeErrorInChildTemplate),
+        ("testSyntaxErrorInBaseTemplate", testSyntaxErrorInBaseTemplate),
+        ("testSyntaxErrorInChildTemplate", testSyntaxErrorInChildTemplate),
+    ]
+}
+
+extension EnvironmentIncludeTemplateTests {
+    static let __allTests = [
+        ("testRuntimeError", testRuntimeError),
+        ("testSyntaxError", testSyntaxError),
     ]
 }
 
 extension EnvironmentTests {
     static let __allTests = [
-        ("testEnvironment", testEnvironment),
+        ("testLoading", testLoading),
+        ("testRendering", testRendering),
+        ("testRenderingError", testRenderingError),
+        ("testSyntaxError", testSyntaxError),
+        ("testUnknownFilter", testUnknownFilter),
     ]
 }
 
 extension ExpressionsTests {
     static let __allTests = [
-        ("testExpressions", testExpressions),
+        ("testAndExpression", testAndExpression),
+        ("testEqualityExpression", testEqualityExpression),
+        ("testExpressionParsing", testExpressionParsing),
+        ("testFalseExpressions", testFalseExpressions),
+        ("testFalseInExpression", testFalseInExpression),
+        ("testInequalityExpression", testInequalityExpression),
+        ("testLessThanEqualExpression", testLessThanEqualExpression),
+        ("testLessThanExpression", testLessThanExpression),
+        ("testMoreThanEqualExpression", testMoreThanEqualExpression),
+        ("testMoreThanExpression", testMoreThanExpression),
+        ("testMultipleExpressions", testMultipleExpressions),
+        ("testNotExpression", testNotExpression),
+        ("testOrExpression", testOrExpression),
+        ("testTrueExpressions", testTrueExpressions),
+        ("testTrueInExpression", testTrueInExpression),
     ]
 }
 
@@ -26,50 +61,95 @@ extension FilterTagTests {
 
 extension FilterTests {
     static let __allTests = [
-        ("testFilter", testFilter),
+        ("testDefaultFilter", testDefaultFilter),
+        ("testDynamicFilters", testDynamicFilters),
+        ("testFilterSuggestion", testFilterSuggestion),
+        ("testIndentContent", testIndentContent),
+        ("testIndentFirstLine", testIndentFirstLine),
+        ("testIndentNotEmptyLines", testIndentNotEmptyLines),
+        ("testIndentWithArbitraryCharacter", testIndentWithArbitraryCharacter),
+        ("testJoinFilter", testJoinFilter),
+        ("testRegistration", testRegistration),
+        ("testRegistrationOverrideDefault", testRegistrationOverrideDefault),
+        ("testRegistrationWithArguments", testRegistrationWithArguments),
+        ("testSplitFilter", testSplitFilter),
+        ("testStringFilters", testStringFilters),
+        ("testStringFiltersWithArrays", testStringFiltersWithArrays),
     ]
 }
 
 extension ForNodeTests {
     static let __allTests = [
+        ("testArrayOfTuples", testArrayOfTuples),
         ("testForNode", testForNode),
+        ("testHandleInvalidInput", testHandleInvalidInput),
+        ("testIterateDictionary", testIterateDictionary),
+        ("testIterateRange", testIterateRange),
+        ("testIterateUsingMirroring", testIterateUsingMirroring),
+        ("testLoopMetadata", testLoopMetadata),
+        ("testWhereExpression", testWhereExpression),
     ]
 }
 
 extension IfNodeTests {
     static let __allTests = [
-        ("testIfNode", testIfNode),
+        ("testEvaluatesNilAsFalse", testEvaluatesNilAsFalse),
+        ("testParseIf", testParseIf),
+        ("testParseIfnot", testParseIfnot),
+        ("testParseIfWithElif", testParseIfWithElif),
+        ("testParseIfWithElifWithoutElse", testParseIfWithElifWithoutElse),
+        ("testParseIfWithElse", testParseIfWithElse),
+        ("testParseMultipleElif", testParseMultipleElif),
+        ("testParsingErrors", testParsingErrors),
+        ("testRendering", testRendering),
+        ("testSupportsRangeVariables", testSupportsRangeVariables),
+        ("testSupportVariableFilters", testSupportVariableFilters),
     ]
 }
 
 extension IncludeTests {
     static let __allTests = [
-        ("testInclude", testInclude),
+        ("testParsing", testParsing),
+        ("testRendering", testRendering),
     ]
 }
 
-extension InheritenceTests {
+extension InheritanceTests {
     static let __allTests = [
-        ("testInheritence", testInheritence),
+        ("testInheritance", testInheritance),
     ]
 }
 
 extension LexerTests {
     static let __allTests = [
-        ("testLexer", testLexer),
+        ("testComment", testComment),
+        ("testContentMixture", testContentMixture),
+        ("testEmptyVariable", testEmptyVariable),
+        ("testEscapeSequence", testEscapeSequence),
+        ("testNewlines", testNewlines),
         ("testPerformance", testPerformance),
+        ("testText", testText),
+        ("testTokenizeIncorrectSyntaxWithoutCrashing", testTokenizeIncorrectSyntaxWithoutCrashing),
+        ("testTokenWithoutSpaces", testTokenWithoutSpaces),
+        ("testUnclosedBlock", testUnclosedBlock),
+        ("testUnclosedTag", testUnclosedTag),
+        ("testVariable", testVariable),
+        ("testVariablesWithoutBeingGreedy", testVariablesWithoutBeingGreedy),
     ]
 }
 
 extension NodeTests {
     static let __allTests = [
-        ("testNode", testNode),
+        ("testRendering", testRendering),
+        ("testTextNode", testTextNode),
+        ("testVariableNode", testVariableNode),
     ]
 }
 
 extension NowNodeTests {
     static let __allTests = [
-        ("testNowNode", testNowNode),
+        ("testParsing", testParsing),
+        ("testRendering", testRendering),
     ]
 }
 
@@ -81,7 +161,8 @@ extension StencilTests {
 
 extension TemplateLoaderTests {
     static let __allTests = [
-        ("testTemplateLoader", testTemplateLoader),
+        ("testDictionaryLoader", testDictionaryLoader),
+        ("testFileSystemLoader", testFileSystemLoader),
     ]
 }
 
@@ -105,6 +186,16 @@ extension TokenTests {
 
 extension VariableTests {
     static let __allTests = [
+        ("testArray", testArray),
+        ("testDictionary", testDictionary),
+        ("testKVO", testKVO),
+        ("testLiterals", testLiterals),
+        ("testMultipleSubscripting", testMultipleSubscripting),
+        ("testOptional", testOptional),
+        ("testRangeVariable", testRangeVariable),
+        ("testReflection", testReflection),
+        ("testSubscripting", testSubscripting),
+        ("testTuple", testTuple),
         ("testVariable", testVariable),
     ]
 }
@@ -113,6 +204,8 @@ extension VariableTests {
 public func __allTests() -> [XCTestCaseEntry] {
     return [
         testCase(ContextTests.__allTests),
+        testCase(EnvironmentBaseAndChildTemplateTests.__allTests),
+        testCase(EnvironmentIncludeTemplateTests.__allTests),
         testCase(EnvironmentTests.__allTests),
         testCase(ExpressionsTests.__allTests),
         testCase(FilterTagTests.__allTests),
@@ -120,7 +213,7 @@ public func __allTests() -> [XCTestCaseEntry] {
         testCase(ForNodeTests.__allTests),
         testCase(IfNodeTests.__allTests),
         testCase(IncludeTests.__allTests),
-        testCase(InheritenceTests.__allTests),
+        testCase(InheritanceTests.__allTests),
         testCase(LexerTests.__allTests),
         testCase(NodeTests.__allTests),
         testCase(NowNodeTests.__allTests),