chore: Update CHANGELOG for 0.8.0

Closes #90

.gitignore

@@ -1,26 +1,3 @@
-# Xcode
-#
-build/
-*.pbxuser
-!default.pbxuser
-*.mode1v3
-!default.mode1v3
-*.mode2v3
-!default.mode2v3
-*.perspectivev3
-!default.perspectivev3
-xcuserdata
-*.xccheckout
-*.moved-aside
-DerivedData
-*.hmap
-*.ipa
-*.xcuserstate
-
-# CocoaPods
-#
-# We recommend against adding the Pods directory to your .gitignore. However
-# you should judge for yourself, the pros and cons are mentioned at:
-# http://guides.cocoapods.org/using/using-cocoapods.html#should-i-ignore-the-pods-directory-in-source-control
-#
-# Pods/
+.conche/
+.build/
+Packages/

.swift-version

@@ -0,0 +1 @@
+3.0.1

.travis.yml

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

ARCHITECTURE.md

@@ -1,175 +0,0 @@
-Stencil Architecture
-====================
-
-This document outlines the architecture of Stencil and how it works internally.
-
-Stencil uses a three-step process for rendering templates. The first step is tokenising the template into an array of Token’s. Afterwards, the array of token’s are transformed into a collection of Node’s. Once we have a collection of Node’s (objects conforming to the `Node` protocol), we then call `render(context)` on each Node instructing it to render itself inside the given context.
-
-## Token
-
-Token is an enum which has four members. These represent a piece of text, a variable, a comment or a template block. They are parsed using the `TokenParser` which takes the template as a string as input and returns an array of Token’s.
-
-### Values
-
-#### Text
-
-A text token represents a string which will be rendered in the template. For example, a text token with the string `Hello World` will be rendered as such in the output.
-
-#### Variable
-
-A variable token represents a variable inside a context. It will be evaluated and rendered in the output. It is created from the template using `{{ string }}`.
-
-#### Comment
-
-The comment token represents a comment inside the source. It is created using `{# This is a comment #}`.
-
-#### Block
-
-A block represents a template tag. It is created using `{% this is a template block %}` inside a template. The template tag in this case would be called `this`. See “Block Token” below for more information.
-
-### Parsing
-
-A template is parsed using the TokenParser into an array of Token’s. For example:
-
-```html+django
-Hello {{ name }}
-```
-
-Would be parsed into two tokens. A token representing the string, `Hello ` and a token representing the variable called `name`. So, in Swift it would be represented as follows:
-
-```swift
-let tokens = [
-  Token.Text("Hello "),
-  Token.Variable("name"),
-]
-```
-
-## Node
-
-Node is a protocol with a single method, to render it inside a context. When rendering a node, it is converted into the output string, or an error if there is a failure. Token’s are converted to Node’s using the `TokenParser` class.
-
-For some Token’s, there is a direct mapping from a Token to a Node. However block node’s do not have a 1:1 mapping.
-
-### Token Parsing
-
-#### Text Token
-
-A text token is converted directly to a `TextNode` which simply returns the text when rendered.
-
-#### Variable Token
-
-Variable Token’s are transformed directly to a `VariableNode`, which will evaluate a variable in the given template when rendered.
-
-#### Comment Token
-
-A comment token is simply omitted, a comment token will be dropped when it is converted to a Node.
-
-#### Block Token
-
-Block token’s are slightly different from the other tokens, there is no direct mapping. A block token is made up of a string representing the token. For example `now` or `for article in articles`. The `TokenParser` will pull out the first word inside the string representation and use that to look-up a parser for the block. So, in this example, the template tag names will be `now` or `for`.
-
-The template tag’s are registered with a block of code which deals with the parsing for the given tag. This allows the parser to parse a set of tokens ahead of the block tone. This is useful for control flow, such as the `for` template tag will want to parse any following tokens up until the `endblock` block token.
-
-For example:
-
-```html+django
-{% for article in articles %}
-  An Article
-{% endfor %}
-```
-
-Or as a set of tokens:
-
-```swift
-let tokens = [
-  Token.Block("for article in articles"),
-  Token.Text("  An Article")
-  Token.Block("endfor")
-]
-```
-
-Will result in a single Node (a `ForNode`) which contains the sub-node containing the text. The `ForNode` class has a property called `forNodes` which contains the text node representing the text token (`  An Article`).
-
-When the `ForNode` is rendered in a context, it will look up the variable `articles` and if it’s an array it will loop over it. Inserting the variable `article` into the context while rendered the `forNodes` for each article.
-
-### Custom Nodes
-
-There are two ways to register custom template tags. A simple way which allows you to map 1:1 a block token to a Node. You can also register a more advanced template tag which has it’s own block of code for handling parsing if you want to parse up until another token such as if you are trying to provide flow-control.
-
-The tags are registered onto the `TokenParser` which you can access from your `Template`.
-
-#### Simple Tags
-
-A simple tag is registered with a string for the tag name and a block of code which is evaluated when the block is rendered in a given context.
-
-Here’s an example. Registering a template tag called `custom` which just renders `Hello World` in the rendered template:
-
-```swift
-parser.registerSimpleTag("custom") { context in
-  return "Hello World"
-}
-```
-
-You would use it as such in a template:
-
-```html+django
-{% custom %}
-```
-
-#### Advanced Tags
-
-If you need more control or functionality than the simple tag’s above, you can use the node based API where you can provide a block of code to deal with parsing. There are a few examples of this in use over at `Node.swift` inside Stencil. There is an implementation of `if` and `for` template tags.
-
-You would register a template tag using the `registerTag` API inside a `TokenParser` which accepts a name for the tag and a block of code to handle parsing. The block of code is invoked with the parser and the current token as an argument. This allows you to use the API on `TokenParser` to parse node’s further in the token array.
-
-As an example, we’re going to create a template tag called `debug` which will optionally render nodes from `debug` up until `enddebug`. When rendering the `DebugNode`, it will only render the nodes inside if a variable called `debug` is set to `true` inside the template Context.
-
-```html+django
-{% debug %}
-  Debugging is enabled!
-{% enddebug %}
-```
-
-This will be represented by a `DebugNode` which will have a property containing all of the Node’s inside the `debug`/`enddebug` block. In the above example, this will just be a TextNode containing `  Debugging is enabled!`.
-
-When the `DebugNode` is rendered, it will determine if debug is enabled by introspecting the context and if it is enabled. We will render the nodes, otherwise just return an empty string to hide the debug output.
-
-So, our `DebugNode` would look like as following:
-
-```swift
-class DebugNode : Node {
-  let nodes:[Node]
-
-  init(nodes:[Node]) {
-    self.nodes = nodes
-  }
-
-  func render(context: Context) throws -> String {
-    // Is there a debug variable inside the context?
-    if let debug = context["debug"] as? Bool {
-      // Is debug set to true?
-      if debug {
-        // Let's render the given nodes in the context since debug is enabled.
-        return renderNodes(nodes, context)
-      }
-    }
-
-    // Debug is turned off, so let's not render anything
-    return ""
-  }
-}
-```
-
-We will need to write a parser to parse up until the `enddebug` template block and create a `DebugNode` with the nodes in-between. If there was another error form another Node inside, then we will return that error.
-
-```swift
-parser.registerTag("debug") { parser, token in
-  // Use the parser to parse every token up until the `enddebug` block.
-  let nodes = try until(["enddebug"]))
-  return DebugNode(nodes)
-}
-```
-
-## Context
-
-A Context is a structure containing any templates you would like to use in a template. It’s somewhat like a dictionary, however you can push and pop to scope variables. So that means that when iterating over a for loop, you can push a new scope into the context to store any variables local to the scope.

CHANGELOG.md

