Merge pull request #3 from vapor/optional-cache

add ability to remove caching

Author: loganwright

Resources/include-addition.leaf Resources/embed-addition.leaf

@@ -0,0 +1 @@
+Leaf embedded: #embed("embed-addition")

Resources/embed-base.leaf

@@ -16,5 +16,6 @@ public var defaultTags: [String: Tag] = [
     "else": Else(),
     "loop": Loop(),
     "uppercased": Uppercased(),
-    "include": Include()
+    "embed": Embed(),
+    "index": Index(),
 ]

Resources/include-base.leaf

@@ -36,16 +36,13 @@ public final class Context {
 
     // TODO: Subscripts
 
-    subscript(path: String) -> Node? {
-        let components = path.components(separatedBy: ".")
-        return self[components]
-    }
+    func get<T: PathIndex>(path: [T]) -> Node? {
+        var next = queue.tip
+        repeat {
+            if let value = next?.value[path] { return value }
+            next = next?.child
+        } while next != nil
 
-    subscript(path: [String]) -> Node? {
-        for node in queue {
-            guard let value = node[path] else { continue }
-            return value
-        }
         return nil
     }
 

Sources/Leaf/Constants.swift

@@ -28,29 +28,32 @@ public final class Link<Value> { // TODO: Rename Context
         Add a new Link to the end of the chain.
     */
     public func extend(_ output: Value) {
-        if let child = child {
-            child.extend(output)
-        } else {
-            let new = Link(output)
-            new.parent = self
-            self.child = new
-        }
+        let tail = self.tail()
+        let new = Link(output)
+        new.parent = tail
+        tail.child = new
     }
 
     /**
         The tip of the chain associated with this link
     */
     public func tip() -> Link {
-        guard let parent = parent else { return self }
-        return parent.tip()
+        var tip = self
+        while let next = tip.parent {
+            tip = next
+        }
+        return tip
     }
 
     /**
         The tail of the chain associated with this link
     */
     public func tail() -> Link {
-        guard let child = child else { return self }
-        return child.tail()
+        var tail = self
+        while let next = tail.child {
+            tail = next
+        }
+        return tail
     }
 
     /**

Sources/Leaf/Context.swift

@@ -12,7 +12,7 @@ extension Stem {
     }
 
     public func spawnLeaf(named name: String) throws -> Leaf {
-        if let existing = cache[name] { return existing }
+        if let existing = cache?[name] { return existing }
 
         var subpath = name.finished(with: SUFFIX)
         if subpath.hasPrefix("/") {

Sources/Leaf/Link.swift

@@ -1,16 +1,17 @@
 public final class Stem {
     public let workingDirectory: String
     public fileprivate(set) var tags: [String: Tag] = defaultTags
-    public fileprivate(set) var cache: [String: Leaf] = [:]
+    public fileprivate(set) var cache: [String: Leaf]?
 
-    public init(workingDirectory: String) {
+    public init(workingDirectory: String, cache: [String: Leaf]? = [:]) {
         self.workingDirectory = workingDirectory.finished(with: "/")
+        self.cache = cache
     }
 }
 
 extension Stem {
     public func cache(_ leaf: Leaf, named name: String) {
-        cache[name] = leaf
+        cache?[name] = leaf
     }
 }
 

Sources/Leaf/Stem+Spawn.swift

@@ -0,0 +1,14 @@
+public protocol BasicTag: Tag {
+    func run(arguments: [Argument]) throws -> Node?
+}
+
+extension BasicTag {
+    public func run(
+        stem: Stem,
+        context: Context,
+        tagTemplate: TagTemplate,
+        arguments: [Argument]
+        ) throws -> Node? {
+        return try run(arguments: arguments)
+    }
+}

Sources/Leaf/Stem.swift

@@ -1,9 +1,9 @@
-public final class Include: Tag {
+public final class Embed: Tag {
     public enum Error: LeafError {
         case expectedSingleConstant(have: [Parameter])
     }
 
-    public let name = "include"
+    public let name = "embed"
 
     public func postCompile(
         stem: Stem,

Sources/Leaf/Tag/BasicTag.swift

@@ -0,0 +1,13 @@
+public class Index: BasicTag {
+    public let name = "index"
+
+    public func run(arguments: [Argument]) throws -> Node? {
+        guard
+            arguments.count == 2,
+            let array = arguments[0].value?.nodeArray,
+            let index = arguments[1].value?.int,
+            index < array.count
+            else { return nil }
+        return array[index]
+    }
+}

Sources/Leaf/Tag/Models/Include.swift Sources/Leaf/Tag/Models/Embed.swift

@@ -33,7 +33,7 @@ extension TagTemplate {
         return parameters.map { arg in
             switch arg {
             case let .variable(path: path):
-                let value = context[path]
+                let value = context.get(path: path)
                 return .variable(path: path, value: value)
             case let .constant(c):
                 return .constant(value: c)

Sources/Leaf/Tag/Models/Index.swift

@@ -0,0 +1,25 @@
+import Foundation
+import XCTest
+@testable import Leaf
+
+class EmbedTests: XCTestCase {
+    static let allTests = [
+        ("testBasicEmbed", testBasicEmbed),
+        ("testEmbedThrow", testEmbedThrow),
+    ]
+
+    func testBasicEmbed() throws {
+        let template = try stem.spawnLeaf(named: "/embed-base")
+        let context = Context(["name": "World"])
+        let rendered = try stem.render(template, with: context).string
+        let expectation = "Leaf embedded: Hello, World!"
+        XCTAssert(rendered == expectation, "have: \(rendered) want: \(expectation)")
+    }
+
+    func testEmbedThrow() throws {
+        do {
+            _ = try stem.spawnLeaf(raw: "#embed(invalid-variable)")
+            XCTFail("Expected throw")
+        } catch Embed.Error.expectedSingleConstant { }
+    }
+}

Sources/Leaf/Tag/TagTemplate.swift

@@ -0,0 +1,26 @@
+import Foundation
+import XCTest
+@testable import Leaf
+
+class IndexTests: XCTestCase {
+    static let allTests = [
+        ("testBasicIndex", testBasicIndex),
+        ("testOutOfBounds", testOutOfBounds)
+    ]
+
+    func testBasicIndex() throws {
+        let template = try stem.spawnLeaf(raw: "Hello, #index(friends, idx)!")
+        let context = Context(["friends": ["Joe", "Jan", "Jay", "Jen"], "idx": 3])
+        let rendered = try stem.render(template, with: context).string
+        let expectation = "Hello, Jen!"
+        XCTAssertEqual(rendered, expectation)
+    }
+
+    func testOutOfBounds() throws {
+        let template = try stem.spawnLeaf(raw: "Hello, #index(friends, idx)!")
+        let context = Context(["friends": [], "idx": 3])
+        let rendered = try stem.render(template, with: context).string
+        let expectation = "Hello, !"
+        XCTAssertEqual(rendered, expectation)
+    }
+}

Tests/LeafTests/EmbedTests.swift

@@ -27,7 +27,7 @@ class PerformanceTests: XCTestCase {
         let ctxt = Context(["name": "World"])
         measure {
             (1...500).forEach { _ in
-                _ = ctxt["name"]
+                _ = ctxt.get(path: ["name"])
             }
         }
     }

Tests/LeafTests/IncludeTests.swift

@@ -8,6 +8,7 @@ class TagTemplateTests: XCTestCase {
         ("testEquatable", testEquatable),
         ("testChainFail", testChainFail),
         ("testMissingOpenParens", testMissingOpenParens),
+        ("testEquatableComponents", testEquatableComponents),
     ]
 
     func testBasic() throws {
@@ -45,6 +46,12 @@ class TagTemplateTests: XCTestCase {
         XCTAssertFalse(other == rhs)
     }
 
+    func testEquatableComponents() throws {
+        let lhs = Leaf.Component.raw("raw".bytes)
+        let rhs = Leaf.Component.chain([])
+        XCTAssertNotEqual(lhs, rhs)
+    }
+
     func testChainFail() throws {
         do {
             _ = try stem.spawnLeaf(raw: "##else() {}")

Tests/LeafTests/IndexTests.swift

@@ -2,17 +2,18 @@ import XCTest
 @testable import LeafTests
 
 XCTMain([
-     testCase(PerformanceTests.allTests),
+     testCase(BufferTests.allTests),
      testCase(ContextTests.allTests),
+     testCase(EmbedTests.allTests),
+     testCase(IfTests.allTests),
+     testCase(IndexTests.allTests),
      testCase(LinkTests.allTests),
-     testCase(TagTemplateTests.allTests),
+     testCase(LoopTests.allTests),
      testCase(NodeRenderTests.allTests),
-     testCase(BufferTests.allTests),
-     testCase(IncludeTests.allTests),
-     testCase(RenderTests.allTests),
      testCase(ParameterTests.allTests),
-     testCase(LoopTests.allTests),
-     testCase(IfTests.allTests),
-     testCase(VariableTests.allTests),
+     testCase(PerformanceTests.allTests),
+     testCase(RenderTests.allTests),
+     testCase(TagTemplateTests.allTests),
      testCase(UppercasedTests.allTests),
+     testCase(VariableTests.allTests),
 ])