refactor: Introducing Environments

Tests/StencilTests/ContextSpec.swift

@@ -1,5 +1,5 @@
 import Spectre
-import Stencil
+@testable import Stencil
 
 
 func testContext() {

Tests/StencilTests/EnvironmentSpec.swift

@@ -0,0 +1,41 @@
+import Spectre
+import Stencil
+
+
+func testEnvironment() {
+  describe("Environment") {
+    let environment = Environment(loader: ExampleLoader())
+
+    $0.it("can load a template from a name") {
+      let template = try environment.loadTemplate(name: "example.html")
+      try expect(template.name) == "example.html"
+    }
+
+    $0.it("can load a template from a names") {
+      let template = try environment.loadTemplate(names: ["first.html", "example.html"])
+      try expect(template.name) == "example.html"
+    }
+
+    $0.it("can render a template from a string") {
+      let result = try environment.renderTemplate(string: "Hello World")
+      try expect(result) == "Hello World"
+    }
+
+    $0.it("can render a template from a file") {
+      let result = try environment.renderTemplate(name: "example.html")
+      try expect(result) == "Hello World!"
+    }
+  }
+}
+
+
+
+fileprivate class ExampleLoader: Loader {
+  func loadTemplate(name: String, environment: Environment) throws -> Template {
+    if name == "example.html" {
+      return Template(templateString: "Hello World!", environment: environment, name: name)
+    }
+
+    throw TemplateDoesNotExist(templateNames: [name], loader: self)
+  }
+}

Tests/StencilTests/FilterSpec.swift

@@ -1,5 +1,5 @@
 import Spectre
-import Stencil
+@testable import Stencil
 
 
 func testFilter() {

Tests/StencilTests/IncludeSpec.swift

@@ -7,6 +7,7 @@ func testInclude() {
   describe("Include") {
     let path = Path(#file) + ".." + "fixtures"
     let loader = FileSystemLoader(paths: [path])
+    let environment = Environment(loader: loader)
 
     $0.describe("parsing") {
       $0.it("throws an error when no template is given") {
@@ -35,7 +36,7 @@ func testInclude() {
         do {
           _ = try node.render(Context())
         } catch {
-          try expect("\(error)") == "Template loader not in context"
+          try expect("\(error)") == "Template named `test.html` does not exist. No loaders found"
         }
       }
 
@@ -43,7 +44,7 @@ func testInclude() {
         let node = IncludeNode(templateName: Variable("\"unknown.html\""))
 
         do {
-          _ = try node.render(Context(dictionary: ["loader": loader]))
+          _ = try node.render(Context(environment: environment))
         } catch {
           try expect("\(error)".hasPrefix("Template named `unknown.html` does not exist in loader")).to.beTrue()
         }
@@ -51,7 +52,7 @@ func testInclude() {
 
       $0.it("successfully renders a found included template") {
         let node = IncludeNode(templateName: Variable("\"test.html\""))
-        let context = Context(dictionary: ["loader":loader, "target": "World"])
+        let context = Context(dictionary: ["target": "World"], environment: environment)
         let value = try node.render(context)
         try expect(value) == "Hello World!"
       }

Tests/StencilTests/InheritenceSpec.swift

@@ -7,17 +7,16 @@ func testInheritence() {
   describe("Inheritence") {
     let path = Path(#file) + ".." + "fixtures"
     let loader = FileSystemLoader(paths: [path])
+    let environment = Environment(loader: loader)
 
     $0.it("can inherit from another template") {
-      let context = Context(dictionary: ["loader": loader])
-      let template = try loader.loadTemplate(name: "child.html")
-      try expect(try template.render(context)) == "Header\nChild"
+      let template = try environment.loadTemplate(name: "child.html")
+      try expect(try template.render()) == "Header\nChild"
     }
 
     $0.it("can inherit from another template inheriting from another template") {
-      let context = Context(dictionary: ["loader": loader])
-      let template = try loader.loadTemplate(name: "child-child.html")
-      try expect(try template.render(context)) == "Child Child Header\nChild"
+      let template = try environment.loadTemplate(name: "child-child.html")
+      try expect(try template.render()) == "Child Child Header\nChild"
     }
   }
 }

Tests/StencilTests/LoaderSpec.swift

@@ -7,25 +7,26 @@ func testTemplateLoader() {
   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") {
-      try expect(try loader.loadTemplate(name: "unknown.html")).toThrow()
+      try expect(try environment.loadTemplate(name: "unknown.html")).toThrow()
     }
 
     $0.it("errors when an array of templates cannot be found") {
-      try expect(try loader.loadTemplate(names: ["unknown.html", "unknown2.html"])).toThrow()
+      try expect(try environment.loadTemplate(names: ["unknown.html", "unknown2.html"])).toThrow()
     }
 
     $0.it("can load a template from a file") {
-      _ = try loader.loadTemplate(name: "test.html")
+      _ = try environment.loadTemplate(name: "test.html")
     }
 
     $0.it("errors when loading absolute file outside of the selected path") {
-      try expect(try loader.loadTemplate(name: "/etc/hosts")).toThrow()
+      try expect(try environment.loadTemplate(name: "/etc/hosts")).toThrow()
     }
 
     $0.it("errors when loading relative file outside of the selected path") {
-      try expect(try loader.loadTemplate(name: "../LoaderSpec.swift")).toThrow()
+      try expect(try environment.loadTemplate(name: "../LoaderSpec.swift")).toThrow()
     }
   }
 }

Tests/StencilTests/NodeSpec.swift

@@ -1,5 +1,5 @@
 import Spectre
-import Stencil
+@testable import Stencil
 
 
 class ErrorNode : NodeType {

Tests/StencilTests/ParserSpec.swift

@@ -1,5 +1,5 @@
 import Spectre
-import Stencil
+@testable import Stencil
 
 
 func testTokenParser() {

Tests/StencilTests/StencilSpec.swift

@@ -25,12 +25,12 @@ func testStencil() {
         "    - {{ article.title }} by {{ article.author }}.\n" +
         "{% endfor %}\n"
 
-      let context = Context(dictionary: [
+      let context = [
         "articles": [
           Article(title: "Migrating from OCUnit to XCTest", author: "Kyle Fuller"),
           Article(title: "Memory Management with ARC", author: "Kyle Fuller"),
         ]
-      ])
+      ]
 
       let template = Template(templateString: templateString)
       let result = try template.render(context)
@@ -45,28 +45,27 @@ func testStencil() {
     }
 
     $0.it("can render a custom template tag") {
-      let templateString = "{% custom %}"
-      let template = Template(templateString: templateString)
-
       let namespace = Namespace()
       namespace.registerTag("custom") { parser, token in
         return CustomNode()
       }
 
-      let result = try template.render(Context(namespace: namespace))
+      let environment = Environment(namespace: namespace)
+      let result = try environment.renderTemplate(string: "{% custom %}")
+
       try expect(result) == "Hello World"
     }
 
     $0.it("can render a simple custom tag") {
-      let templateString = "{% custom %}"
-      let template = Template(templateString: templateString)
-
       let namespace = Namespace()
       namespace.registerSimpleTag("custom") { context in
         return "Hello World"
       }
 
-      try expect(try template.render(Context(namespace: namespace))) == "Hello World"
+      let environment = Environment(namespace: namespace)
+      let result = try environment.renderTemplate(string: "{% custom %}")
+
+      try expect(result) == "Hello World"
     }
   }
 }

Tests/StencilTests/TemplateSpec.swift

@@ -5,16 +5,14 @@ import Stencil
 func testTemplate() {
   describe("Template") {
     $0.it("can render a template from a string") {
-      let context = Context(dictionary: [ "name": "Kyle" ])
       let template = Template(templateString: "Hello World")
-      let result = try template.render(context)
+      let result = try template.render([ "name": "Kyle" ])
       try expect(result) == "Hello World"
     }
 
     $0.it("can render a template from a string literal") {
-        let context = Context(dictionary: [ "name": "Kyle" ])
         let template: Template = "Hello World"
-        let result = try template.render(context)
+        let result = try template.render([ "name": "Kyle" ])
         try expect(result) == "Hello World"
     }
   }

Tests/StencilTests/VariableSpec.swift

@@ -1,6 +1,6 @@
 import Foundation
 import Spectre
-import Stencil
+@testable import Stencil
 
 
 #if os(OSX)

Tests/StencilTests/XCTest.swift

@@ -18,6 +18,7 @@ public func stencilTests() {
   testInclude()
   testInheritence()
   testFilterTag()
+  testEnvironment()
   testStencil()
 }