@@ -0,0 +1,156 @@
+# Stencil Changelog
+
+## 0.8.0
+
+### Breaking
+
+- It is no longer possible to create `Context` objects. Instead, you can pass a
+  dictionary directly to a `Template`s `render` method.
+
+  ```diff
+  - try template.render(Context(dictionary: ["name": "Kyle"]))
+  + try template.render(["name": "Kyle"])
+  ```
+
+- Template loader are no longer passed into a `Context`, instead you will need
+  to pass the `Loader` to an `Environment` and create a template from the
+  `Environment`.
+
+  ```diff
+  let loader = FileSystemLoader(paths: ["templates/"])
+
+  - let template = loader.loadTemplate(name: "index.html")
+  - try template.render(Context(dictionary: ["loader": loader]))
+  + let environment = Environment(loader: loader)
+  + try environment.renderTemplate(name: "index.html")
+  ```
+
+- `Loader`s will now throw a `TemplateDoesNotExist` error when a template
+  is not found.
+
+- `Namespace` has been removed and replaced by extensions. You can create an
+  extension including any custom template tags and filters. A collection of
+  extensions can be passed to an `Environment`.
+
+### Enhancements
+
+- `Environment` is a new way to load templates. You can configure an
+  environment with custom template filters, tags and loaders and then create a
+  template from an environment.
+
+  Environment also provides a convenience method to render a template directly.
+
+- `FileSystemLoader` will now ensure that template paths are within the base
+  path. Any template names that try to escape the base path will raise a
+  `SuspiciousFileOperation` error.
+
+- New `{% filter %}` tag allowing you to perform a filter across the contents
+  of a block.
+
+  ```html+django
+  {% filter lowercase %}
+    This Text Will Be Lowercased.
+  {% endfilter %}
+  ```
+
+- You can now use `{{ block.super }}` to render a super block from another `{%
+  block %}`.
+
+- `Environment` allows you to provide a custom `Template` subclass, allowing
+  new template to use a specific subclass.
+
+- If expressions may now contain filters on variables. For example
+  `{% if name|uppercase == "TEST" %}` is now supported.
+
+### Deprecations
+
+- `Template` initialisers have been deprecated in favour of using a template
+  loader such as `FileSystemLoader` inside an `Environment`.
+
+- The use of whitespace inside variable filter expression is now deprecated.
+
+  ```diff
+  - {{ name | uppercase }}
+  + {{ name|uppercase }}
+  ```
+
+### Bug Fixes
+
+- Restores compatibility with ARM based platforms such as iOS. Stencil 0.7
+  introduced compilation errors due to using the `Float80` type which is not
+  available.
+
+
+## 0.7.1
+
+### Bug Fixes
+
+- Fixes an issue where using `{% if %}` statements which use operators would
+  throw a syntax error.
+
+
+## 0.7.0
+
+### Breaking
+
+- `TemplateLoader` has been renamed to `FileSystemLoader`. The
+  `loadTemplate(s)` methods are now throwing and now take labels for the `name`
+  and `names` arguments.
+
+- Many internal classes are no longer public. Some APIs were previously
+  accessible due to earlier versions of Swift requiring the types to be public
+  to be able to test. Now we have access to `@testable` these can correctly be
+  private.
+
+- `{% ifnot %}` tag is now deprecated, please use `{% if not %}` instead.
+
+### Enhancements
+
+- Variable lookup now supports introspection of Swift types. You can now lookup
+  values of Swift structures and classes inside a Context.
+
+- If tags can now use prefix and infix operators such as `not`, `and`, `or`,
+  `==`, `!=`, `>`, `>=`, `<` and `<=`.
+
+    ```html+django
+    {% if one or two and not three %}
+    ```
+
+- You may now register custom template filters which make use of arguments.
+- There is now a `default` filter.
+
+    ```html+django
+    Hello {{ name|default:"World" }}
+    ```
+
+- There is now a `join` filter.
+
+    ```html+django
+    {{ value|join:", " }}
+    ```
+
+- `{% for %}` tag now supports filters.
+
+    ```html+django
+    {% for user in non_admins|default:admins %}
+      {{ user }}
+    {% endfor %}
+    ```
+
+### Bug Fixes
+
+- Variables (`{{ variable.5 }}`) that reference an array index at an unknown
+  index will now resolve to `nil` instead of causing a crash.
+  [#72](https://github.com/kylef/Stencil/issues/72)
+
+- Templates can now extend templates that extend other templates.
+  [#60](https://github.com/kylef/Stencil/issues/60)
+
+- If comparisons will now treat 0 and below numbers as negative.
+
+
+## 0.6.0
+
+### Enhancements
+
+- Adds support for Swift 3.0.

Package.swift

@@ -0,0 +1,11 @@
+import PackageDescription
+
+let package = Package(
+  name: "Stencil",
+  dependencies: [
+    .Package(url: "https://github.com/kylef/PathKit.git", majorVersion: 0, minor: 8),
+
+    // https://github.com/apple/swift-package-manager/pull/597
+    .Package(url: "https://github.com/kylef/Spectre.git", majorVersion: 0, minor: 7),
+  ]
+)

Podfile

@@ -1,10 +0,0 @@
-use_frameworks!
-
-target 'Stencil' do
-  podspec
-end
-
-target 'StencilTests' do
-  podspec
-end
-

Podfile.lock

@@ -1,10 +0,0 @@
-PODS:
-  - PathKit (0.5.0)
-
-DEPENDENCIES:
-  - PathKit (~> 0.5.0)
-
-SPEC CHECKSUMS:
-  PathKit: 64e70cb924d6faed9251049f5f28662855524baf
-
-COCOAPODS: 0.38.2

README.md

@@ -1,45 +1,42 @@
-Stencil
-=======
+# 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
 feel right at home with Stencil.
 
-### Example
+## Example
 
 ```html+django
 There are {{ articles.count }} articles.
 
-{% for article in articles %}
-  - {{ article.title }} by {{ article.author }}.
-{% endfor %}
+<ul>
+  {% for article in articles %}
+    <li>{{ article.title }} by {{ article.author }}</li>
+  {% endfor %}
+</ul>
 ```
 
 ```swift
-let context = Context(dictionary: [
-  "articles": [
-    [ "title": "Migrating from OCUnit to XCTest", "author": "Kyle Fuller" ],
-    [ "title": "Memory Management with ARC", "author": "Kyle Fuller" ],
-  ]
-])
+import Stencil
 
-do {
-  let template = Template(named: "template.stencil")
-  let rendered = template.render(context)
-  print(rendered)
-} catch {
-  print("Failed to render template \(error)")
+struct Article {
+  let title: String
+  let author: String
 }
-```
 
-## Installation
+let context = [
+  "articles": [
+    Article(title: "Migrating from OCUnit to XCTest", author: "Kyle Fuller"),
+    Article(title: "Memory Management with ARC", author: "Kyle Fuller"),
+  ]
+]
 
-Installation with CocoaPods is recommended.
+let environment = Environment(loader: FileSystemLoader(paths: ["templates/"])
+let rendered = try environment.renderTemplate(name: context)
 
-```ruby
-pod 'Stencil'
+print(rendered)
 ```
 
 ## Philosophy
@@ -52,134 +49,21 @@ Stencil follows the same philosophy of Django:
 > design: the template system is meant to express presentation, not program
 > logic.
 
-## Templates
+## The User Guide
 
-### Variables
+Resources for Stencil template authors to write Stencil templates:
 
-A variable can be defined in your template using the following:
+- [Language overview](http://stencil.fuller.li/en/latest/templates.html)
+- [Built-in template tags and filters](http://stencil.fuller.li/en/latest/builtins.html)
 
-```html+django
-{{ variable }}
-```
+Resources to help you integrate Stencil into a Swift project:
 
-Stencil will look up the variable inside the current variable context and
-evaluate it. When a variable contains a dot, it will try doing the
-following lookup:
-
-- Context lookup
-- Dictionary lookup
-- Array lookup (first, last, count, index)
-- Key value coding lookup
-
-For example, if `people` was an array:
-
-```html+django
-There are {{ people.count }} people, {{ people.first }} is first person.
-Followed by {{ people.1 }}.
-```
-
-### Tags
-
-Tags are a mechanism to execute a piece of code, allowing you to have
-control flow within your template.
-
-```html+django
-{% if variable %}
-  {{ variable }} was found.
-{% endif %}
-```
-
-A tag can also affect the context and define variables as follows:
-
-```html+django
-{% for item in items %}
-  {{ item }}
-{% endfor %}
-```
-
-Stencil has a couple of built-in tags which are listed below. You can also
-extend Stencil by providing your own tags.
-
-#### for
-
-A for loop allows you to iterate over an array found by variable lookup.
-
-```html+django
-{% for item in items %}
-  {{ item }}
-{% empty %}
-  There we're no items.
-{% endfor %}
-```
-
-#### if
-
-```html+django
-{% if variable %}
-  The variable was found in the current context.
-{% else %}
-  The variable was not found.
-{% endif %}
-```
-
-#### ifnot
-
-```html+django
-{% ifnot variable %}
-  The variable was NOT found in the current context.
-{% else %}
-  The variable was found.
-{% endif %}
-```
-
-#### include
-
-You can include another template using the `include` tag.
-
-```html+django
-{% include "comment.html" %}
-```
-
-The `include` tag requires a TemplateLoader to be found inside your context with the paths, or bundles used to lookup the template.
-
-```swift
-let context = Context(dictionary: [
-  "loader": TemplateLoader(bundle:[NSBundle.mainBundle()])
-])
-```
-
-#### Building custom tags
-
-You can build a custom template tag. There are a couple of APIs to allow
-you to write your own custom tags. The following is the simplest form:
-
-```swift
-template.parser.registerSimpleTag("custom") { context in
-  return "Hello World"
-}
-```
-
-When your tag is used via `{% custom %}` it will execute the registered block
-of code allowing you to modify or retrieve a value from the context. Then
-return either a string rendered in your template, or throw an error.
-
-If you want to accept arguments or to capture different tokens between two sets
-of template tags. You will need to call the `registerTag` API which accepts a
-closure to handle the parsing. You can find examples of the `now`, `if` and
-`for` tags found inside `Node.swift`.
-
-The architecture of Stencil along with how to build advanced plugins can be found in the [architecture](ARCHITECTURE.md) document.
-
-### Comments
-
-To comment out part of your template, you can use the following syntax:
-
-```html+django
-{# My comment is completely hidden #}
-```
+- [Installation](http://stencil.fuller.li/en/latest/installation.html)
+- [Getting Started](http://stencil.fuller.li/en/latest/getting-started.html)
+- [API Reference](http://stencil.fuller.li/en/latest/api.html)
+- [Custom Template Tags and Filters](http://stencil.fuller.li/en/latest/custom-template-tags-and-filters.html)
 
 ## License
 
 Stencil is licensed under the BSD license. See [LICENSE](LICENSE) for more
 info.
-

Sources/Context.swift

@@ -0,0 +1,69 @@
+/// A container for template variables.
+public class Context {
+  var dictionaries: [[String: Any?]]
+
+  public let environment: Environment
+
+  init(dictionary: [String: Any]? = nil, environment: Environment? = nil) {
+    if let dictionary = dictionary {
+      dictionaries = [dictionary]
+    } else {
+      dictionaries = []
+    }
+
+    self.environment = environment ?? Environment()
+  }
+
+  public subscript(key: String) -> Any? {
+    /// Retrieves a variable's value, starting at the current context and going upwards
+    get {
+      for dictionary in Array(dictionaries.reversed()) {
+        if let value = dictionary[key] {
+          return value
+        }
+      }
+
+      return nil
+    }
+
+    /// Set a variable in the current context, deleting the variable if it's nil
+    set(value) {
+      if let dictionary = dictionaries.popLast() {
+        var mutable_dictionary = dictionary
+        mutable_dictionary[key] = value
+        dictionaries.append(mutable_dictionary)
+      }
+    }
+  }
+
+  /// Push a new level into the Context
+  fileprivate func push(_ dictionary: [String: Any]? = nil) {
+    dictionaries.append(dictionary ?? [:])
+  }
+
+  /// Pop the last level off of the Context
+  fileprivate func pop() -> [String: Any]? {
+    return dictionaries.popLast()
+  }
+
+  /// Push a new level onto the context for the duration of the execution of the given closure
+  public func push<Result>(dictionary: [String: Any]? = nil, closure: (() throws -> Result)) rethrows -> Result {
+    push(dictionary)
+    defer { _ = pop() }
+    return try closure()
+  }
+
+  public func flatten() -> [String: Any] {
+    var accumulator: [String: Any] = [:]
+
+    for dictionary in dictionaries {
+      for (key, value) in dictionary {
+        if let value = value {
+          accumulator.updateValue(value, forKey: key)
+        }
+      }
+    }
+
+    return accumulator
+  }
+}

Sources/Environment.swift

@@ -0,0 +1,38 @@
+public struct Environment {
+  public let templateClass: Template.Type
+  public let extensions: [Extension]
+
+  public var loader: Loader?
+
+  public init(loader: Loader? = nil, extensions: [Extension]? = nil, templateClass: Template.Type = Template.self) {
+    self.templateClass = templateClass
+    self.loader = loader
+    self.extensions = (extensions ?? []) + [DefaultExtension()]
+  }
+
+  public func loadTemplate(name: String) throws -> Template {
+    if let loader = loader {
+      return try loader.loadTemplate(name: name, environment: self)
+    } else {
+      throw TemplateDoesNotExist(templateNames: [name], loader: nil)
+    }
+  }
+
+  public func loadTemplate(names: [String]) throws -> Template {
+    if let loader = loader {
+      return try loader.loadTemplate(names: names, environment: self)
+    } else {
+      throw TemplateDoesNotExist(templateNames: names, loader: nil)
+    }
+  }
+
+  public func renderTemplate(name: String, context: [String: Any]? = nil) throws -> String {
+    let template = try loadTemplate(name: name)
+    return try template.render(context)
+  }
+
+  public func renderTemplate(string: String, context: [String: Any]? = nil) throws -> String {
+    let template = templateClass.init(templateString: string, environment: self)
+    return try template.render(context)
+  }
+}

Sources/Errors.swift

@@ -0,0 +1,19 @@
+public class TemplateDoesNotExist: Error, CustomStringConvertible {
+  let templateNames: [String]
+  let loader: Loader?
+
+  public init(templateNames: [String], loader: Loader? = nil) {
+    self.templateNames = templateNames
+    self.loader = loader
+  }
+
+  public var description: String {
+    let templates = templateNames.joined(separator: ", ")
+
+    if let loader = loader {
+      return "Template named `\(templates)` does not exist in loader \(loader)"
+    }
+
+    return "Template named `\(templates)` does not exist. No loaders found"
+  }
+}

Sources/Expression.swift

@@ -0,0 +1,300 @@
+protocol Expression: CustomStringConvertible {
+  func evaluate(context: Context) throws -> Bool
+}
+
+
+protocol InfixOperator: Expression {
+  init(lhs: Expression, rhs: Expression)
+}
+
+
+protocol PrefixOperator: Expression {
+  init(expression: Expression)
+}
+
+
+final class StaticExpression: Expression, CustomStringConvertible {
+  let value: Bool
+
+  init(value: Bool) {
+    self.value = value
+  }
+
+  func evaluate(context: Context) throws -> Bool {
+    return value
+  }
+
+  var description: String {
+    return "\(value)"
+  }
+}
+
+
+final class VariableExpression: Expression, CustomStringConvertible {
+  let variable: Resolvable
+
+  init(variable: Resolvable) {
+    self.variable = variable
+  }
+
+  var description: String {
+    return "(variable: \(variable))"
+  }
+
+  /// Resolves a variable in the given context as boolean
+  func resolve(context: Context, variable: Resolvable) throws -> Bool {
+    let result = try variable.resolve(context)
+    var truthy = false
+
+    if let result = result as? [Any] {
+      truthy = !result.isEmpty
+    } else if let result = result as? [String:Any] {
+      truthy = !result.isEmpty
+    } else if let result = result as? Bool {
+      truthy = result
+    } else if let result = result as? String {
+      truthy = !result.isEmpty
+    } else if let value = result, let result = toNumber(value: value) {
+      truthy = result > 0
+    } else if result != nil {
+      truthy = true
+    }
+
+    return truthy
+  }
+
+  func evaluate(context: Context) throws -> Bool {
+    return try resolve(context: context, variable: variable)
+  }
+}
+
+
+final class NotExpression: Expression, PrefixOperator, CustomStringConvertible {
+  let expression: Expression
+
+  init(expression: Expression) {
+    self.expression = expression
+  }
+
+  var description: String {
+    return "not \(expression)"
+  }
+
+  func evaluate(context: Context) throws -> Bool {
+    return try !expression.evaluate(context: context)
+  }
+}
+
+
+final class OrExpression: Expression, InfixOperator, CustomStringConvertible {
+  let lhs: Expression
+  let rhs: Expression
+
+  init(lhs: Expression, rhs: Expression) {
+    self.lhs = lhs
+    self.rhs = rhs
+  }
+
+  var description: String {
+    return "(\(lhs) or \(rhs))"
+  }
+
+  func evaluate(context: Context) throws -> Bool {
+    let lhs = try self.lhs.evaluate(context: context)
+    if lhs {
+      return lhs
+    }
+
+    return try rhs.evaluate(context: context)
+  }
+}
+
+
+final class AndExpression: Expression, InfixOperator, CustomStringConvertible {
+  let lhs: Expression
+  let rhs: Expression
+
+  init(lhs: Expression, rhs: Expression) {
+    self.lhs = lhs
+    self.rhs = rhs
+  }
+
+  var description: String {
+    return "(\(lhs) and \(rhs))"
+  }
+
+  func evaluate(context: Context) throws -> Bool {
+    let lhs = try self.lhs.evaluate(context: context)
+    if !lhs {
+      return lhs
+    }
+
+    return try rhs.evaluate(context: context)
+  }
+}
+
+
+class EqualityExpression: Expression, InfixOperator, CustomStringConvertible {
+  let lhs: Expression
+  let rhs: Expression
+
+  required init(lhs: Expression, rhs: Expression) {
+    self.lhs = lhs
+    self.rhs = rhs
+  }
+
+  var description: String {
+    return "(\(lhs) == \(rhs))"
+  }
+
+  func evaluate(context: Context) throws -> Bool {
+    if let lhs = lhs as? VariableExpression, let rhs = rhs as? VariableExpression {
+      let lhsValue = try lhs.variable.resolve(context)
+      let rhsValue = try rhs.variable.resolve(context)
+
+      if let lhs = lhsValue, let rhs = rhsValue {
+        if let lhs = toNumber(value: lhs), let rhs = toNumber(value: rhs) {
+          return lhs == rhs
+        } else if let lhs = lhsValue as? String, let rhs = rhsValue as? String {
+          return lhs == rhs
+        } else if let lhs = lhsValue as? Bool, let rhs = rhsValue as? Bool {
+          return lhs == rhs
+        }
+      } else if lhsValue == nil && rhsValue == nil {
+        return true
+      }
+    }
+
+    return false
+  }
+}
+
+
+class NumericExpression: Expression, InfixOperator, CustomStringConvertible {
+  let lhs: Expression
+  let rhs: Expression
+
+  required init(lhs: Expression, rhs: Expression) {
+    self.lhs = lhs
+    self.rhs = rhs
+  }
+
+  var description: String {
+    return "(\(lhs) \(op) \(rhs))"
+  }
+
+  func evaluate(context: Context) throws -> Bool {
+    if let lhs = lhs as? VariableExpression, let rhs = rhs as? VariableExpression {
+      let lhsValue = try lhs.variable.resolve(context)
+      let rhsValue = try rhs.variable.resolve(context)
+
+      if let lhs = lhsValue, let rhs = rhsValue {
+        if let lhs = toNumber(value: lhs), let rhs = toNumber(value: rhs) {
+          return compare(lhs: lhs, rhs: rhs)
+        }
+      }
+    }
+
+    return false
+  }
+
+  var op: String {
+    return ""
+  }
+
+  func compare(lhs: Number, rhs: Number) -> Bool {
+    return false
+  }
+}
+
+
+class MoreThanExpression: NumericExpression {
+  override var op: String {
+    return ">"
+  }
+
+  override func compare(lhs: Number, rhs: Number) -> Bool {
+    return lhs > rhs
+  }
+}
+
+
+class MoreThanEqualExpression: NumericExpression {
+  override var op: String {
+    return ">="
+  }
+
+  override func compare(lhs: Number, rhs: Number) -> Bool {
+    return lhs >= rhs
+  }
+}
+
+
+class LessThanExpression: NumericExpression {
+  override var op: String {
+    return "<"
+  }
+
+  override func compare(lhs: Number, rhs: Number) -> Bool {
+    return lhs < rhs
+  }
+}
+
+
+class LessThanEqualExpression: NumericExpression {
+  override var op: String {
+    return "<="
+  }
+
+  override func compare(lhs: Number, rhs: Number) -> Bool {
+    return lhs <= rhs
+  }
+}
+
+
+class InequalityExpression: EqualityExpression {
+  override var description: String {
+    return "(\(lhs) != \(rhs))"
+  }
+
+  override func evaluate(context: Context) throws -> Bool {
+    return try !super.evaluate(context: context)
+  }
+}
+
+
+func toNumber(value: Any) -> Number? {
+    if let value = value as? Float {
+        return Number(value)
+    } else if let value = value as? Double {
+        return Number(value)
+    } else if let value = value as? UInt {
+        return Number(value)
+    } else if let value = value as? Int {
+        return Number(value)
+    } else if let value = value as? Int8 {
+        return Number(value)
+    } else if let value = value as? Int16 {
+        return Number(value)
+    } else if let value = value as? Int32 {
+        return Number(value)
+    } else if let value = value as? Int64 {
+        return Number(value)
+    } else if let value = value as? UInt8 {
+        return Number(value)
+    } else if let value = value as? UInt16 {
+        return Number(value)
+    } else if let value = value as? UInt32 {
+        return Number(value)
+    } else if let value = value as? UInt64 {
+        return Number(value)
+    } else if let value = value as? Number {
+        return value
+    } else if let value = value as? Float64 {
+        return Number(value)
+    } else if let value = value as? Float32 {
+        return Number(value)
+    }
+
+    return nil
+}

Sources/Extension.swift

@@ -0,0 +1,84 @@
+open class Extension {
+  typealias TagParser = (TokenParser, Token) throws -> NodeType
+  var tags = [String: TagParser]()
+
+  var filters = [String: Filter]()
+
+  public init() {
+  }
+
+  /// Registers a new template tag
+  public func registerTag(_ name: String, parser: @escaping (TokenParser, Token) throws -> NodeType) {
+    tags[name] = parser
+  }
+
+  /// Registers a simple template tag with a name and a handler
+  public func registerSimpleTag(_ name: String, handler: @escaping (Context) throws -> String) {
+    registerTag(name, parser: { parser, token in
+      return SimpleNode(handler: handler)
+    })
+  }
+
+  /// Registers a template filter with the given name
+  public func registerFilter(_ name: String, filter: @escaping (Any?) throws -> Any?) {
+    filters[name] = .simple(filter)
+  }
+
+  /// Registers a template filter with the given name
+  public func registerFilter(_ name: String, filter: @escaping (Any?, [Any?]) throws -> Any?) {
+    filters[name] = .arguments(filter)
+  }
+}
+
+
+class DefaultExtension: Extension {
+  override init() {
+    super.init()
+    registerDefaultTags()
+    registerDefaultFilters()
+  }
+
+  fileprivate func registerDefaultTags() {
+    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)
+    registerTag("filter", parser: FilterNode.parse)
+  }
+
+  fileprivate func registerDefaultFilters() {
+    registerFilter("default", filter: defaultFilter)
+    registerFilter("capitalize", filter: capitalise)
+    registerFilter("uppercase", filter: uppercase)
+    registerFilter("lowercase", filter: lowercase)
+    registerFilter("join", filter: joinFilter)
+  }
+}
+
+
+protocol FilterType {
+  func invoke(value: Any?, arguments: [Any?]) throws -> Any?
+}
+
+enum Filter: FilterType {
+  case simple(((Any?) throws -> Any?))
+  case arguments(((Any?, [Any?]) throws -> Any?))
+
+  func invoke(value: Any?, arguments: [Any?]) throws -> Any? {
+    switch self {
+    case let .simple(filter):
+      if !arguments.isEmpty {
+        throw TemplateSyntaxError("cannot invoke filter with an argument")
+      }
+
+      return try filter(value)
+    case let .arguments(filter):
+      return try filter(value, arguments)
+    }
+  }
+}

Sources/FilterTag.swift

@@ -0,0 +1,35 @@
+class FilterNode : NodeType {
+  let resolvable: Resolvable
+  let nodes: [NodeType]
+
+  class func parse(_ parser: TokenParser, token: Token) throws -> NodeType {
+    let bits = token.components()
+
+    guard bits.count == 2 else {
+      throw TemplateSyntaxError("'filter' tag takes one argument, the filter expression")
+    }
+
+    let blocks = try parser.parse(until(["endfilter"]))
+
+    guard parser.nextToken() != nil else {
+      throw TemplateSyntaxError("`endfilter` was not found.")
+    }
+
+    let resolvable = try parser.compileFilter("filter_value|\(bits[1])")
+    return FilterNode(nodes: blocks, resolvable: resolvable)
+  }
+
+  init(nodes: [NodeType], resolvable: Resolvable) {
+    self.nodes = nodes
+    self.resolvable = resolvable
+  }
+
+  func render(_ context: Context) throws -> String {
+    let value = try renderNodes(nodes, context)
+
+    return try context.push(dictionary: ["filter_value": value]) {
+      return try VariableNode(variable: resolvable).render(context)
+    }
+  }
+}
+

Sources/Filters.swift

@@ -0,0 +1,41 @@
+func capitalise(_ value: Any?) -> Any? {
+  return stringify(value).capitalized
+}
+
+func uppercase(_ value: Any?) -> Any? {
+  return stringify(value).uppercased()
+}
+
+func lowercase(_ value: Any?) -> Any? {
+  return stringify(value).lowercased()
+}
+
+func defaultFilter(value: Any?, arguments: [Any?]) -> Any? {
+  if let value = value {
+    return value
+  }
+
+  for argument in arguments {
+    if let argument = argument {
+      return argument
+    }
+  }
+
+  return nil
+}
+
+func joinFilter(value: Any?, arguments: [Any?]) throws -> Any? {
+  guard arguments.count < 2 else {
+    throw TemplateSyntaxError("'join' filter takes a single argument")
+  }
+
+  let separator = stringify(arguments.first ?? "")
+
+  if let value = value as? [Any] {
+    return value
+      .map(stringify)
+      .joined(separator: separator)
+  }
+
+  return value
+}

Sources/ForTag.swift

@@ -0,0 +1,63 @@
+class ForNode : NodeType {
+  let resolvable: Resolvable
+  let loopVariable:String
+  let nodes:[NodeType]
+  let emptyNodes: [NodeType]
+
+  class func parse(_ parser:TokenParser, token:Token) throws -> NodeType {
+    let components = token.components()
+
+    guard components.count == 4 && components[2] == "in" else {
+      throw TemplateSyntaxError("'for' statements should use the following 'for x in y' `\(token.contents)`.")
+    }
+
+    let loopVariable = components[1]
+    let variable = components[3]
+
+    var emptyNodes = [NodeType]()
+
+    let forNodes = try parser.parse(until(["endfor", "empty"]))
+
+    guard let token = parser.nextToken() else {
+      throw TemplateSyntaxError("`endfor` was not found.")
+    }
+
+    if token.contents == "empty" {
+      emptyNodes = try parser.parse(until(["endfor"]))
+      _ = parser.nextToken()
+    }
+
+    let filter = try parser.compileFilter(variable)
+    return ForNode(resolvable: filter, loopVariable: loopVariable, nodes: forNodes, emptyNodes:emptyNodes)
+  }
+
+  init(resolvable: Resolvable, loopVariable:String, nodes:[NodeType], emptyNodes:[NodeType]) {
+    self.resolvable = resolvable
+    self.loopVariable = loopVariable
+    self.nodes = nodes
+    self.emptyNodes = emptyNodes
+  }
+
+  func render(_ context: Context) throws -> String {
+    let values = try resolvable.resolve(context)
+
+    if let values = values as? [Any] , values.count > 0 {
+      let count = values.count
+      return try values.enumerated().map { index, item in
+        let forContext: [String: Any] = [
+          "first": index == 0,
+          "last": index == (count - 1),
+          "counter": index + 1,
+        ]
+
+        return try context.push(dictionary: [loopVariable: item, "forloop": forContext]) {
+          try renderNodes(nodes, context)
+        }
+      }.joined(separator: "")
+    }
+
+    return try context.push {
+      try renderNodes(emptyNodes, context)
+    }
+  }
+}

Sources/IfTag.swift

@@ -0,0 +1,230 @@
+enum Operator {
+  case infix(String, Int, InfixOperator.Type)
+  case prefix(String, Int, PrefixOperator.Type)
+
+  var name: String {
+    switch self {
+    case .infix(let name, _, _):
+      return name
+    case .prefix(let name, _, _):
+      return name
+    }
+  }
+}
+
+
+let operators: [Operator] = [
+  .infix("or", 6, OrExpression.self),
+  .infix("and", 7, AndExpression.self),
+  .prefix("not", 8, NotExpression.self),
+  .infix("==", 10, EqualityExpression.self),
+  .infix("!=", 10, InequalityExpression.self),
+  .infix(">", 10, MoreThanExpression.self),
+  .infix(">=", 10, MoreThanEqualExpression.self),
+  .infix("<", 10, LessThanExpression.self),
+  .infix("<=", 10, LessThanEqualExpression.self),
+]
+
+
+func findOperator(name: String) -> Operator? {
+  for op in operators {
+    if op.name == name {
+      return op
+    }
+  }
+
+  return nil
+}
+
+
+enum IfToken {
+  case infix(name: String, bindingPower: Int, op: InfixOperator.Type)
+  case prefix(name: String, bindingPower: Int, op: PrefixOperator.Type)
+  case variable(Resolvable)
+  case end
+
+  var bindingPower: Int {
+    switch self {
+    case .infix(_, let bindingPower, _):
+      return bindingPower
+    case .prefix(_, let bindingPower, _):
+      return bindingPower
+    case .variable(_):
+      return 0
+    case .end:
+        return 0
+    }
+  }
+
+  func nullDenotation(parser: IfExpressionParser) throws -> Expression {
+    switch self {
+    case .infix(let name, _, _):
+      throw TemplateSyntaxError("'if' expression error: infix operator '\(name)' doesn't have a left hand side")
+    case .prefix(_, let bindingPower, let op):
+      let expression = try parser.expression(bindingPower: bindingPower)
+      return op.init(expression: expression)
+    case .variable(let variable):
+      return VariableExpression(variable: variable)
+    case .end:
+      throw TemplateSyntaxError("'if' expression error: end")
+    }
+  }
+
+  func leftDenotation(left: Expression, parser: IfExpressionParser) throws -> Expression {
+    switch self {
+    case .infix(_, let bindingPower, let op):
+      let right = try parser.expression(bindingPower: bindingPower)
+      return op.init(lhs: left, rhs: right)
+    case .prefix(let name, _, _):
+      throw TemplateSyntaxError("'if' expression error: prefix operator '\(name)' was called with a left hand side")
+    case .variable(let variable):
+      throw TemplateSyntaxError("'if' expression error: variable '\(variable)' was called with a left hand side")
+    case .end:
+      throw TemplateSyntaxError("'if' expression error: end")
+    }
+  }
+
+  var isEnd: Bool {
+    switch self {
+    case .end:
+      return true
+    default:
+      return false
+    }
+  }
+}
+
+
+final class IfExpressionParser {
+  let tokens: [IfToken]
+  var position: Int = 0
+
+  init(components: [String], tokenParser: TokenParser) throws {
+    self.tokens = try components.map { component in
+      if let op = findOperator(name: component) {
+        switch op {
+        case .infix(let name, let bindingPower, let cls):
+          return .infix(name: name, bindingPower: bindingPower, op: cls)
+        case .prefix(let name, let bindingPower, let cls):
+          return .prefix(name: name, bindingPower: bindingPower, op: cls)
+        }
+      }
+
+      return .variable(try tokenParser.compileFilter(component))
+    }
+  }
+
+  var currentToken: IfToken {
+    if tokens.count > position {
+      return tokens[position]
+    }
+
+    return .end
+  }
+
+  var nextToken: IfToken {
+    position += 1
+    return currentToken
+  }
+
+  func parse() throws -> Expression {
+    let expression = try self.expression()
+
+    if !currentToken.isEnd {
+      throw TemplateSyntaxError("'if' expression error: dangling token")
+    }
+
+    return expression
+  }
+
+  func expression(bindingPower: Int = 0) throws -> Expression {
+    var token = currentToken
+    position += 1
+
+    var left = try token.nullDenotation(parser: self)
+
+    while bindingPower < currentToken.bindingPower {
+      token = currentToken
+      position += 1
+      left = try token.leftDenotation(left: left, parser: self)
+    }
+
+    return left
+  }
+}
+
+
+func parseExpression(components: [String], tokenParser: TokenParser) throws -> Expression {
+  let parser = try IfExpressionParser(components: components, tokenParser: tokenParser)
+  return try parser.parse()
+}
+
+
+class IfNode : NodeType {
+  let expression: Expression
+  let trueNodes: [NodeType]
+  let falseNodes: [NodeType]
+
+  class func parse(_ parser: TokenParser, token: Token) throws -> NodeType {
+    var components = token.components()
+    components.removeFirst()
+    var trueNodes = [NodeType]()
+    var falseNodes = [NodeType]()
+
+    trueNodes = try parser.parse(until(["endif", "else"]))
+
+    guard let token = parser.nextToken() else {
+      throw TemplateSyntaxError("`endif` was not found.")
+    }
+
+    if token.contents == "else" {
+      falseNodes = try parser.parse(until(["endif"]))
+      _ = parser.nextToken()
+    }
+
+    let expression = try parseExpression(components: components, tokenParser: parser)
+    return IfNode(expression: expression, trueNodes: trueNodes, falseNodes: falseNodes)
+  }
+
+  class func parse_ifnot(_ parser: TokenParser, token: Token) throws -> NodeType {
+    var components = token.components()
+    guard components.count == 2 else {
+      throw TemplateSyntaxError("'ifnot' statements should use the following 'ifnot condition' `\(token.contents)`.")
+    }
+    components.removeFirst()
+    var trueNodes = [NodeType]()
+    var falseNodes = [NodeType]()
+
+    falseNodes = try parser.parse(until(["endif", "else"]))
+
+    guard let token = parser.nextToken() else {
+      throw TemplateSyntaxError("`endif` was not found.")
+    }
+
+    if token.contents == "else" {
+      trueNodes = try parser.parse(until(["endif"]))
+      _ = parser.nextToken()
+    }
+
+    let expression = try parseExpression(components: components, tokenParser: parser)
+    return IfNode(expression: expression, trueNodes: trueNodes, falseNodes: falseNodes)
+  }
+
+  init(expression: Expression, trueNodes: [NodeType], falseNodes: [NodeType]) {
+    self.expression = expression
+    self.trueNodes = trueNodes
+    self.falseNodes = falseNodes
+  }
+
+  func render(_ context: Context) throws -> String {
+    let truthy = try expression.evaluate(context: context)
+
+    return try context.push {
+      if truthy {
+        return try renderNodes(trueNodes, context)
+      } else {
+        return try renderNodes(falseNodes, context)
+      }
+    }
+  }
+}

Sources/Include.swift

@@ -0,0 +1,33 @@
+import PathKit
+
+
+class IncludeNode : NodeType {
+  let templateName: Variable
+
+  class func parse(_ parser: TokenParser, token: Token) throws -> NodeType {
+    let bits = token.components()
+
+    guard bits.count == 2 else {
+      throw TemplateSyntaxError("'include' tag takes one argument, the template file to be included")
+    }
+
+    return IncludeNode(templateName: Variable(bits[1]))
+  }
+
+  init(templateName: Variable) {
+    self.templateName = templateName
+  }
+
+  func render(_ context: Context) throws -> String {
+    guard let templateName = try self.templateName.resolve(context) as? String else {
+      throw TemplateSyntaxError("'\(self.templateName)' could not be resolved as a string")
+    }
+
+    let template = try context.environment.loadTemplate(name: templateName)
+
+    return try context.push {
+      return try template.render(context)
+    }
+  }
+}
+

Sources/Inheritence.swift

@@ -0,0 +1,119 @@
+class BlockContext {
+  class var contextKey: String { return "block_context" }
+
+  var blocks: [String: BlockNode]
+
+  init(blocks: [String: BlockNode]) {
+    self.blocks = blocks
+  }
+
+  func pop(_ blockName: String) -> BlockNode? {
+    return blocks.removeValue(forKey: blockName)
+  }
+}
+
+
+extension Collection {
+  func any(_ closure: (Iterator.Element) -> Bool) -> Iterator.Element? {
+    for element in self {
+      if closure(element) {
+        return element
+      }
+    }
+
+    return nil
+  }
+}
+
+
+class ExtendsNode : NodeType {
+  let templateName: Variable
+  let blocks: [String:BlockNode]
+
+  class func parse(_ parser: TokenParser, token: Token) throws -> NodeType {
+    let bits = token.components()
+
+    guard bits.count == 2 else {
+      throw TemplateSyntaxError("'extends' takes one argument, the template file to be extended")
+    }
+
+    let parsedNodes = try parser.parse()
+    guard (parsedNodes.any { $0 is ExtendsNode }) == nil else {
+      throw TemplateSyntaxError("'extends' cannot appear more than once in the same template")
+    }
+
+    let blockNodes = parsedNodes.flatMap { $0 as? BlockNode }
+
+    let nodes = blockNodes.reduce([String: BlockNode]()) { (accumulator, node) -> [String: BlockNode] in
+      var dict = accumulator
+      dict[node.name] = node
+      return dict
+    }
+
+    return ExtendsNode(templateName: Variable(bits[1]), blocks: nodes)
+  }
+
+  init(templateName: Variable, blocks: [String: BlockNode]) {
+    self.templateName = templateName
+    self.blocks = blocks
+  }
+
+  func render(_ context: Context) throws -> String {
+    guard let templateName = try self.templateName.resolve(context) as? String else {
+      throw TemplateSyntaxError("'\(self.templateName)' could not be resolved as a string")
+    }
+
+    let template = try context.environment.loadTemplate(name: templateName)
+
+    let blockContext: BlockContext
+    if let context = context[BlockContext.contextKey] as? BlockContext {
+      blockContext = context
+
+      for (key, value) in blocks {
+        if !blockContext.blocks.keys.contains(key) {
+          blockContext.blocks[key] = value
+        }
+      }
+    } else {
+      blockContext = BlockContext(blocks: blocks)
+    }
+
+    return try context.push(dictionary: [BlockContext.contextKey: blockContext]) {
+      return try template.render(context)
+    }
+  }
+}
+
+
+class BlockNode : NodeType {
+  let name: String
+  let nodes: [NodeType]
+
+  class func parse(_ parser: TokenParser, token: Token) throws -> NodeType {
+    let bits = token.components()
+
+    guard bits.count == 2 else {
+      throw TemplateSyntaxError("'block' tag takes one argument, the block name")
+    }
+
+    let blockName = bits[1]
+    let nodes = try parser.parse(until(["endblock"]))
+    _ = parser.nextToken()
+    return BlockNode(name:blockName, nodes:nodes)
+  }
+
+  init(name: String, nodes: [NodeType]) {
+    self.name = name
+    self.nodes = nodes
+  }
+
+  func render(_ context: Context) throws -> String {
+    if let blockContext = context[BlockContext.contextKey] as? BlockContext, let node = blockContext.pop(name) {
+      return try context.push(dictionary: ["block": ["super": self]]) {
+        return try node.render(context)
+      }
+    }
+
+    return try renderNodes(nodes, context)
+  }
+}

Sources/Lexer.swift

@@ -0,0 +1,152 @@
+struct Lexer {
+  let templateString: String
+
+  init(templateString: String) {
+    self.templateString = templateString
+  }
+
+  func createToken(string:String) -> Token {
+    func strip() -> String {
+      let start = string.index(string.startIndex, offsetBy: 2)
+      let end = string.index(string.endIndex, offsetBy: -2)
+      return string[start..<end].trim(character: " ")
+    }
+
+    if string.hasPrefix("{{") {
+      return .variable(value: strip())
+    } else if string.hasPrefix("{%") {
+      return .block(value: strip())
+    } else if string.hasPrefix("{#") {
+      return .comment(value: strip())
+    }
+
+    return .text(value: string)
+  }
+
+  /// Returns an array of tokens from a given template string.
+  func tokenize() -> [Token] {
+    var tokens: [Token] = []
+
+    let scanner = Scanner(templateString)
+
+    let map = [
+      "{{": "}}",
+      "{%": "%}",
+      "{#": "#}",
+    ]
+
+    while !scanner.isEmpty {
+      if let text = scanner.scan(until: ["{{", "{%", "{#"]) {
+        if !text.1.isEmpty {
+          tokens.append(createToken(string: text.1))
+        }
+
+        let end = map[text.0]!
+        let result = scanner.scan(until: end, returnUntil: true)
+        tokens.append(createToken(string: result))
+      } else {
+        tokens.append(createToken(string: scanner.content))
+        scanner.content = ""
+      }
+    }
+
+    return tokens
+  }
+}
+
+
+class Scanner {
+  var content: String
+
+  init(_ content: String) {
+    self.content = content
+  }
+
+  var isEmpty: Bool {
+    return content.isEmpty
+  }
+
+  func scan(until: String, returnUntil: Bool = false) -> String {
+    if until.isEmpty {
+      return ""
+    }
+
+    var index = content.startIndex
+    while index != content.endIndex {
+      let substring = content.substring(from: index)
+
+      if substring.hasPrefix(until) {
+        let result = content.substring(to: index)
+        content = substring
+
+        if returnUntil {
+          content = content.substring(from: until.endIndex)
+          return result + until
+        }
+
+        return result
+      }
+
+      index = content.index(after: index)
+    }
+
+    return ""
+  }
+
+  func scan(until: [String]) -> (String, String)? {
+    if until.isEmpty {
+      return nil
+    }
+
+    var index = content.startIndex
+    while index != content.endIndex {
+      let substring = content.substring(from: index)
+      for string in until {
+        if substring.hasPrefix(string) {
+          let result = content.substring(to: index)
+          content = substring
+          return (string, result)
+        }
+      }
+
+      index = content.index(after: index)
+    }
+
+    return nil
+  }
+}
+
+
+extension String {
+  func findFirstNot(character: Character) -> String.Index? {
+    var index = startIndex
+
+    while index != endIndex {
+      if character != self[index] {
+        return index
+      }
+      index = self.index(after: index)
+    }
+
+    return nil
+  }
+
+  func findLastNot(character: Character) -> String.Index? {
+    var index = self.index(before: endIndex)
+
+    while index != startIndex {
+      if character != self[index] {
+        return self.index(after: index)
+      }
+      index = self.index(before: index)
+    }
+
+    return nil
+  }
+
+  func trim(character: Character) -> String {
+    let first = findFirstNot(character: character) ?? startIndex
+    let last = findLastNot(character: character) ?? endIndex
+    return self[first..<last]
+  }
+}

Sources/Loader.swift

@@ -0,0 +1,103 @@
+import Foundation
+import PathKit
+
+
+public protocol Loader {
+  func loadTemplate(name: String, environment: Environment) throws -> Template
+  func loadTemplate(names: [String], environment: Environment) throws -> Template
+}
+
+
+extension Loader {
+  public func loadTemplate(names: [String], environment: Environment) throws -> Template {
+    for name in names {
+      do {
+        return try loadTemplate(name: name, environment: environment)
+      } catch is TemplateDoesNotExist {
+        continue
+      } catch {
+        throw error
+      }
+    }
+
+    throw TemplateDoesNotExist(templateNames: names, loader: self)
+  }
+}
+
+
+// A class for loading a template from disk
+public class FileSystemLoader: Loader, CustomStringConvertible {
+  public let paths: [Path]
+
+  public init(paths: [Path]) {
+    self.paths = paths
+  }
+
+  public init(bundle: [Bundle]) {
+    self.paths = bundle.map {
+      return Path($0.bundlePath)
+    }
+  }
+
+  public var description: String {
+    return "FileSystemLoader(\(paths))"
+  }
+
+  public func loadTemplate(name: String, environment: Environment) throws -> Template {
+    for path in paths {
+      let templatePath = try path.safeJoin(path: Path(name))
+
+      if !templatePath.exists {
+        continue
+      }
+
+      let content: String = try templatePath.read()
+      return try environment.templateClass.init(templateString: content, environment: environment, name: name)
+    }
+
+    throw TemplateDoesNotExist(templateNames: [name], loader: self)
+  }
+
+  public func loadTemplate(names: [String], environment: Environment) throws -> Template {
+    for path in paths {
+      for templateName in names {
+        let templatePath = try path.safeJoin(path: Path(templateName))
+
+        if templatePath.exists {
+          let content: String = try templatePath.read()
+          return try environment.templateClass.init(templateString: content, environment: environment, name: templateName)
+        }
+      }
+    }
+
+    throw TemplateDoesNotExist(templateNames: names, loader: self)
+  }
+}
+
+
+extension Path {
+  func safeJoin(path: Path) throws -> Path {
+    let newPath = self + path
+
+    if !newPath.absolute().description.hasPrefix(absolute().description) {
+      throw SuspiciousFileOperation(basePath: self, path: newPath)
+    }
+
+    return newPath
+  }
+}
+
+
+class SuspiciousFileOperation: Error {
+  let basePath: Path
+  let path: Path
+
+  init(basePath: Path, path: Path) {
+    self.basePath = basePath
+    self.path = path
+  }
+
+  var description: String {
+    return "Path `\(path)` is located outside of base path `\(basePath)`"
+  }
+}

Sources/Node.swift

@@ -0,0 +1,88 @@
+import Foundation
+
+
+public struct TemplateSyntaxError : Error, Equatable, CustomStringConvertible {
+  public let description:String
+
+  public init(_ description:String) {
+    self.description = description
+  }
+}
+
+
+public func ==(lhs:TemplateSyntaxError, rhs:TemplateSyntaxError) -> Bool {
+  return lhs.description == rhs.description
+}
+
+
+public protocol NodeType {
+  /// Render the node in the given context
+  func render(_ context:Context) throws -> String
+}
+
+
+/// Render the collection of nodes in the given context
+public func renderNodes(_ nodes:[NodeType], _ context:Context) throws -> String {
+  return try nodes.map { try $0.render(context) }.joined(separator: "")
+}
+
+public class SimpleNode : NodeType {
+  public let handler:(Context) throws -> String
+
+  public init(handler: @escaping (Context) throws -> String) {
+    self.handler = handler
+  }
+
+  public func render(_ context: Context) throws -> String {
+    return try handler(context)
+  }
+}
+
+
+public class TextNode : NodeType {
+  public let text:String
+
+  public init(text:String) {
+    self.text = text
+  }
+
+  public func render(_ context:Context) throws -> String {
+    return self.text
+  }
+}
+
+
+public protocol Resolvable {
+  func resolve(_ context: Context) throws -> Any?
+}
+
+
+public class VariableNode : NodeType {
+  public let variable: Resolvable
+
+  public init(variable: Resolvable) {
+    self.variable = variable
+  }
+
+  public init(variable: String) {
+    self.variable = Variable(variable)
+  }
+
+  public func render(_ context: Context) throws -> String {
+    let result = try variable.resolve(context)
+    return stringify(result)
+  }
+}
+
+
+func stringify(_ result: Any?) -> String {
+  if let result = result as? String {
+    return result
+  } else if let result = result as? CustomStringConvertible {
+    return result.description
+  } else if let result = result as? NSObject {
+    return result.description
+  }
+
+  return ""
+}

Sources/NowTag.swift

@@ -0,0 +1,43 @@
+#if !os(Linux)
+import Foundation
+
+
+class NowNode : NodeType {
+  let format:Variable
+
+  class func parse(_ parser:TokenParser, token:Token) throws -> NodeType {
+    var format:Variable?
+
+    let components = token.components()
+    guard components.count <= 2 else {
+      throw TemplateSyntaxError("'now' tags may only have one argument: the format string `\(token.contents)`.")
+    }
+    if components.count == 2 {
+      format = Variable(components[1])
+    }
+
+    return NowNode(format:format)
+  }
+
+  init(format:Variable?) {
+    self.format = format ?? Variable("\"yyyy-MM-dd 'at' HH:mm\"")
+  }
+
+  func render(_ context: Context) throws -> String {
+    let date = Date()
+    let format = try self.format.resolve(context)
+    var formatter:DateFormatter?
+
+    if let format = format as? DateFormatter {
+      formatter = format
+    } else if let format = format as? String {
+      formatter = DateFormatter()
+      formatter!.dateFormat = format
+    } else {
+      return ""
+    }
+
+    return formatter!.string(from: date)
+  }
+}
+#endif

Sources/Parser.swift

@@ -0,0 +1,98 @@
+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
+  }
+}
+
+
+/// A class for parsing an array of tokens and converts them into a collection of Node's
+public class TokenParser {
+  public typealias TagParser = (TokenParser, Token) throws -> NodeType
+
+  fileprivate var tokens: [Token]
+  fileprivate let environment: Environment
+
+  public init(tokens: [Token], environment: Environment) {
+    self.tokens = tokens
+    self.environment = environment
+  }
+
+  /// Parse the given tokens into nodes
+  public func parse() throws -> [NodeType] {
+    return try parse(nil)
+  }
+
+  public func parse(_ parse_until:((_ parser:TokenParser, _ token:Token) -> (Bool))?) throws -> [NodeType] {
+    var nodes = [NodeType]()
+
+    while tokens.count > 0 {
+      let token = nextToken()!
+
+      switch token {
+      case .text(let text):
+        nodes.append(TextNode(text: text))
+      case .variable:
+        nodes.append(VariableNode(variable: try compileFilter(token.contents)))
+      case .block:
+        if let parse_until = parse_until , parse_until(self, token) {
+          prependToken(token)
+          return nodes
+        }
+
+        if let tag = token.components().first {
+          let parser = try findTag(name: tag)
+          nodes.append(try parser(self, token))
+        }
+      case .comment:
+        continue
+      }
+    }
+
+    return nodes
+  }
+
+  public func nextToken() -> Token? {
+    if tokens.count > 0 {
+      return tokens.remove(at: 0)
+    }
+
+    return nil
+  }
+
+  public func prependToken(_ token:Token) {
+    tokens.insert(token, at: 0)
+  }
+
+  func findTag(name: String) throws -> Extension.TagParser {
+    for ext in environment.extensions {
+      if let filter = ext.tags[name] {
+        return filter
+      }
+    }
+
+    throw TemplateSyntaxError("Unknown template tag '\(name)'")
+  }
+
+  func findFilter(_ name: String) throws -> FilterType {
+    for ext in environment.extensions {
+      if let filter = ext.filters[name] {
+        return filter
+      }
+    }
+
+    throw TemplateSyntaxError("Unknown filter '\(name)'")
+  }
+
+  public func compileFilter(_ token: String) throws -> Resolvable {
+    return try FilterExpression(token: token, parser: self)
+  }
+
+}

Sources/Template.swift

@@ -0,0 +1,77 @@
+import Foundation
+import PathKit
+
+#if os(Linux)
+let NSFileNoSuchFileError = 4
+#endif
+
+/// A class representing a template
+open class Template: ExpressibleByStringLiteral {
+  let environment: Environment
+  let tokens: [Token]
+
+  /// The name of the loaded Template if the Template was loaded from a Loader
+  public let name: String?
+
+  /// Create a template with a template string
+  public required init(templateString: String, environment: Environment? = nil, name: String? = nil) {
+    self.environment = environment ?? Environment()
+    self.name = name
+
+    let lexer = Lexer(templateString: templateString)
+    tokens = lexer.tokenize()
+  }
+
+  /// Create a template with the given name inside the given bundle
+  @available(*, deprecated, message: "Use Environment/FileSystemLoader instead")
+  public convenience init(named:String, inBundle bundle:Bundle? = nil) throws {
+    let useBundle = bundle ??  Bundle.main
+    guard let url = useBundle.url(forResource: named, withExtension: nil) else {
+      throw NSError(domain: NSCocoaErrorDomain, code: NSFileNoSuchFileError, userInfo: nil)
+    }
+
+    try self.init(URL:url)
+  }
+
+  /// Create a template with a file found at the given URL
+  @available(*, deprecated, message: "Use Environment/FileSystemLoader instead")
+  public convenience init(URL:Foundation.URL) throws {
+    try self.init(path: Path(URL.path))
+  }
+
+  /// Create a template with a file found at the given path
+  @available(*, deprecated, message: "Use Environment/FileSystemLoader instead")
+  public convenience init(path: Path, environment: Environment? = nil, name: String? = nil) throws {
+    self.init(templateString: try path.read(), environment: environment, name: name)
+  }
+
+  // MARK: ExpressibleByStringLiteral
+
+  // Create a templaVte with a template string literal
+  public convenience required init(stringLiteral value: String) {
+    self.init(templateString: value)
+  }
+
+  // Create a template with a template string literal
+  public convenience required init(extendedGraphemeClusterLiteral value: StringLiteralType) {
+    self.init(stringLiteral: value)
+  }
+
+  // Create a template with a template string literal
+  public convenience required init(unicodeScalarLiteral value: StringLiteralType) {
+    self.init(stringLiteral: value)
+  }
+
+  /// Render the given template with a context
+  func render(_ context: Context) throws -> String {
+    let context = context
+    let parser = TokenParser(tokens: tokens, environment: context.environment)
+    let nodes = try parser.parse()
+    return try renderNodes(nodes, context)
+  }
+
+  /// Render the given template
+  open func render(_ dictionary: [String: Any]? = nil) throws -> String {
+    return try render(Context(dictionary: dictionary, environment: environment))
+  }
+}

Sources/Tokenizer.swift

@@ -0,0 +1,95 @@
+import Foundation
+
+
+extension String {
+  /// Split a string by a separator leaving quoted phrases together
+  func smartSplit(separator: Character = " ") -> [String] {
+    var word = ""
+    var components: [String] = []
+    var separate: Character = separator
+
+    for character in self.characters {
+      if character == separate {
+        if separate != separator {
+          word.append(separate)
+        }
+
+        if !word.isEmpty {
+          components.append(word)
+          word = ""
+        }
+
+        separate = separator
+      } else {
+        if separate == separator && (character == "'" || character == "\"") {
+          separate = character
+        }
+        word.append(character)
+      }
+    }
+
+    if !word.isEmpty {
+      components.append(word)
+    }
+
+    return components
+  }
+}
+
+
+public enum Token : Equatable {
+  /// A token representing a piece of text.
+  case text(value: String)
+
+  /// A token representing a variable.
+  case variable(value: String)
+
+  /// A token representing a comment.
+  case comment(value: String)
+
+  /// A token representing a template block.
+  case block(value: String)
+
+  /// Returns the underlying value as an array seperated by spaces
+  public func components() -> [String] {
+    switch self {
+    case .block(let value):
+      return value.smartSplit()
+    case .variable(let value):
+      return value.smartSplit()
+    case .text(let value):
+      return value.smartSplit()
+    case .comment(let value):
+      return value.smartSplit()
+    }
+  }
+
+  public var contents: String {
+    switch self {
+    case .block(let value):
+      return value
+    case .variable(let value):
+      return value
+    case .text(let value):
+      return value
+    case .comment(let value):
+      return value
+    }
+  }
+}
+
+
+public func == (lhs: Token, rhs: Token) -> Bool {
+  switch (lhs, rhs) {
+  case (.text(let lhsValue), .text(let rhsValue)):
+    return lhsValue == rhsValue
+  case (.variable(let lhsValue), .variable(let rhsValue)):
+    return lhsValue == rhsValue
+  case (.block(let lhsValue), .block(let rhsValue)):
+    return lhsValue == rhsValue
+  case (.comment(let lhsValue), .comment(let rhsValue)):
+    return lhsValue == rhsValue
+  default:
+    return false
+  }
+}

Sources/Variable.swift

@@ -0,0 +1,173 @@
+import Foundation
+
+
+typealias Number = Float
+
+
+class FilterExpression : Resolvable {
+  let filters: [(FilterType, [Variable])]
+  let variable: Variable
+
+  init(token: String, parser: TokenParser) throws {
+    let bits = token.characters.split(separator: "|").map({ String($0).trim(character: " ") })
+    if bits.isEmpty {
+      filters = []
+      variable = Variable("")
+      throw TemplateSyntaxError("Variable tags must include at least 1 argument")
+    }
+
+    variable = Variable(bits[0])
+    let filterBits = bits[bits.indices.suffix(from: 1)]
+
+    do {
+      filters = try filterBits.map {
+        let (name, arguments) = parseFilterComponents(token: $0)
+        let filter = try parser.findFilter(name)
+        return (filter, arguments)
+      }
+    } catch {
+      filters = []
+      throw error
+    }
+  }
+
+  func resolve(_ context: Context) throws -> Any? {
+    let result = try variable.resolve(context)
+
+    return try filters.reduce(result) { x, y in
+      let arguments = try y.1.map { try $0.resolve(context) }
+      return try y.0.invoke(value: x, arguments: arguments)
+    }
+  }
+}
+
+/// A structure used to represent a template variable, and to resolve it in a given context.
+public struct Variable : Equatable, Resolvable {
+  public let variable: String
+
+  /// Create a variable with a string representing the variable
+  public init(_ variable: String) {
+    self.variable = variable
+  }
+
+  fileprivate func lookup() -> [String] {
+    return variable.characters.split(separator: ".").map(String.init)
+  }
+
+  /// Resolve the variable in the given context
+  public func resolve(_ context: Context) throws -> Any? {
+    var current: Any? = context
+
+    if (variable.hasPrefix("'") && variable.hasSuffix("'")) || (variable.hasPrefix("\"") && variable.hasSuffix("\"")) {
+      // String literal
+      return variable[variable.characters.index(after: variable.startIndex) ..< variable.characters.index(before: variable.endIndex)]
+    }
+
+    if let number = Number(variable) {
+      // Number literal
+      return number
+    }
+
+    for bit in lookup() {
+      current = normalize(current)
+
+      if let context = current as? Context {
+        current = context[bit]
+      } else if let dictionary = current as? [String: Any] {
+        current = dictionary[bit]
+      } else if let array = current as? [Any] {
+        if let index = Int(bit) {
+          if index >= 0 && index < array.count {
+            current = array[index]
+          } else {
+            current = nil
+          }
+        } else if bit == "first" {
+          current = array.first
+        } else if bit == "last" {
+          current = array.last
+        } else if bit == "count" {
+          current = array.count
+        }
+      } else if let object = current as? NSObject {  // NSKeyValueCoding
+#if os(Linux)
+        return nil
+#else
+        current = object.value(forKey: bit)
+#endif
+      } else if let value = current {
+        let mirror = Mirror(reflecting: value)
+        current = mirror.descendant(bit)
+
+        if current == nil {
+          return nil
+        }
+      } else {
+        return nil
+      }
+    }
+
+    if let resolvable = current as? Resolvable {
+      current = try resolvable.resolve(context)
+    } else if let node = current as? NodeType {
+      current = try node.render(context)
+    }
+
+    return normalize(current)
+  }
+}
+
+public func ==(lhs: Variable, rhs: Variable) -> Bool {
+  return lhs.variable == rhs.variable
+}
+
+
+func normalize(_ current: Any?) -> Any? {
+  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
+  }
+}
+
+func parseFilterComponents(token: String) -> (String, [Variable]) {
+  var components = token.smartSplit(separator: ":")
+  let name = components.removeFirst()
+  let variables = components
+    .joined(separator: ":")
+    .smartSplit(separator: ",")
+    .map { Variable($0) }
+  return (name, variables)
+}

Stencil.podspec

@@ -1,16 +0,0 @@
-Pod::Spec.new do |spec|
-  spec.name = 'Stencil'
-  spec.version = '0.3.0'
-  spec.summary = 'Stencil is a simple and powerful template language for Swift.'
-  spec.homepage = 'https://github.com/kylef/Stencil'
-  spec.license = { :type => 'BSD', :file => 'LICENSE' }
-  spec.author = { 'Kyle Fuller' => 'inbox@kylefuller.co.uk' }
-  spec.social_media_url = 'http://twitter.com/kylefuller'
-  spec.source = { :git => 'https://github.com/kylef/Stencil.git', :tag => spec.version }
-  spec.source_files = 'Stencil/*.swift', 'Stencil/TemplateLoader/*.swift'
-  spec.ios.deployment_target = '8.0'
-  spec.osx.deployment_target = '10.9'
-  spec.requires_arc = true
-  spec.dependency 'PathKit', '~> 0.5.0'
-end
-

Stencil.podspec.json

@@ -0,0 +1,30 @@
+{
+  "name": "Stencil",
+  "version": "0.8.0",
+  "summary": "Stencil is a simple and powerful template language for Swift.",
+  "homepage": "https://stencil.fuller.li",
+  "license": {
+    "type": "BSD",
+    "file": "LICENSE"
+  },
+  "authors": {
+    "Kyle Fuller": "kyle@fuller.li"
+  },
+  "social_media_url": "https://twitter.com/kylefuller",
+  "source": {
+    "git": "https://github.com/kylef/Stencil.git",
+    "tag": "0.8.0"
+  },
+  "source_files": [
+    "Sources/*.swift"
+  ],
+  "platforms": {
+    "ios": "8.0",
+    "osx": "10.9",
+    "tvos": "9.0"
+  },
+  "requires_arc": true,
+  "dependencies": {
+    "PathKit": [ "~> 0.8.0" ]
+  }
+}

Stencil.xcodeproj/project.pbxproj

@@ -1,648 +0,0 @@
-// !$*UTF8*$!
-{
-	archiveVersion = 1;
-	classes = {
-	};
-	objectVersion = 46;
-	objects = {
-
-/* Begin PBXBuildFile section */
-		27A848E41B42240E004ACA13 /* Inheritence.swift in Sources */ = {isa = PBXBuildFile; fileRef = 27A848E31B42240E004ACA13 /* Inheritence.swift */; };
-		27A848E91B42242C004ACA13 /* base.html in Resources */ = {isa = PBXBuildFile; fileRef = 27A848E71B42242C004ACA13 /* base.html */; };
-		27A848EA1B42242C004ACA13 /* child.html in Resources */ = {isa = PBXBuildFile; fileRef = 27A848E81B42242C004ACA13 /* child.html */; };
-		27A848EC1B42247D004ACA13 /* InheritenceTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 27A848EB1B42247D004ACA13 /* InheritenceTests.swift */; };
-		27CE0ADE1A50BEC3004A105B /* TemplateLoader.swift in Sources */ = {isa = PBXBuildFile; fileRef = 27CE0ADD1A50BEC3004A105B /* TemplateLoader.swift */; };
-		27CE0AE01A50BF05004A105B /* TemplateLoaderTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 27CE0ADF1A50BF05004A105B /* TemplateLoaderTests.swift */; };
-		27CE0AFA1A50C963004A105B /* test.html in Resources */ = {isa = PBXBuildFile; fileRef = 27CE0AF91A50C963004A105B /* test.html */; };
-		27CE0B011A50CBD1004A105B /* Include.swift in Sources */ = {isa = PBXBuildFile; fileRef = 27CE0B001A50CBD1004A105B /* Include.swift */; };
-		27CE0B041A50CBEA004A105B /* IncludeTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 27CE0B031A50CBEA004A105B /* IncludeTests.swift */; };
-		7725B3CB19F92B4F002CF74B /* VariableTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7725B3CA19F92B4F002CF74B /* VariableTests.swift */; };
-		7725B3CD19F92B61002CF74B /* Variable.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7725B3CC19F92B61002CF74B /* Variable.swift */; };
-		7725B3CF19F94214002CF74B /* Tokenizer.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7725B3CE19F94214002CF74B /* Tokenizer.swift */; };
-		7725B3D319F9437F002CF74B /* NodeTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7725B3D219F9437F002CF74B /* NodeTests.swift */; };
-		7725B3D519F9438F002CF74B /* Node.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7725B3D419F9438F002CF74B /* Node.swift */; };
-		7725B3D719F94A43002CF74B /* Parser.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7725B3D619F94A43002CF74B /* Parser.swift */; };
-		7725B3D919F94A61002CF74B /* ParserTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7725B3D819F94A61002CF74B /* ParserTests.swift */; };
-		77EB082519F96E88001870F1 /* Template.swift in Sources */ = {isa = PBXBuildFile; fileRef = 77EB082419F96E88001870F1 /* Template.swift */; };
-		77EB082719F96E9C001870F1 /* TemplateTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 77EB082619F96E9C001870F1 /* TemplateTests.swift */; };
-		77EB082919FA85F2001870F1 /* LexerTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 77EB082819FA85F2001870F1 /* LexerTests.swift */; };
-		77EB082B19FA8600001870F1 /* Lexer.swift in Sources */ = {isa = PBXBuildFile; fileRef = 77EB082A19FA8600001870F1 /* Lexer.swift */; };
-		77FAAE5819F91E480029DC5E /* Stencil.h in Headers */ = {isa = PBXBuildFile; fileRef = 77FAAE5719F91E480029DC5E /* Stencil.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		77FAAE5E19F91E480029DC5E /* Stencil.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 77FAAE5219F91E480029DC5E /* Stencil.framework */; };
-		77FAAE6519F91E480029DC5E /* StencilTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 77FAAE6419F91E480029DC5E /* StencilTests.swift */; };
-		77FAAE6F19F920750029DC5E /* Context.swift in Sources */ = {isa = PBXBuildFile; fileRef = 77FAAE6E19F920750029DC5E /* Context.swift */; };
-		77FAAE7119F9208C0029DC5E /* ContextTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 77FAAE7019F9208C0029DC5E /* ContextTests.swift */; };
-		B47F77A0E91D074331ECA4BA /* Pods_StencilTests.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 993D1013A77A01814D8E4A04 /* Pods_StencilTests.framework */; settings = {ATTRIBUTES = (Weak, ); }; };
-		EE07225918EA237F21D8B902 /* Pods_Stencil.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 19D2CE595625A4F7A865B0BD /* Pods_Stencil.framework */; settings = {ATTRIBUTES = (Weak, ); }; };
-/* End PBXBuildFile section */
-
-/* Begin PBXContainerItemProxy section */
-		27CE0AF51A50C292004A105B /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 77FAAE4919F91E480029DC5E /* Project object */;
-			proxyType = 1;
-			remoteGlobalIDString = 77FAAE5119F91E480029DC5E;
-			remoteInfo = Stencil;
-		};
-/* End PBXContainerItemProxy section */
-
-/* Begin PBXFileReference section */
-		19D2CE595625A4F7A865B0BD /* Pods_Stencil.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = Pods_Stencil.framework; sourceTree = BUILT_PRODUCTS_DIR; };
-		1F9D5A26B78DADAECC18CA94 /* Pods-Stencil.debug.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-Stencil.debug.xcconfig"; path = "Pods/Target Support Files/Pods-Stencil/Pods-Stencil.debug.xcconfig"; sourceTree = "<group>"; };
-		27A848E31B42240E004ACA13 /* Inheritence.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Inheritence.swift; sourceTree = "<group>"; };
-		27A848E71B42242C004ACA13 /* base.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = base.html; sourceTree = "<group>"; };
-		27A848E81B42242C004ACA13 /* child.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = child.html; sourceTree = "<group>"; };
-		27A848EB1B42247D004ACA13 /* InheritenceTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = InheritenceTests.swift; sourceTree = "<group>"; };
-		27CE0ADD1A50BEC3004A105B /* TemplateLoader.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = TemplateLoader.swift; sourceTree = "<group>"; };
-		27CE0ADF1A50BF05004A105B /* TemplateLoaderTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = TemplateLoaderTests.swift; sourceTree = "<group>"; };
-		27CE0AF91A50C963004A105B /* test.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = test.html; sourceTree = "<group>"; };
-		27CE0B001A50CBD1004A105B /* Include.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Include.swift; sourceTree = "<group>"; };
-		27CE0B031A50CBEA004A105B /* IncludeTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = IncludeTests.swift; sourceTree = "<group>"; };
-		7725B3CA19F92B4F002CF74B /* VariableTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = VariableTests.swift; sourceTree = "<group>"; };
-		7725B3CC19F92B61002CF74B /* Variable.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Variable.swift; sourceTree = "<group>"; };
-		7725B3CE19F94214002CF74B /* Tokenizer.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Tokenizer.swift; sourceTree = "<group>"; };
-		7725B3D219F9437F002CF74B /* NodeTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = NodeTests.swift; sourceTree = "<group>"; };
-		7725B3D419F9438F002CF74B /* Node.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Node.swift; sourceTree = "<group>"; };
-		7725B3D619F94A43002CF74B /* Parser.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Parser.swift; sourceTree = "<group>"; };
-		7725B3D819F94A61002CF74B /* ParserTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = ParserTests.swift; sourceTree = "<group>"; };
-		77EB082419F96E88001870F1 /* Template.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Template.swift; sourceTree = "<group>"; };
-		77EB082619F96E9C001870F1 /* TemplateTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = TemplateTests.swift; sourceTree = "<group>"; };
-		77EB082819FA85F2001870F1 /* LexerTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = LexerTests.swift; sourceTree = "<group>"; };
-		77EB082A19FA8600001870F1 /* Lexer.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Lexer.swift; sourceTree = "<group>"; };
-		77FAAE5219F91E480029DC5E /* Stencil.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = Stencil.framework; sourceTree = BUILT_PRODUCTS_DIR; };
-		77FAAE5619F91E480029DC5E /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
-		77FAAE5719F91E480029DC5E /* Stencil.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = Stencil.h; sourceTree = "<group>"; };
-		77FAAE5D19F91E480029DC5E /* StencilTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = StencilTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; };
-		77FAAE6319F91E480029DC5E /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
-		77FAAE6419F91E480029DC5E /* StencilTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = StencilTests.swift; sourceTree = "<group>"; };
-		77FAAE6E19F920750029DC5E /* Context.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Context.swift; sourceTree = "<group>"; };
-		77FAAE7019F9208C0029DC5E /* ContextTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = ContextTests.swift; sourceTree = "<group>"; };
-		8E90EE157CBB4F8E96884DED /* Pods-Stencil.release.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-Stencil.release.xcconfig"; path = "Pods/Target Support Files/Pods-Stencil/Pods-Stencil.release.xcconfig"; sourceTree = "<group>"; };
-		993D1013A77A01814D8E4A04 /* Pods_StencilTests.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = Pods_StencilTests.framework; sourceTree = BUILT_PRODUCTS_DIR; };
-		D504530B9669DDF40C6890DF /* Pods-StencilTests.release.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-StencilTests.release.xcconfig"; path = "Pods/Target Support Files/Pods-StencilTests/Pods-StencilTests.release.xcconfig"; sourceTree = "<group>"; };
-		D7B326C5BB2955F522787D9B /* Pods-StencilTests.debug.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-StencilTests.debug.xcconfig"; path = "Pods/Target Support Files/Pods-StencilTests/Pods-StencilTests.debug.xcconfig"; sourceTree = "<group>"; };
-/* End PBXFileReference section */
-
-/* Begin PBXFrameworksBuildPhase section */
-		77FAAE4E19F91E480029DC5E /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				EE07225918EA237F21D8B902 /* Pods_Stencil.framework in Frameworks */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-		77FAAE5A19F91E480029DC5E /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				77FAAE5E19F91E480029DC5E /* Stencil.framework in Frameworks */,
-				B47F77A0E91D074331ECA4BA /* Pods_StencilTests.framework in Frameworks */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXFrameworksBuildPhase section */
-
-/* Begin PBXGroup section */
-		27CE0AFF1A50CBBF004A105B /* TemplateLoader */ = {
-			isa = PBXGroup;
-			children = (
-				27CE0B001A50CBD1004A105B /* Include.swift */,
-				27A848E31B42240E004ACA13 /* Inheritence.swift */,
-			);
-			path = TemplateLoader;
-			sourceTree = "<group>";
-		};
-		27CE0B021A50CBEA004A105B /* TemplateLoader */ = {
-			isa = PBXGroup;
-			children = (
-				27CE0B031A50CBEA004A105B /* IncludeTests.swift */,
-				27A848EB1B42247D004ACA13 /* InheritenceTests.swift */,
-			);
-			path = TemplateLoader;
-			sourceTree = "<group>";
-		};
-		77FAAE4819F91E480029DC5E = {
-			isa = PBXGroup;
-			children = (
-				77FAAE5419F91E480029DC5E /* Stencil */,
-				77FAAE6119F91E480029DC5E /* StencilTests */,
-				77FAAE5319F91E480029DC5E /* Products */,
-				C06534353970612CB8F9960D /* Pods */,
-				A82CB85756DE155E072D4047 /* Frameworks */,
-			);
-			indentWidth = 2;
-			sourceTree = "<group>";
-			tabWidth = 2;
-		};
-		77FAAE5319F91E480029DC5E /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				77FAAE5219F91E480029DC5E /* Stencil.framework */,
-				77FAAE5D19F91E480029DC5E /* StencilTests.xctest */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		77FAAE5419F91E480029DC5E /* Stencil */ = {
-			isa = PBXGroup;
-			children = (
-				77FAAE5719F91E480029DC5E /* Stencil.h */,
-				77FAAE6E19F920750029DC5E /* Context.swift */,
-				77EB082A19FA8600001870F1 /* Lexer.swift */,
-				7725B3D419F9438F002CF74B /* Node.swift */,
-				7725B3D619F94A43002CF74B /* Parser.swift */,
-				77EB082419F96E88001870F1 /* Template.swift */,
-				27CE0ADD1A50BEC3004A105B /* TemplateLoader.swift */,
-				7725B3CE19F94214002CF74B /* Tokenizer.swift */,
-				7725B3CC19F92B61002CF74B /* Variable.swift */,
-				27CE0AFF1A50CBBF004A105B /* TemplateLoader */,
-				77FAAE5519F91E480029DC5E /* Supporting Files */,
-			);
-			path = Stencil;
-			sourceTree = "<group>";
-		};
-		77FAAE5519F91E480029DC5E /* Supporting Files */ = {
-			isa = PBXGroup;
-			children = (
-				77FAAE5619F91E480029DC5E /* Info.plist */,
-			);
-			name = "Supporting Files";
-			sourceTree = "<group>";
-		};
-		77FAAE6119F91E480029DC5E /* StencilTests */ = {
-			isa = PBXGroup;
-			children = (
-				77FAAE6419F91E480029DC5E /* StencilTests.swift */,
-				77FAAE7019F9208C0029DC5E /* ContextTests.swift */,
-				7725B3CA19F92B4F002CF74B /* VariableTests.swift */,
-				7725B3D219F9437F002CF74B /* NodeTests.swift */,
-				7725B3D819F94A61002CF74B /* ParserTests.swift */,
-				77EB082819FA85F2001870F1 /* LexerTests.swift */,
-				77EB082619F96E9C001870F1 /* TemplateTests.swift */,
-				27CE0ADF1A50BF05004A105B /* TemplateLoaderTests.swift */,
-				27CE0B021A50CBEA004A105B /* TemplateLoader */,
-				27CE0AF91A50C963004A105B /* test.html */,
-				27A848E71B42242C004ACA13 /* base.html */,
-				27A848E81B42242C004ACA13 /* child.html */,
-				77FAAE6219F91E480029DC5E /* Supporting Files */,
-			);
-			path = StencilTests;
-			sourceTree = "<group>";
-		};
-		77FAAE6219F91E480029DC5E /* Supporting Files */ = {
-			isa = PBXGroup;
-			children = (
-				77FAAE6319F91E480029DC5E /* Info.plist */,
-			);
-			name = "Supporting Files";
-			sourceTree = "<group>";
-		};
-		A82CB85756DE155E072D4047 /* Frameworks */ = {
-			isa = PBXGroup;
-			children = (
-				19D2CE595625A4F7A865B0BD /* Pods_Stencil.framework */,
-				993D1013A77A01814D8E4A04 /* Pods_StencilTests.framework */,
-			);
-			name = Frameworks;
-			sourceTree = "<group>";
-		};
-		C06534353970612CB8F9960D /* Pods */ = {
-			isa = PBXGroup;
-			children = (
-				1F9D5A26B78DADAECC18CA94 /* Pods-Stencil.debug.xcconfig */,
-				8E90EE157CBB4F8E96884DED /* Pods-Stencil.release.xcconfig */,
-				D7B326C5BB2955F522787D9B /* Pods-StencilTests.debug.xcconfig */,
-				D504530B9669DDF40C6890DF /* Pods-StencilTests.release.xcconfig */,
-			);
-			name = Pods;
-			sourceTree = "<group>";
-		};
-/* End PBXGroup section */
-
-/* Begin PBXHeadersBuildPhase section */
-		77FAAE4F19F91E480029DC5E /* Headers */ = {
-			isa = PBXHeadersBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				77FAAE5819F91E480029DC5E /* Stencil.h in Headers */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXHeadersBuildPhase section */
-
-/* Begin PBXNativeTarget section */
-		77FAAE5119F91E480029DC5E /* Stencil */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = 77FAAE6819F91E480029DC5E /* Build configuration list for PBXNativeTarget "Stencil" */;
-			buildPhases = (
-				AFE0827734C5388F8E996172 /* Check Pods Manifest.lock */,
-				77FAAE4D19F91E480029DC5E /* Sources */,
-				77FAAE4E19F91E480029DC5E /* Frameworks */,
-				77FAAE4F19F91E480029DC5E /* Headers */,
-				77FAAE5019F91E480029DC5E /* Resources */,
-				5374160581EF83B2213B72F1 /* Copy Pods Resources */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-			);
-			name = Stencil;
-			productName = Stencil;
-			productReference = 77FAAE5219F91E480029DC5E /* Stencil.framework */;
-			productType = "com.apple.product-type.framework";
-		};
-		77FAAE5C19F91E480029DC5E /* StencilTests */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = 77FAAE6B19F91E480029DC5E /* Build configuration list for PBXNativeTarget "StencilTests" */;
-			buildPhases = (
-				C50FF01A96AD1CEACBF2E02A /* Check Pods Manifest.lock */,
-				77FAAE5919F91E480029DC5E /* Sources */,
-				77FAAE5A19F91E480029DC5E /* Frameworks */,
-				77FAAE5B19F91E480029DC5E /* Resources */,
-				138C1DDF1FB55A83668EE384 /* Embed Pods Frameworks */,
-				36A8E92EBDE6D917075028D4 /* Copy Pods Resources */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-				27CE0AF61A50C292004A105B /* PBXTargetDependency */,
-			);
-			name = StencilTests;
-			productName = StencilTests;
-			productReference = 77FAAE5D19F91E480029DC5E /* StencilTests.xctest */;
-			productType = "com.apple.product-type.bundle.unit-test";
-		};
-/* End PBXNativeTarget section */
-
-/* Begin PBXProject section */
-		77FAAE4919F91E480029DC5E /* Project object */ = {
-			isa = PBXProject;
-			attributes = {
-				LastSwiftUpdateCheck = 0700;
-				LastUpgradeCheck = 0700;
-				ORGANIZATIONNAME = Cocode;
-				TargetAttributes = {
-					77FAAE5119F91E480029DC5E = {
-						CreatedOnToolsVersion = 6.1;
-					};
-					77FAAE5C19F91E480029DC5E = {
-						CreatedOnToolsVersion = 6.1;
-					};
-				};
-			};
-			buildConfigurationList = 77FAAE4C19F91E480029DC5E /* Build configuration list for PBXProject "Stencil" */;
-			compatibilityVersion = "Xcode 3.2";
-			developmentRegion = English;
-			hasScannedForEncodings = 0;
-			knownRegions = (
-				en,
-			);
-			mainGroup = 77FAAE4819F91E480029DC5E;
-			productRefGroup = 77FAAE5319F91E480029DC5E /* Products */;
-			projectDirPath = "";
-			projectRoot = "";
-			targets = (
-				77FAAE5119F91E480029DC5E /* Stencil */,
-				77FAAE5C19F91E480029DC5E /* StencilTests */,
-			);
-		};
-/* End PBXProject section */
-
-/* Begin PBXResourcesBuildPhase section */
-		77FAAE5019F91E480029DC5E /* Resources */ = {
-			isa = PBXResourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-		77FAAE5B19F91E480029DC5E /* Resources */ = {
-			isa = PBXResourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				27CE0AFA1A50C963004A105B /* test.html in Resources */,
-				27A848EA1B42242C004ACA13 /* child.html in Resources */,
-				27A848E91B42242C004ACA13 /* base.html in Resources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXResourcesBuildPhase section */
-
-/* Begin PBXShellScriptBuildPhase section */
-		138C1DDF1FB55A83668EE384 /* Embed Pods Frameworks */ = {
-			isa = PBXShellScriptBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			inputPaths = (
-			);
-			name = "Embed Pods Frameworks";
-			outputPaths = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-			shellPath = /bin/sh;
-			shellScript = "\"${SRCROOT}/Pods/Target Support Files/Pods-StencilTests/Pods-StencilTests-frameworks.sh\"\n";
-			showEnvVarsInLog = 0;
-		};
-		36A8E92EBDE6D917075028D4 /* Copy Pods Resources */ = {
-			isa = PBXShellScriptBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			inputPaths = (
-			);
-			name = "Copy Pods Resources";
-			outputPaths = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-			shellPath = /bin/sh;
-			shellScript = "\"${SRCROOT}/Pods/Target Support Files/Pods-StencilTests/Pods-StencilTests-resources.sh\"\n";
-			showEnvVarsInLog = 0;
-		};
-		5374160581EF83B2213B72F1 /* Copy Pods Resources */ = {
-			isa = PBXShellScriptBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			inputPaths = (
-			);
-			name = "Copy Pods Resources";
-			outputPaths = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-			shellPath = /bin/sh;
-			shellScript = "\"${SRCROOT}/Pods/Target Support Files/Pods-Stencil/Pods-Stencil-resources.sh\"\n";
-			showEnvVarsInLog = 0;
-		};
-		AFE0827734C5388F8E996172 /* Check Pods Manifest.lock */ = {
-			isa = PBXShellScriptBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			inputPaths = (
-			);
-			name = "Check Pods Manifest.lock";
-			outputPaths = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-			shellPath = /bin/sh;
-			shellScript = "diff \"${PODS_ROOT}/../Podfile.lock\" \"${PODS_ROOT}/Manifest.lock\" > /dev/null\nif [[ $? != 0 ]] ; then\n    cat << EOM\nerror: The sandbox is not in sync with the Podfile.lock. Run 'pod install' or update your CocoaPods installation.\nEOM\n    exit 1\nfi\n";
-			showEnvVarsInLog = 0;
-		};
-		C50FF01A96AD1CEACBF2E02A /* Check Pods Manifest.lock */ = {
-			isa = PBXShellScriptBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			inputPaths = (
-			);
-			name = "Check Pods Manifest.lock";
-			outputPaths = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-			shellPath = /bin/sh;
-			shellScript = "diff \"${PODS_ROOT}/../Podfile.lock\" \"${PODS_ROOT}/Manifest.lock\" > /dev/null\nif [[ $? != 0 ]] ; then\n    cat << EOM\nerror: The sandbox is not in sync with the Podfile.lock. Run 'pod install' or update your CocoaPods installation.\nEOM\n    exit 1\nfi\n";
-			showEnvVarsInLog = 0;
-		};
-/* End PBXShellScriptBuildPhase section */
-
-/* Begin PBXSourcesBuildPhase section */
-		77FAAE4D19F91E480029DC5E /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				27CE0B011A50CBD1004A105B /* Include.swift in Sources */,
-				77FAAE6F19F920750029DC5E /* Context.swift in Sources */,
-				77EB082B19FA8600001870F1 /* Lexer.swift in Sources */,
-				7725B3CF19F94214002CF74B /* Tokenizer.swift in Sources */,
-				7725B3D719F94A43002CF74B /* Parser.swift in Sources */,
-				77EB082519F96E88001870F1 /* Template.swift in Sources */,
-				7725B3CD19F92B61002CF74B /* Variable.swift in Sources */,
-				7725B3D519F9438F002CF74B /* Node.swift in Sources */,
-				27CE0ADE1A50BEC3004A105B /* TemplateLoader.swift in Sources */,
-				27A848E41B42240E004ACA13 /* Inheritence.swift in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-		77FAAE5919F91E480029DC5E /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				77FAAE6519F91E480029DC5E /* StencilTests.swift in Sources */,
-				7725B3D319F9437F002CF74B /* NodeTests.swift in Sources */,
-				27A848EC1B42247D004ACA13 /* InheritenceTests.swift in Sources */,
-				27CE0AE01A50BF05004A105B /* TemplateLoaderTests.swift in Sources */,
-				7725B3D919F94A61002CF74B /* ParserTests.swift in Sources */,
-				77EB082719F96E9C001870F1 /* TemplateTests.swift in Sources */,
-				7725B3CB19F92B4F002CF74B /* VariableTests.swift in Sources */,
-				27CE0B041A50CBEA004A105B /* IncludeTests.swift in Sources */,
-				77EB082919FA85F2001870F1 /* LexerTests.swift in Sources */,
-				77FAAE7119F9208C0029DC5E /* ContextTests.swift in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXSourcesBuildPhase section */
-
-/* Begin PBXTargetDependency section */
-		27CE0AF61A50C292004A105B /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			target = 77FAAE5119F91E480029DC5E /* Stencil */;
-			targetProxy = 27CE0AF51A50C292004A105B /* PBXContainerItemProxy */;
-		};
-/* End PBXTargetDependency section */
-
-/* Begin XCBuildConfiguration section */
-		77FAAE6619F91E480029DC5E /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ALWAYS_SEARCH_USER_PATHS = NO;
-				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
-				CLANG_CXX_LIBRARY = "libc++";
-				CLANG_ENABLE_MODULES = YES;
-				CLANG_ENABLE_OBJC_ARC = YES;
-				CLANG_WARN_BOOL_CONVERSION = YES;
-				CLANG_WARN_CONSTANT_CONVERSION = YES;
-				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
-				CLANG_WARN_EMPTY_BODY = YES;
-				CLANG_WARN_ENUM_CONVERSION = YES;
-				CLANG_WARN_INT_CONVERSION = YES;
-				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
-				CLANG_WARN_UNREACHABLE_CODE = YES;
-				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
-				COPY_PHASE_STRIP = NO;
-				CURRENT_PROJECT_VERSION = 1;
-				ENABLE_STRICT_OBJC_MSGSEND = YES;
-				ENABLE_TESTABILITY = YES;
-				GCC_C_LANGUAGE_STANDARD = gnu99;
-				GCC_DYNAMIC_NO_PIC = NO;
-				GCC_OPTIMIZATION_LEVEL = 0;
-				GCC_PREPROCESSOR_DEFINITIONS = (
-					"DEBUG=1",
-					"$(inherited)",
-				);
-				GCC_SYMBOLS_PRIVATE_EXTERN = NO;
-				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
-				GCC_WARN_UNDECLARED_SELECTOR = YES;
-				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
-				GCC_WARN_UNUSED_FUNCTION = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				MACOSX_DEPLOYMENT_TARGET = 10.9;
-				MTL_ENABLE_DEBUG_INFO = YES;
-				ONLY_ACTIVE_ARCH = YES;
-				SDKROOT = macosx;
-				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
-				VERSIONING_SYSTEM = "apple-generic";
-				VERSION_INFO_PREFIX = "";
-			};
-			name = Debug;
-		};
-		77FAAE6719F91E480029DC5E /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ALWAYS_SEARCH_USER_PATHS = NO;
-				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
-				CLANG_CXX_LIBRARY = "libc++";
-				CLANG_ENABLE_MODULES = YES;
-				CLANG_ENABLE_OBJC_ARC = YES;
-				CLANG_WARN_BOOL_CONVERSION = YES;
-				CLANG_WARN_CONSTANT_CONVERSION = YES;
-				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
-				CLANG_WARN_EMPTY_BODY = YES;
-				CLANG_WARN_ENUM_CONVERSION = YES;
-				CLANG_WARN_INT_CONVERSION = YES;
-				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
-				CLANG_WARN_UNREACHABLE_CODE = YES;
-				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
-				COPY_PHASE_STRIP = YES;
-				CURRENT_PROJECT_VERSION = 1;
-				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
-				ENABLE_NS_ASSERTIONS = NO;
-				ENABLE_STRICT_OBJC_MSGSEND = YES;
-				GCC_C_LANGUAGE_STANDARD = gnu99;
-				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
-				GCC_WARN_UNDECLARED_SELECTOR = YES;
-				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
-				GCC_WARN_UNUSED_FUNCTION = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				MACOSX_DEPLOYMENT_TARGET = 10.9;
-				MTL_ENABLE_DEBUG_INFO = NO;
-				SDKROOT = macosx;
-				VERSIONING_SYSTEM = "apple-generic";
-				VERSION_INFO_PREFIX = "";
-			};
-			name = Release;
-		};
-		77FAAE6919F91E480029DC5E /* Debug */ = {
-			isa = XCBuildConfiguration;
-			baseConfigurationReference = 1F9D5A26B78DADAECC18CA94 /* Pods-Stencil.debug.xcconfig */;
-			buildSettings = {
-				CLANG_ENABLE_MODULES = YES;
-				COMBINE_HIDPI_IMAGES = YES;
-				DEFINES_MODULE = YES;
-				DYLIB_COMPATIBILITY_VERSION = 1;
-				DYLIB_CURRENT_VERSION = 1;
-				DYLIB_INSTALL_NAME_BASE = "@rpath";
-				FRAMEWORK_VERSION = A;
-				INFOPLIST_FILE = Stencil/Info.plist;
-				INSTALL_PATH = "$(LOCAL_LIBRARY_DIR)/Frameworks";
-				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/../Frameworks @loader_path/Frameworks";
-				PRODUCT_BUNDLE_IDENTIFIER = "org.cocode.$(PRODUCT_NAME:rfc1034identifier)";
-				PRODUCT_NAME = "$(TARGET_NAME)";
-				SKIP_INSTALL = YES;
-				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
-			};
-			name = Debug;
-		};
-		77FAAE6A19F91E480029DC5E /* Release */ = {
-			isa = XCBuildConfiguration;
-			baseConfigurationReference = 8E90EE157CBB4F8E96884DED /* Pods-Stencil.release.xcconfig */;
-			buildSettings = {
-				CLANG_ENABLE_MODULES = YES;
-				COMBINE_HIDPI_IMAGES = YES;
-				DEFINES_MODULE = YES;
-				DYLIB_COMPATIBILITY_VERSION = 1;
-				DYLIB_CURRENT_VERSION = 1;
-				DYLIB_INSTALL_NAME_BASE = "@rpath";
-				FRAMEWORK_VERSION = A;
-				INFOPLIST_FILE = Stencil/Info.plist;
-				INSTALL_PATH = "$(LOCAL_LIBRARY_DIR)/Frameworks";
-				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/../Frameworks @loader_path/Frameworks";
-				PRODUCT_BUNDLE_IDENTIFIER = "org.cocode.$(PRODUCT_NAME:rfc1034identifier)";
-				PRODUCT_NAME = "$(TARGET_NAME)";
-				SKIP_INSTALL = YES;
-			};
-			name = Release;
-		};
-		77FAAE6C19F91E480029DC5E /* Debug */ = {
-			isa = XCBuildConfiguration;
-			baseConfigurationReference = D7B326C5BB2955F522787D9B /* Pods-StencilTests.debug.xcconfig */;
-			buildSettings = {
-				COMBINE_HIDPI_IMAGES = YES;
-				FRAMEWORK_SEARCH_PATHS = (
-					"$(DEVELOPER_FRAMEWORKS_DIR)",
-					"$(inherited)",
-				);
-				GCC_PREPROCESSOR_DEFINITIONS = (
-					"DEBUG=1",
-					"$(inherited)",
-				);
-				INFOPLIST_FILE = StencilTests/Info.plist;
-				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/../Frameworks @loader_path/../Frameworks";
-				PRODUCT_BUNDLE_IDENTIFIER = "org.cocode.$(PRODUCT_NAME:rfc1034identifier)";
-				PRODUCT_NAME = "$(TARGET_NAME)";
-			};
-			name = Debug;
-		};
-		77FAAE6D19F91E480029DC5E /* Release */ = {
-			isa = XCBuildConfiguration;
-			baseConfigurationReference = D504530B9669DDF40C6890DF /* Pods-StencilTests.release.xcconfig */;
-			buildSettings = {
-				COMBINE_HIDPI_IMAGES = YES;
-				FRAMEWORK_SEARCH_PATHS = (
-					"$(DEVELOPER_FRAMEWORKS_DIR)",
-					"$(inherited)",
-				);
-				INFOPLIST_FILE = StencilTests/Info.plist;
-				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/../Frameworks @loader_path/../Frameworks";
-				PRODUCT_BUNDLE_IDENTIFIER = "org.cocode.$(PRODUCT_NAME:rfc1034identifier)";
-				PRODUCT_NAME = "$(TARGET_NAME)";
-			};
-			name = Release;
-		};
-/* End XCBuildConfiguration section */
-
-/* Begin XCConfigurationList section */
-		77FAAE4C19F91E480029DC5E /* Build configuration list for PBXProject "Stencil" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				77FAAE6619F91E480029DC5E /* Debug */,
-				77FAAE6719F91E480029DC5E /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		77FAAE6819F91E480029DC5E /* Build configuration list for PBXNativeTarget "Stencil" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				77FAAE6919F91E480029DC5E /* Debug */,
-				77FAAE6A19F91E480029DC5E /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		77FAAE6B19F91E480029DC5E /* Build configuration list for PBXNativeTarget "StencilTests" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				77FAAE6C19F91E480029DC5E /* Debug */,
-				77FAAE6D19F91E480029DC5E /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-/* End XCConfigurationList section */
-	};
-	rootObject = 77FAAE4919F91E480029DC5E /* Project object */;
-}

