astzweig/swiftpm-mustache
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove HB prefix, make Parser private (#26)

Browse Source
This commit is contained in:
Adam Fowler
2024-03-11 22:07:05 +00:00
committed by GitHub
parent f029081b61
commit bdfa05391a
25 changed files with 300 additions and 262 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
Tests/HummingbirdMustacheTests/ErrorTests.swift
View File

@@ -17,14 +17,14 @@ import XCTest
final class ErrorTests: XCTestCase {
func testSectionCloseNameIncorrect() {
XCTAssertThrowsError(try HBMustacheTemplate(string: """
XCTAssertThrowsError(try MustacheTemplate(string: """
{{#test}}
{{.}}
{{/test2}}
""")) { error in
switch error {
case let error as HBMustacheTemplate.ParserError:
XCTAssertEqual(error.error as? HBMustacheTemplate.Error, .sectionCloseNameIncorrect)
case let error as MustacheTemplate.ParserError:
XCTAssertEqual(error.error as? MustacheTemplate.Error, .sectionCloseNameIncorrect)
XCTAssertEqual(error.context.line, "{{/test2}}")
XCTAssertEqual(error.context.lineNumber, 3)
XCTAssertEqual(error.context.columnNumber, 4)
@@ -36,14 +36,14 @@ final class ErrorTests: XCTestCase {
}
func testUnfinishedName() {
XCTAssertThrowsError(try HBMustacheTemplate(string: """
XCTAssertThrowsError(try MustacheTemplate(string: """
{{#test}}
{{name}
{{/test2}}
""")) { error in
switch error {
case let error as HBMustacheTemplate.ParserError:
XCTAssertEqual(error.error as? HBMustacheTemplate.Error, .unfinishedName)
case let error as MustacheTemplate.ParserError:
XCTAssertEqual(error.error as? MustacheTemplate.Error, .unfinishedName)
XCTAssertEqual(error.context.line, "{{name}")
XCTAssertEqual(error.context.lineNumber, 2)
XCTAssertEqual(error.context.columnNumber, 7)
@@ -55,13 +55,13 @@ final class ErrorTests: XCTestCase {
}
func testExpectedSectionEnd() {
XCTAssertThrowsError(try HBMustacheTemplate(string: """
XCTAssertThrowsError(try MustacheTemplate(string: """
{{#test}}
{{.}}
""")) { error in
switch error {
case let error as HBMustacheTemplate.ParserError:
XCTAssertEqual(error.error as? HBMustacheTemplate.Error, .expectedSectionEnd)
case let error as MustacheTemplate.ParserError:
XCTAssertEqual(error.error as? MustacheTemplate.Error, .expectedSectionEnd)
XCTAssertEqual(error.context.line, "{{.}}")
XCTAssertEqual(error.context.lineNumber, 2)
XCTAssertEqual(error.context.columnNumber, 6)
@@ -73,14 +73,14 @@ final class ErrorTests: XCTestCase {
}
func testInvalidSetDelimiter() {
XCTAssertThrowsError(try HBMustacheTemplate(string: """
XCTAssertThrowsError(try MustacheTemplate(string: """
{{=<% %>=}}
<%.%>
<%={{}}=%>
""")) { error in
switch error {
case let error as HBMustacheTemplate.ParserError:
XCTAssertEqual(error.error as? HBMustacheTemplate.Error, .invalidSetDelimiter)
case let error as MustacheTemplate.ParserError:
XCTAssertEqual(error.error as? MustacheTemplate.Error, .invalidSetDelimiter)
XCTAssertEqual(error.context.line, "<%={{}}=%>")
XCTAssertEqual(error.context.lineNumber, 3)
XCTAssertEqual(error.context.columnNumber, 4)

8
Tests/HummingbirdMustacheTests/LibraryTests.swift
View File

@@ -24,7 +24,7 @@ final class LibraryTests: XCTestCase {
try mustache.write(to: URL(fileURLWithPath: "templates/test.mustache"))
defer { XCTAssertNoThrow(try fs.removeItem(atPath: "templates/test.mustache")) }
let library = try await HBMustacheLibrary(directory: "./templates")
let library = try await MustacheLibrary(directory: "./templates")
let object = ["value": ["value1", "value2"]]
XCTAssertEqual(library.render(object, withTemplate: "test"), "<test><value>value1</value><value>value2</value></test>")
}
@@ -42,7 +42,7 @@ final class LibraryTests: XCTestCase {
XCTAssertNoThrow(try fs.removeItem(atPath: "templates"))
}
let library = try await HBMustacheLibrary(directory: "./templates")
let library = try await MustacheLibrary(directory: "./templates")
let object = ["value": ["value1", "value2"]]
XCTAssertEqual(library.render(object, withTemplate: "test"), "<test><value>value1</value><value>value2</value></test>")
}
@@ -63,8 +63,8 @@ final class LibraryTests: XCTestCase {
defer { XCTAssertNoThrow(try fs.removeItem(atPath: "templates/error.mustache")) }
do {
_ = try await HBMustacheLibrary(directory: "./templates")
} catch let parserError as HBMustacheLibrary.ParserError {
_ = try await MustacheLibrary(directory: "./templates")
} catch let parserError as MustacheLibrary.ParserError {
XCTAssertEqual(parserError.filename, "error.mustache")
XCTAssertEqual(parserError.context.line, "{{{name}}")
XCTAssertEqual(parserError.context.lineNumber, 2)

22
Tests/HummingbirdMustacheTests/PartialTests.swift
View File

@@ -18,17 +18,17 @@ import XCTest
final class PartialTests: XCTestCase {
/// Testing partials
func testMustacheManualExample9() throws {
let template = try HBMustacheTemplate(string: """
let template = try MustacheTemplate(string: """
<h2>Names</h2>
{{#names}}
{{> user}}
{{/names}}
""")
let template2 = try HBMustacheTemplate(string: """
let template2 = try MustacheTemplate(string: """
<strong>{{.}}</strong>
""")
let library = HBMustacheLibrary(templates: ["base": template, "user": template2])
let library = MustacheLibrary(templates: ["base": template, "user": template2])
let object: [String: Any] = ["names": ["john", "adam", "claire"]]
XCTAssertEqual(library.render(object, withTemplate: "base"), """
@@ -43,7 +43,7 @@ final class PartialTests: XCTestCase {
/// Test where last line of partial generates no content. It should not add a
/// tab either
func testPartialEmptyLineTabbing() throws {
let template = try HBMustacheTemplate(string: """
let template = try MustacheTemplate(string: """
<h2>Names</h2>
{{#names}}
{{> user}}
@@ -51,7 +51,7 @@ final class PartialTests: XCTestCase {
Text after
""")
let template2 = try HBMustacheTemplate(string: """
let template2 = try MustacheTemplate(string: """
{{^empty(.)}}
<strong>{{.}}</strong>
{{/empty(.)}}
@@ -60,9 +60,9 @@ final class PartialTests: XCTestCase {
{{/empty(.)}}
""")
var library = HBMustacheLibrary()
var library = MustacheLibrary()
library.register(template, named: "base")
library.register(template2, named: "user") // , withTemplate: String)// = HBMustacheLibrary(templates: ["base": template, "user": template2])
library.register(template2, named: "user") // , withTemplate: String)// = MustacheLibrary(templates: ["base": template, "user": template2])
let object: [String: Any] = ["names": ["john", "adam", "claire"]]
XCTAssertEqual(library.render(object, withTemplate: "base"), """
@@ -77,16 +77,16 @@ final class PartialTests: XCTestCase {
/// Testing dynamic partials
func testDynamicPartials() throws {
let template = try HBMustacheTemplate(string: """
let template = try MustacheTemplate(string: """
<h2>Names</h2>
{{partial}}
""")
let template2 = try HBMustacheTemplate(string: """
let template2 = try MustacheTemplate(string: """
{{#names}}
<strong>{{.}}</strong>
{{/names}}
""")
let library = HBMustacheLibrary(templates: ["base": template])
let library = MustacheLibrary(templates: ["base": template])
let object: [String: Any] = ["names": ["john", "adam", "claire"], "partial": template2]
XCTAssertEqual(library.render(object, withTemplate: "base"), """
@@ -100,7 +100,7 @@ final class PartialTests: XCTestCase {
/// test inheritance
func testInheritance() throws {
var library = HBMustacheLibrary()
var library = MustacheLibrary()
try library.register(
"""
<head>

10
Tests/HummingbirdMustacheTests/SpecTests.swift
View File

@@ -68,17 +68,17 @@ final class MustacheSpecTests: XCTestCase {
func run() throws {
// print("Test: \(self.name)")
if let partials = self.partials {
let template = try HBMustacheTemplate(string: self.template)
var templates: [String: HBMustacheTemplate] = ["__test__": template]
let template = try MustacheTemplate(string: self.template)
var templates: [String: MustacheTemplate] = ["__test__": template]
for (key, value) in partials {
let template = try HBMustacheTemplate(string: value)
let template = try MustacheTemplate(string: value)
templates[key] = template
}
let library = HBMustacheLibrary(templates: templates)
let library = MustacheLibrary(templates: templates)
let result = library.render(self.data.value, withTemplate: "__test__")
self.XCTAssertSpecEqual(result, self)
} else {
let template = try HBMustacheTemplate(string: self.template)
let template = try MustacheTemplate(string: self.template)
let result = template.render(self.data.value)
self.XCTAssertSpecEqual(result, self)
}

36
Tests/HummingbirdMustacheTests/TemplateParserTests.swift
View File

@@ -17,55 +17,55 @@ import XCTest
final class TemplateParserTests: XCTestCase {
func testText() throws {
let template = try HBMustacheTemplate(string: "test template")
let template = try MustacheTemplate(string: "test template")
XCTAssertEqual(template.tokens, [.text("test template")])
}
func testVariable() throws {
let template = try HBMustacheTemplate(string: "test {{variable}}")
let template = try MustacheTemplate(string: "test {{variable}}")
XCTAssertEqual(template.tokens, [.text("test "), .variable(name: "variable")])
}
func testSection() throws {
let template = try HBMustacheTemplate(string: "test {{#section}}text{{/section}}")
let template = try MustacheTemplate(string: "test {{#section}}text{{/section}}")
XCTAssertEqual(template.tokens, [.text("test "), .section(name: "section", template: .init([.text("text")]))])
}
func testInvertedSection() throws {
let template = try HBMustacheTemplate(string: "test {{^section}}text{{/section}}")
let template = try MustacheTemplate(string: "test {{^section}}text{{/section}}")
XCTAssertEqual(template.tokens, [.text("test "), .invertedSection(name: "section", template: .init([.text("text")]))])
}
func testComment() throws {
let template = try HBMustacheTemplate(string: "test {{!section}}")
let template = try MustacheTemplate(string: "test {{!section}}")
XCTAssertEqual(template.tokens, [.text("test ")])
}
func testWhitespace() throws {
let template = try HBMustacheTemplate(string: "{{ section }}")
let template = try MustacheTemplate(string: "{{ section }}")
XCTAssertEqual(template.tokens, [.variable(name: "section")])
}
func testContentType() throws {
let template = try HBMustacheTemplate(string: "{{% CONTENT_TYPE:TEXT}}")
let template1 = try HBMustacheTemplate(string: "{{% CONTENT_TYPE:TEXT }}")
let template2 = try HBMustacheTemplate(string: "{{% CONTENT_TYPE: TEXT}}")
let template3 = try HBMustacheTemplate(string: "{{%CONTENT_TYPE:TEXT}}")
XCTAssertEqual(template.tokens, [.contentType(HBTextContentType())])
XCTAssertEqual(template1.tokens, [.contentType(HBTextContentType())])
XCTAssertEqual(template2.tokens, [.contentType(HBTextContentType())])
XCTAssertEqual(template3.tokens, [.contentType(HBTextContentType())])
let template = try MustacheTemplate(string: "{{% CONTENT_TYPE:TEXT}}")
let template1 = try MustacheTemplate(string: "{{% CONTENT_TYPE:TEXT }}")
let template2 = try MustacheTemplate(string: "{{% CONTENT_TYPE: TEXT}}")
let template3 = try MustacheTemplate(string: "{{%CONTENT_TYPE:TEXT}}")
XCTAssertEqual(template.tokens, [.contentType(TextContentType())])
XCTAssertEqual(template1.tokens, [.contentType(TextContentType())])
XCTAssertEqual(template2.tokens, [.contentType(TextContentType())])
XCTAssertEqual(template3.tokens, [.contentType(TextContentType())])
}
}
extension HBMustacheTemplate: Equatable {
public static func == (lhs: HBMustacheTemplate, rhs: HBMustacheTemplate) -> Bool {
extension MustacheTemplate: Equatable {
public static func == (lhs: MustacheTemplate, rhs: MustacheTemplate) -> Bool {
lhs.tokens == rhs.tokens
}
}
extension HBMustacheTemplate.Token: Equatable {
public static func == (lhs: HBMustacheTemplate.Token, rhs: HBMustacheTemplate.Token) -> Bool {
extension MustacheTemplate.Token: Equatable {
public static func == (lhs: MustacheTemplate.Token, rhs: MustacheTemplate.Token) -> Bool {
switch (lhs, rhs) {
case (.text(let lhs), .text(let rhs)):
return lhs == rhs

72
Tests/HummingbirdMustacheTests/TemplateRendererTests.swift
View File

@@ -17,50 +17,50 @@ import XCTest
final class TemplateRendererTests: XCTestCase {
func testText() throws {
let template = try HBMustacheTemplate(string: "test text")
let template = try MustacheTemplate(string: "test text")
XCTAssertEqual(template.render("test"), "test text")
}
func testStringVariable() throws {
let template = try HBMustacheTemplate(string: "test {{.}}")
let template = try MustacheTemplate(string: "test {{.}}")
XCTAssertEqual(template.render("text"), "test text")
}
func testIntegerVariable() throws {
let template = try HBMustacheTemplate(string: "test {{.}}")
let template = try MustacheTemplate(string: "test {{.}}")
XCTAssertEqual(template.render(101), "test 101")
}
func testDictionary() throws {
let template = try HBMustacheTemplate(string: "test {{value}} {{bool}}")
let template = try MustacheTemplate(string: "test {{value}} {{bool}}")
XCTAssertEqual(template.render(["value": "test2", "bool": true]), "test test2 true")
}
func testArraySection() throws {
let template = try HBMustacheTemplate(string: "test {{#value}}*{{.}}{{/value}}")
let template = try MustacheTemplate(string: "test {{#value}}*{{.}}{{/value}}")
XCTAssertEqual(template.render(["value": ["test2", "bool"]]), "test *test2*bool")
XCTAssertEqual(template.render(["value": ["test2"]]), "test *test2")
XCTAssertEqual(template.render(["value": []]), "test ")
}
func testBooleanSection() throws {
let template = try HBMustacheTemplate(string: "test {{#.}}Yep{{/.}}")
let template = try MustacheTemplate(string: "test {{#.}}Yep{{/.}}")
XCTAssertEqual(template.render(true), "test Yep")
XCTAssertEqual(template.render(false), "test ")
}
func testIntegerSection() throws {
let template = try HBMustacheTemplate(string: "test {{#.}}{{.}}{{/.}}")
let template = try MustacheTemplate(string: "test {{#.}}{{.}}{{/.}}")
XCTAssertEqual(template.render(23), "test 23")
}
func testStringSection() throws {
let template = try HBMustacheTemplate(string: "test {{#.}}{{.}}{{/.}}")
let template = try MustacheTemplate(string: "test {{#.}}{{.}}{{/.}}")
XCTAssertEqual(template.render("Hello"), "test Hello")
}
func testInvertedSection() throws {
let template = try HBMustacheTemplate(string: "test {{^.}}Inverted{{/.}}")
let template = try MustacheTemplate(string: "test {{^.}}Inverted{{/.}}")
XCTAssertEqual(template.render(true), "test ")
XCTAssertEqual(template.render(false), "test Inverted")
}
@@ -69,7 +69,7 @@ final class TemplateRendererTests: XCTestCase {
struct Test {
let string: String
}
let template = try HBMustacheTemplate(string: "test {{string}}")
let template = try MustacheTemplate(string: "test {{string}}")
XCTAssertEqual(template.render(Test(string: "string")), "test string")
}
@@ -77,7 +77,7 @@ final class TemplateRendererTests: XCTestCase {
struct Test {
let string: String?
}
let template = try HBMustacheTemplate(string: "test {{string}}")
let template = try MustacheTemplate(string: "test {{string}}")
XCTAssertEqual(template.render(Test(string: "string")), "test string")
XCTAssertEqual(template.render(Test(string: nil)), "test ")
}
@@ -86,10 +86,10 @@ final class TemplateRendererTests: XCTestCase {
struct Test {
let string: String?
}
let template = try HBMustacheTemplate(string: "test {{#string}}*{{.}}{{/string}}")
let template = try MustacheTemplate(string: "test {{#string}}*{{.}}{{/string}}")
XCTAssertEqual(template.render(Test(string: "string")), "test *string")
XCTAssertEqual(template.render(Test(string: nil)), "test ")
let template2 = try HBMustacheTemplate(string: "test {{^string}}*{{/string}}")
let template2 = try MustacheTemplate(string: "test {{^string}}*{{/string}}")
XCTAssertEqual(template2.render(Test(string: "string")), "test ")
XCTAssertEqual(template2.render(Test(string: nil)), "test *")
}
@@ -98,7 +98,7 @@ final class TemplateRendererTests: XCTestCase {
struct Test {
let string: String?
}
let template = try HBMustacheTemplate(string: "test {{#.}}{{string}}{{/.}}")
let template = try MustacheTemplate(string: "test {{#.}}{{string}}{{/.}}")
XCTAssertEqual(template.render([Test(string: "string")]), "test string")
}
@@ -106,7 +106,7 @@ final class TemplateRendererTests: XCTestCase {
struct Test {
let string: String?
}
let template = try HBMustacheTemplate(string: "test {{#.}}{{#string}}*{{.}}{{/string}}{{/.}}")
let template = try MustacheTemplate(string: "test {{#.}}{{#string}}*{{.}}{{/string}}{{/.}}")
XCTAssertEqual(template.render([Test(string: "string")]), "test *string")
}
@@ -118,20 +118,20 @@ final class TemplateRendererTests: XCTestCase {
let test: SubTest
}
let template = try HBMustacheTemplate(string: "test {{test.string}}")
let template = try MustacheTemplate(string: "test {{test.string}}")
XCTAssertEqual(template.render(Test(test: .init(string: "sub"))), "test sub")
}
func testTextEscaping() throws {
let template1 = try HBMustacheTemplate(string: "{{% CONTENT_TYPE:TEXT}}{{.}}")
let template1 = try MustacheTemplate(string: "{{% CONTENT_TYPE:TEXT}}{{.}}")
XCTAssertEqual(template1.render("<>"), "<>")
let template2 = try HBMustacheTemplate(string: "{{% CONTENT_TYPE:HTML}}{{.}}")
let template2 = try MustacheTemplate(string: "{{% CONTENT_TYPE:HTML}}{{.}}")
XCTAssertEqual(template2.render("<>"), "&lt;&gt;")
}
func testStopClimbingStack() throws {
let template1 = try HBMustacheTemplate(string: "{{#test}}{{name}}{{/test}}")
let template2 = try HBMustacheTemplate(string: "{{#test}}{{.name}}{{/test}}")
let template1 = try MustacheTemplate(string: "{{#test}}{{name}}{{/test}}")
let template2 = try MustacheTemplate(string: "{{#test}}{{.name}}{{/test}}")
let object: [String: Any] = ["test": [:], "name": "John"]
let object2: [String: Any] = ["test": ["name": "Jane"], "name": "John"]
XCTAssertEqual(template1.render(object), "John")
@@ -141,7 +141,7 @@ final class TemplateRendererTests: XCTestCase {
/// variables
func testMustacheManualExample1() throws {
let template = try HBMustacheTemplate(string: """
let template = try MustacheTemplate(string: """
Hello {{name}}
You have just won {{value}} dollars!
{{#in_ca}}
@@ -159,7 +159,7 @@ final class TemplateRendererTests: XCTestCase {
/// test esacped and unescaped text
func testMustacheManualExample2() throws {
let template = try HBMustacheTemplate(string: """
let template = try MustacheTemplate(string: """
*{{name}}
*{{age}}
*{{company}}
@@ -176,7 +176,7 @@ final class TemplateRendererTests: XCTestCase {
/// test boolean
func testMustacheManualExample3() throws {
let template = try HBMustacheTemplate(string: """
let template = try MustacheTemplate(string: """
Shown.
{{#person}}
Never shown!
@@ -191,7 +191,7 @@ final class TemplateRendererTests: XCTestCase {
/// test non-empty lists
func testMustacheManualExample4() throws {
let template = try HBMustacheTemplate(string: """
let template = try MustacheTemplate(string: """
{{#repo}}
<b>{{name}}</b>
{{/repo}}
@@ -207,13 +207,13 @@ final class TemplateRendererTests: XCTestCase {
/// test lambdas
func testMustacheManualExample5() throws {
let template = try HBMustacheTemplate(string: """
let template = try MustacheTemplate(string: """
{{#wrapped}}{{name}} is awesome.{{/wrapped}}
""")
func wrapped(object: Any, template: HBMustacheTemplate) -> String {
func wrapped(object: Any, template: MustacheTemplate) -> String {
return "<b>\(template.render(object))</b>"
}
let object: [String: Any] = ["name": "Willy", "wrapped": HBMustacheLambda(wrapped)]
let object: [String: Any] = ["name": "Willy", "wrapped": MustacheLambda(wrapped)]
XCTAssertEqual(template.render(object), """
<b>Willy is awesome.</b>
""")
@@ -221,7 +221,7 @@ final class TemplateRendererTests: XCTestCase {
/// test setting context object
func testMustacheManualExample6() throws {
let template = try HBMustacheTemplate(string: """
let template = try MustacheTemplate(string: """
{{#person?}}
Hi {{name}}!
{{/person?}}
@@ -235,7 +235,7 @@ final class TemplateRendererTests: XCTestCase {
/// test inverted sections
func testMustacheManualExample7() throws {
let template = try HBMustacheTemplate(string: """
let template = try MustacheTemplate(string: """
{{#repo}}
<b>{{name}}</b>
{{/repo}}
@@ -252,7 +252,7 @@ final class TemplateRendererTests: XCTestCase {
/// test comments
func testMustacheManualExample8() throws {
let template = try HBMustacheTemplate(string: """
let template = try MustacheTemplate(string: """
<h1>Today{{! ignore me }}.</h1>
""")
let object: [String: Any] = ["repo": []]
@@ -261,12 +261,12 @@ final class TemplateRendererTests: XCTestCase {
""")
}
/// test HBMustacheCustomRenderable
/// test MustacheCustomRenderable
func testCustomRenderable() throws {
let template = try HBMustacheTemplate(string: "{{.}}")
let template1 = try HBMustacheTemplate(string: "{{#.}}not null{{/.}}")
let template2 = try HBMustacheTemplate(string: "{{^.}}null{{/.}}")
struct Object: HBMustacheCustomRenderable {
let template = try MustacheTemplate(string: "{{.}}")
let template1 = try MustacheTemplate(string: "{{#.}}not null{{/.}}")
let template2 = try MustacheTemplate(string: "{{^.}}null{{/.}}")
struct Object: MustacheCustomRenderable {
let value: String
var renderText: String { self.value.uppercased() }
@@ -282,7 +282,7 @@ final class TemplateRendererTests: XCTestCase {
}
func testPerformance() throws {
let template = try HBMustacheTemplate(string: """
let template = try MustacheTemplate(string: """
{{#repo}}
<b>{{name}}</b>
{{/repo}}

26
Tests/HummingbirdMustacheTests/TransformTests.swift
View File

@@ -17,7 +17,7 @@ import XCTest
final class TransformTests: XCTestCase {
func testLowercased() throws {
let template = try HBMustacheTemplate(string: """
let template = try MustacheTemplate(string: """
{{ lowercased(name) }}
""")
let object: [String: Any] = ["name": "Test"]
@@ -25,7 +25,7 @@ final class TransformTests: XCTestCase {
}
func testUppercased() throws {
let template = try HBMustacheTemplate(string: """
let template = try MustacheTemplate(string: """
{{ uppercased(name) }}
""")
let object: [String: Any] = ["name": "Test"]
@@ -33,7 +33,7 @@ final class TransformTests: XCTestCase {
}
func testNewline() throws {
let template = try HBMustacheTemplate(string: """
let template = try MustacheTemplate(string: """
{{#repo}}
<b>{{name}}</b>
{{/repo}}
@@ -49,7 +49,7 @@ final class TransformTests: XCTestCase {
}
func testFirstLast() throws {
let template = try HBMustacheTemplate(string: """
let template = try MustacheTemplate(string: """
{{#repo}}
<b>{{#first()}}first: {{/first()}}{{#last()}}last: {{/last()}}{{ name }}</b>
{{/repo}}
@@ -65,7 +65,7 @@ final class TransformTests: XCTestCase {
}
func testIndex() throws {
let template = try HBMustacheTemplate(string: """
let template = try MustacheTemplate(string: """
{{#repo}}
<b>{{#index()}}{{plusone(.)}}{{/index()}}) {{ name }}</b>
{{/repo}}
@@ -81,7 +81,7 @@ final class TransformTests: XCTestCase {
}
func testEvenOdd() throws {
let template = try HBMustacheTemplate(string: """
let template = try MustacheTemplate(string: """
{{#repo}}
<b>{{index()}}) {{#even()}}even {{/even()}}{{#odd()}}odd {{/odd()}}{{ name }}</b>
{{/repo}}
@@ -97,7 +97,7 @@ final class TransformTests: XCTestCase {
}
func testReversed() throws {
let template = try HBMustacheTemplate(string: """
let template = try MustacheTemplate(string: """
{{#reversed(repo)}}
<b>{{ name }}</b>
{{/reversed(repo)}}
@@ -113,7 +113,7 @@ final class TransformTests: XCTestCase {
}
func testArrayIndex() throws {
let template = try HBMustacheTemplate(string: """
let template = try MustacheTemplate(string: """
{{#repo}}
<b>{{ index() }}) {{ name }}</b>
{{/repo}}
@@ -128,7 +128,7 @@ final class TransformTests: XCTestCase {
}
func testArraySorted() throws {
let template = try HBMustacheTemplate(string: """
let template = try MustacheTemplate(string: """
{{#sorted(repo)}}
<b>{{ index() }}) {{ . }}</b>
{{/sorted(repo)}}
@@ -143,7 +143,7 @@ final class TransformTests: XCTestCase {
}
func testDictionaryEmpty() throws {
let template = try HBMustacheTemplate(string: """
let template = try MustacheTemplate(string: """
{{#empty(array)}}Array{{/empty(array)}}{{#empty(dictionary)}}Dictionary{{/empty(dictionary)}}
""")
let object: [String: Any] = ["array": [], "dictionary": [:]]
@@ -152,12 +152,12 @@ final class TransformTests: XCTestCase {
func testListOutput() throws {
let object = [1, 2, 3, 4]
let template = try HBMustacheTemplate(string: "{{#.}}{{.}}{{^last()}}, {{/last()}}{{/.}}")
let template = try MustacheTemplate(string: "{{#.}}{{.}}{{^last()}}, {{/last()}}{{/.}}")
XCTAssertEqual(template.render(object), "1, 2, 3, 4")
}
func testDictionaryEnumerated() throws {
let template = try HBMustacheTemplate(string: """
let template = try MustacheTemplate(string: """
{{#enumerated(.)}}<b>{{ key }} = {{ value }}</b>{{/enumerated(.)}}
""")
let object: [String: Any] = ["one": 1, "two": 2]
@@ -166,7 +166,7 @@ final class TransformTests: XCTestCase {
}
func testDictionarySortedByKey() throws {
let template = try HBMustacheTemplate(string: """
let template = try MustacheTemplate(string: """
{{#sorted(.)}}<b>{{ key }} = {{ value }}</b>{{/sorted(.)}}
""")
let object: [String: Any] = ["one": 1, "two": 2, "three": 3]