Refactor render nodes to return a Result

Stencil/Node.swift

@@ -37,16 +37,16 @@ extension Array {
     }
 }
 
-public func renderNodes(nodes:[Node], context:Context) -> (String?, Error?) {
+public func renderNodes(nodes:[Node], context:Context) -> Result {
     let result:(results:[String]?, error:Error?) = nodes.map {
         return $0.render(context)
     }
 
     if let result = result.0 {
-        return ("".join(result), nil)
+        return .Success(string:"".join(result))
     }
 
-    return (nil, result.1)
+    return .Error(error:result.1!)
 }
 
 public class TextNode : Node {
@@ -178,26 +178,25 @@ public class ForNode : Node {
 
     public func render(context: Context) -> (String?, Error?) {
         let values = variable.resolve(context) as? [AnyObject]
-        var result = ""
+        var output = ""
 
         if let values = values {
             for item in values {
                 context.push()
                 context[loopVariable] = item
-                let (string, error) = renderNodes(nodes, context)
+                let result = renderNodes(nodes, context)
                 context.pop()
 
-                if let error = error {
+                switch result {
+                    case .Success(let string):
+                        output += string
+                    case .Error(let error):
                         return (nil, error)
                 }
-
-                if let string = string {
-                    result += string
-                }
             }
         }
 
-        return (result, nil)
+        return (output, nil)
     }
 }
 
@@ -283,9 +282,14 @@ public class IfNode : Node {
         }
 
         context.push()
-        let (string, error) = renderNodes(truthy ? trueNodes : falseNodes, context)
+        let output = renderNodes(truthy ? trueNodes : falseNodes, context)
         context.pop()
 
-        return (string, error)
+        switch output {
+            case .Success(let string):
+                return (string, nil)
+            case .Error(let error):
+                return (nil, error)
+        }
     }
 }

Stencil/Template.swift

@@ -39,13 +39,7 @@ public class Template {
     public func render(context:Context) -> Result {
         switch parser.parse() {
             case .Success(let nodes):
-                let (result, error) = renderNodes(nodes, context)
-                if let result = result {
-                    return .Success(string:result)
-                } else if let error = error {
-                    return .Error(error:error)
-                }
-                return .Success(string:"")
+                return renderNodes(nodes, context)
 
             case .Error(let error):
                 return .Error(error:error)

StencilTests/NodeTests.swift

@@ -55,18 +55,23 @@ class VariableNodeTests: NodeTests {
 class RenderNodeTests: NodeTests {
     func testRenderingNodes() {
         let nodes = [TextNode(text:"Hello "), VariableNode(variable: "name")] as [Node]
-        let (result:String?, error:Error?) = renderNodes(nodes, context)
-
-        XCTAssertEqual(result!, "Hello Kyle")
-        XCTAssertTrue(error == nil)
+        switch renderNodes(nodes, context) {
+        case .Success(let result):
+            XCTAssertEqual(result, "Hello Kyle")
+        case .Error(let error):
+            XCTAssert(false, "Unexpected error")
+        }
     }
 
     func testRenderingNodesWithFailure() {
         let nodes = [TextNode(text:"Hello "), VariableNode(variable: "name"), ErrorNode()] as [Node]
-        let (result:String?, error:Error?) = renderNodes(nodes, context)
 
-        XCTAssertEqual(error!.description, "Node Error")
-        XCTAssertTrue(result == nil)
+        switch renderNodes(nodes, context) {
+        case .Success(let result):
+            XCTAssert(false, "Unexpected success")
+        case .Error(let error):
+            XCTAssertEqual("\(error)", "Node Error")
+        }
     }
 }