Stencil.xcodeproj/project.xcworkspace/contents.xcworkspacedata

@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<Workspace
-   version = "1.0">
-   <FileRef
-      location = "self:Stencil.xcodeproj">
-   </FileRef>
-</Workspace>

Stencil.xcodeproj/xcshareddata/xcschemes/Stencil.xcscheme

@@ -1,113 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<Scheme
-   LastUpgradeVersion = "0700"
-   version = "1.3">
-   <BuildAction
-      parallelizeBuildables = "YES"
-      buildImplicitDependencies = "YES">
-      <BuildActionEntries>
-         <BuildActionEntry
-            buildForTesting = "YES"
-            buildForRunning = "YES"
-            buildForProfiling = "YES"
-            buildForArchiving = "YES"
-            buildForAnalyzing = "YES">
-            <BuildableReference
-               BuildableIdentifier = "primary"
-               BlueprintIdentifier = "77FAAE5119F91E480029DC5E"
-               BuildableName = "Stencil.framework"
-               BlueprintName = "Stencil"
-               ReferencedContainer = "container:Stencil.xcodeproj">
-            </BuildableReference>
-         </BuildActionEntry>
-         <BuildActionEntry
-            buildForTesting = "YES"
-            buildForRunning = "YES"
-            buildForProfiling = "NO"
-            buildForArchiving = "NO"
-            buildForAnalyzing = "YES">
-            <BuildableReference
-               BuildableIdentifier = "primary"
-               BlueprintIdentifier = "77FAAE5C19F91E480029DC5E"
-               BuildableName = "StencilTests.xctest"
-               BlueprintName = "StencilTests"
-               ReferencedContainer = "container:Stencil.xcodeproj">
-            </BuildableReference>
-         </BuildActionEntry>
-      </BuildActionEntries>
-   </BuildAction>
-   <TestAction
-      buildConfiguration = "Debug"
-      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
-      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
-      shouldUseLaunchSchemeArgsEnv = "YES">
-      <Testables>
-         <TestableReference
-            skipped = "NO">
-            <BuildableReference
-               BuildableIdentifier = "primary"
-               BlueprintIdentifier = "77FAAE5C19F91E480029DC5E"
-               BuildableName = "StencilTests.xctest"
-               BlueprintName = "StencilTests"
-               ReferencedContainer = "container:Stencil.xcodeproj">
-            </BuildableReference>
-         </TestableReference>
-      </Testables>
-      <MacroExpansion>
-         <BuildableReference
-            BuildableIdentifier = "primary"
-            BlueprintIdentifier = "77FAAE5119F91E480029DC5E"
-            BuildableName = "Stencil.framework"
-            BlueprintName = "Stencil"
-            ReferencedContainer = "container:Stencil.xcodeproj">
-         </BuildableReference>
-      </MacroExpansion>
-      <AdditionalOptions>
-      </AdditionalOptions>
-   </TestAction>
-   <LaunchAction
-      buildConfiguration = "Debug"
-      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
-      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
-      launchStyle = "0"
-      useCustomWorkingDirectory = "NO"
-      ignoresPersistentStateOnLaunch = "NO"
-      debugDocumentVersioning = "YES"
-      debugServiceExtension = "internal"
-      allowLocationSimulation = "YES">
-      <MacroExpansion>
-         <BuildableReference
-            BuildableIdentifier = "primary"
-            BlueprintIdentifier = "77FAAE5119F91E480029DC5E"
-            BuildableName = "Stencil.framework"
-            BlueprintName = "Stencil"
-            ReferencedContainer = "container:Stencil.xcodeproj">
-         </BuildableReference>
-      </MacroExpansion>
-      <AdditionalOptions>
-      </AdditionalOptions>
-   </LaunchAction>
-   <ProfileAction
-      buildConfiguration = "Release"
-      shouldUseLaunchSchemeArgsEnv = "YES"
-      savedToolIdentifier = ""
-      useCustomWorkingDirectory = "NO"
-      debugDocumentVersioning = "YES">
-      <MacroExpansion>
-         <BuildableReference
-            BuildableIdentifier = "primary"
-            BlueprintIdentifier = "77FAAE5119F91E480029DC5E"
-            BuildableName = "Stencil.framework"
-            BlueprintName = "Stencil"
-            ReferencedContainer = "container:Stencil.xcodeproj">
-         </BuildableReference>
-      </MacroExpansion>
-   </ProfileAction>
-   <AnalyzeAction
-      buildConfiguration = "Debug">
-   </AnalyzeAction>
-   <ArchiveAction
-      buildConfiguration = "Release"
-      revealArchiveInOrganizer = "YES">
-   </ArchiveAction>
-</Scheme>

