Load templates and render objects

Tests/HummingbirdMustacheTests/TemplateParserTests.swift

@@ -0,0 +1,52 @@
+import XCTest
+@testable import HummingbirdMustache
+
+final class TemplateParserTests: XCTestCase {
+    func testText() throws {
+        let template = try HBTemplate("test template")
+        XCTAssertEqual(template.tokens, [.text("test template")])
+    }
+
+    func testVariable() throws {
+        let template = try HBTemplate("test {{variable}}")
+        XCTAssertEqual(template.tokens, [.text("test "), .variable("variable")])
+    }
+
+    func testSection() throws {
+        let template = try HBTemplate("test {{#section}}text{{/section}}")
+        XCTAssertEqual(template.tokens, [.text("test "), .section("section", .init([.text("text")]))])
+    }
+
+    func testInvertedSection() throws {
+        let template = try HBTemplate("test {{^section}}text{{/section}}")
+        XCTAssertEqual(template.tokens, [.text("test "), .invertedSection("section", .init([.text("text")]))])
+    }
+
+    func testComment() throws {
+        let template = try HBTemplate("test {{!section}}")
+        XCTAssertEqual(template.tokens, [.text("test ")])
+    }
+}
+
+extension HBTemplate: Equatable {
+    public static func == (lhs: HBTemplate, rhs: HBTemplate) -> Bool {
+        lhs.tokens == rhs.tokens
+    }
+}
+
+extension HBTemplate.Token: Equatable {
+    public static func == (lhs: HBTemplate.Token, rhs: HBTemplate.Token) -> Bool {
+        switch (lhs, rhs) {
+        case (.text(let lhs), .text(let rhs)):
+            return lhs == rhs
+        case (.variable(let lhs), .variable(let rhs)):
+            return lhs == rhs
+        case (.section(let lhs1, let lhs2), .section(let rhs1, let rhs2)):
+            return lhs1 == rhs1 && lhs2 == rhs2
+        case (.invertedSection(let lhs1, let lhs2), .invertedSection(let rhs1, let rhs2)):
+            return lhs1 == rhs1 && lhs2 == rhs2
+        default:
+            return false
+        }
+    }
+}

Tests/HummingbirdMustacheTests/TemplateRendererTests.swift

@@ -0,0 +1,82 @@
+import XCTest
+@testable import HummingbirdMustache
+
+final class TemplateRendererTests: XCTestCase {
+    func testText() throws {
+        let template = try HBTemplate("test text")
+        XCTAssertEqual(template.render("test"), "test text")
+    }
+
+    func testStringVariable() throws {
+        let template = try HBTemplate("test {{.}}")
+        XCTAssertEqual(template.render("text"), "test text")
+    }
+
+    func testIntegerVariable() throws {
+        let template = try HBTemplate("test {{.}}")
+        XCTAssertEqual(template.render(101), "test 101")
+    }
+
+    func testDictionary() throws {
+        let template = try HBTemplate("test {{value}} {{bool}}")
+        XCTAssertEqual(template.render(["value": "test2", "bool": true]), "test test2 true")
+    }
+
+    func testArraySection() throws {
+        let template = try HBTemplate("test {{#value}}*{{.}}{{/value}}")
+        XCTAssertEqual(template.render(["value": ["test2", "bool"]]), "test *test2*bool")
+        XCTAssertEqual(template.render(["value": []]), "test ")
+    }
+
+    func testBooleanSection() throws {
+        let template = try HBTemplate("test {{#.}}Yep{{/.}}")
+        XCTAssertEqual(template.render(true), "test Yep")
+        XCTAssertEqual(template.render(false), "test ")
+    }
+
+    func testIntegerSection() throws {
+        let template = try HBTemplate("test {{#.}}{{.}}{{/.}}")
+        XCTAssertEqual(template.render(23), "test 23")
+        XCTAssertEqual(template.render(0), "test ")
+    }
+
+    func testStringSection() throws {
+        let template = try HBTemplate("test {{#.}}{{.}}{{/.}}")
+        XCTAssertEqual(template.render("Hello"), "test Hello")
+    }
+
+    func testInvertedSection() throws {
+        let template = try HBTemplate("test {{^.}}Inverted{{/.}}")
+        XCTAssertEqual(template.render(true), "test ")
+        XCTAssertEqual(template.render(false), "test Inverted")
+    }
+
+    func testMirror() throws {
+        struct Test {
+            let string: String
+        }
+        let template = try HBTemplate("test {{string}}")
+        XCTAssertEqual(template.render(Test(string: "string")), "test string")
+    }
+
+    func testOptionalMirror() throws {
+        struct Test {
+            let string: String?
+        }
+        let template = try HBTemplate("test {{string}}")
+        XCTAssertEqual(template.render(Test(string: "string")), "test string")
+        XCTAssertEqual(template.render(Test(string: nil)), "test ")
+    }
+    
+    func testOptionalSequence() throws {
+        struct Test {
+            let string: String?
+        }
+        let template = try HBTemplate("test {{#string}}*{{.}}{{/string}}")
+        XCTAssertEqual(template.render(Test(string: "string")), "test *string")
+        XCTAssertEqual(template.render(Test(string: nil)), "test ")
+        let template2 = try HBTemplate("test {{^string}}*{{/string}}")
+        XCTAssertEqual(template2.render(Test(string: "string")), "test ")
+        XCTAssertEqual(template2.render(Test(string: nil)), "test *")
+    }
+}

Tests/HummingbirdMustacheTests/hummingbird_mustacheTests.swift

@@ -1,15 +0,0 @@
-import XCTest
-@testable import hummingbird_mustache
-
-final class hummingbird_mustacheTests: XCTestCase {
-    func testExample() {
-        // This is an example of a functional test case.
-        // Use XCTAssert and related functions to verify your tests produce the correct
-        // results.
-        XCTAssertEqual(hummingbird_mustache().text, "Hello, World!")
-    }
-
-    static var allTests = [
-        ("testExample", testExample),
-    ]
-}