Added the option to throw when variable not found in context

CHANGELOG.md

@@ -12,6 +12,9 @@ _None_
 , i.e. `myfilter = "uppercase"` and then use it to invoke this filter with `{{ string|filter:myfilter }}`.  
   [Ilya Puchka](https://github.com/ilyapuchka)
   [#203](https://github.com/stencilproject/Stencil/pull/203)
+- Added option to throw when a variable used in a template could not be resolved.  
+  [Andres Cecilia Luque](https://github.com/acecilia)
+  [#289](https://github.com/stencilproject/Stencil/pull/289)
 
 ### Deprecations
 

Sources/Environment.swift

@@ -1,16 +1,19 @@
 public struct Environment {
   public let templateClass: Template.Type
   public var extensions: [Extension]
+  public let throwOnUnresolvedVariable: Bool
 
   public var loader: Loader?
 
   public init(loader: Loader? = nil,
               extensions: [Extension] = [],
+              throwOnUnresolvedVariable: Bool = false,
               templateClass: Template.Type = Template.self) {
 
     self.templateClass = templateClass
     self.loader = loader
     self.extensions = extensions + [DefaultExtension()]
+    self.throwOnUnresolvedVariable = throwOnUnresolvedVariable
   }
 
   public func loadTemplate(name: String) throws -> Template {

Sources/Errors.swift

@@ -55,6 +55,7 @@ public protocol ErrorReporter: AnyObject {
 }
 
 open class SimpleErrorReporter: ErrorReporter {
+  public init() { }
 
   open func renderError(_ error: Error) -> String {
     guard let templateError = error as? TemplateSyntaxError else { return error.localizedDescription }

Sources/Variable.swift

@@ -30,10 +30,16 @@ class FilterExpression: Resolvable {
   func resolve(_ context: Context) throws -> Any? {
     let result = try variable.resolve(context)
 
-    return try filters.reduce(result) { value, filter in
+    let filteredResult = try filters.reduce(result) { value, filter in
       let arguments = try filter.1.map { try $0.resolve(context) }
       return try filter.0.invoke(value: value, arguments: arguments, context: context)
     }
+
+    if filteredResult == nil, context.environment.throwOnUnresolvedVariable {
+      throw TemplateSyntaxError("Variable could not be resolved")
+    }
+
+    return filteredResult
   }
 }
 

Tests/StencilTests/EnvironmentSpec.swift

@@ -182,7 +182,57 @@ final class EnvironmentTests: XCTestCase {
     }
   }
 
+  func testUnresolvedVariable() {
+    self.template = Template(templateString: "Hello {{ human.name }}")
+
+    it("can render a variable not defined in the context and throwing is disabled") {
+      self.environment = Environment()
+      let result = try self.environment.render(template: self.template, context: [:])
+      try expect(result) == "Hello "
+    }
+
+    it("throws when a variable is not defined in the context and throwing is enabled") {
+      self.environment = Environment(throwOnUnresolvedVariable: true)
+      try self.expectError(context: [:], reason: "Variable could not be resolved", token: "human.name")
+    }
+  }
+
+  func testUnresolvedVariableWithDefaultFilter() {
+    self.template = Template(templateString: """
+      Hello {{ human.name|default:"World" }}
+      """)
+    self.environment = Environment(throwOnUnresolvedVariable: true)
+
+    it("does not throw when a filter provides a default value, even though the variable is undefined") {
+      let result = try self.environment.render(template: self.template, context: [:])
+      try expect(result) == "Hello World"
+    }
+  }
+
+  func testUnresolvedVariableWithTags() {
+    self.template = Template(templateString: """
+      {% if human.name %}Hello {{ human.name }}{% else %}No hello for you{% endif %}
+      """)
+    self.environment = Environment(throwOnUnresolvedVariable: true)
+
+    it("does not throw when using tags with defined variables") {
+      let result = try self.environment.render(template: self.template, context: ["human": ["name": "John"]])
+      try expect(result) == "Hello John"
+    }
+
+    it("throws when using tags with undefined variables") {
+      try self.expectError(context: [:], reason: "Variable could not be resolved", token: "if human.name")
+    }
+
+    it("does not throw when using empty variables instead of undefined ones") {
+      let result = try self.environment.render(template: self.template, context: ["human": ["name": ""]])
+      try expect(result) == "No hello for you"
+    }
+  }
+
+
   private func expectError(
+    context: [String: Any] = ["names": ["Bob", "Alice"], "name": "Bob"],
     reason: String,
     token: String,
     file: String = #file,
@@ -192,7 +242,7 @@ final class EnvironmentTests: XCTestCase {
     let expectedError = expectedSyntaxError(token: token, template: template, description: reason)
 
     let error = try expect(
-      self.environment.render(template: self.template, context: ["names": ["Bob", "Alice"], "name": "Bob"]),
+      self.environment.render(template: self.template, context: context),
       file: file,
       line: line,
       function: function