Stencil.xcworkspace/contents.xcworkspacedata

@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<Workspace
-   version = "1.0">
-   <FileRef
-      location = "group:Stencil.xcodeproj">
-   </FileRef>
-   <FileRef
-      location = "group:Pods/Pods.xcodeproj">
-   </FileRef>
-</Workspace>

Stencil/Context.swift

@@ -1,49 +0,0 @@
-/// A container for template variables.
-public class Context : Equatable {
-  var dictionaries:[[String:AnyObject]]
-
-  /// Initialise a Context with a dictionary
-  public init(dictionary:[String:AnyObject]) {
-    dictionaries = [dictionary]
-  }
-
-  /// Initialise an empty Context
-  public init() {
-    dictionaries = []
-  }
-
-  public subscript(key: String) -> AnyObject? {
-    /// Retrieves a variable's value, starting at the current context and going upwards
-    get {
-      for dictionary in Array(dictionaries.reverse()) {
-        if let value = dictionary[key] {
-          return value
-        }
-      }
-
-      return nil
-    }
-
-    /// Set a variable in the current context, deleting the variable if it's nil
-    set(value) {
-      if var dictionary = dictionaries.popLast() {
-        dictionary[key] = value
-        dictionaries.append(dictionary)
-      }
-    }
-  }
-
-  /// Push a new level into the Context
-  public func push(dictionary:[String:AnyObject]? = nil) {
-    dictionaries.append(dictionary ?? [:])
-  }
-
-  /// Pop the last level off of the Context
-  public func pop() -> [String:AnyObject]? {
-    return dictionaries.popLast()
-  }
-}
-
-public func ==(lhs:Context, rhs:Context) -> Bool {
-  return lhs.dictionaries == rhs.dictionaries
-}

