Release 0.5.3

Make tests pass and run on Linux

.swift-version

@@ -1 +1 @@
-2.2-dev
+DEVELOPMENT-SNAPSHOT-2016-01-25-a

.travis.yml

@@ -0,0 +1,11 @@
+os:
+  - osx
+  - linux
+language: generic
+sudo: required
+dist: trusty
+osx_image: xcode7.2
+install:
+  - eval "$(curl -sL https://gist.githubusercontent.com/kylef/5c0475ff02b7c7671d2a/raw/02090c7ede5a637b76e6df1710e83cd0bbe7dcdf/swiftenv-install.sh)"
+script:
+- make test

Makefile

@@ -0,0 +1,7 @@
+stencil:
+	@echo "Building Stencil"
+	@swift build
+
+test: stencil
+	@echo "Running Tests"
+	@.build/debug/spectre-build

Package.swift

@@ -1,8 +1,11 @@
 import PackageDescription
 
 let package = Package(
-	name: "Stencil",
-	dependencies: [
-		.Package(url: "https://github.com/kylef/PathKit.git", majorVersion: 0, minor: 5),
-	]
+  name: "Stencil",
+  dependencies: [
+    .Package(url: "https://github.com/kylef/PathKit.git", majorVersion: 0, minor: 6),
+  ],
+  testDependencies: [
+    .Package(url: "https://github.com/kylef/spectre-build", majorVersion: 0),
+  ]
 )

README.md

@@ -1,6 +1,6 @@
 # Stencil
 