Stencil/Info.plist

@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>CFBundleDevelopmentRegion</key>
-	<string>en</string>
-	<key>CFBundleExecutable</key>
-	<string>$(EXECUTABLE_NAME)</string>
-	<key>CFBundleIdentifier</key>
-	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
-	<key>CFBundleInfoDictionaryVersion</key>
-	<string>6.0</string>
-	<key>CFBundleName</key>
-	<string>$(PRODUCT_NAME)</string>
-	<key>CFBundlePackageType</key>
-	<string>FMWK</string>
-	<key>CFBundleShortVersionString</key>
-	<string>1.0</string>
-	<key>CFBundleSignature</key>
-	<string>????</string>
-	<key>CFBundleVersion</key>
-	<string>$(CURRENT_PROJECT_VERSION)</string>
-	<key>NSHumanReadableCopyright</key>
-	<string>Copyright © 2014 Cocode. All rights reserved.</string>
-	<key>NSPrincipalClass</key>
-	<string></string>
-</dict>
-</plist>

Stencil/Lexer.swift

@@ -1,59 +0,0 @@
-import Foundation
-
-public struct Lexer {
-  public let templateString:String
-  let regex = try! NSRegularExpression(pattern: "(\\{\\{.*?\\}\\}|\\{%.*?%\\}|\\{#.*?#\\})", options: [])
-
-  public init(templateString:String) {
-    self.templateString = templateString
-  }
-
-  func createToken(string:String) -> Token {
-    func strip() -> String {
-      return string[string.startIndex.successor().successor()..<string.endIndex.predecessor().predecessor()].stringByTrimmingCharactersInSet(NSCharacterSet.whitespaceCharacterSet())
-    }
-
-    if string.hasPrefix("{{") {
-      return Token.Variable(value: strip())
-    } else if string.hasPrefix("{%") {
-      return Token.Block(value: strip())
-    } else if string.hasPrefix("{#") {
-      return Token.Comment(value: strip())
-    }
-
-    return Token.Text(value: string)
-  }
-
-  /// Returns an array of tokens from a given template string.
-  public func tokenize() -> [Token] {
-    // Unfortunately NSRegularExpression doesn't have a split.
-    // So here's a really terrible implementation
-
-    var tokens = [Token]()
-
-    let range = NSMakeRange(0, templateString.characters.count)
-    var lastIndex = 0
-    let nsTemplateString = templateString as NSString
-    let options = NSMatchingOptions(rawValue: 0)
-    regex.enumerateMatchesInString(templateString, options: options, range: range) { (result, flags, b) in
-      if let result = result {
-        if result.range.location != lastIndex {
-          let previousMatch = nsTemplateString.substringWithRange(NSMakeRange(lastIndex, result.range.location - lastIndex))
-          tokens.append(self.createToken(previousMatch))
-        }
-
-        let match = nsTemplateString.substringWithRange(result.range)
-        tokens.append(self.createToken(match))
-
-        lastIndex = result.range.location + result.range.length
-      }
-    }
-
-    if lastIndex < templateString.characters.count {
-      let substring = (templateString as NSString).substringFromIndex(lastIndex)
-      tokens.append(Token.Text(value: substring))
-    }
-
-    return tokens
-  }
-}

Stencil/Node.swift

@@ -1,237 +0,0 @@
-import Foundation
-
-public struct TemplateSyntaxError : ErrorType, Equatable, CustomStringConvertible {
-  public let description:String
-
-  public init(_ description:String) {
-    self.description = description
-  }
-}
-
-public func ==(lhs:TemplateSyntaxError, rhs:TemplateSyntaxError) -> Bool {
-  return lhs.description == rhs.description
-}
-
-public protocol NodeType {
-  /// Render the node in the given context
-  func render(context:Context) throws -> String
-}
-
-/// Render the collection of nodes in the given context
-public func renderNodes(nodes:[NodeType], _ context:Context) throws -> String {
-  return try nodes.map { try $0.render(context) }.joinWithSeparator("")
-}
-
-public class SimpleNode : NodeType {
-  let handler:Context throws -> String
-
-  public init(handler:Context throws -> String) {
-    self.handler = handler
-  }
-
-  public func render(context: Context) throws -> String {
-    return try handler(context)
-  }
-}
-
-public class TextNode : NodeType {
-  public let text:String
-
-  public init(text:String) {
-    self.text = text
-  }
-
-  public func render(context:Context) throws -> String {
-    return self.text
-  }
-}
-
-public class VariableNode : NodeType {
-  public let variable:Variable
-
-  public init(variable:Variable) {
-    self.variable = variable
-  }
-
-  public init(variable:String) {
-    self.variable = Variable(variable)
-  }
-
-  public func render(context:Context) throws -> String {
-    let result:AnyObject? = variable.resolve(context)
-
-    if let result = result as? String {
-      return result
-    } else if let result = result as? NSObject {
-      return result.description
-    }
-
-    return ""
-  }
-}
-
-public class NowNode : NodeType {
-  public let format:Variable
-
-  public class func parse(parser:TokenParser, token:Token) -> NodeType {
-    var format:Variable?
-
-    let components = token.components()
-    if components.count == 2 {
-      format = Variable(components[1])
-    }
-
-    return NowNode(format:format)
-  }
-
-  public init(format:Variable?) {
-    if let format = format {
-      self.format = format
-    } else {
-      self.format = Variable("\"yyyy-MM-dd 'at' HH:mm\"")
-    }
-  }
-
-  public func render(context: Context) throws -> String {
-    let date = NSDate()
-    let format: AnyObject? = self.format.resolve(context)
-    var formatter:NSDateFormatter?
-
-    if let format = format as? NSDateFormatter {
-      formatter = format
-    } else if let format = format as? String {
-      formatter = NSDateFormatter()
-      formatter!.dateFormat = format
-    } else {
-      return ""
-    }
-
-    return formatter!.stringFromDate(date)
-  }
-}
-
-public class ForNode : NodeType {
-  let variable:Variable
-  let loopVariable:String
-  let nodes:[NodeType]
-
-  public class func parse(parser:TokenParser, token:Token) throws -> NodeType {
-    let components = token.components()
-
-    if components.count == 4 && components[2] == "in" {
-      let loopVariable = components[1]
-      let variable = components[3]
-
-      var emptyNodes = [NodeType]()
-
-      let forNodes = try parser.parse(until(["endfor", "empty"]))
-
-      if let token = parser.nextToken() {
-        if token.contents == "empty" {
-          emptyNodes = try parser.parse(until(["endfor"]))
-          parser.nextToken()
-        }
-      } else {
-        throw TemplateSyntaxError("`endfor` was not found.")
-      }
-
-      return ForNode(variable: variable, loopVariable: loopVariable, nodes: forNodes, emptyNodes:emptyNodes)
-    }
-
-    throw TemplateSyntaxError("'for' statements should use the following 'for x in y' `\(token.contents)`.")
-  }
-
-  public init(variable:String, loopVariable:String, nodes:[NodeType], emptyNodes:[NodeType]) {
-    self.variable = Variable(variable)
-    self.loopVariable = loopVariable
-    self.nodes = nodes
-  }
-
-  public func render(context: Context) throws -> String {
-    if let values = variable.resolve(context) as? [AnyObject] {
-      return try values.map { item in
-        context.push()
-        context[loopVariable] = item
-        let result = try renderNodes(nodes, context)
-        context.pop()
-        return result
-      }.joinWithSeparator("")
-    }
-
-    return ""
-  }
-}
-
-public class IfNode : NodeType {
-  public let variable:Variable
-  public let trueNodes:[NodeType]
-  public let falseNodes:[NodeType]
-
-  public class func parse(parser:TokenParser, token:Token) throws -> NodeType {
-    let variable = token.components()[1]
-    var trueNodes = [NodeType]()
-    var falseNodes = [NodeType]()
-
-    trueNodes = try parser.parse(until(["endif", "else"]))
-
-    if let token = parser.nextToken() {
-      if token.contents == "else" {
-        falseNodes = try parser.parse(until(["endif"]))
-        parser.nextToken()
-      }
-    } else {
-      throw TemplateSyntaxError("`endif` was not found.")
-    }
-
-    return IfNode(variable: variable, trueNodes: trueNodes, falseNodes: falseNodes)
-  }
-
-  public class func parse_ifnot(parser:TokenParser, token:Token) throws -> NodeType {
-    let variable = token.components()[1]
-    var trueNodes = [NodeType]()
-    var falseNodes = [NodeType]()
-
-    falseNodes = try parser.parse(until(["endif", "else"]))
-
-    if let token = parser.nextToken() {
-      if token.contents == "else" {
-        trueNodes = try parser.parse(until(["endif"]))
-        parser.nextToken()
-      }
-    } else {
-      throw TemplateSyntaxError("`endif` was not found.")
-    }
-
-    return IfNode(variable: variable, trueNodes: trueNodes, falseNodes: falseNodes)
-  }
-
-  public init(variable:String, trueNodes:[NodeType], falseNodes:[NodeType]) {
-    self.variable = Variable(variable)
-    self.trueNodes = trueNodes
-    self.falseNodes = falseNodes
-  }
-
-  public func render(context: Context) throws -> String {
-    let result: AnyObject? = variable.resolve(context)
-    var truthy = false
-
-    if let result = result as? [AnyObject] {
-      if result.count > 0 {
-        truthy = true
-      }
-    } else if result != nil {
-      truthy = true
-    }
-
-    context.push()
-    let output:String
-    if truthy {
-      output = try renderNodes(trueNodes, context)
-    } else {
-      output = try renderNodes(falseNodes, context)
-    }
-    context.pop()
-
-    return output
-  }
-}

Stencil/Parser.swift

@@ -1,91 +0,0 @@
-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
-      }
-    }
-  }
-
-  return false
-}
-
-/// A class for parsing an array of tokens and converts them into a collection of Node's
-public class TokenParser {
-  public typealias TagParser = (TokenParser, Token) throws -> NodeType
-
-  private var tokens:[Token]
-  private var tags = [String:TagParser]()
-
-  public init(tokens:[Token]) {
-    self.tokens = tokens
-    registerTag("for", parser: ForNode.parse)
-    registerTag("if", parser: IfNode.parse)
-    registerTag("ifnot", parser: IfNode.parse_ifnot)
-    registerTag("now", parser: NowNode.parse)
-    registerTag("include", parser: IncludeNode.parse)
-    registerTag("extends", parser: ExtendsNode.parse)
-    registerTag("block", parser: BlockNode.parse)
-  }
-
-  /// Registers a new template tag
-  public func registerTag(name:String, parser:TagParser) {
-    tags[name] = parser
-  }
-
-  /// Registers a simple template tag with a name and a handler
-  public func registerSimpleTag(name:String, handler:(Context throws -> String)) {
-    registerTag(name, parser: { parser, token in
-      return SimpleNode(handler: handler)
-    })
-  }
-
-  /// Parse the given tokens into nodes
-  public func parse() throws -> [NodeType] {
-    return try parse(nil)
-  }
-
-  public func parse(parse_until:((parser:TokenParser, token:Token) -> (Bool))?) throws -> [NodeType] {
-    var nodes = [NodeType]()
-
-    while tokens.count > 0 {
-      let token = nextToken()!
-
-      switch token {
-      case .Text(let text):
-        nodes.append(TextNode(text: text))
-      case .Variable(let variable):
-        nodes.append(VariableNode(variable: variable))
-      case .Block:
-        let tag = token.components().first
-
-        if let parse_until = parse_until {
-          if parse_until(parser: self, token: token) {
-            prependToken(token)
-            return nodes
-          }
-        }
-
-        if let tag = tag, let parser = self.tags[tag] {
-          nodes.append(try parser(self, token))
-        }
-      case .Comment:
-        continue
-      }
-    }
-
-    return nodes
-  }
-
-  public func nextToken() -> Token? {
-    if tokens.count > 0 {
-      return tokens.removeAtIndex(0)
-    }
-
-    return nil
-  }
-
-  public func prependToken(token:Token) {
-    tokens.insert(token, atIndex: 0)
-  }
-}

Stencil/Stencil.h

@@ -1,18 +0,0 @@
-//
-//  Stencil.h
-//  Stencil
-//
-//  Created by Kyle Fuller on 23/10/2014.
-//  Copyright (c) 2014 Cocode. All rights reserved.
-//  See LICENSE for more details.
-//
-
-#import <Foundation/Foundation.h>
-
-//! Project version number for Stencil.
-FOUNDATION_EXPORT double StencilVersionNumber;
-
-//! Project version string for Stencil.
-FOUNDATION_EXPORT const unsigned char StencilVersionString[];
-
-// In this header, you should import all the public headers of your framework using statements like #import <Stencil/PublicHeader.h>

Stencil/Template.swift

@@ -1,48 +0,0 @@
-import Foundation
-import PathKit
-
-/// A class representing a template
-public class Template {
-  public let parser:TokenParser
-
-  /// Create a template with the given name inside the main bundle
-  public convenience init(named:String) throws {
-    try self.init(named:named, inBundle:nil)
-  }
-
-  /// Create a template with the given name inside the given bundle
-  public convenience init(named:String, inBundle bundle:NSBundle?) throws {
-    let url:NSURL
-
-    if let bundle = bundle {
-      url = bundle.URLForResource(named, withExtension: nil)!
-    } else {
-      url = NSBundle.mainBundle().URLForResource(named, withExtension: nil)!
-    }
-
-    try self.init(URL:url)
-  }
-
-  /// Create a template with a file found at the given URL
-  public convenience init(URL:NSURL) throws {
-    try self.init(path: Path(URL.absoluteString))
-  }
-
-  /// Create a template with a file found at the given path
-  public convenience init(path:Path) throws {
-    self.init(templateString: try path.read())
-  }
-
-  /// Create a template with a template string
-  public init(templateString:String) {
-    let lexer = Lexer(templateString: templateString)
-    let tokens = lexer.tokenize()
-    parser = TokenParser(tokens: tokens)
-  }
-
-  /// Render the given template
-  public func render(context:Context? = nil) throws -> String {
-    let nodes = try parser.parse()
-    return try renderNodes(nodes, context ?? Context())
-  }
-}

Stencil/TemplateLoader.swift

@@ -1,37 +0,0 @@
-import Foundation
-import PathKit
-
-// A class for loading a template from disk
-public class TemplateLoader {
-  public let paths:[Path]
-
-  public init(paths:[Path]) {
-    self.paths = paths
-  }
-
-  public init(bundle:[NSBundle]) {
-    self.paths = bundle.map {
-      return Path($0.bundlePath)
-    }
-  }
-
-  public func loadTemplate(templateName:String) -> Template? {
-    return loadTemplate([templateName])
-  }
-
-  public func loadTemplate(templateNames:[String]) -> Template? {
-    for path in paths {
-      for templateName in templateNames {
-        let templatePath = path + Path(templateName)
-
-        if templatePath.exists {
-          if let template = try? Template(path: templatePath) {
-            return template
-          }
-        }
-      }
-    }
-
-    return nil
-  }
-}

Stencil/TemplateLoader/Include.swift

@@ -1,37 +0,0 @@
-import Foundation
-import PathKit
-
-
-public class IncludeNode : NodeType {
-  public let templateName:String
-
-  public class func parse(parser:TokenParser, token:Token) throws -> NodeType {
-    let bits = token.contents.componentsSeparatedByString("\"")
-
-    if bits.count != 3 {
-      throw TemplateSyntaxError("'include' tag takes one argument, the template file to be included")
-    }
-
-    return IncludeNode(templateName: bits[1])
-  }
-
-  public init(templateName:String) {
-    self.templateName = templateName
-  }
-
-  public func render(context: Context) throws -> String {
-    if let loader =  context["loader"] as? TemplateLoader {
-      if let template = loader.loadTemplate(templateName) {
-        return try template.render(context)
-      }
-
-      let paths:String = loader.paths.map { path in
-        return path.description
-      }.joinWithSeparator(", ")
-      throw TemplateSyntaxError("'\(templateName)' template not found in \(paths)")
-    }
-
-    throw TemplateSyntaxError("Template loader not in context")
-  }
-}
-

Stencil/TemplateLoader/Inheritence.swift

@@ -1,108 +0,0 @@
-import Foundation
-
-class BlockContext {
-  class var contextKey:String { return "block_context" }
-
-  var blocks:[String:BlockNode]
-
-  init(blocks:[String:BlockNode]) {
-    self.blocks = blocks
-  }
-
-  func pop(blockName:String) -> BlockNode? {
-    return blocks.removeValueForKey(blockName)
-  }
-}
-
-func any<Element>(elements:[Element], closure:(Element -> Bool)) -> Element? {
-  for element in elements {
-    if closure(element) {
-      return element
-    }
-  }
-
-  return nil
-}
-
-class ExtendsNode : NodeType {
-  let templateName:String
-  let blocks:[String:BlockNode]
-
-  class func parse(parser:TokenParser, token:Token) throws -> NodeType {
-    let bits = token.contents.componentsSeparatedByString("\"")
-
-    if bits.count != 3 {
-      throw TemplateSyntaxError("'extends' takes one argument, the template file to be extended")
-    }
-
-    let parsedNodes = try parser.parse()
-    if (any(parsedNodes) { ($0 as? ExtendsNode) != nil }) != nil {
-      throw TemplateSyntaxError("'extends' cannot appear more than once in the same template")
-    }
-
-    let blockNodes = parsedNodes.filter { node in node is BlockNode }
-
-    let nodes = blockNodes.reduce([String:BlockNode](), combine: { (accumulator, node:NodeType) -> [String:BlockNode] in
-      let node = (node as! BlockNode)
-      var dict = accumulator
-      dict[node.name] = node
-      return dict
-    })
-
-    return ExtendsNode(templateName: bits[1], blocks: nodes)
-  }
-
-  init(templateName:String, blocks:[String:BlockNode]) {
-    self.templateName = templateName
-    self.blocks = blocks
-  }
-
-  func render(context: Context) throws -> String {
-    if let loader =  context["loader"] as? TemplateLoader {
-      if let template = loader.loadTemplate(templateName) {
-        let blockContext = BlockContext(blocks: blocks)
-        context.push([BlockContext.contextKey: blockContext])
-        let result = try template.render(context)
-        context.pop()
-        return result
-      }
-
-      let paths:String = loader.paths.map { path in
-        return path.description
-        }.joinWithSeparator(", ")
-      throw TemplateSyntaxError("'\(templateName)' template not found in \(paths)")
-    }
-
-    throw TemplateSyntaxError("Template loader not in context")
-  }
-}
-
-class BlockNode : NodeType {
-  let name:String
-  let nodes:[NodeType]
-
-  class func parse(parser:TokenParser, token:Token) throws -> NodeType {
-    let bits = token.components()
-
-    if bits.count != 2 {
-      throw TemplateSyntaxError("'block' tag takes one argument, the template file to be included")
-    }
-
-    let blockName = bits[1]
-    let nodes = try parser.parse(until(["endblock"]))
-    return BlockNode(name:blockName, nodes:nodes)
-  }
-
-  init(name:String, nodes:[NodeType]) {
-    self.name = name
-    self.nodes = nodes
-  }
-
-  func render(context: Context) throws -> String {
-    if let blockContext = context[BlockContext.contextKey] as? BlockContext, node = blockContext.pop(name) {
-      return try node.render(context)
-    }
-
-    return try renderNodes(nodes, context)
-  }
-}

Stencil/Tokenizer.swift

@@ -1,62 +0,0 @@
-public enum Token : Equatable {
-  /// A token representing a piece of text.
-  case Text(value:String)
-
-  /// A token representing a variable.
-  case Variable(value:String)
-
-  /// A token representing a comment.
-  case Comment(value:String)
-
-  /// A token representing a template block.
-  case Block(value:String)
-
-  /// Returns the underlying value as an array seperated by spaces
-  func components() -> [String] {
-    // TODO: Make this smarter and treat quoted strings as a single component
-    let characterSet = NSCharacterSet.whitespaceAndNewlineCharacterSet()
-
-    func strip(value: String) -> [String] {
-      return value.stringByTrimmingCharactersInSet(characterSet).componentsSeparatedByCharactersInSet(characterSet)
-    }
-
-    switch self {
-    case .Block(let value):
-      return strip(value)
-    case .Variable(let value):
-      return strip(value)
-    case .Text(let value):
-      return strip(value)
-    case .Comment(let value):
-      return strip(value)
-    }
-  }
-
-  var contents:String {
-    switch self {
-    case .Block(let value):
-      return value
-    case .Variable(let value):
-      return value
-    case .Text(let value):
-      return value
-    case .Comment(let value):
-      return value
-    }
-  }
-}
-
-public func ==(lhs:Token, rhs:Token) -> Bool {
-  switch (lhs, rhs) {
-  case (.Text(let lhsValue), .Text(let rhsValue)):
-    return lhsValue == rhsValue
-  case (.Variable(let lhsValue), .Variable(let rhsValue)):
-    return lhsValue == rhsValue
-  case (.Block(let lhsValue), .Block(let rhsValue)):
-    return lhsValue == rhsValue
-  case (.Comment(let lhsValue), .Comment(let rhsValue)):
-    return lhsValue == rhsValue
-  default:
-    return false
-  }
-}

Stencil/Variable.swift

@@ -1,53 +0,0 @@
-import Foundation
-
-
-/// A structure used to represent a template variable, and to resolve it in a given context.
-public struct Variable : Equatable {
-  public let variable:String
-
-  /// Create a variable with a string representing the variable
-  public init(_ variable:String) {
-    self.variable = variable
-  }
-
-  private func lookup() -> [String] {
-    return variable.componentsSeparatedByString(".")
-  }
-
-  /// Resolve the variable in the given context
-  public func resolve(context:Context) -> AnyObject? {
-    var current:AnyObject? = context
-
-    if (variable.hasPrefix("'") && variable.hasSuffix("'")) || (variable.hasPrefix("\"") && variable.hasSuffix("\"")) {
-      return variable.substringWithRange(variable.startIndex.successor() ..< variable.endIndex.predecessor())
-    }
-
-    for bit in lookup() {
-      if let context = current as? Context {
-        current = context[bit]
-      } else if let dictionary = current as? [String:AnyObject] {
-        current = dictionary[bit]
-      } else if let array = current as? [AnyObject] {
-        if let index = Int(bit) {
-          current = array[index]
-        } else if bit == "first" {
-          current = array.first
-        } else if bit == "last" {
-          current = array.last
-        } else if bit == "count" {
-          current = array.count
-        }
-      } else if let object = current as? NSObject {
-        current = object.valueForKey(bit)
-      } else {
-        return nil
-      }
-    }
-
-    return current
-  }
-}
-
-public func ==(lhs:Variable, rhs:Variable) -> Bool {
-  return lhs.variable == rhs.variable
-}

StencilTests/ContextTests.swift

@@ -1,65 +0,0 @@
-import Foundation
-import XCTest
-import Stencil
-
-class ContextTests: XCTestCase {
-  var context:Context!
-
-  override func setUp() {
-    context = Context(dictionary: ["name": "Kyle"])
-  }
-
-  func testItAllowsYouToRetrieveAValue() {
-    let name = context["name"] as! String
-    XCTAssertEqual(name, "Kyle")
-  }
-
-  func testItAllowsYouToSetValue() {
-    context["name"] = "Katie"
-
-    let name = context["name"] as! String
-    XCTAssertEqual(name, "Katie")
-  }
-
-  func testItAllowsYouToRemoveAValue() {
-    context["name"] = nil
-    XCTAssertNil(context["name"])
-  }
-
-  func testItAllowsYouToRetrieveAValueFromParent() {
-    context.push()
-
-    let name = context["name"] as! String
-    XCTAssertEqual(name, "Kyle")
-  }
-
-  func testItAllowsYouToOverideAParentVariable() {
-    context.push()
-    context["name"] = "Katie"
-
-    let name = context["name"] as! String
-    XCTAssertEqual(name, "Katie")
-  }
-
-  func testShowAllowYouToPopVariablesRestoringPreviousState() {
-    context.push()
-    context["name"] = "Katie"
-    context.pop()
-
-    let name = context["name"] as! String
-    XCTAssertEqual(name, "Kyle")
-  }
-
-  func testItAllowsYouToPushADictionaryToTheStack() {
-    context.push(["name": "Katie"])
-
-    let name = context["name"] as! String
-    XCTAssertEqual(name, "Katie")
-  }
-
-  func testItAllowsYouToCompareTwoContextsForEquality() {
-    let otherContext = Context(dictionary: ["name": "Kyle"])
-
-    XCTAssertEqual(otherContext, context)
-  }
-}

StencilTests/Info.plist

@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>CFBundleDevelopmentRegion</key>
-	<string>en</string>
-	<key>CFBundleExecutable</key>
-	<string>$(EXECUTABLE_NAME)</string>
-	<key>CFBundleIdentifier</key>
-	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
-	<key>CFBundleInfoDictionaryVersion</key>
-	<string>6.0</string>
-	<key>CFBundleName</key>
-	<string>$(PRODUCT_NAME)</string>
-	<key>CFBundlePackageType</key>
-	<string>BNDL</string>
-	<key>CFBundleShortVersionString</key>
-	<string>1.0</string>
-	<key>CFBundleSignature</key>
-	<string>????</string>
-	<key>CFBundleVersion</key>
-	<string>1</string>
-</dict>
-</plist>

StencilTests/LexerTests.swift

@@ -1,50 +0,0 @@
-import Foundation
-import XCTest
-import Stencil
-
-class LexerTests: XCTestCase {
-
-  func testTokenizeText() {
-    let lexer = Lexer(templateString:"Hello World")
-    let tokens = lexer.tokenize()
-
-    XCTAssertEqual(tokens.count, 1)
-    XCTAssertEqual(tokens.first!, Token.Text(value: "Hello World"))
-  }
-
-  func testTokenizeComment() {
-    let lexer = Lexer(templateString:"{# Comment #}")
-    let tokens = lexer.tokenize()
-
-    XCTAssertEqual(tokens.count, 1)
-    XCTAssertEqual(tokens.first!, Token.Comment(value: "Comment"))
-  }
-
-  func testTokenizeVariable() {
-    let lexer = Lexer(templateString:"{{ Variable }}")
-    let tokens = lexer.tokenize()
-
-    XCTAssertEqual(tokens.count, 1)
-    XCTAssertEqual(tokens.first!, Token.Variable(value: "Variable"))
-  }
-
-  func testTokenizeMixture() {
-    let lexer = Lexer(templateString:"My name is {{ name }}.")
-    let tokens = lexer.tokenize()
-
-    XCTAssertEqual(tokens.count, 3)
-    XCTAssertEqual(tokens[0], Token.Text(value: "My name is "))
-    XCTAssertEqual(tokens[1], Token.Variable(value: "name"))
-    XCTAssertEqual(tokens[2], Token.Text(value: "."))
-  }
-
-  func testTokenizeTwoVariables() { // Don't be greedy
-    let lexer = Lexer(templateString:"{{ thing }}{{ name }}")
-    let tokens = lexer.tokenize()
-
-    XCTAssertEqual(tokens.count, 2)
-    XCTAssertEqual(tokens[0], Token.Variable(value: "thing"))
-    XCTAssertEqual(tokens[1], Token.Variable(value: "name"))
-  }
-
-}

StencilTests/NodeTests.swift

@@ -1,184 +0,0 @@
-import Foundation
-import XCTest
-import Stencil
-
-
-class ErrorNode : NodeType {
-  func render(context: Context) throws -> String {
-    throw TemplateSyntaxError("Custom Error")
-  }
-}
-
-class NodeTests: XCTestCase {
-  var context:Context!
-
-  override func setUp() {
-    context = Context(dictionary: [
-      "name": "Kyle",
-      "age": 27,
-      "items": [1,2,3],
-      ])
-  }
-}
-
-class TextNodeTests: NodeTests {
-  func testTextNodeResolvesText() {
-    let node = TextNode(text:"Hello World")
-    XCTAssertEqual(try? node.render(context), "Hello World")
-  }
-}
-
-class VariableNodeTests: NodeTests {
-  func testVariableNodeResolvesVariable() {
-    let node = VariableNode(variable:Variable("name"))
-    XCTAssertEqual(try? node.render(context), "Kyle")
-  }
-
-  func testVariableNodeResolvesNonStringVariable() {
-    let node = VariableNode(variable:Variable("age"))
-    XCTAssertEqual(try? node.render(context), "27")
-  }
-}
-
-class RenderNodeTests: NodeTests {
-  func testRenderingNodes() {
-    let nodes = [TextNode(text:"Hello "), VariableNode(variable: "name")] as [NodeType]
-    XCTAssertEqual(try? renderNodes(nodes, context), "Hello Kyle")
-  }
-
-  func testRenderingNodesWithFailure() {
-    let nodes = [TextNode(text:"Hello "), VariableNode(variable: "name"), ErrorNode()] as [NodeType]
-
-    assertFailure(try renderNodes(nodes, context), TemplateSyntaxError("Custom Error"))
-  }
-}
-
-class ForNodeTests: NodeTests {
-  func testForNodeRender() {
-    let node = ForNode(variable: "items", loopVariable: "item", nodes: [VariableNode(variable: "item")], emptyNodes:[])
-    XCTAssertEqual(try? node.render(context), "123")
-  }
-}
-
-class IfNodeTests: NodeTests {
-
-  // MARK: Parsing
-
-  func testParseIf() {
-    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)
-    assertSuccess(try parser.parse()) { nodes in
-      let node = nodes.first as! IfNode
-      let trueNode = node.trueNodes.first as! TextNode
-      let falseNode = node.falseNodes.first as! TextNode
-
-      XCTAssertEqual(nodes.count, 1)
-      XCTAssertEqual(node.variable.variable, "value")
-      XCTAssertEqual(node.trueNodes.count, 1)
-      XCTAssertEqual(trueNode.text, "true")
-      XCTAssertEqual(node.falseNodes.count, 1)
-      XCTAssertEqual(falseNode.text, "false")
-    }
-  }
-
-  func testParseIfNot() {
-    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)
-    assertSuccess(try parser.parse()) { nodes in
-      let node = nodes.first as! IfNode
-      let trueNode = node.trueNodes.first as! TextNode
-      let falseNode = node.falseNodes.first as! TextNode
-
-      XCTAssertEqual(nodes.count, 1)
-      XCTAssertEqual(node.variable.variable, "value")
-      XCTAssertEqual(node.trueNodes.count, 1)
-      XCTAssertEqual(trueNode.text, "true")
-      XCTAssertEqual(node.falseNodes.count, 1)
-      XCTAssertEqual(falseNode.text, "false")
-    }
-  }
-
-  func testParseIfWithoutEndIfError() {
-    let tokens = [
-      Token.Block(value: "if value"),
-    ]
-
-    let parser = TokenParser(tokens: tokens)
-    assertFailure(try parser.parse(), TemplateSyntaxError("`endif` was not found."))
-  }
-
-  func testParseIfNotWithoutEndIfError() {
-    let tokens = [
-      Token.Block(value: "ifnot value"),
-    ]
-
-    let parser = TokenParser(tokens: tokens)
-    assertFailure(try parser.parse(), TemplateSyntaxError("`endif` was not found."))
-  }
-
-  // MARK: Rendering
-
-  func testIfNodeRenderTruth() {
-    let node = IfNode(variable: "items", trueNodes: [TextNode(text: "true")], falseNodes: [TextNode(text: "false")])
-    XCTAssertEqual(try? node.render(context), "true")
-  }
-
-  func testIfNodeRenderFalse() {
-    let node = IfNode(variable: "unknown", trueNodes: [TextNode(text: "true")], falseNodes: [TextNode(text: "false")])
-    XCTAssertEqual(try? node.render(context), "false")
-  }
-
-}
-
-class NowNodeTests: NodeTests {
-
-  // MARK: Parsing
-
-  func testParseDefaultNow() {
-    let tokens = [ Token.Block(value: "now") ]
-    let parser = TokenParser(tokens: tokens)
-
-    assertSuccess(try parser.parse()) { nodes in
-      let node = nodes.first as! NowNode
-      XCTAssertEqual(nodes.count, 1)
-      XCTAssertEqual(node.format.variable, "\"yyyy-MM-dd 'at' HH:mm\"")
-    }
-  }
-
-  func testParseNowWithFormat() {
-    let tokens = [ Token.Block(value: "now \"HH:mm\"") ]
-    let parser = TokenParser(tokens: tokens)
-
-    assertSuccess(try parser.parse()) { nodes in
-      let node = nodes.first as! NowNode
-      XCTAssertEqual(nodes.count, 1)
-      XCTAssertEqual(node.format.variable, "\"HH:mm\"")
-    }
-  }
-
-  // MARK: Rendering
-
-  func testRenderNowNode() {
-    let node = NowNode(format: Variable("\"yyyy-MM-dd\""))
-
-    let formatter = NSDateFormatter()
-    formatter.dateFormat = "yyyy-MM-dd"
-    let date = formatter.stringFromDate(NSDate())
-
-    XCTAssertEqual(try? node.render(context), date)
-  }
-}

StencilTests/ParserTests.swift

@@ -1,49 +0,0 @@
-import Foundation
-import XCTest
-import Stencil
-
-class TokenParserTests: XCTestCase {
-  func testParsingTextToken() {
-    let parser = TokenParser(tokens: [
-      Token.Text(value: "Hello World")
-      ])
-
-    assertSuccess(try parser.parse()) { nodes in
-      let node = nodes.first as! TextNode
-      XCTAssertEqual(nodes.count, 1)
-      XCTAssertEqual(node.text, "Hello World")
-    }
-  }
-
-  func testParsingVariableToken() {
-    let parser = TokenParser(tokens: [
-      Token.Variable(value: "name")
-      ])
-
-    assertSuccess(try parser.parse()) { nodes in
-      let node = nodes.first as! VariableNode
-      XCTAssertEqual(nodes.count, 1)
-      XCTAssertEqual(node.variable, Variable("name"))
-    }
-  }
-
-  func testParsingCommentToken() {
-    let parser = TokenParser(tokens: [
-      Token.Comment(value: "Secret stuff!")
-      ])
-
-    assertSuccess(try parser.parse()) { nodes in
-      XCTAssertEqual(nodes.count, 0)
-    }
-  }
-
-  func testParsingTagToken() {
-    let parser = TokenParser(tokens: [
-      Token.Block(value: "now"),
-      ])
-
-    assertSuccess(try parser.parse()) { nodes in
-      XCTAssertEqual(nodes.count, 1)
-    }
-  }
-}

StencilTests/StencilTests.swift

@@ -1,77 +0,0 @@
-import Foundation
-import XCTest
-import Stencil
-
-func assertSuccess<T>(@autoclosure closure:() throws -> (T), block:(T -> ())) {
-  do {
-    block(try closure())
-  } catch {
-    XCTFail("Unexpected error \(error)")
-  }
-}
-
-func assertFailure<T, U : Equatable>(@autoclosure closure:() throws -> (T), _ error:U) {
-  do {
-    try closure()
-  } catch let e as U {
-    XCTAssertEqual(e, error)
-  } catch {
-    XCTFail()
-  }
-}
-
-class CustomNode : NodeType {
-  func render(context:Context) throws -> String {
-    return "Hello World"
-  }
-}
-
-class StencilTests: XCTestCase {
-  func testReadmeExample() {
-    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 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"
-
-    XCTAssertEqual(result, fixture)
-  }
-
-  func testCustomTag() {
-    let templateString = "{% custom %}"
-    let template = Template(templateString:templateString)
-
-    template.parser.registerTag("custom") { parser, token in
-      return CustomNode()
-    }
-
-    XCTAssertEqual(try? template.render(), "Hello World")
-  }
-
-  func testSimpleCustomTag() {
-    let templateString = "{% custom %}"
-    let template = Template(templateString:templateString)
-
-    template.parser.registerSimpleTag("custom") { context in
-      return "Hello World"
-    }
-
-    XCTAssertEqual(try? template.render(), "Hello World")
-  }
-}

StencilTests/TemplateLoader/IncludeTests.swift

@@ -1,64 +0,0 @@
-import Foundation
-import XCTest
-import Stencil
-import PathKit
-
-class IncludeTests: NodeTests {
-
-  var loader:TemplateLoader!
-
-  override func setUp() {
-    super.setUp()
-
-    let path = (Path(__FILE__) + Path("../..")).absolute()
-    loader = TemplateLoader(paths: [path])
-  }
-
-  // MARK: Parsing
-
-  func testParseMissingTemplate() {
-    let tokens = [ Token.Block(value: "include") ]
-    let parser = TokenParser(tokens: tokens)
-
-    assertFailure(try parser.parse(), TemplateSyntaxError("'include' tag takes one argument, the template file to be included"))
-  }
-
-  func testParse() {
-    let tokens = [ Token.Block(value: "include \"test.html\"") ]
-    let parser = TokenParser(tokens: tokens)
-
-    assertSuccess(try parser.parse()) { nodes in
-      let node = nodes.first as! IncludeNode
-      XCTAssertEqual(nodes.count, 1)
-      XCTAssertEqual(node.templateName, "test.html")
-    }
-  }
-
-  // MARK: Render
-
-  func testRenderWithoutLoader() {
-    let node = IncludeNode(templateName: "test.html")
-
-    do {
-      try node.render(Context())
-    } catch {
-      XCTAssertEqual("\(error)", "Template loader not in context")
-    }
-  }
-
-  func testRenderWithoutTemplateNamed() {
-    let node = IncludeNode(templateName: "unknown.html")
-
-    do {
-      try node.render(Context(dictionary:["loader":loader]))
-    } catch {
-      XCTAssertTrue("\(error)".hasPrefix("'unknown.html' template not found"))
-    }
-  }
-
-  func testRender() {
-    let node = IncludeNode(templateName: "test.html")
-    let value = try? node.render(Context(dictionary:["loader":loader, "target": "World"]))
-    XCTAssertEqual(value, "Hello World!")
-  }
-}

StencilTests/TemplateLoader/InheritenceTests.swift

@@ -1,44 +0,0 @@
-import Foundation
-import XCTest
-import Stencil
-import PathKit
-
-class InheritenceTests: NodeTests {
-  var loader:TemplateLoader!
-
-  override func setUp() {
-    super.setUp()
-
-    let path = (Path(__FILE__) + Path("../..")).absolute()
-    loader = TemplateLoader(paths: [path])
-  }
-
-  func testInheritence() {
-    context = Context(dictionary: ["loader": loader])
-    let template = loader.loadTemplate("child.html")!
-    XCTAssertEqual(try? template.render(context), "Header\nChild")
-  }
-}
-
-//class BlockNodeTests: NodeTests {
-//    func testBlockNodeWithoutChildren() {
-//        let context = Context()
-//        let block = BlockNode(name:"header", nodes:[TextNode(text: "contents")])
-//        let result = block.render(context)
-//
-//        assertSuccess(result) { rendered in
-//            XCTAssertEqual(rendered, "contents")
-//        }
-//    }
-//
-//    func testBlockNodeWithChild() {
-//        let context = Context()
-//        let node = BlockNode(name:"header", nodes:[TextNode(text: "contents")])
-//        let childBlock = BlockNode(name: "header", nodes: [TextNode(text: "child contents")])
-//        let result = node.render(context)
-//
-//        assertSuccess(result) { rendered in
-//            XCTAssertEqual(rendered, "child contents")
-//        }
-//    }
-//}

StencilTests/TemplateLoaderTests.swift

@@ -1,24 +0,0 @@
-import Foundation
-import XCTest
-import Stencil
-import PathKit
-
-class TemplateLoaderTests: XCTestCase {
-
-  func testLoadingUnknownTemplate() {
-    let loader = TemplateLoader(paths:[])
-    XCTAssertNil(loader.loadTemplate("unknown.html"))
-  }
-
-  func testLoadingUnknownTemplates() {
-    let loader = TemplateLoader(paths:[])
-    XCTAssertNil(loader.loadTemplate(["unknown.html", "unknown2.html"]))
-  }
-
-  func testLoadingTemplate() {
-    let path = (Path(__FILE__) + Path("..")).absolute()
-    let loader = TemplateLoader(paths: [path])
-    XCTAssertTrue(loader.loadTemplate("test.html") != nil)
-  }
-
-}

StencilTests/TemplateTests.swift

@@ -1,12 +0,0 @@
-import Foundation
-import XCTest
-import Stencil
-
-class TemplateTests: XCTestCase {
-  func testTemplate() {
-    let context = Context(dictionary: [ "name": "Kyle" ])
-    let template = Template(templateString: "Hello World")
-    let result = try? template.render(context)
-    XCTAssertEqual(result, "Hello World")
-  }
-}

StencilTests/VariableTests.swift

@@ -1,62 +0,0 @@
-import Foundation
-import XCTest
-import Stencil
-
-@objc class Object : NSObject {
-  let title = "Hello World"
-}
-
-class VariableTests: XCTestCase {
-  var context:Context!
-
-  override func setUp() {
-    context = Context(dictionary: [
-      "name": "Kyle",
-      "contacts": [ "Katie", "Orta", ],
-      "profiles": [ "github": "kylef", ],
-      "object": Object(),
-      ])
-  }
-
-  func testResolvingStringLiteral() {
-    let variable = Variable("\"name\"")
-    let result = variable.resolve(context) as! String
-    XCTAssertEqual(result, "name")
-  }
-
-  func testResolvingVariable() {
-    let variable = Variable("name")
-    let result = variable.resolve(context) as! String
-    XCTAssertEqual(result, "Kyle")
-  }
-
-  func testResolvingItemFromDictionary() {
-    let variable = Variable("profiles.github")
-    let result = variable.resolve(context) as! String
-    XCTAssertEqual(result, "kylef")
-  }
-
-  func testResolvingItemFromArrayWithIndex() {
-    let variable = Variable("contacts.0")
-    let result = variable.resolve(context) as! String
-    XCTAssertEqual(result, "Katie")
-  }
-
-  func testResolvingFirstItemFromArray() {
-    let variable = Variable("contacts.first")
-    let result = variable.resolve(context) as! String
-    XCTAssertEqual(result, "Katie")
-  }
-
-  func testResolvingLastItemFromArray() {
-    let variable = Variable("contacts.last")
-    let result = variable.resolve(context) as! String
-    XCTAssertEqual(result, "Orta")
-  }
-
-  func testResolvingValueViaKVO() {
-    let variable = Variable("object.title")
-    let result = variable.resolve(context) as! String
-    XCTAssertEqual(result, "Hello World")
-  }
-}

Tests/LinuxMain.swift

@@ -0,0 +1,3 @@
+import StencilTests
+
+stencilTests()

Tests/StencilTests/ContextSpec.swift

@@ -0,0 +1,81 @@
+import Spectre
+@testable import Stencil
+
+
+func testContext() {
+  describe("Context") {
+    var context: Context!
+
+    $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 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") {
+      try context.push {
+        try expect(context["name"] as? String) == "Kyle"
+      }
+    }
+
+    $0.it("allows you to override a parent's value") {
+      try 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"
+      }
+
+      try expect(context["name"] as? String) == "Kyle"
+    }
+
+    $0.it("allows you to remove a parent's value in a level") {
+      try context.push {
+        context["name"] = nil
+        try expect(context["name"]).to.beNil()
+      }
+
+      try expect(context["name"] as? String) == "Kyle"
+    }
+
+    $0.it("allows you to push a dictionary and run a closure then restoring previous state") {
+      var didRun = false
+
+      try context.push(dictionary: ["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 flatten the context contents") {
+      try context.push(dictionary: ["test": "abc"]) {
+        let flattened = context.flatten()
+
+        try expect(flattened.count) == 2
+        try expect(flattened["name"] as? String) == "Kyle"
+        try expect(flattened["test"] as? String) == "abc"
+      }
+    }
+  }
+}

Tests/StencilTests/EnvironmentSpec.swift

@@ -0,0 +1,54 @@
+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!"
+    }
+
+    $0.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"
+    }
+  }
+}
+
+
+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)
+  }
+}
+
+
+class CustomTemplate: Template {
+  override func render(_ dictionary: [String: Any]? = nil) throws -> String {
+    return "here"
+  }
+}

Tests/StencilTests/ExpressionSpec.swift

@@ -0,0 +1,284 @@
+import Spectre
+@testable import Stencil
+
+
+func testExpressions() {
+  describe("Expression") {
+    let parser = TokenParser(tokens: [], environment: Environment())
+
+    $0.describe("VariableExpression") {
+      let expression = VariableExpression(variable: Variable("value"))
+
+      $0.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") {
+        let context = Context()
+        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") {
+        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") {
+        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") {
+        let context = Context(dictionary: ["value": "test"])
+        try expect(try expression.evaluate(context: context)).to.beTrue()
+      }
+
+      $0.it("evaluates to false when empty string") {
+        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") {
+        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") {
+        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") {
+        let context = Context(dictionary: ["value": UInt(0)])
+        try expect(try expression.evaluate(context: context)).to.beFalse()
+      }
+    }
+
+    $0.describe("NotExpression") {
+      $0.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") {
+        let expression = NotExpression(expression: StaticExpression(value: false))
+        try expect(expression.evaluate(context: Context())).to.beTrue()
+      }
+    }
+
+    $0.describe("expression parsing") {
+      $0.it("can parse a variable expression") {
+        let expression = try parseExpression(components: ["value"], tokenParser: parser)
+        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") {
+        let expression = try parseExpression(components: ["not", "value"], tokenParser: parser)
+        try expect(expression.evaluate(context: Context())).to.beTrue()
+        try expect(expression.evaluate(context: Context(dictionary: ["value": true]))).to.beFalse()
+      }
+
+      $0.describe("and expression") {
+        let expression = try! parseExpression(components: ["lhs", "and", "rhs"], tokenParser: parser)
+
+        $0.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") {
+          try expect(expression.evaluate(context: Context(dictionary: ["lhs": true, "rhs": false]))).to.beFalse()
+        }
+
+        $0.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") {
+          try expect(expression.evaluate(context: Context(dictionary: ["lhs": true, "rhs": true]))).to.beTrue()
+        }
+      }
+
+      $0.describe("or expression") {
+        let expression = try! parseExpression(components: ["lhs", "or", "rhs"], tokenParser: parser)
+
+        $0.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") {
+          try expect(expression.evaluate(context: Context(dictionary: ["lhs": false, "rhs": true]))).to.beTrue()
+        }
+
+        $0.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") {
+          try expect(expression.evaluate(context: Context(dictionary: ["lhs": false, "rhs": false]))).to.beFalse()
+        }
+      }
+
+      $0.describe("equality expression") {
+        let expression = try! parseExpression(components: ["lhs", "==", "rhs"], tokenParser: parser)
+
+        $0.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") {
+          try expect(expression.evaluate(context: Context(dictionary: ["lhs": "a", "rhs": "b"]))).to.beFalse()
+        }
+
+        $0.it("evaluates to true with nils") {
+          try expect(expression.evaluate(context: Context(dictionary: [:]))).to.beTrue()
+        }
+
+        $0.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") {
+          try expect(expression.evaluate(context: Context(dictionary: ["lhs": 1, "rhs": 1.1]))).to.beFalse()
+        }
+
+        $0.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") {
+          try expect(expression.evaluate(context: Context(dictionary: ["lhs": true, "rhs": false]))).to.beFalse()
+        }
+
+        $0.it("evaluates to false with different types") {
+          try expect(expression.evaluate(context: Context(dictionary: ["lhs": true, "rhs": 1]))).to.beFalse()
+        }
+      }
+
+      $0.describe("inequality expression") {
+        let expression = try! parseExpression(components: ["lhs", "!=", "rhs"], tokenParser: parser)
+
+        $0.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") {
+          try expect(expression.evaluate(context: Context(dictionary: ["lhs": "b", "rhs": "b"]))).to.beFalse()
+        }
+      }
+
+      $0.describe("more than expression") {
+        let expression = try! parseExpression(components: ["lhs", ">", "rhs"], tokenParser: parser)
+
+        $0.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") {
+          try expect(expression.evaluate(context: Context(dictionary: ["lhs": 5.0, "rhs": 5.0]))).to.beFalse()
+        }
+      }
+
+      $0.describe("more than equal expression") {
+        let expression = try! parseExpression(components: ["lhs", ">=", "rhs"], tokenParser: parser)
+
+        $0.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") {
+          try expect(expression.evaluate(context: Context(dictionary: ["lhs": 5.0, "rhs": 5.1]))).to.beFalse()
+        }
+      }
+
+      $0.describe("less than expression") {
+        let expression = try! parseExpression(components: ["lhs", "<", "rhs"], tokenParser: parser)
+
+        $0.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") {
+          try expect(expression.evaluate(context: Context(dictionary: ["lhs": 5.0, "rhs": 5.0]))).to.beFalse()
+        }
+      }
+
+      $0.describe("less than equal expression") {
+        let expression = try! parseExpression(components: ["lhs", "<=", "rhs"], tokenParser: parser)
+
+        $0.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") {
+          try expect(expression.evaluate(context: Context(dictionary: ["lhs": 5.1, "rhs": 5.0]))).to.beFalse()
+        }
+      }
+
+      $0.describe("multiple expression") {
+        let expression = try! parseExpression(components: ["one", "or", "two", "and", "not", "three"], tokenParser: parser)
+
+        $0.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") {
+          try expect(expression.evaluate(context: Context(dictionary: ["one": true, "three": true]))).to.beTrue()
+        }
+
+        $0.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") {
+          try expect(expression.evaluate(context: Context(dictionary: ["two": true, "three": true]))).to.beFalse()
+        }
+
+        $0.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") {
+          try expect(expression.evaluate(context: Context())).to.beFalse()
+        }
+      }
+    }
+  }
+}

Tests/StencilTests/FilterSpec.swift

@@ -0,0 +1,150 @@
+import Spectre
+@testable import Stencil
+
+
+func testFilter() {
+  describe("template filters") {
+    let context: [String: Any] = ["name": "Kyle"]
+
+    $0.it("allows you to register a custom filter") {
+      let template = Template(templateString: "{{ name|repeat }}")
+
+      let repeatExtension = Extension()
+      repeatExtension.registerFilter("repeat") { (value: Any?) in
+        if let value = value as? String {
+          return "\(value) \(value)"
+        }
+
+        return nil
+      }
+
+      let result = try template.render(Context(dictionary: context, environment: Environment(extensions: [repeatExtension])))
+      try expect(result) == "Kyle Kyle"
+    }
+
+    $0.it("allows you to register a custom filter which accepts arguments") {
+      let template = Template(templateString: "{{ name|repeat:'value' }}")
+
+      let repeatExtension = Extension()
+      repeatExtension.registerFilter("repeat") { value, arguments in
+        if !arguments.isEmpty {
+          return "\(value!) \(value!) with args \(arguments.first!!)"
+        }
+
+        return nil
+      }
+
+      let result = try template.render(Context(dictionary: context, environment: Environment(extensions: [repeatExtension])))
+      try expect(result) == "Kyle Kyle with args value"
+    }
+
+    $0.it("allows you to register a custom which throws") {
+      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("No Repeat"))
+    }
+
+    $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: "{{ name | uppercase }}")
+      let result = try template.render(Context(dictionary: ["name": "kyle"]))
+      try expect(result) == "KYLE"
+    }
+
+    $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("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("default filter") {
+    let template = Template(templateString: "Hello {{ name|default:\"World\" }}")
+
+    $0.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") {
+      let result = try template.render(Context(dictionary: [:]))
+      try expect(result) == "Hello World"
+    }
+
+    $0.it("supports multiple defaults") {
+      let template = Template(templateString: "Hello {{ name|default:a,b,c,\"World\" }}")
+      let result = try template.render(Context(dictionary: [:]))
+      try expect(result) == "Hello World"
+    }
+  }
+
+  describe("join filter") {
+    let template = Template(templateString: "{{ value|join:\", \" }}")
+
+    $0.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") {
+      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") {
+      let template = Template(templateString: "{{ value|join:separator }}")
+      let result = try template.render(Context(dictionary: ["value": ["One", "Two"], "separator": true]))
+      try expect(result) == "OnetrueTwo"
+    }
+
+    $0.it("can join without arguments") {
+      let template = Template(templateString: "{{ value|join }}")
+      let result = try template.render(Context(dictionary: ["value": ["One", "Two"]]))
+      try expect(result) == "OneTwo"
+    }
+  }
+}