-[![Build Status](http://img.shields.io/circleci/project/kylef/Stencil/master.svg)](https://circleci.com/gh/kylef/Stencil)
+[![Build Status](https://travis-ci.org/kylef/Stencil.svg?branch=master)](https://travis-ci.org/kylef/Stencil)
 
 Stencil is a simple and powerful template language for Swift. It provides a
 syntax similar to Django and Mustache. If you're familiar with these, you will

Sources/Namespace.swift

@@ -13,7 +13,9 @@ public class Namespace {
     registerTag("for", parser: ForNode.parse)
     registerTag("if", parser: IfNode.parse)
     registerTag("ifnot", parser: IfNode.parse_ifnot)
+#if !os(Linux)
     registerTag("now", parser: NowNode.parse)
+#endif
     registerTag("include", parser: IncludeNode.parse)
     registerTag("extends", parser: ExtendsNode.parse)
     registerTag("block", parser: BlockNode.parse)

Sources/Node.swift

@@ -76,6 +76,8 @@ public class VariableNode : NodeType {
   }
 }
 
+
+#if !os(Linux)
 public class NowNode : NodeType {
   public let format:Variable
 
@@ -114,6 +116,8 @@ public class NowNode : NodeType {
     return formatter!.stringFromDate(date)
   }
 }
+#endif
+
 
 public class ForNode : NodeType {
   let variable:Variable
@@ -158,8 +162,15 @@ public class ForNode : NodeType {
     let values = try variable.resolve(context)
 
     if let values = values as? [Any] where values.count > 0 {
-      return try values.map { item in
-        try context.push([loopVariable: item]) {
+      let count = values.count
+      return try values.enumerate().map { index, item in
+        let forContext: [String: Any] = [
+          "first": index == 0,
+          "last": index == (count - 1),
+          "counter": index + 1,
+        ]
+
+        return try context.push([loopVariable: item, "forloop": forContext]) {
           try renderNodes(nodes, context)
         }
       }.joinWithSeparator("")

Sources/Parser.swift

@@ -1,13 +1,15 @@
-public func until(tags:[String])(parser:TokenParser, token:Token) -> Bool {
-  if let name = token.components().first {
-    for tag in tags {
-      if name == tag {
-        return true
+public func until(tags: [String]) -> ((TokenParser, Token) -> Bool) {
+  return { parser, token in
+    if let name = token.components().first {
+      for tag in tags {
+        if name == tag {
+          return true
+        }
       }
     }
-  }
 
-  return false
+    return false
+  }
 }
 
 public typealias Filter = Any? throws -> Any?

Sources/Variable.swift

@@ -56,11 +56,13 @@ public struct Variable : Equatable, Resolvable {
     }
 
     for bit in lookup() {
+      current = normalize(current)
+
       if let context = current as? Context {
         current = context[bit]
-      } else if let dictionary = resolveDictionary(current) {
+      } else if let dictionary = current as? [String: Any] {
         current = dictionary[bit]
-      } else if let array = resolveArray(current) {
+      } else if let array = current as? [Any] {
         if let index = Int(bit) {
           current = array[index]
         } else if bit == "first" {
@@ -90,50 +92,42 @@ public func ==(lhs: Variable, rhs: Variable) -> Bool {
 }
 
 
-func resolveDictionary(current: Any?) -> [String: Any]? {
-  switch current {
-  case let dictionary as [String: Any]:
-      return dictionary
-  case let dictionary as [String: AnyObject]:
-      var result: [String: Any] = [:]
-      for (k, v) in dictionary {
-          result[k] = v as Any
-      }
-      return result
-  case let dictionary as NSDictionary:
-      var result: [String: Any] = [:]
-      for (k, v) in dictionary {
-          if let k = k as? String {
-              result[k] = v as Any
-          }
-      }
-      return result
-  default:
-      return nil
-  }
-}
-
-func resolveArray(current: Any?) -> [Any]? {
-  switch current {
-  case let array as [Any]:
-      return array
-  case let array as [AnyObject]:
-      return array.map { $0 as Any }
-  case let array as NSArray:
-      return array.map { $0 as Any }
-  default:
-      return nil
-  }
-}
-
 func normalize(current: Any?) -> Any? {
-  if let array = resolveArray(current) {
-    return array
-  }
-
-  if let dictionary = resolveDictionary(current) {
-    return dictionary
+  if let current = current as? Normalizable {
+    return current.normalize()
   }
 
   return current
 }
+
+protocol Normalizable {
+  func normalize() -> Any?
+}
+
+extension Array : Normalizable {
+  func normalize() -> Any? {
+    return map { $0 as Any }
+  }
+}
+
+extension NSArray : Normalizable {
+  func normalize() -> Any? {
+    return map { $0 as Any }
+  }
+}
+
+extension Dictionary : Normalizable {
+  func normalize() -> Any? {
+    var dictionary: [String: Any] = [:]
+
+    for (key, value) in self {
+      if let key = key as? String {
+        dictionary[key] = Stencil.normalize(value)
+      } else if let key = key as? CustomStringConvertible {
+        dictionary[key.description] = Stencil.normalize(value)
+      }
+    }
+
+    return dictionary
+  }
+}

Stencil.podspec.json

@@ -1,6 +1,6 @@
 {
   "name": "Stencil",
-  "version": "0.4.0",
+  "version": "0.5.3",
   "summary": "Stencil is a simple and powerful template language for Swift.",
   "homepage": "https://github.com/kylef/Stencil",
   "license": {
@@ -8,12 +8,12 @@
     "file": "LICENSE"
   },
   "authors": {
-    "Kyle Fuller": "inbox@kylefuller.co.uk"
+    "Kyle Fuller": "kyle@fuller.li"
   },
   "social_media_url": "http://twitter.com/kylefuller",
   "source": {
     "git": "https://github.com/kylef/Stencil.git",
-    "tag": "0.4.0"
+    "tag": "0.5.3"
   },
   "source_files": [
     "Sources/*.swift"
@@ -24,17 +24,6 @@
   },
   "requires_arc": true,
   "dependencies": {
-    "PathKit": [ "~> 0.5.0" ]
-  },
-  "test_specification": {
-    "source_files": [
-      "Tests/*.swift",
-      "Tests/TemplateLoader/*.swift",
-      "Tests/Nodes/*.swift"
-    ],
-    "dependencies": {
-      "Spectre": [ "~> 0.5.0" ],
-      "PathKit": [ "~> 0.5.0" ]
-    }
+    "PathKit": [ "~> 0.6.0" ]
   }
 }

Tests/ContextSpec.swift

@@ -2,64 +2,66 @@ import Spectre
 import Stencil
 
 
-describe("Context") {
-  var context: Context!
+func testContext() {
+  describe("Context") {
+    var context: Context!
 
-  $0.before {
-    context = Context(dictionary: ["name": "Kyle"])
-  }
+    $0.before {
+      context = Context(dictionary: ["name": "Kyle"])
+    }
 
-  $0.it("allows you to get a value via subscripting") {
-    try expect(context["name"] as? String) == "Kyle"
-  }
+    $0.it("allows you to get a value via subscripting") {
+      try expect(context["name"] as? String) == "Kyle"
+    }
 
-  $0.it("allows you to set a value via subscripting") {
-    context["name"] = "Katie"
+    $0.it("allows you to set a value via subscripting") {
+      context["name"] = "Katie"
 
-    try expect(context["name"] as? String) == "Katie"
-  }
-
-  $0.it("allows you to remove a value via subscripting") {
-    context["name"] = nil
-
-    try expect(context["name"]).to.beNil()
-  }
-
-  $0.it("allows you to retrieve a value from a parent") {
-    context.push()
-
-    try expect(context["name"] as? String) == "Kyle"
-  }
-
-  $0.it("allows you to override a parent's value") {
-    context.push()
-    context["name"] = "Katie"
-
-    try expect(context["name"] as? String) == "Katie"
-  }
-
-  $0.it("allows you to pop to restore previous state") {
-    context.push()
-    context["name"] = "Katie"
-    context.pop()
-
-    try expect(context["name"] as? String) == "Kyle"
-  }
-
-  $0.it("allows you to push a dictionary onto the stack") {
-    context.push(["name": "Katie"])
-    try expect(context["name"] as? String) == "Katie"
-  }
-
-  $0.it("allows you to push a dictionary and run a closure then restoring previous state") {
-    var didRun = false
-
-    try context.push(["name": "Katie"]) {
-      didRun = true
       try expect(context["name"] as? String) == "Katie"
     }
 
-    try expect(didRun).to.beTrue()
-    try expect(context["name"] as? String) == "Kyle"
+    $0.it("allows you to remove a value via subscripting") {
+      context["name"] = nil
+
+      try expect(context["name"]).to.beNil()
+    }
+
+    $0.it("allows you to retrieve a value from a parent") {
+      context.push()
+
+      try expect(context["name"] as? String) == "Kyle"
+    }
+
+    $0.it("allows you to override a parent's value") {
+      context.push()
+      context["name"] = "Katie"
+
+      try expect(context["name"] as? String) == "Katie"
+    }
+
+    $0.it("allows you to pop to restore previous state") {
+      context.push()
+      context["name"] = "Katie"
+      context.pop()
+
+      try expect(context["name"] as? String) == "Kyle"
+    }
+
+    $0.it("allows you to push a dictionary onto the stack") {
+      context.push(["name": "Katie"])
+      try expect(context["name"] as? String) == "Katie"
+    }
+
+    $0.it("allows you to push a dictionary and run a closure then restoring previous state") {
+      var didRun = false
+
+      try context.push(["name": "Katie"]) {
+        didRun = true
+        try expect(context["name"] as? String) == "Katie"
+      }
+
+      try expect(didRun).to.beTrue()
+      try expect(context["name"] as? String) == "Kyle"
+    }
   }
 }

Tests/FilterSpec.swift

@@ -2,68 +2,69 @@ import Spectre
 import Stencil
 
 
-describe("template filters") {
-  let context = Context(dictionary: ["name": "Kyle"])
+func testFilter() {
+  describe("template filters") {
+    let context = Context(dictionary: ["name": "Kyle"])
 
-  $0.it("allows you to register a custom filter") {
-    let template = Template(templateString: "{{ name|repeat }}")
+    $0.it("allows you to register a custom filter") {
+      let template = Template(templateString: "{{ name|repeat }}")
 
-    let namespace = Namespace()
-    namespace.registerFilter("repeat") { value in
-      if let value = value as? String {
-        return "\(value) \(value)"
+      let namespace = Namespace()
+      namespace.registerFilter("repeat") { value in
+        if let value = value as? String {
+          return "\(value) \(value)"
+        }
+
+        return nil
       }
 
-      return nil
+      let result = try template.render(context, namespace: namespace)
+      try expect(result) == "Kyle Kyle"
     }
 
-    let result = try template.render(context, namespace: namespace)
-    try expect(result) == "Kyle Kyle"
-  }
+    $0.it("allows you to register a custom which throws") {
+      let template = Template(templateString: "{{ name|repeat }}")
+      let namespace = Namespace()
+      namespace.registerFilter("repeat") { value in
+        throw TemplateSyntaxError("No Repeat")
+      }
 
-  $0.it("allows you to register a custom filter") {
-    let template = Template(templateString: "{{ name|repeat }}")
-    let namespace = Namespace()
-    namespace.registerFilter("repeat") { value in
-      throw TemplateSyntaxError("No Repeat")
+      try expect(try template.render(context, namespace: namespace)).toThrow(TemplateSyntaxError("No Repeat"))
     }
 
-    try expect(try template.render(context, namespace: namespace)).toThrow(TemplateSyntaxError("No Repeat"))
+    $0.it("allows whitespace in expression") {
+      let template = Template(templateString: "{{ name | uppercase }}")
+      let result = try template.render(Context(dictionary: ["name": "kyle"]))
+      try expect(result) == "KYLE"
+    }
   }
 
-  $0.it("allows whitespace in expression") {
-    let template = Template(templateString: "{{ name | uppercase }}")
-    let result = try template.render(Context(dictionary: ["name": "kyle"]))
-    try expect(result) == "KYLE"
-  }
-}
-
-
-describe("capitalize filter") {
-  let template = Template(templateString: "{{ name|capitalize }}")
-
-  $0.it("capitalizes a string") {
-    let result = try template.render(Context(dictionary: ["name": "kyle"]))
-    try expect(result) == "Kyle"
-  }
-}
-
-
-describe("uppercase filter") {
-  let template = Template(templateString: "{{ name|uppercase }}")
-
-  $0.it("transforms a string to be uppercase") {
-    let result = try template.render(Context(dictionary: ["name": "kyle"]))
-    try expect(result) == "KYLE"
-  }
-}
-
-
-describe("lowercase filter") {
-  let template = Template(templateString: "{{ name|lowercase }}")
-
-  $0.it("transforms a string to be lowercase") {
-    let result = try template.render(Context(dictionary: ["name": "Kyle"]))
-    try expect(result) == "kyle"
+
+  describe("capitalize filter") {
+    let template = Template(templateString: "{{ name|capitalize }}")
+
+    $0.it("capitalizes a string") {
+      let result = try template.render(Context(dictionary: ["name": "kyle"]))
+      try expect(result) == "Kyle"
+    }
+  }
+
+
+  describe("uppercase filter") {
+    let template = Template(templateString: "{{ name|uppercase }}")
+
+    $0.it("transforms a string to be uppercase") {
+      let result = try template.render(Context(dictionary: ["name": "kyle"]))
+      try expect(result) == "KYLE"
+    }
+  }
+
+  describe("lowercase filter") {
+    let template = Template(templateString: "{{ name|lowercase }}")
+
+    $0.it("transforms a string to be lowercase") {
+      let result = try template.render(Context(dictionary: ["name": "Kyle"]))
+      try expect(result) == "kyle"
+    }
   }
 }

Tests/LexerSpec.swift

@@ -2,47 +2,49 @@ import Spectre
 import Stencil
 
 
-describe("Lexer") {
-  $0.it("can tokenize text") {
-    let lexer = Lexer(templateString: "Hello World")
-    let tokens = lexer.tokenize()
+func testLexer() {
+  describe("Lexer") {
+    $0.it("can tokenize text") {
+      let lexer = Lexer(templateString: "Hello World")
+      let tokens = lexer.tokenize()
 
-    try expect(tokens.count) == 1
-    try expect(tokens.first) == Token.Text(value: "Hello World")
-  }
+      try expect(tokens.count) == 1
+      try expect(tokens.first) == Token.Text(value: "Hello World")
+    }
 
-  $0.it("can tokenize a comment") {
-    let lexer = Lexer(templateString: "{# Comment #}")
-    let tokens = lexer.tokenize()
+    $0.it("can tokenize a comment") {
+      let lexer = Lexer(templateString: "{# Comment #}")
+      let tokens = lexer.tokenize()
 
-    try expect(tokens.count) == (1)
-    try expect(tokens.first) == Token.Comment(value: "Comment")
-  }
+      try expect(tokens.count) == (1)
+      try expect(tokens.first) == Token.Comment(value: "Comment")
+    }
 
-  $0.it("can tokenize a variable") {
-    let lexer = Lexer(templateString: "{{ Variable }}")
-    let tokens = lexer.tokenize()
+    $0.it("can tokenize a variable") {
+      let lexer = Lexer(templateString: "{{ Variable }}")
+      let tokens = lexer.tokenize()
 
-    try expect(tokens.count) == 1
-    try expect(tokens.first) == Token.Variable(value: "Variable")
-  }
+      try expect(tokens.count) == 1
+      try expect(tokens.first) == Token.Variable(value: "Variable")
+    }
 
-  $0.it("can tokenize a mixture of content") {
-    let lexer = Lexer(templateString: "My name is {{ name }}.")
-    let tokens = lexer.tokenize()
+    $0.it("can tokenize a mixture of content") {
+      let lexer = Lexer(templateString: "My name is {{ name }}.")
+      let tokens = lexer.tokenize()
 
-    try expect(tokens.count) == 3
-    try expect(tokens[0]) == Token.Text(value: "My name is ")
-    try expect(tokens[1]) == Token.Variable(value: "name")
-    try expect(tokens[2]) == Token.Text(value: ".")
-  }
+      try expect(tokens.count) == 3
+      try expect(tokens[0]) == Token.Text(value: "My name is ")
+      try expect(tokens[1]) == Token.Variable(value: "name")
+      try expect(tokens[2]) == Token.Text(value: ".")
+    }
 
-  $0.it("can tokenize two variables without being greedy") {
-    let lexer = Lexer(templateString: "{{ thing }}{{ name }}")
-    let tokens = lexer.tokenize()
+    $0.it("can tokenize two variables without being greedy") {
+      let lexer = Lexer(templateString: "{{ thing }}{{ name }}")
+      let tokens = lexer.tokenize()
 
-    try expect(tokens.count) == 2
-    try expect(tokens[0]) == Token.Variable(value: "thing")
-    try expect(tokens[1]) == Token.Variable(value: "name")
+      try expect(tokens.count) == 2
+      try expect(tokens[0]) == Token.Variable(value: "thing")
+      try expect(tokens[1]) == Token.Variable(value: "name")
+    }
   }
 }

Tests/Nodes/ForNodeSpec.swift

@@ -3,42 +3,64 @@ import Stencil
 import Foundation
 
 
-describe("ForNode") {
-  let context = Context(dictionary: [
-    "items": [1, 2, 3],
-    "emptyItems": [Int](),
-  ])
+func testForNode() {
+  describe("ForNode") {
+    let context = Context(dictionary: [
+      "items": [1, 2, 3],
+      "emptyItems": [Int](),
+    ])
 
-  $0.it("renders the given nodes for each item") {
-    let nodes: [NodeType] = [VariableNode(variable: "item")]
-    let node = ForNode(variable: "items", loopVariable: "item", nodes: nodes, emptyNodes: [])
-    try expect(try node.render(context)) == "123"
-  }
+    $0.it("renders the given nodes for each item") {
+      let nodes: [NodeType] = [VariableNode(variable: "item")]
+      let node = ForNode(variable: "items", loopVariable: "item", nodes: nodes, emptyNodes: [])
+      try expect(try node.render(context)) == "123"
+    }
 
-  $0.it("renders the given empty nodes when no items found item") {
-    let nodes: [NodeType] = [VariableNode(variable: "item")]
-    let emptyNodes: [NodeType] = [TextNode(text: "empty")]
-    let node = ForNode(variable: "emptyItems", loopVariable: "item", nodes: nodes, emptyNodes: emptyNodes)
-    try expect(try node.render(context)) == "empty"
-  }
+    $0.it("renders the given empty nodes when no items found item") {
+      let nodes: [NodeType] = [VariableNode(variable: "item")]
+      let emptyNodes: [NodeType] = [TextNode(text: "empty")]
+      let node = ForNode(variable: "emptyItems", loopVariable: "item", nodes: nodes, emptyNodes: emptyNodes)
+      try expect(try node.render(context)) == "empty"
+    }
 
-  $0.it("renders a context variable of type Array<Any>") {
-    let any_context = Context(dictionary: [
+    $0.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(variable: "items", loopVariable: "item", nodes: nodes, emptyNodes: [])
-    try expect(try node.render(any_context)) == "123" 
-  }
+      let nodes: [NodeType] = [VariableNode(variable: "item")]
+      let node = ForNode(variable: "items", loopVariable: "item", nodes: nodes, emptyNodes: [])
+      try expect(try node.render(any_context)) == "123" 
+    }
 
-  $0.it("renders a context variable of type NSArray") {
-    let nsarray_context = Context(dictionary: [
+#if os(OSX)
+    $0.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(variable: "items", loopVariable: "item", nodes: nodes, emptyNodes: [])
-    try expect(try node.render(nsarray_context)) == "123" 
+      let nodes: [NodeType] = [VariableNode(variable: "item")]
+      let node = ForNode(variable: "items", loopVariable: "item", nodes: nodes, emptyNodes: [])
+      try expect(try node.render(nsarray_context)) == "123"
+    }
+#endif
+
+    $0.it("renders the given nodes while providing if the item is first in the context") {
+      let nodes: [NodeType] = [VariableNode(variable: "item"), VariableNode(variable: "forloop.first")]
+      let node = ForNode(variable: "items", loopVariable: "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(variable: "items", loopVariable: "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(variable: "items", loopVariable: "item", nodes: nodes, emptyNodes: [])
+      try expect(try node.render(context)) == "112233"
+    }
   }
 }

Tests/Nodes/IfNodeSpec.swift

@@ -1,113 +1,116 @@
 import Spectre
 import Stencil
 
-describe("IfNode") {
-  $0.describe("parsing") {
-    $0.it("can parse an if block") {
-      let tokens = [
-        Token.Block(value: "if value"),
-        Token.Text(value: "true"),
-        Token.Block(value: "else"),
-        Token.Text(value: "false"),
-        Token.Block(value: "endif")
-      ]
 
-      let parser = TokenParser(tokens: tokens, namespace: Namespace())
-      let nodes = try parser.parse()
-      let node = nodes.first as? IfNode
-      let trueNode = node?.trueNodes.first as? TextNode
-      let falseNode = node?.falseNodes.first as? TextNode
+func testIfNode() {
+  describe("IfNode") {
+    $0.describe("parsing") {
+      $0.it("can parse an if block") {
+        let tokens = [
+          Token.Block(value: "if value"),
+          Token.Text(value: "true"),
+          Token.Block(value: "else"),
+          Token.Text(value: "false"),
+          Token.Block(value: "endif")
+        ]
 
-      try expect(nodes.count) == 1
-      try expect(node?.variable.variable) == "value"
-      try expect(node?.trueNodes.count) == 1
-      try expect(trueNode?.text) == "true"
-      try expect(node?.falseNodes.count) == 1
-      try expect(falseNode?.text) == "false"
+        let parser = TokenParser(tokens: tokens, namespace: Namespace())
+        let nodes = try parser.parse()
+        let node = nodes.first as? IfNode
+        let trueNode = node?.trueNodes.first as? TextNode
+        let falseNode = node?.falseNodes.first as? TextNode
+
+        try expect(nodes.count) == 1
+        try expect(node?.variable.variable) == "value"
+        try expect(node?.trueNodes.count) == 1
+        try expect(trueNode?.text) == "true"
+        try expect(node?.falseNodes.count) == 1
+        try expect(falseNode?.text) == "false"
+      }
+
+      $0.it("can parse an ifnot block") {
+        let tokens = [
+          Token.Block(value: "ifnot value"),
+          Token.Text(value: "false"),
+          Token.Block(value: "else"),
+          Token.Text(value: "true"),
+          Token.Block(value: "endif")
+        ]
+
+        let parser = TokenParser(tokens: tokens, namespace: Namespace())
+        let nodes = try parser.parse()
+        let node = nodes.first as? IfNode
+        let trueNode = node?.trueNodes.first as? TextNode
+        let falseNode = node?.falseNodes.first as? TextNode
+
+        try expect(nodes.count) == 1
+        try expect(node?.variable.variable) == "value"
+        try expect(node?.trueNodes.count) == 1
+        try expect(trueNode?.text) == "true"
+        try expect(node?.falseNodes.count) == 1
+        try expect(falseNode?.text) == "false"
+      }
+
+      $0.it("throws an error when parsing an if block without an endif") {
+        let tokens = [
+          Token.Block(value: "if value"),
+        ]
+
+        let parser = TokenParser(tokens: tokens, namespace: Namespace())
+        let error = TemplateSyntaxError("`endif` was not found.")
+        try expect(try parser.parse()).toThrow(error)
+      }
+
+      $0.it("throws an error when parsing an ifnot without an endif") {
+        let tokens = [
+          Token.Block(value: "ifnot value"),
+        ]
+
+        let parser = TokenParser(tokens: tokens, namespace: Namespace())
+        let error = TemplateSyntaxError("`endif` was not found.")
+        try expect(try parser.parse()).toThrow(error)
+      }
     }
 
-    $0.it("can parse an ifnot block") {
-      let tokens = [
-        Token.Block(value: "ifnot value"),
-        Token.Text(value: "false"),
-        Token.Block(value: "else"),
-        Token.Text(value: "true"),
-        Token.Block(value: "endif")
-      ]
+    $0.describe("rendering") {
+      let context = Context(dictionary: ["items": true])
 
-      let parser = TokenParser(tokens: tokens, namespace: Namespace())
-      let nodes = try parser.parse()
-      let node = nodes.first as? IfNode
-      let trueNode = node?.trueNodes.first as? TextNode
-      let falseNode = node?.falseNodes.first as? TextNode
+      $0.it("renders the truth when expression evaluates to true") {
+        let node = IfNode(variable: "items", trueNodes: [TextNode(text: "true")], falseNodes: [TextNode(text: "false")])
+        try expect(try node.render(context)) == "true"
+      }
 
-      try expect(nodes.count) == 1
-      try expect(node?.variable.variable) == "value"
-      try expect(node?.trueNodes.count) == 1
-      try expect(trueNode?.text) == "true"
-      try expect(node?.falseNodes.count) == 1
-      try expect(falseNode?.text) == "false"
-    }
+      $0.it("renders the false when expression evaluates to false") {
+        let node = IfNode(variable: "unknown", trueNodes: [TextNode(text: "true")], falseNodes: [TextNode(text: "false")])
+        try expect(try node.render(context)) == "false"
+      }
 
-    $0.it("throws an error when parsing an if block without an endif") {
-      let tokens = [
-        Token.Block(value: "if value"),
-      ]
+      $0.it("renders the truth when array expression is not empty") {
+        let items: [[String: Any]] = [["key":"key1","value":42],["key":"key2","value":1337]]
+        let arrayContext = Context(dictionary: ["items": [items]])
+        let node = IfNode(variable: "items", trueNodes: [TextNode(text: "true")], falseNodes: [TextNode(text: "false")])
+        try expect(try node.render(arrayContext)) == "true"
+      }
 
-      let parser = TokenParser(tokens: tokens, namespace: Namespace())
-      let error = TemplateSyntaxError("`endif` was not found.")
-      try expect(try parser.parse()).toThrow(error)
-    }
+      $0.it("renders the false when array expression is empty") {
+        let emptyItems = [[String: Any]]()
+        let arrayContext = Context(dictionary: ["items": emptyItems])
+        let node = IfNode(variable: "items", trueNodes: [TextNode(text: "true")], falseNodes: [TextNode(text: "false")])
+        try expect(try node.render(arrayContext)) == "false"
+      }
 
-    $0.it("throws an error when parsing an ifnot without an endif") {
-      let tokens = [
-        Token.Block(value: "ifnot value"),
-      ]
+      $0.it("renders the false when dictionary expression is empty") {
+        let emptyItems = [String:Any]()
+        let arrayContext = Context(dictionary: ["items": emptyItems])
+        let node = IfNode(variable: "items", trueNodes: [TextNode(text: "true")], falseNodes: [TextNode(text: "false")])
+        try expect(try node.render(arrayContext)) == "false"
+      }
 
-      let parser = TokenParser(tokens: tokens, namespace: Namespace())
-      let error = TemplateSyntaxError("`endif` was not found.")
-      try expect(try parser.parse()).toThrow(error)
-    }
-  }
-
-  $0.describe("rendering") {
-    let context = Context(dictionary: ["items": true])
-
-    $0.it("renders the truth when expression evaluates to true") {
-      let node = IfNode(variable: "items", trueNodes: [TextNode(text: "true")], falseNodes: [TextNode(text: "false")])
-      try expect(try node.render(context)) == "true"
-    }
-
-    $0.it("renders the false when expression evaluates to false") {
-      let node = IfNode(variable: "unknown", trueNodes: [TextNode(text: "true")], falseNodes: [TextNode(text: "false")])
-      try expect(try node.render(context)) == "false"
-    }
-
-    $0.it("renders the truth when array expression is not empty") {
-      let items: Array<[String:AnyObject]> = [["key":"key1","value":42],["key":"key2","value":1337]]
-      let arrayContext = Context(dictionary: ["items": [items]])
-      let node = IfNode(variable: "items", trueNodes: [TextNode(text: "true")], falseNodes: [TextNode(text: "false")])
-      try expect(try node.render(arrayContext)) == "true"
-    }
-
-    $0.it("renders the false when array expression is empty") {
-      let emptyItems = Array<[String:AnyObject]>()
-      let arrayContext = Context(dictionary: ["items": emptyItems])
-      let node = IfNode(variable: "items", trueNodes: [TextNode(text: "true")], falseNodes: [TextNode(text: "false")])
-      try expect(try node.render(arrayContext)) == "false"
-    }
-
-    $0.it("renders the false when dictionary expression is empty") {
-      let emptyItems = [String:AnyObject]()
-      let arrayContext = Context(dictionary: ["items": emptyItems])
-      let node = IfNode(variable: "items", trueNodes: [TextNode(text: "true")], falseNodes: [TextNode(text: "false")])
-      try expect(try node.render(arrayContext)) == "false"
-    }
-
-    $0.it("renders the false when Array<Any> variable is empty") {
-      let arrayContext = Context(dictionary: ["items": ([] as [Any])])
-      let node = IfNode(variable: "items", trueNodes: [TextNode(text: "true")], falseNodes: [TextNode(text: "false")])
-      try expect(try node.render(arrayContext)) == "false"
+      $0.it("renders the false when Array<Any> variable is empty") {
+        let arrayContext = Context(dictionary: ["items": ([] as [Any])])
+        let node = IfNode(variable: "items", trueNodes: [TextNode(text: "true")], falseNodes: [TextNode(text: "false")])
+        try expect(try node.render(arrayContext)) == "false"
+      }
     }
   }
 }

Tests/Nodes/NodeSpec.swift

@@ -9,50 +9,52 @@ class ErrorNode : NodeType {
 }
 
 
-describe("Node") {
-  let context = Context(dictionary: [
-    "name": "Kyle",
-    "age": 27,
-    "items": [1, 2, 3],
-  ])
+func testNode() {
+  describe("Node") {
+    let context = Context(dictionary: [
+      "name": "Kyle",
+      "age": 27,
+      "items": [1, 2, 3],
+    ])
 
-  $0.describe("TextNode") {
-    $0.it("renders the given text") {
-      let node = TextNode(text: "Hello World")
-      try expect(try node.render(context)) == "Hello World"
-    }
-  }
-
-  $0.describe("VariableNode") {
-    $0.it("resolves and renders the variable") {
-      let node = VariableNode(variable: Variable("name"))
-      try expect(try node.render(context)) == "Kyle"
+    $0.describe("TextNode") {
+      $0.it("renders the given text") {
+        let node = TextNode(text: "Hello World")
+        try expect(try node.render(context)) == "Hello World"
+      }
     }
 
-    $0.it("resolves and renders a non string variable") {
-      let node = VariableNode(variable: Variable("age"))
-      try expect(try node.render(context)) == "27"
-    }
-  }
+    $0.describe("VariableNode") {
+      $0.it("resolves and renders the variable") {
+        let node = VariableNode(variable: Variable("name"))
+        try expect(try node.render(context)) == "Kyle"
+      }
 
-  $0.describe("rendering nodes") {
-    $0.it("renders the nodes") {
-      let nodes: [NodeType] = [
-        TextNode(text:"Hello "),
-        VariableNode(variable: "name"),
-      ]
-
-      try expect(try renderNodes(nodes, context)) == "Hello Kyle"
+      $0.it("resolves and renders a non string variable") {
+        let node = VariableNode(variable: Variable("age"))
+        try expect(try node.render(context)) == "27"
+      }
     }
 
-    $0.it("correctly throws a nodes failure") {
-      let nodes: [NodeType] = [
-        TextNode(text:"Hello "),
-        VariableNode(variable: "name"),
-        ErrorNode(),
-      ]
+    $0.describe("rendering nodes") {
+      $0.it("renders the nodes") {
+        let nodes: [NodeType] = [
+          TextNode(text:"Hello "),
+          VariableNode(variable: "name"),
+        ]
 
-      try expect(try renderNodes(nodes, context)).toThrow(TemplateSyntaxError("Custom Error"))
+        try expect(try renderNodes(nodes, context)) == "Hello Kyle"
+      }
+
+      $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/Nodes/NowNodeSpec.swift

@@ -3,37 +3,41 @@ import Spectre
 import Stencil
 
 
-describe("NowNode") {
-  $0.describe("parsing") {
-    $0.it("parses default format without any now arguments") {
-      let tokens = [ Token.Block(value: "now") ]
-      let parser = TokenParser(tokens: tokens, namespace: Namespace())
+func testNowNode() {
+#if !os(Linux)
+  describe("NowNode") {
+    $0.describe("parsing") {
+      $0.it("parses default format without any now arguments") {
+        let tokens = [ Token.Block(value: "now") ]
+        let parser = TokenParser(tokens: tokens, namespace: Namespace())
 
-      let nodes = try parser.parse()
-      let node = nodes.first as? NowNode
-      try expect(nodes.count) == 1
-      try expect(node?.format.variable) == "\"yyyy-MM-dd 'at' HH:mm\""
+        let nodes = try parser.parse()
+        let node = nodes.first as? NowNode
+        try expect(nodes.count) == 1
+        try expect(node?.format.variable) == "\"yyyy-MM-dd 'at' HH:mm\""
+      }
+
+      $0.it("parses now with a format") {
+        let tokens = [ Token.Block(value: "now \"HH:mm\"") ]
+        let parser = TokenParser(tokens: tokens, namespace: Namespace())
+        let nodes = try parser.parse()
+        let node = nodes.first as? NowNode
+        try expect(nodes.count) == 1
+        try expect(node?.format.variable) == "\"HH:mm\""
+      }
     }
 
-    $0.it("parses now with a format") {
-      let tokens = [ Token.Block(value: "now \"HH:mm\"") ]
-      let parser = TokenParser(tokens: tokens, namespace: Namespace())
-      let nodes = try parser.parse()
-      let node = nodes.first as? NowNode
-      try expect(nodes.count) == 1
-      try expect(node?.format.variable) == "\"HH:mm\""
-    }
-  }
-
-  $0.describe("rendering") {
-    $0.it("renders the date") {
-      let node = NowNode(format: Variable("\"yyyy-MM-dd\""))
-
-      let formatter = NSDateFormatter()
-      formatter.dateFormat = "yyyy-MM-dd"
-      let date = formatter.stringFromDate(NSDate())
-
-      try expect(try node.render(Context())) == date
+    $0.describe("rendering") {
+      $0.it("renders the date") {
+        let node = NowNode(format: Variable("\"yyyy-MM-dd\""))
+
+        let formatter = NSDateFormatter()
+        formatter.dateFormat = "yyyy-MM-dd"
+        let date = formatter.stringFromDate(NSDate())
+
+        try expect(try node.render(Context())) == date
+      }
     }
   }
+#endif
 }

Tests/ParserSpec.swift

@@ -2,54 +2,61 @@ import Spectre
 import Stencil
 
 
-describe("TokenParser") {
-  $0.it("can parse a text token") {
-    let parser = TokenParser(tokens: [
-      Token.Text(value: "Hello World")
-    ], namespace: Namespace())
+func testTokenParser() {
+  describe("TokenParser") {
+    $0.it("can parse a text token") {
+      let parser = TokenParser(tokens: [
+        Token.Text(value: "Hello World")
+      ], namespace: Namespace())
 
-    let nodes = try parser.parse()
-    let node = nodes.first as? TextNode
+      let nodes = try parser.parse()
+      let node = nodes.first as? TextNode
 
-    try expect(nodes.count) == 1
-    try expect(node?.text) == "Hello World"
-  }
+      try expect(nodes.count) == 1
+      try expect(node?.text) == "Hello World"
+    }
 
-  $0.it("can parse a variable token") {
-    let parser = TokenParser(tokens: [
-      Token.Variable(value: "'name'")
-    ], namespace: Namespace())
+    $0.it("can parse a variable token") {
+      let parser = TokenParser(tokens: [
+        Token.Variable(value: "'name'")
+      ], namespace: Namespace())
 
-    let nodes = try parser.parse()
-    let node = nodes.first as? VariableNode
-    try expect(nodes.count) == 1
-    let result = try node?.render(Context())
-    try expect(result) == "name"
-  }
+      let nodes = try parser.parse()
+      let node = nodes.first as? VariableNode
+      try expect(nodes.count) == 1
+      let result = try node?.render(Context())
+      try expect(result) == "name"
+    }
 
-  $0.it("can parse a comment token") {
-    let parser = TokenParser(tokens: [
-      Token.Comment(value: "Secret stuff!")
-    ], namespace: Namespace())
+    $0.it("can parse a comment token") {
+      let parser = TokenParser(tokens: [
+        Token.Comment(value: "Secret stuff!")
+      ], namespace: Namespace())
 
-    let nodes = try parser.parse()
-    try expect(nodes.count) == 0
-  }
+      let nodes = try parser.parse()
+      try expect(nodes.count) == 0
+    }
 
-  $0.it("can parse a tag token") {
-    let parser = TokenParser(tokens: [
-      Token.Block(value: "now"),
-    ], namespace: Namespace())
+    $0.it("can parse a tag token") {
+      let namespace = Namespace()
+      namespace.registerSimpleTag("known") { _ in
+        return ""
+      }
 
-    let nodes = try parser.parse()
-    try expect(nodes.count) == 1
-  }
+      let parser = TokenParser(tokens: [
+        Token.Block(value: "known"),
+      ], namespace: namespace)
 
-  $0.it("errors when parsing an unknown tag") {
-    let parser = TokenParser(tokens: [
-      Token.Block(value: "unknown"),
-    ], namespace: Namespace())
+      let nodes = try parser.parse()
+      try expect(nodes.count) == 1
+    }
 
-    try expect(try parser.parse()).toThrow(TemplateSyntaxError("Unknown template tag 'unknown'"))
+    $0.it("errors when parsing an unknown tag") {
+      let parser = TokenParser(tokens: [
+        Token.Block(value: "unknown"),
+      ], namespace: Namespace())
+
+      try expect(try parser.parse()).toThrow(TemplateSyntaxError("Unknown template tag 'unknown'"))
+    }
   }
 }

Tests/StencilSpec.swift

@@ -9,55 +9,57 @@ class CustomNode : NodeType {
 }
 
 
-describe("Stencil") {
-  $0.it("can render the README example") {
-    let templateString = "There are {{ articles.count }} articles.\n" +
-      "\n" +
-      "{% for article in articles %}" +
-      "    - {{ article.title }} by {{ article.author }}.\n" +
-    "{% endfor %}\n"
+func testStencil() {
+  describe("Stencil") {
+    $0.it("can render the README example") {
+      let templateString = "There are {{ articles.count }} articles.\n" +
+        "\n" +
+        "{% for article in articles %}" +
+        "    - {{ article.title }} by {{ article.author }}.\n" +
+        "{% endfor %}\n"
 
-    let context = Context(dictionary: [
-      "articles": [
-        [ "title": "Migrating from OCUnit to XCTest", "author": "Kyle Fuller" ],
-        [ "title": "Memory Management with ARC", "author": "Kyle Fuller" ],
-      ]
-    ])
+      let context = Context(dictionary: [
+        "articles": [
+          [ "title": "Migrating from OCUnit to XCTest", "author": "Kyle Fuller" ],
+          [ "title": "Memory Management with ARC", "author": "Kyle Fuller" ],
+        ]
+      ])
 
-    let template = Template(templateString:templateString)
-    let result = try template.render(context)
+      let template = Template(templateString: templateString)
+      let result = try template.render(context)
 
-    let fixture = "There are 2 articles.\n" +
-      "\n" +
-      "    - Migrating from OCUnit to XCTest by Kyle Fuller.\n" +
-      "    - Memory Management with ARC by Kyle Fuller.\n" +
-    "\n"
+      let fixture = "There are 2 articles.\n" +
+        "\n" +
+        "    - Migrating from OCUnit to XCTest by Kyle Fuller.\n" +
+        "    - Memory Management with ARC by Kyle Fuller.\n" +
+        "\n"
 
-    try expect(result) == fixture
-  }
-
-  $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()
+      try expect(result) == fixture
     }
 
-    let result = try template.render(namespace: namespace)
-    try expect(result) == "Hello World"
-  }
+    $0.it("can render a custom template tag") {
+      let templateString = "{% custom %}"
+      let template = Template(templateString: templateString)
 
-  $0.it("can render a simple custom tag") {
-    let templateString = "{% custom %}"
-    let template = Template(templateString: templateString)
+      let namespace = Namespace()
+      namespace.registerTag("custom") { parser, token in
+        return CustomNode()
+      }
 
-    let namespace = Namespace()
-    namespace.registerSimpleTag("custom") { context in
-      return "Hello World"
+      let result = try template.render(namespace: namespace)
+      try expect(result) == "Hello World"
     }
 
-    try expect(try template.render(namespace: namespace)) == "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(namespace: namespace)) == "Hello World"
+    }
   }
 }

Tests/TemplateLoader/IncludeSpec.swift

@@ -3,56 +3,58 @@ import Stencil
 import PathKit
 
 
-describe("Include") {
-  let path = Path(__FILE__) + ".." + ".." + "Tests" + "fixtures"
-  let loader = TemplateLoader(paths: [path])
+func testInclude() {
+  describe("Include") {
+    let path = Path(__FILE__) + ".." + ".." + "fixtures"
+    let loader = TemplateLoader(paths: [path])
 
-  $0.describe("parsing") {
-    $0.it("throws an error when no template is given") {
-      let tokens = [ Token.Block(value: "include") ]
-      let parser = TokenParser(tokens: tokens, namespace: Namespace())
+    $0.describe("parsing") {
+      $0.it("throws an error when no template is given") {
+        let tokens = [ Token.Block(value: "include") ]
+        let parser = TokenParser(tokens: tokens, namespace: Namespace())
 
-      let error = TemplateSyntaxError("'include' tag takes one argument, the template file to be included")
-      try expect(try parser.parse()).toThrow(error)
-    }
+        let error = TemplateSyntaxError("'include' tag takes one argument, the template file to be included")
+        try expect(try parser.parse()).toThrow(error)
+      }
 
-    $0.it("can parse a valid include block") {
-      let tokens = [ Token.Block(value: "include \"test.html\"") ]
-      let parser = TokenParser(tokens: tokens, namespace: Namespace())
+      $0.it("can parse a valid include block") {
+        let tokens = [ Token.Block(value: "include \"test.html\"") ]
+        let parser = TokenParser(tokens: tokens, namespace: Namespace())
 
-      let nodes = try parser.parse()
-      let node = nodes.first as? IncludeNode
-      try expect(nodes.count) == 1
-      try expect(node?.templateName) == Variable("\"test.html\"")
-    }
-  }
-
-  $0.describe("rendering") {
-    $0.it("throws an error when rendering without a loader") {
-      let node = IncludeNode(templateName: Variable("\"test.html\""))
-
-      do {
-        try node.render(Context())
-      } catch {
-        try expect("\(error)") == "Template loader not in context"
+        let nodes = try parser.parse()
+        let node = nodes.first as? IncludeNode
+        try expect(nodes.count) == 1
+        try expect(node?.templateName) == Variable("\"test.html\"")
       }
     }
 
-    $0.it("throws an error when it cannot find the included template") {
-      let node = IncludeNode(templateName: Variable("\"unknown.html\""))
+    $0.describe("rendering") {
+      $0.it("throws an error when rendering without a loader") {
+        let node = IncludeNode(templateName: Variable("\"test.html\""))
 
-      do {
-        try node.render(Context(dictionary: ["loader": loader]))
-      } catch {
-        try expect("\(error)".hasPrefix("'unknown.html' template not found")).to.beTrue()
+        do {
+          try node.render(Context())
+        } catch {
+          try expect("\(error)") == "Template loader not in context"
+        }
       }
-    }
 
-    $0.it("successfully renders a found included template") {
-      let node = IncludeNode(templateName: Variable("\"test.html\""))
-      let context = Context(dictionary: ["loader":loader, "target": "World"])
-      let value = try node.render(context)
-      try expect(value) == "Hello World!"
+      $0.it("throws an error when it cannot find the included template") {
+        let node = IncludeNode(templateName: Variable("\"unknown.html\""))
+
+        do {
+          try node.render(Context(dictionary: ["loader": loader]))
+        } catch {
+          try expect("\(error)".hasPrefix("'unknown.html' template not found")).to.beTrue()
+        }
+      }
+
+      $0.it("successfully renders a found included template") {
+        let node = IncludeNode(templateName: Variable("\"test.html\""))
+        let context = Context(dictionary: ["loader":loader, "target": "World"])
+        let value = try node.render(context)
+        try expect(value) == "Hello World!"
+      }
     }
   }
 }

Tests/TemplateLoader/InheritenceSpec.swift

@@ -3,13 +3,15 @@ import Stencil
 import PathKit
 
 
-describe("Inheritence") {
-  let path = Path(__FILE__) + ".." + ".." + "Tests" + "fixtures"
-  let loader = TemplateLoader(paths: [path])
+func testInheritence() {
+  describe("Inheritence") {
+    let path = Path(__FILE__) + ".." + ".." + "fixtures"
+    let loader = TemplateLoader(paths: [path])
 
-  $0.it("can inherit from another template") {
-    let context = Context(dictionary: ["loader": loader])
-    let template = loader.loadTemplate("child.html")
-    try expect(try template?.render(context)) == "Header\nChild"
+    $0.it("can inherit from another template") {
+      let context = Context(dictionary: ["loader": loader])
+      let template = loader.loadTemplate("child.html")
+      try expect(try template?.render(context)) == "Header\nChild"
+    }
   }
 }

Tests/TemplateLoaderSpec.swift

@@ -3,21 +3,23 @@ import Stencil
 import PathKit
 
 
-describe("TemplateLoader") {
-  let path = Path(__FILE__) + ".." + ".." + "Tests" + "fixtures"
-  let loader = TemplateLoader(paths: [path])
+func testTemplateLoader() {
+  describe("TemplateLoader") {
+    let path = Path(__FILE__) + ".." + ".." + "Tests" + "fixtures"
+    let loader = TemplateLoader(paths: [path])
 
-  $0.it("returns nil when a template cannot be found") {
-    try expect(loader.loadTemplate("unknown.html")).to.beNil()
-  }
+    $0.it("returns nil when a template cannot be found") {
+      try expect(loader.loadTemplate("unknown.html")).to.beNil()
+    }
 
-  $0.it("returns nil when an array of templates cannot be found") {
-    try expect(loader.loadTemplate(["unknown.html", "unknown2.html"])).to.beNil()
-  }
+    $0.it("returns nil when an array of templates cannot be found") {
+      try expect(loader.loadTemplate(["unknown.html", "unknown2.html"])).to.beNil()
+    }
 
-  $0.it("can load a template from a file") {
-    if loader.loadTemplate("test.html") == nil {
-      throw failure("didn't find the template")
+    $0.it("can load a template from a file") {
+      if loader.loadTemplate("test.html") == nil {
+        throw failure("didn't find the template")
+      }
     }
   }
 }

Tests/TemplateSpec.swift

@@ -2,11 +2,13 @@ import Spectre
 import Stencil
 
 
-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)
-    try expect(result) == "Hello World"
+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)
+      try expect(result) == "Hello World"
+    }
   }
 }

Tests/TokenSpec.swift

@@ -2,31 +2,33 @@ import Spectre
 import Stencil
 
 
-describe("Token") {
-  $0.it("can split the contents into components") {
-    let token = Token.Text(value: "hello world")
-    let components = token.components()
+func testToken() {
+  describe("Token") {
+    $0.it("can split the contents into components") {
+      let token = Token.Text(value: "hello world")
+      let components = token.components()
 
-    try expect(components.count) == 2
-    try expect(components[0]) == "hello"
-    try expect(components[1]) == "world"
-  }
+      try expect(components.count) == 2
+      try expect(components[0]) == "hello"
+      try expect(components[1]) == "world"
+    }
 
-  $0.it("can split the contents into components with single quoted strings") {
-    let token = Token.Text(value: "hello 'kyle fuller'")
-    let components = token.components()
+    $0.it("can split the contents into components with single quoted strings") {
+      let token = Token.Text(value: "hello 'kyle fuller'")
+      let components = token.components()
 
-    try expect(components.count) == 2
-    try expect(components[0]) == "hello"
-    try expect(components[1]) == "'kyle fuller'"
-  }
+      try expect(components.count) == 2
+      try expect(components[0]) == "hello"
+      try expect(components[1]) == "'kyle fuller'"
+    }
 
-  $0.it("can split the contents into components with double quoted strings") {
-    let token = Token.Text(value: "hello \"kyle fuller\"")
-    let components = token.components()
+    $0.it("can split the contents into components with double quoted strings") {
+      let token = Token.Text(value: "hello \"kyle fuller\"")
+      let components = token.components()
 
-    try expect(components.count) == 2
-    try expect(components[0]) == "hello"
-    try expect(components[1]) == "\"kyle fuller\""
+      try expect(components.count) == 2
+      try expect(components[0]) == "hello"
+      try expect(components[1]) == "\"kyle fuller\""
+    }
   }
 }

Tests/VariableSpec.swift

@@ -3,66 +3,75 @@ import Spectre
 import Stencil
 
 
+#if os(OSX)
 @objc class Object : NSObject {
   let title = "Hello World"
 }
+#endif
 
 
-describe("Variable") {
-  let context = Context(dictionary: [
-    "name": "Kyle",
-    "contacts": ["Katie", "Carlton"],
-    "profiles": [
-      "github": "kylef",
-    ],
-    "object": Object(),
-  ])
+func testVariable() {
+  describe("Variable") {
+    let context = Context(dictionary: [
+      "name": "Kyle",
+      "contacts": ["Katie", "Carlton"],
+      "profiles": [
+        "github": "kylef",
+      ],
+    ])
 
-  $0.it("can resolve a string literal with double quotes") {
-    let variable = Variable("\"name\"")
-    let result = try variable.resolve(context) as? String
-    try expect(result) == "name"
-  }
+#if os(OSX)
+    context.push(["object": Object()])
+#endif
 
-  $0.it("can resolve a string literal with single quotes") {
-    let variable = Variable("'name'")
-    let result = try variable.resolve(context) as? String
-    try expect(result) == "name"
-  }
+    $0.it("can resolve a string literal with double quotes") {
+      let variable = Variable("\"name\"")
+      let result = try variable.resolve(context) as? String
+      try expect(result) == "name"
+    }
 
-  $0.it("can resolve a string variable") {
-    let variable = Variable("name")
-    let result = try variable.resolve(context) as? String
-    try expect(result) == "Kyle"
-  }
+    $0.it("can resolve a string literal with single quotes") {
+      let variable = Variable("'name'")
+      let result = try variable.resolve(context) as? String
+      try expect(result) == "name"
+    }
 
-  $0.it("can resolve an item from a dictionary") {
-    let variable = Variable("profiles.github")
-    let result = try variable.resolve(context) as? String
-    try expect(result) == "kylef"
-  }
+    $0.it("can resolve a string variable") {
+      let variable = Variable("name")
+      let result = try variable.resolve(context) as? String
+      try expect(result) == "Kyle"
+    }
 
-  $0.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
-    try expect(result) == "Katie"
-  }
+    $0.it("can resolve an item from a dictionary") {
+      let variable = Variable("profiles.github")
+      let result = try variable.resolve(context) as? String
+      try expect(result) == "kylef"
+    }
 
-  $0.it("can resolve the first item from an array") {
-    let variable = Variable("contacts.first")
-    let result = try variable.resolve(context) as? String
-    try expect(result) == "Katie"
-  }
+    $0.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
+      try expect(result) == "Katie"
+    }
 
-  $0.it("can resolve the last item from an array") {
-    let variable = Variable("contacts.last")
-    let result = try variable.resolve(context) as? String
-    try expect(result) == "Carlton"
-  }
+    $0.it("can resolve the first item from an array") {
+      let variable = Variable("contacts.first")
+      let result = try variable.resolve(context) as? String
+      try expect(result) == "Katie"
+    }
 
-  $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 the last item from an array") {
+      let variable = Variable("contacts.last")
+      let result = try variable.resolve(context) as? String
+      try expect(result) == "Carlton"
+    }
+
+#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"
+    }
+#endif
   }
 }

Tests/main.swift

@@ -0,0 +1,15 @@
+testContext()
+testFilter()
+testLexer()
+testToken()
+testTokenParser()
+testTemplateLoader()
+testTemplate()
+testVariable()
+testNode()
+testForNode()
+testIfNode()
+testNowNode()
+testInclude()
+testInheritence()
+testStencil()

circle.yml

@@ -1,21 +0,0 @@
-machine:
-  xcode:
-    version: "7.0"
-  environment:
-    XCODE_SCHEME: NONE
-    XCODE_PROJECT: NONE
-
-dependencies:
-  post:
-    - brew install --HEAD kylef/formulae/conche
-
-test:
-  override:
-    - conche test
-
-deployment:
-  release:
-    tag: /.*/
-    commands:
-      - pod trunk push
-