Tests/StencilTests/FilterTagSpec.swift

@@ -0,0 +1,25 @@
+import Spectre
+import Stencil
+
+
+func testFilterTag() {
+  describe("Filter Tag") {
+    $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") {
+      let template = Template(templateString: "{% filter lowercase|capitalize %}TEST{% endfilter %}")
+      let result = try template.render()
+      try expect(result) == "Test"
+    }
+
+    $0.it("errors without a filter") {
+      let template = Template(templateString: "{% filter %}Test{% endfilter %}")
+      try expect(try template.render()).toThrow()
+    }
+
+  }
+}

Tests/StencilTests/ForNodeSpec.swift

@@ -0,0 +1,95 @@
+import Spectre
+@testable import Stencil
+import Foundation
+
+
+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(resolvable: 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(resolvable: 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: [
+        "items": ([1, 2, 3] as [Any])
+      ])
+
+      let nodes: [NodeType] = [VariableNode(variable: "item")]
+      let node = ForNode(resolvable: Variable("items"), loopVariable: "item", nodes: nodes, emptyNodes: [])
+      try expect(try node.render(any_context)) == "123"
+    }
+
+#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(resolvable: 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(resolvable: 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(resolvable: 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(resolvable: Variable("items"), loopVariable: "item", nodes: nodes, emptyNodes: [])
+      try expect(try node.render(context)) == "112233"
+    }
+
+    $0.it("can render a filter") {
+      let templateString = "{% for article in ars|default:articles %}" +
+        "- {{ article.title }} by {{ article.author }}.\n" +
+        "{% endfor %}\n"
+
+      let context = Context(dictionary: [
+        "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)
+
+      let fixture = "" +
+        "- Migrating from OCUnit to XCTest by Kyle Fuller.\n" +
+        "- Memory Management with ARC by Kyle Fuller.\n" +
+        "\n"
+
+      try expect(result) == fixture
+    }
+  }
+}
+
+
+fileprivate struct Article {
+  let title: String
+  let author: String
+}

Tests/StencilTests/IfNodeSpec.swift

@@ -0,0 +1,121 @@
+import Spectre
+@testable import Stencil
+
+
+func testIfNode() {
+  describe("IfNode") {
+    $0.describe("parsing") {
+      $0.it("can parse an if block") {
+        let tokens: [Token] = [
+          .block(value: "if value"),
+          .text(value: "true"),
+          .block(value: "else"),
+          .text(value: "false"),
+          .block(value: "endif")
+        ]
+
+        let parser = TokenParser(tokens: tokens, environment: Environment())
+        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?.trueNodes.count) == 1
+        try expect(trueNode?.text) == "true"
+        try expect(node?.falseNodes.count) == 1
+        try expect(falseNode?.text) == "false"
+      }
+
+      $0.it("can parse an if with complex expression") {
+        let tokens: [Token] = [
+          .block(value: "if value == \"test\" and not name"),
+          .text(value: "true"),
+          .block(value: "else"),
+          .text(value: "false"),
+          .block(value: "endif")
+        ]
+
+        let parser = TokenParser(tokens: tokens, environment: Environment())
+        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?.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"),
+          .text(value: "false"),
+          .block(value: "else"),
+          .text(value: "true"),
+          .block(value: "endif")
+        ]
+
+        let parser = TokenParser(tokens: tokens, environment: Environment())
+        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?.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, environment: Environment())
+        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, environment: Environment())
+        let error = TemplateSyntaxError("`endif` was not found.")
+        try expect(try parser.parse()).toThrow(error)
+      }
+    }
+
+    $0.describe("rendering") {
+      $0.it("renders the truth when expression evaluates to true") {
+        let node = IfNode(expression: StaticExpression(value: true), 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(expression: StaticExpression(value: false), trueNodes: [TextNode(text: "true")], falseNodes: [TextNode(text: "false")])
+        try expect(try node.render(Context())) == "false"
+      }
+    }
+
+    $0.it("supports variable filters in the if expression") {
+        let tokens: [Token] = [
+          .block(value: "if value|uppercase == \"TEST\""),
+          .text(value: "true"),
+          .block(value: "endif")
+        ]
+
+        let parser = TokenParser(tokens: tokens, environment: Environment())
+        let nodes = try parser.parse()
+
+        let result = try renderNodes(nodes, Context(dictionary: ["value": "test"]))
+        try expect(result) == "true"
+    }
+  }
+}

Tests/StencilTests/IncludeSpec.swift

@@ -0,0 +1,61 @@
+import Spectre
+@testable import Stencil
+import PathKit
+
+
+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") {
+        let tokens: [Token] = [ .block(value: "include") ]
+        let parser = TokenParser(tokens: tokens, environment: Environment())
+
+        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, environment: Environment())
+
+        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 named `test.html` does not exist. No loaders found"
+        }
+      }
+
+      $0.it("throws an error when it cannot find the included template") {
+        let node = IncludeNode(templateName: Variable("\"unknown.html\""))
+
+        do {
+          _ = try node.render(Context(environment: 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") {
+        let node = IncludeNode(templateName: Variable("\"test.html\""))
+        let context = Context(dictionary: ["target": "World"], environment: environment)
+        let value = try node.render(context)
+        try expect(value) == "Hello World!"
+      }
+    }
+  }
+}

Tests/StencilTests/InheritenceSpec.swift

@@ -0,0 +1,27 @@
+import Spectre
+import Stencil
+import PathKit
+
+
+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 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 template = try environment.loadTemplate(name: "child-child.html")
+      try expect(try template.render()) == "Child Child Header\nChild"
+    }
+
+    $0.it("can inherit from a template that calls a super block") {
+      let template = try environment.loadTemplate(name: "child-super.html")
+      try expect(try template.render()) == "Header\nChild Body"
+    }
+  }
+}

Tests/StencilTests/LexerSpec.swift

@@ -0,0 +1,50 @@
+import Spectre
+@testable import Stencil
+
+
+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) == .text(value: "Hello World")
+    }
+
+    $0.it("can tokenize a comment") {
+      let lexer = Lexer(templateString: "{# Comment #}")
+      let tokens = lexer.tokenize()
+
+      try expect(tokens.count) == (1)
+      try expect(tokens.first) == .comment(value: "Comment")
+    }
+
+    $0.it("can tokenize a variable") {
+      let lexer = Lexer(templateString: "{{ Variable }}")
+      let tokens = lexer.tokenize()
+
+      try expect(tokens.count) == 1
+      try expect(tokens.first) == .variable(value: "Variable")
+    }
+
+    $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: ".")
+    }
+
+    $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")
+    }
+  }
+}

Tests/StencilTests/LoaderSpec.swift

@@ -0,0 +1,32 @@
+import Spectre
+import Stencil
+import PathKit
+
+
+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 environment.loadTemplate(name: "unknown.html")).toThrow()
+    }
+
+    $0.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") {
+      _ = try environment.loadTemplate(name: "test.html")
+    }
+
+    $0.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") {
+      try expect(try environment.loadTemplate(name: "../LoaderSpec.swift")).toThrow()
+    }
+  }
+}

Tests/StencilTests/NodeSpec.swift

@@ -0,0 +1,60 @@
+import Spectre
+@testable import Stencil
+
+
+class ErrorNode : NodeType {
+  func render(_ context: Context) throws -> String {
+    throw TemplateSyntaxError("Custom Error")
+  }
+}
+
+
+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.it("resolves and renders a non string variable") {
+        let node = VariableNode(variable: Variable("age"))
+        try expect(try node.render(context)) == "27"
+      }
+    }
+
+    $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("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

@@ -0,0 +1,43 @@
+import Foundation
+import Spectre
+@testable import Stencil
+
+
+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, environment: Environment())
+
+        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, 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\""
+      }
+    }
+
+    $0.describe("rendering") {
+      $0.it("renders the date") {
+        let node = NowNode(format: Variable("\"yyyy-MM-dd\""))
+
+        let formatter = DateFormatter()
+        formatter.dateFormat = "yyyy-MM-dd"
+        let date = formatter.string(from: NSDate() as Date)
+
+        try expect(try node.render(Context())) == date
+      }
+    }
+  }
+#endif
+}

Tests/StencilTests/ParserSpec.swift

@@ -0,0 +1,62 @@
+import Spectre
+@testable import Stencil
+
+
+func testTokenParser() {
+  describe("TokenParser") {
+    $0.it("can parse a text token") {
+      let parser = TokenParser(tokens: [
+        .text(value: "Hello World")
+      ], environment: Environment())
+
+      let nodes = try parser.parse()
+      let node = nodes.first as? TextNode
+
+      try expect(nodes.count) == 1
+      try expect(node?.text) == "Hello World"
+    }
+
+    $0.it("can parse a variable token") {
+      let parser = TokenParser(tokens: [
+        .variable(value: "'name'")
+      ], environment: Environment())
+
+      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: [
+        .comment(value: "Secret stuff!")
+      ], environment: Environment())
+
+      let nodes = try parser.parse()
+      try expect(nodes.count) == 0
+    }
+
+    $0.it("can parse a tag token") {
+      let simpleExtension = Extension()
+      simpleExtension.registerSimpleTag("known") { _ in
+        return ""
+      }
+
+      let parser = TokenParser(tokens: [
+        .block(value: "known"),
+      ], environment: Environment(extensions: [simpleExtension]))
+
+      let nodes = try parser.parse()
+      try expect(nodes.count) == 1
+    }
+
+    $0.it("errors when parsing an unknown tag") {
+      let parser = TokenParser(tokens: [
+        .block(value: "unknown"),
+      ], environment: Environment())
+
+      try expect(try parser.parse()).toThrow(TemplateSyntaxError("Unknown template tag 'unknown'"))
+    }
+  }
+}

Tests/StencilTests/StencilSpec.swift

@@ -0,0 +1,69 @@
+import Spectre
+import Stencil
+
+
+fileprivate class CustomNode : NodeType {
+  func render(_ context:Context) throws -> String {
+    return "Hello World"
+  }
+}
+
+
+fileprivate struct Article {
+  let title: String
+  let author: String
+}
+
+
+func testStencil() {
+  describe("Stencil") {
+    let exampleExtension = Extension()
+
+    exampleExtension.registerSimpleTag("simpletag") { context in
+      return "Hello World"
+    }
+
+    exampleExtension.registerTag("customtag") { parser, token in
+      return CustomNode()
+    }
+
+    let environment = Environment(extensions: [exampleExtension])
+
+    $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 = [
+        "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)
+
+      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 result = try environment.renderTemplate(string: "{% customtag %}")
+      try expect(result) == "Hello World"
+    }
+
+    $0.it("can render a simple custom tag") {
+      let result = try environment.renderTemplate(string: "{% simpletag %}")
+      try expect(result) == "Hello World"
+    }
+  }
+}

Tests/StencilTests/TemplateSpec.swift

@@ -0,0 +1,19 @@
+import Spectre
+import Stencil
+
+
+func testTemplate() {
+  describe("Template") {
+    $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") {
+        let template: Template = "Hello World"
+        let result = try template.render([ "name": "Kyle" ])
+        try expect(result) == "Hello World"
+    }
+  }
+}

Tests/StencilTests/TokenSpec.swift

@@ -0,0 +1,34 @@
+import Spectre
+import Stencil
+
+
+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"
+    }
+
+    $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'"
+    }
+
+    $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\""
+    }
+  }
+}

Tests/StencilTests/VariableSpec.swift

@@ -0,0 +1,118 @@
+import Foundation
+import Spectre
+@testable import Stencil
+
+
+#if os(OSX)
+@objc class Object : NSObject {
+  let title = "Hello World"
+}
+#endif
+
+fileprivate struct Person {
+  let name: String
+}
+
+fileprivate struct Article {
+  let author: Person
+}
+
+
+func testVariable() {
+  describe("Variable") {
+    let context = Context(dictionary: [
+      "name": "Kyle",
+      "contacts": ["Katie", "Carlton"],
+      "profiles": [
+        "github": "kylef",
+      ],
+      "article": Article(author: Person(name: "Kyle"))
+    ])
+
+#if os(OSX)
+    context["object"] = Object()
+#endif
+
+    $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 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 integer literal") {
+      let variable = Variable("5")
+      let result = try variable.resolve(context) as? Number
+      try expect(result) == 5
+    }
+
+    $0.it("can resolve an float literal") {
+      let variable = Variable("3.14")
+      let result = try variable.resolve(context) as? Number
+      try expect(result) == 3.14
+    }
+
+    $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 a dictionary") {
+      let variable = Variable("profiles.github")
+      let result = try variable.resolve(context) as? String
+      try expect(result) == "kylef"
+    }
+
+    $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"
+
+        let variable1 = Variable("contacts.1")
+        let result1 = try variable1.resolve(context) as? String
+        try expect(result1) == "Carlton"
+    }
+
+    $0.it("can resolve an item from an array via unknown index") {
+      let variable = Variable("contacts.5")
+      let result = try variable.resolve(context) as? String
+      try expect(result).to.beNil()
+
+      let variable1 = Variable("contacts.-5")
+      let result1 = try variable1.resolve(context) as? String
+      try expect(result1).to.beNil()
+    }
+
+    $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 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 a property with reflection") {
+      let variable = Variable("article.author.name")
+      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"
+    }
+#endif
+  }
+}

Tests/StencilTests/XCTest.swift

@@ -0,0 +1,30 @@
+import XCTest
+
+
+public func stencilTests() {
+  testContext()
+  testFilter()
+  testLexer()
+  testToken()
+  testTokenParser()
+  testTemplateLoader()
+  testTemplate()
+  testVariable()
+  testNode()
+  testForNode()
+  testExpressions()
+  testIfNode()
+  testNowNode()
+  testInclude()
+  testInheritence()
+  testFilterTag()
+  testEnvironment()
+  testStencil()
+}
+
+
+class StencilTests: XCTestCase {
+  func testRunStencilTests() {
+    stencilTests()
+  }
+}

Tests/StencilTests/fixtures/child-child.html

@@ -0,0 +1,2 @@
+{% extends "child.html" %}
+{% block header %}Child Child Header{% endblock %}

Tests/StencilTests/fixtures/child-super.html

@@ -0,0 +1,3 @@
+{% extends "base.html" %}
+{% block body %}Child {{ block.super }}{% endblock %}
+

circle.yml

@@ -1,15 +0,0 @@
-machine:
-  xcode:
-    version: "7.0"
-
-test:
-  override:
-    - set -o pipefail && xcodebuild -workspace Stencil.xcworkspace -scheme Stencil test | tee $CIRCLE_ARTIFACTS/xcode_raw_ios.log | xcpretty -c
-    - pod lib lint
-
-deployment:
-  release:
-    tag: /.*/
-    commands:
-      - pod trunk push
-

docs/Makefile

@@ -0,0 +1,225 @@
+# Makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line.
+SPHINXOPTS    =
+SPHINXBUILD   = sphinx-build
+PAPER         =
+BUILDDIR      = _build
+
+# Internal variables.
+PAPEROPT_a4     = -D latex_paper_size=a4
+PAPEROPT_letter = -D latex_paper_size=letter
+ALLSPHINXOPTS   = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
+# the i18n builder cannot share the environment and doctrees with the others
+I18NSPHINXOPTS  = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
+
+.PHONY: help
+help:
+	@echo "Please use \`make <target>' where <target> is one of"
+	@echo "  html       to make standalone HTML files"
+	@echo "  dirhtml    to make HTML files named index.html in directories"
+	@echo "  singlehtml to make a single large HTML file"
+	@echo "  pickle     to make pickle files"
+	@echo "  json       to make JSON files"
+	@echo "  htmlhelp   to make HTML files and a HTML help project"
+	@echo "  qthelp     to make HTML files and a qthelp project"
+	@echo "  applehelp  to make an Apple Help Book"
+	@echo "  devhelp    to make HTML files and a Devhelp project"
+	@echo "  epub       to make an epub"
+	@echo "  epub3      to make an epub3"
+	@echo "  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
+	@echo "  latexpdf   to make LaTeX files and run them through pdflatex"
+	@echo "  latexpdfja to make LaTeX files and run them through platex/dvipdfmx"
+	@echo "  text       to make text files"
+	@echo "  man        to make manual pages"
+	@echo "  texinfo    to make Texinfo files"
+	@echo "  info       to make Texinfo files and run them through makeinfo"
+	@echo "  gettext    to make PO message catalogs"
+	@echo "  changes    to make an overview of all changed/added/deprecated items"
+	@echo "  xml        to make Docutils-native XML files"
+	@echo "  pseudoxml  to make pseudoxml-XML files for display purposes"
+	@echo "  linkcheck  to check all external links for integrity"
+	@echo "  doctest    to run all doctests embedded in the documentation (if enabled)"
+	@echo "  coverage   to run coverage check of the documentation (if enabled)"
+	@echo "  dummy      to check syntax errors of document sources"
+
+.PHONY: clean
+clean:
+	rm -rf $(BUILDDIR)/*
+
+.PHONY: html
+html:
+	$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
+	@echo
+	@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
+
+.PHONY: dirhtml
+dirhtml:
+	$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
+	@echo
+	@echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
+
+.PHONY: singlehtml
+singlehtml:
+	$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
+	@echo
+	@echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
+
+.PHONY: pickle
+pickle:
+	$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
+	@echo
+	@echo "Build finished; now you can process the pickle files."
+
+.PHONY: json
+json:
+	$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
+	@echo
+	@echo "Build finished; now you can process the JSON files."
+
+.PHONY: htmlhelp
+htmlhelp:
+	$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
+	@echo
+	@echo "Build finished; now you can run HTML Help Workshop with the" \
+	      ".hhp project file in $(BUILDDIR)/htmlhelp."
+
+.PHONY: qthelp
+qthelp:
+	$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
+	@echo
+	@echo "Build finished; now you can run "qcollectiongenerator" with the" \
+	      ".qhcp project file in $(BUILDDIR)/qthelp, like this:"
+	@echo "# qcollectiongenerator $(BUILDDIR)/qthelp/Stencil.qhcp"
+	@echo "To view the help file:"
+	@echo "# assistant -collectionFile $(BUILDDIR)/qthelp/Stencil.qhc"
+
+.PHONY: applehelp
+applehelp:
+	$(SPHINXBUILD) -b applehelp $(ALLSPHINXOPTS) $(BUILDDIR)/applehelp
+	@echo
+	@echo "Build finished. The help book is in $(BUILDDIR)/applehelp."
+	@echo "N.B. You won't be able to view it unless you put it in" \
+	      "~/Library/Documentation/Help or install it in your application" \
+	      "bundle."
+
+.PHONY: devhelp
+devhelp:
+	$(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
+	@echo
+	@echo "Build finished."
+	@echo "To view the help file:"
+	@echo "# mkdir -p $$HOME/.local/share/devhelp/Stencil"
+	@echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/Stencil"
+	@echo "# devhelp"
+
+.PHONY: epub
+epub:
+	$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
+	@echo
+	@echo "Build finished. The epub file is in $(BUILDDIR)/epub."
+
+.PHONY: epub3
+epub3:
+	$(SPHINXBUILD) -b epub3 $(ALLSPHINXOPTS) $(BUILDDIR)/epub3
+	@echo
+	@echo "Build finished. The epub3 file is in $(BUILDDIR)/epub3."
+
+.PHONY: latex
+latex:
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo
+	@echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
+	@echo "Run \`make' in that directory to run these through (pdf)latex" \
+	      "(use \`make latexpdf' here to do that automatically)."
+
+.PHONY: latexpdf
+latexpdf:
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo "Running LaTeX files through pdflatex..."
+	$(MAKE) -C $(BUILDDIR)/latex all-pdf
+	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
+
+.PHONY: latexpdfja
+latexpdfja:
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo "Running LaTeX files through platex and dvipdfmx..."
+	$(MAKE) -C $(BUILDDIR)/latex all-pdf-ja
+	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
+
+.PHONY: text
+text:
+	$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
+	@echo
+	@echo "Build finished. The text files are in $(BUILDDIR)/text."
+
+.PHONY: man
+man:
+	$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man
+	@echo
+	@echo "Build finished. The manual pages are in $(BUILDDIR)/man."
+
+.PHONY: texinfo
+texinfo:
+	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
+	@echo
+	@echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo."
+	@echo "Run \`make' in that directory to run these through makeinfo" \
+	      "(use \`make info' here to do that automatically)."
+
+.PHONY: info
+info:
+	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
+	@echo "Running Texinfo files through makeinfo..."
+	make -C $(BUILDDIR)/texinfo info
+	@echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo."
+
+.PHONY: gettext
+gettext:
+	$(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale
+	@echo
+	@echo "Build finished. The message catalogs are in $(BUILDDIR)/locale."
+
+.PHONY: changes
+changes:
+	$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
+	@echo
+	@echo "The overview file is in $(BUILDDIR)/changes."
+
+.PHONY: linkcheck
+linkcheck:
+	$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
+	@echo
+	@echo "Link check complete; look for any errors in the above output " \
+	      "or in $(BUILDDIR)/linkcheck/output.txt."
+
+.PHONY: doctest
+doctest:
+	$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
+	@echo "Testing of doctests in the sources finished, look at the " \
+	      "results in $(BUILDDIR)/doctest/output.txt."
+
+.PHONY: coverage
+coverage:
+	$(SPHINXBUILD) -b coverage $(ALLSPHINXOPTS) $(BUILDDIR)/coverage
+	@echo "Testing of coverage in the sources finished, look at the " \
+	      "results in $(BUILDDIR)/coverage/python.txt."
+
+.PHONY: xml
+xml:
+	$(SPHINXBUILD) -b xml $(ALLSPHINXOPTS) $(BUILDDIR)/xml
+	@echo
+	@echo "Build finished. The XML files are in $(BUILDDIR)/xml."
+
+.PHONY: pseudoxml
+pseudoxml:
+	$(SPHINXBUILD) -b pseudoxml $(ALLSPHINXOPTS) $(BUILDDIR)/pseudoxml
+	@echo
+	@echo "Build finished. The pseudo-XML files are in $(BUILDDIR)/pseudoxml."
+
+.PHONY: dummy
+dummy:
+	$(SPHINXBUILD) -b dummy $(ALLSPHINXOPTS) $(BUILDDIR)/dummy
+	@echo
+	@echo "Build finished. Dummy builder generates no files."

docs/_templates/sidebar_intro.html

@@ -0,0 +1,33 @@
+<h1><a href="/">Stencil</a></h1>
+
+<p>
+  <iframe
+      src="https://ghbtns.com/github-btn.html?user=kylef&repo=Stencil&type=watch&count=true&size=large"
+      allowtransparency="true" frameborder="0" scrolling="0" width="200px" height="35px">
+  </iframe>
+</p>
+
+<p>Stencil is a simple and powerful template language for Swift.</p>
+
+<div class="social">
+  <p>
+    <iframe
+      src="https://ghbtns.com/github-btn.html?user=kylef&type=follow&count=false"
+      allowtransparency="true" frameborder="0" scrolling="0" width="200" height="20">
+    </iframe>
+  </p>
+
+  <p>
+    <a href="https://twitter.com/kylefuller" class="twitter-follow-button" data-show-count="false">Follow @kylefuller</a> <script>!function(d,s,id){var js,fjs=d.getElementsByTagName(s)[0],p=/^http:/.test(d.location)?'http':'https';if(!d.getElementById(id)){js=d.createElement(s);js.id=id;js.src=p+'://platform.twitter.com/widgets.js';fjs.parentNode.insertBefore(js,fjs);}}(document, 'script', 'twitter-wjs');</script>
+  </p>
+</div>
+
+<h3>Other Projects</h3>
+
+<p>More <a href="https://fuller.li/">Kyle Fuller</a> projects:</p>
+<ul>
+  <li><a href="https://github.com/kylef/Commander">Commander</a></li>
+  <li><a href="https://curassow.fuller.li/">Curassow</a></li>
+  <li><a href="https://github.com/kylef/Spectre">Spectre</a></li>
+  <li><a href="https://github.com/kylef/heroku-buildpack-swift">Heroku Swift buildpack</a></li>
+</ul>

docs/api.rst

@@ -0,0 +1,140 @@
+Template API
+============
+
+This document describes Stencils Swift API, and not the Swift template language.
+
+.. contents:: :depth: 2
+
+Environment
+-----------
+
+An environment contains shared configuration such as custom filters and tags
+along with template loaders.
+
+.. code-block:: swift
+
+    let environment = Environment()
+
+You can optionally provide a loader or extensions when creating an environment:
+
+.. code-block:: swift
+
+    let environment = Environment(loader: ..., extensions: [...])
+
+Rendering a Template
+~~~~~~~~~~~~~~~~~~~~
+
+Environment provides convinience methods to render a template either from a
+string or a template loader.
+
+.. code-block:: swift
+
+    let template = "Hello {{ name }}"
+    let context = ["name": "Kyle"]
+    let rendered = environment.renderTemplate(string: template, context: context)
+
+Rendering a template from the configured loader:
+
+.. code-block:: swift
+
+    let context = ["name": "Kyle"]
+    let rendered = environment.renderTemplate(name: "example.html", context: context)
+
+Loading a Template
+~~~~~~~~~~~~~~~~~~
+
+Environment provides an API to load a template from the configured loader.
+
+.. code-block:: swift
+
+    let template = try environment.loadTemplate(name: "example.html")
+
+Loader
+------
+
+Loaders are responsible for loading templates from a resource such as the file
+system.
+
+Stencil provides a ``FileSytemLoader`` which allows you to load a template
+directly from the file system.
+
+FileSystemLoader
+~~~~~~~~~~~~~~~~
+
+Loads templates from the file system. This loader can find templates in folders
+on the file system.
+
+.. code-block:: swift
+
+    FileSystemLoader(paths: ["./templates"])
+
+.. code-block:: swift
+
+    FileSystemLoader(bundle: [Bundle.main])
+
+
+Custom Loaders
+~~~~~~~~~~~~~~
+
+``Loader`` is a protocol, so you can implement your own compatible loaders. You
+will need to implement a ``loadTemplate`` method to load the template,
+throwing a ``TemplateDoesNotExist`` when the template is not found.
+
+.. code-block:: swift
+
+    class ExampleMemoryLoader: Loader {
+      func loadTemplate(name: String, environment: Environment) throws -> Template {
+        if name == "index.html" {
+          return Template(templateString: "Hello", environment: environment)
+        }
+
+        throw TemplateDoesNotExist(name: name, loader: self)
+      }
+    }
+
+
+Context
+-------
+
+A ``Context`` is a structure containing any templates you would like to use in
+a template. It’s somewhat like a dictionary, however you can push and pop to
+scope variables. So that means that when iterating over a for loop, you can
+push a new scope into the context to store any variables local to the scope.
+
+You would normally only access the ``Context`` within a custom template tag or
+filter.
+
+Subscripting
+~~~~~~~~~~~~
+
+You can use subscripting to get and set values from the context.
+
+.. code-block:: swift
+
+    context["key"] = value
+    let value = context["key"]
+
+``push()``
+~~~~~~~~~~
+
+A ``Context`` is a stack. You can push a new level onto the ``Context`` so that
+modifications can easily be poped off. This is useful for isolating mutations
+into scope of a template tag. Such as ``{% if %}`` and ``{% for %}`` tags.
+
+.. code-block:: swift
+
+    context.push(["name": "example"]) {
+        // context contains name which is `example`.
+    }
+
+    // name is popped off the context after the duration of the closure.
+
+``flatten()``
+~~~~~~~~~~~~~
+
+Using ``flatten()`` method you can get whole ``Context`` stack as one
+dictionary including all variables.
+
+.. code-block:: swift
+
+    let dictionary = context.flatten()

docs/builtins.rst

@@ -0,0 +1,288 @@
+Built-in template tags and filters
+==================================
+
+.. _built-in-tags:
+
+Built-in Tags
+-------------
+
+``for``
+~~~~~~~
+
+A for loop allows you to iterate over an array found by variable lookup.
+
+.. code-block:: html+django
+
+    <ul>
+      {% for user in users %}
+        <li>{{ user }}</li>
+      {% endfor %}
+    </ul>
+
+The ``for`` tag can take an optional ``{% empty %}`` block that will be
+displayed if the given list is empty or could not be found.
+
+.. code-block:: html+django
+
+    <ul>
+      {% for user in users %}
+        <li>{{ user }}</li>
+      {% empty %}
+        <li>There are no users.</li>
+      {% endfor %}
+    </ul>
+
+The for block sets a few variables available within the loop:
+
+- ``first`` - True if this is the first time through the loop
+- ``last`` - True if this is the last time through the loop
+- ``counter`` - The current iteration of the loop
+
+``if``
+~~~~~~
+
+The ``{% if %}`` tag evaluates a variable, and if that variable evaluates to
+true the contents of the block are processed. Being true is defined as:
+
+* Present in the context
+* Being non-empty (dictionaries or arrays)
+* Not being a false boolean value
+* Not being a numerical value of 0 or below
+* Not being an empty string
+
+.. code-block:: html+django
+
+    {% if variable %}
+      The variable was found in the current context.
+    {% else %}
+      The variable was not found.
+    {% endif %}
+
+Operators
+^^^^^^^^^
+
+``if`` tags may combine ``and``, ``or`` and ``not`` to test multiple variables
+or to negate a variable.
+
+.. code-block:: html+django
+
+    {% if one and two %}
+        Both one and two evaluate to true.
+    {% endif %}
+
+    {% if not one %}
+        One evaluates to false
+    {% endif %}
+
+    {% if one or two %}
+        Either one or two evaluates to true.
+    {% endif %}
+
+    {% if not one or two %}
+        One does not evaluate to false or two evaluates to true.
+    {% endif %}
+
+You may use ``and``, ``or`` and ``not`` multiple times together. ``not`` has
+higest prescidence followed by ``and``. For example:
+
+.. code-block:: html+django
+
+    {% if one or two and three %}
+
+Will be treated as:
+
+.. code-block:: text
+
+    one or (two and three)
+
+``==`` operator
+"""""""""""""""
+
+.. code-block:: html+django
+
+    {% if value == other_value %}
+      value is equal to other_value
+    {% endif %}
+
+.. note:: The equality operator only supports numerical, string and boolean types.
+
+``!=`` operator
+"""""""""""""""
+
+.. code-block:: html+django
+
+    {% if value != other_value %}
+      value is not equal to other_value
+    {% endif %}
+
+.. note:: The inequality operator only supports numerical, string and boolean types.
+
+``<`` operator
+"""""""""""""""
+
+.. code-block:: html+django
+
+    {% if value < other_value %}
+      value is less than other_value
+    {% endif %}
+
+.. note:: The less than operator only supports numerical types.
+
+``<=`` operator
+"""""""""""""""
+
+.. code-block:: html+django
+
+    {% if value <= other_value %}
+      value is less than or equal to other_value
+    {% endif %}
+
+.. note:: The less than equal operator only supports numerical types.
+
+``>`` operator
+"""""""""""""""
+
+.. code-block:: html+django
+
+    {% if value > other_value %}
+      value is more than other_value
+    {% endif %}
+
+.. note:: The more than operator only supports numerical types.
+
+``>=`` operator
+"""""""""""""""
+
+.. code-block:: html+django
+
+    {% if value >= other_value %}
+      value is more than or equal to other_value
+    {% endif %}
+
+.. note:: The more than equal operator only supports numerical types.
+
+``ifnot``
+~~~~~~~~~
+
+.. note:: ``{% ifnot %}`` is deprecated. You should use ``{% if not %}``.
+
+.. code-block:: html+django
+
+    {% ifnot variable %}
+      The variable was NOT found in the current context.
+    {% else %}
+      The variable was found.
+    {% endif %}
+
+``now``
+~~~~~~~
+
+``filter``
+~~~~~~~~~~
+
+Filters the contents of the block.
+
+.. code-block:: html+django
+
+    {% filter lowercase %}
+      This Text Will Be Lowercased.
+    {% endfilter %}
+
+You can chain multiple filters with a pipe (`|`).
+
+.. code-block:: html+django
+
+    {% filter lowercase|capitalize %}
+      This Text Will First Be Lowercased, Then The First Character Will BE
+      Capitalised.
+    {% endfilter %}
+
+``include``
+~~~~~~~~~~~
+
+You can include another template using the `include` tag.
+
+.. code-block:: html+django
+
+    {% include "comment.html" %}
+
+The `include` tag requires you to provide a loader which will be used to lookup
+the template.
+
+.. code-block:: swift
+
+    let environment = Environment(bundle: [Bundle.main])
+    let template = environment.loadTemplate(name: "index.html")
+
+``extends``
+~~~~~~~~~~~
+
+Extends the template from a parent template.
+
+.. code-block:: html+django
+
+    {% extends "base.html" %}
+
+See :ref:`template-inheritance` for more information.
+
+``block``
+~~~~~~~~~
+
+Defines a block that can be overridden by child templates. See
+:ref:`template-inheritance` for more information.
+
+.. _built-in-filters:
+
+Built-in Filters
+----------------
+
+``capitalize``
+~~~~~~~~~~~~~~
+
+The capitalize filter allows you to capitalize a string.
+For example, `stencil` to `Stencil`.
+
+.. code-block:: html+django
+
+    {{ "stencil"|capitalize }}
+
+``uppercase``
+~~~~~~~~~~~~~
+
+The uppercase filter allows you to transform a string to uppercase.
+For example, `Stencil` to `STENCIL`.
+
+.. code-block:: html+django
+
+    {{ "Stencil"|uppercase }}
+
+``lowercase``
+~~~~~~~~~~~~~
+
+The uppercase filter allows you to transform a string to lowercase.
+For example, `Stencil` to `stencil`.
+
+.. code-block:: html+django
+
+    {{ "Stencil"|lowercase }}
+
+``default``
+~~~~~~~~~~~
+
+If a variable not present in the context, use given default. Otherwise, use the
+value of the variable. For example:
+
+.. code-block:: html+django
+
+    Hello {{ name|default:"World" }}
+
+``join``
+~~~~~~~~
+
+Join an array of items.
+
+.. code-block:: html+django
+
+    {{ value|join:", " }}
+
+.. note:: The value MUST be an array.

docs/conf.py

@@ -0,0 +1,341 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# Stencil documentation build configuration file, created by
+# sphinx-quickstart on Sun Nov 27 05:54:36 2016.
+#
+# This file is execfile()d with the current directory set to its
+# containing dir.
+#
+# Note that not all possible configuration values are present in this
+# autogenerated file.
+#
+# All configuration values have a default; values that are commented out
+# serve to show the default.
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#
+# import os
+# import sys
+# sys.path.insert(0, os.path.abspath('.'))
+
+# -- General configuration ------------------------------------------------
+
+# If your documentation needs a minimal Sphinx version, state it here.
+#
+# needs_sphinx = '1.0'
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = []
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# The suffix(es) of source filenames.
+# You can specify multiple suffix as a list of string:
+#
+# source_suffix = ['.rst', '.md']
+source_suffix = '.rst'
+
+# The encoding of source files.
+#
+# source_encoding = 'utf-8-sig'
+
+# The master toctree document.
+master_doc = 'index'
+
+# General information about the project.
+project = 'Stencil'
+copyright = '2016, Kyle Fuller'
+author = 'Kyle Fuller'
+
+# The version info for the project you're documenting, acts as replacement for
+# |version| and |release|, also used in various other places throughout the
+# built documents.
+#
+# The short X.Y version.
+version = '0.7.0'
+# The full version, including alpha/beta/rc tags.
+release = '0.7.0'
+
+# The language for content autogenerated by Sphinx. Refer to documentation
+# for a list of supported languages.
+#
+# This is also used if you do content translation via gettext catalogs.
+# Usually you set "language" from the command line for these cases.
+language = None
+
+# There are two options for replacing |today|: either, you set today to some
+# non-false value, then it is used:
+#
+# today = ''
+#
+# Else, today_fmt is used as the format for a strftime call.
+#
+# today_fmt = '%B %d, %Y'
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This patterns also effect to html_static_path and html_extra_path
+exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
+
+# The reST default role (used for this markup: `text`) to use for all
+# documents.
+#
+# default_role = None
+
+# If true, '()' will be appended to :func: etc. cross-reference text.
+#
+# add_function_parentheses = True
+
+# If true, the current module name will be prepended to all description
+# unit titles (such as .. function::).
+#
+# add_module_names = True
+
+# If true, sectionauthor and moduleauthor directives will be shown in the
+# output. They are ignored by default.
+#
+# show_authors = False
+
+# The name of the Pygments (syntax highlighting) style to use.
+pygments_style = 'sphinx'
+
+# A list of ignored prefixes for module index sorting.
+# modindex_common_prefix = []
+
+# If true, keep warnings as "system message" paragraphs in the built documents.
+# keep_warnings = False
+
+# If true, `todo` and `todoList` produce output, else they produce nothing.
+todo_include_todos = False
+
+
+# -- Options for HTML output ----------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+#
+html_theme = 'alabaster'
+
+# Theme options are theme-specific and customize the look and feel of a theme
+# further.  For a list of options available for each theme, see the
+# documentation.
+#
+# html_theme_options = {}
+
+# Add any paths that contain custom themes here, relative to this directory.
+# html_theme_path = []
+
+# The name for this set of Sphinx documents.
+# "<project> v<release> documentation" by default.
+#
+# html_title = 'Stencil v0.6.0'
+
+# A shorter title for the navigation bar.  Default is the same as html_title.
+#
+# html_short_title = None
+
+# The name of an image file (relative to this directory) to place at the top
+# of the sidebar.
+#
+# html_logo = None
+
+# The name of an image file (relative to this directory) to use as a favicon of
+# the docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
+# pixels large.
+#
+# html_favicon = None
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ['_static']
+
+# Add any extra paths that contain custom files (such as robots.txt or
+# .htaccess) here, relative to this directory. These files are copied
+# directly to the root of the documentation.
+#
+# html_extra_path = []
+
+# If not None, a 'Last updated on:' timestamp is inserted at every page
+# bottom, using the given strftime format.
+# The empty string is equivalent to '%b %d, %Y'.
+#
+# html_last_updated_fmt = None
+
+# If true, SmartyPants will be used to convert quotes and dashes to
+# typographically correct entities.
+#
+# html_use_smartypants = True
+
+# Custom sidebar templates, maps document names to template names.
+html_sidebars = {
+    'index': ['sidebar_intro.html', 'searchbox.html'],
+    '**': ['sidebar_intro.html', 'localtoc.html', 'relations.html', 'searchbox.html'],
+}
+
+# Additional templates that should be rendered to pages, maps page names to
+# template names.
+#
+# html_additional_pages = {}
+
+# If false, no module index is generated.
+#
+# html_domain_indices = True
+
+# If false, no index is generated.
+#
+# html_use_index = True
+
+# If true, the index is split into individual pages for each letter.
+#
+# html_split_index = False
+
+# If true, links to the reST sources are added to the pages.
+#
+# html_show_sourcelink = True
+
+# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
+#
+# html_show_sphinx = True
+
+# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
+#
+# html_show_copyright = True
+
+# If true, an OpenSearch description file will be output, and all pages will
+# contain a <link> tag referring to it.  The value of this option must be the
+# base URL from which the finished HTML is served.
+#
+# html_use_opensearch = ''
+
+# This is the file name suffix for HTML files (e.g. ".xhtml").
+# html_file_suffix = None
+
+# Language to be used for generating the HTML full-text search index.
+# Sphinx supports the following languages:
+#   'da', 'de', 'en', 'es', 'fi', 'fr', 'h', 'it', 'ja'
+#   'nl', 'no', 'pt', 'ro', 'r', 'sv', 'tr', 'zh'
+#
+# html_search_language = 'en'
+
+# A dictionary with options for the search language support, empty by default.
+# 'ja' uses this config value.
+# 'zh' user can custom change `jieba` dictionary path.
+#
+# html_search_options = {'type': 'default'}
+
+# The name of a javascript file (relative to the configuration directory) that
+# implements a search results scorer. If empty, the default will be used.
+#
+# html_search_scorer = 'scorer.js'
+
+# Output file base name for HTML help builder.
+htmlhelp_basename = 'Stencildoc'
+
+# -- Options for LaTeX output ---------------------------------------------
+
+latex_elements = {
+     # The paper size ('letterpaper' or 'a4paper').
+     #
+     # 'papersize': 'letterpaper',
+
+     # The font size ('10pt', '11pt' or '12pt').
+     #
+     # 'pointsize': '10pt',
+
+     # Additional stuff for the LaTeX preamble.
+     #
+     # 'preamble': '',
+
+     # Latex figure (float) alignment
+     #
+     # 'figure_align': 'htbp',
+}
+
+# Grouping the document tree into LaTeX files. List of tuples
+# (source start file, target name, title,
+#  author, documentclass [howto, manual, or own class]).
+latex_documents = [
+    (master_doc, 'Stencil.tex', 'Stencil Documentation',
+     'Kyle Fuller', 'manual'),
+]
+
+# The name of an image file (relative to this directory) to place at the top of
+# the title page.
+#
+# latex_logo = None
+
+# For "manual" documents, if this is true, then toplevel headings are parts,
+# not chapters.
+#
+# latex_use_parts = False
+
+# If true, show page references after internal links.
+#
+# latex_show_pagerefs = False
+
+# If true, show URL addresses after external links.
+#
+# latex_show_urls = False
+
+# Documents to append as an appendix to all manuals.
+#
+# latex_appendices = []
+
+# It false, will not define \strong, \code, 	itleref, \crossref ... but only
+# \sphinxstrong, ..., \sphinxtitleref, ... To help avoid clash with user added
+# packages.
+#
+# latex_keep_old_macro_names = True
+
+# If false, no module index is generated.
+#
+# latex_domain_indices = True
+
+
+# -- Options for manual page output ---------------------------------------
+
+# One entry per manual page. List of tuples
+# (source start file, name, description, authors, manual section).
+man_pages = [
+    (master_doc, 'stencil', 'Stencil Documentation',
+     [author], 1)
+]
+
+# If true, show URL addresses after external links.
+#
+# man_show_urls = False
+
+
+# -- Options for Texinfo output -------------------------------------------
+
+# Grouping the document tree into Texinfo files. List of tuples
+# (source start file, target name, title, author,
+#  dir menu entry, description, category)
+texinfo_documents = [
+    (master_doc, 'Stencil', 'Stencil Documentation',
+     author, 'Stencil', 'One line description of project.',
+     'Miscellaneous'),
+]
+
+# Documents to append as an appendix to all manuals.
+#
+# texinfo_appendices = []
+
+# If false, no module index is generated.
+#
+# texinfo_domain_indices = True
+
+# How to display URL addresses: 'footnote', 'no', or 'inline'.
+#
+# texinfo_show_urls = 'footnote'
+
+# If true, do not generate a @detailmenu in the "Top" node's menu.
+#
+# texinfo_no_detailmenu = False

docs/custom-template-tags-and-filters.rst

@@ -0,0 +1,70 @@
+Custom Template Tags and Filters
+================================
+
+You can build your own custom filters and tags and pass them down while
+rendering your template. Any custom filters or tags must be registered with a
+extension which contains all filters and tags available to the template.
+
+.. code-block:: swift
+
+    let ext = Extension()
+    // Register your filters and tags with the extension
+
+    let environment = Environment(extensions: [ext])
+    try environment.renderTemplate(name: "example.html")
+
+Custom Filters
+--------------
+
+Registering custom filters:
+
+.. code-block:: swift
+
+    ext.registerFilter("double") { (value: Any?) in
+      if let value = value as? Int {
+        return value * 2
+      }
+
+      return value
+    }
+
+Registering custom filters with arguments:
+
+.. code-block:: swift
+
+    ext.registerFilter("multiply") { (value: Any?, arguments: [Any?]) in
+      let amount: Int
+
+      if let value = arguments.first as? Int {
+        amount = value
+      } else {
+        throw TemplateSyntaxError("multiple tag must be called with an integer argument")
+      }
+
+      if let value = value as? Int {
+        return value * 2
+      }
+
+      return value
+    }
+
+Custom Tags
+-----------
+
+You can build a custom template tag. There are a couple of APIs to allow you to
+write your own custom tags. The following is the simplest form:
+
+.. code-block:: swift
+
+    ext.registerSimpleTag("custom") { context in
+      return "Hello World"
+    }
+
+When your tag is used via ``{% custom %}`` it will execute the registered block
+of code allowing you to modify or retrieve a value from the context. Then
+return either a string rendered in your template, or throw an error.
+
+If you want to accept arguments or to capture different tokens between two sets
+of template tags. You will need to call the ``registerTag`` API which accepts a
+closure to handle the parsing. You can find examples of the ``now``, ``if`` and
+``for`` tags found inside Stencil source code.

docs/getting-started.rst

@@ -0,0 +1,37 @@
+Getting Started
+===============
+
+The easiest way to render a template using Stencil is to create a template and
+call render on it providing a context.
+
+.. code-block:: swift
+
+    let template = Template(templateString: "Hello {{ name }}")
+    try template.render(["name": "kyle"])
+
+For more advanced uses, you would normally create an ``Environment`` and call
+the ``renderTemplate`` convinience method.
+
+.. code-block:: swift
+
+    let environment = Environment()
+
+    let context = ["name": "kyle"]
+    try template.renderTemplate(string: "Hello {{ name }}", context: context)
+
+Template Loaders
+----------------
+
+A template loader allows you to load files from disk or elsewhere. Using a
+``FileSystemLoader`` we can easily render a template from disk.
+
+For example, to render a template called ``index.html`` inside the
+``templates/`` directory we can use the following:
+
+.. code-block:: swift
+
+    let fsLoader = FileSystemLoader(paths: ["templates/"])
+    let environment = Environment(loader: fsLoader)
+
+    let context = ["name": "kyle"]
+    try template.renderTemplate(name: "index.html", context: context)

docs/index.rst

@@ -0,0 +1,64 @@
+The Stencil template language
+=============================
+
+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
+feel right at home with Stencil.
+
+.. code-block:: html+django
+
+    There are {{ articles.count }} articles.
+
+    <ul>
+      {% for article in articles %}
+        <li>{{ article.title }} by {{ article.author }}</li>
+      {% endfor %}
+    </ul>
+
+.. code-block:: swift
+
+    import Stencil
+
+    struct Article {
+      let title: String
+      let author: String
+    }
+
+    let context = [
+      "articles": [
+        Article(title: "Migrating from OCUnit to XCTest", author: "Kyle Fuller"),
+        Article(title: "Memory Management with ARC", author: "Kyle Fuller"),
+      ]
+    ]
+
+    let environment = Environment(loader: FileSystemLoader(paths: ["templates/"])
+    let rendered = try environment.renderTemplate(name: context)
+
+    print(rendered)
+
+The User Guide
+--------------
+
+For Template Writers
+~~~~~~~~~~~~~~~~~~~~
+
+Resources for Stencil template authors to write Stencil templates.
+
+.. toctree::
+   :maxdepth: 2
+
+   templates
+   builtins
+
+For Developers
+~~~~~~~~~~~~~~
+
+Resources to help you integrate Stencil into a Swift project.
+
+.. toctree::
+   :maxdepth: 1
+
+   installation
+   getting-started
+   api
+   custom-template-tags-and-filters

docs/installation.rst

@@ -0,0 +1,52 @@
+Installation
+============
+
+Swift Package Mangaer
+---------------------
+
+If you're using the Swift Package Manager, you can add ``Stencil`` to your
+dependencies inside ``Package.swift``.
+
+.. code-block:: swift
+
+    import PackageDescription
+
+    let package = Package(
+      name: "MyApplication",
+      dependencies: [
+        .Package(url: "https://github.com/kylef/Stencil.git", majorVersion: 0, minor: 8),
+      ]
+    )
+
+CocoaPods
+---------
+
+If you're using CocoaPods, you can add Stencil to your ``Podfile`` and then run
+``pod install``.
+
+.. code-block:: ruby
+
+    pod 'Stencil', '~> 0.8.0'
+
+Carthage
+--------
+
+.. note:: Use at your own risk. We don't offer support for Carthage and instead recommend you use Swift Package Manager.
+
+1) Add ``Stencil`` to your ``Cartfile``:
+
+    .. code-block:: text
+
+        github "kylef/Stencil" ~> 0.8.0
+
+2) Checkout your dependencies, generate the Stencil Xcode project, and then use Carthage to build Stencil:
+
+    .. code-block:: shell
+
+        $ carthage update
+        $ (cd Carthage/Checkouts/Stencil && swift package generate-xcodeproj)
+        $ carthage build
+
+3) Follow the Carthage steps to add the built frameworks to your project.
+
+To learn more about this approach see `Using Swift Package Manager with Carthage <https://fuller.li/posts/using-swift-package-manager-with-carthage/>`_.

docs/templates.rst

@@ -0,0 +1,167 @@
+Language overview
+==================
+
+- ``{{ ... }}`` for variables to print to the template output
+- ``{% ... %}`` for tags
+- ``{# ... #}`` for comments not included in the template output
+
+Variables
+---------
+
+A variable can be defined in your template using the following:
+
+.. code-block:: html+django
+
+    {{ variable }}
+
+Stencil will look up the variable inside the current variable context and
+evaluate it. When a variable contains a dot, it will try doing the
+following lookup:
+
+- Context lookup
+- Dictionary lookup
+- Array lookup (first, last, count, index)
+- Key value coding lookup
+- Type introspection
+
+For example, if `people` was an array:
+
+.. code-block:: html+django
+
+    There are {{ people.count }} people. {{ people.first }} is the first
+    person, followed by {{ people.1 }}.
+
+Filters
+~~~~~~~
+
+Filters allow you to transform the values of variables. For example, they look like:
+
+.. code-block:: html+django
+
+    {{ variable|uppercase }}
+
+See :ref:`all builtin filters <built-in-filters>`.
+
+Tags
+----
+
+Tags are a mechanism to execute a piece of code, allowing you to have
+control flow within your template.
+
+.. code-block:: html+django
+
+    {% if variable %}
+      {{ variable }} was found.
+    {% endif %}
+
+A tag can also affect the context and define variables as follows:
+
+.. code-block:: html+django
+
+    {% for item in items %}
+      {{ item }}
+    {% endfor %}
+
+Stencil includes of built-in tags which are listed below. You can also
+extend Stencil by providing your own tags.
+
+See :ref:`all builtin tags <built-in-tags>`.
+
+Comments
+--------
+
+To comment out part of your template, you can use the following syntax:
+
+.. code-block:: html+django
+
+    {# My comment is completely hidden #}
+
+.. _template-inheritance:
+
+Template inheritance
+--------------------
+
+Template inheritance allows the common components surrounding individual pages
+to be shared across other templates. You can define blocks which can be
+overidden in any child template.
+
+Let's take a look at an example. Here is our base template (``base.html``):
+
+.. code-block:: html+django
+
+    <html>
+      <head>
+        <title>{% block title %}Example{% endblock %}</title>
+      </head>
+
+      <body>
+        <aside>
+          {% block sidebar %}
+            <ul>
+              <li><a href="/">Home</a></li>
+              <li><a href="/notes/">Notes</a></li>
+            </ul>
+          {% endblock %}
+        </aside>
+
+        <section>
+          {% block content %}{% endblock %}
+        </section>
+      </body>
+    </html>
+
+This example declares three blocks, ``title``, ``sidebar`` and ``content``. We
+can use the ``{% extends %}`` template tag to inherit from out base template
+and then use ``{% block %}`` to override any blocks from our base template.
+
+A child template might look like the following:
+
+.. code-block:: html+django
+
+    {% extends "base.html" %}
+
+    {% block title %}Notes{% endblock %}
+
+    {% block content %}
+      {% for note in notes %}
+        <h2>{{ note }}</h2>
+      {% endfor %}
+    {% endblock %}
+
+.. note:: You can use ``{{ block.super }}` inside a block to render the contents of the parent block inline.
+
+Since our child template doesn't declare a sidebar block. The original sidebar
+from our base template will be used. Depending on the content of ``notes`` our
+template might be rendered like the following:
+
+.. code-block:: html
+
+    <html>
+      <head>
+        <title>Notes</title>
+      </head>
+
+      <body>
+        <aside>
+          <ul>
+            <li><a href="/">Home</a></li>
+            <li><a href="/notes/">Notes</a></li>
+          </ul>
+        </aside>
+
+        <section>
+          <h2>Pick up food</h2>
+          <h2>Do laundry</h2>
+        </section>
+      </body>
+    </html>
+
+You can use as many levels of inheritance as needed. One common way of using
+inheritance is the following three-level approach:
+
+* Create a ``base.html`` template that holds the main look-and-feel of your site.
+* Create a ``base_SECTIONNAME.html`` template for each “section” of your site.
+  For example, ``base_news.html``, ``base_news.html``. These templates all
+  extend ``base.html`` and include section-specific styles/design.
+* Create individual templates for each type of page, such as a news article or
+  blog entry. These templates extend the appropriate section template.