Add methods for Array and Dictionary

Sources/HummingbirdMustache/Method.swift

@@ -22,6 +22,32 @@ extension String: HBMustacheBaseMethods {
         switch name {
         case "lowercased":
             return self.lowercased()
+        case "uppercased":
+            return self.uppercased()
+        default:
+            return nil
+        }
+    }
+}
+
+extension Array: HBMustacheBaseMethods {
+    func runMethod(_ name: String) -> Any? {
+        switch name {
+        case "reversed":
+            return self.reversed()
+        case "enumerated":
+            return self.enumerated()
+        default:
+            return nil
+        }
+    }
+}
+
+extension Dictionary: HBMustacheBaseMethods {
+    func runMethod(_ name: String) -> Any? {
+        switch name {
+        case "enumerated":
+            return self.enumerated()
         default:
             return nil
         }

Sources/HummingbirdMustache/Template+Parser.swift

@@ -24,21 +24,21 @@ extension HBMustacheTemplate {
             switch parser.current() {
             case "#":
                 parser.unsafeAdvance()
-                let (name, _) = try parseName(&parser)
+                let (name, method) = try parseName(&parser)
                 if parser.current() == "\n" {
                     parser.unsafeAdvance()
                 }
                 let sectionTokens = try parse(&parser, sectionName: name)
-                tokens.append(.section(name, HBMustacheTemplate(sectionTokens)))
+                tokens.append(.section(name: name, method: method, template: HBMustacheTemplate(sectionTokens)))
 
             case "^":
                 parser.unsafeAdvance()
-                let (name, _) = try parseName(&parser)
+                let (name, method) = try parseName(&parser)
                 if parser.current() == "\n" {
                     parser.unsafeAdvance()
                 }
                 let sectionTokens = try parse(&parser, sectionName: name)
-                tokens.append(.invertedSection(name, HBMustacheTemplate(sectionTokens)))
+                tokens.append(.invertedSection(name: name, method: method, template: HBMustacheTemplate(sectionTokens)))
 
             case "/":
                 parser.unsafeAdvance()
@@ -53,9 +53,9 @@ extension HBMustacheTemplate {
 
             case "{":
                 parser.unsafeAdvance()
-                let (name, _) = try parseName(&parser)
+                let (name, method) = try parseName(&parser)
                 guard try parser.read("}") else { throw Error.unfinishedName }
-                tokens.append(.unescapedVariable(name))
+                tokens.append(.unescapedVariable(name: name, method: method))
 
             case "!":
                 parser.unsafeAdvance()
@@ -68,7 +68,7 @@ extension HBMustacheTemplate {
 
             default:
                 let (name, method) = try parseName(&parser)
-                tokens.append(.variable(name, method))
+                tokens.append(.variable(name: name, method: method))
             }
         }
         // should never get here if reading section

Sources/HummingbirdMustache/Template+Render.swift

@@ -7,29 +7,23 @@ extension HBMustacheTemplate {
             case .text(let text):
                 string += text
             case .variable(let variable, let method):
-                if var child = getChild(named: variable, from: object) {
-                    if let method = method,
-                       let runnable = child as? HBMustacheBaseMethods {
-                        if let result = runnable.runMethod(method) {
-                            child = result
-                        }
-                    }
+                if let child = getChild(named: variable, from: object, method: method) {
                     if let template = child as? HBMustacheTemplate {
                         string += template.render(object, library: library)
                     } else {
                         string += htmlEscape(String(describing: child))
                     }
                 }
-            case .unescapedVariable(let variable):
-                if let child = getChild(named: variable, from: object) {
+            case .unescapedVariable(let variable, let method):
+                if let child = getChild(named: variable, from: object, method: method) {
                     string += String(describing: child)
                 }
-            case .section(let variable, let template):
-                let child = getChild(named: variable, from: object)
+            case .section(let variable, let method, let template):
+                let child = getChild(named: variable, from: object, method: method)
                 string += renderSection(child, parent: object, with: template, library: library)
                 
-            case .invertedSection(let variable, let template):
-                let child = getChild(named: variable, from: object)
+            case .invertedSection(let variable, let method, let template):
+                let child = getChild(named: variable, from: object, method: method)
                 string += renderInvertedSection(child, parent: object, with: template, library: library)
                 
             case .partial(let name):
@@ -67,7 +61,7 @@ extension HBMustacheTemplate {
         }
     }
     
-    func getChild(named name: String, from object: Any) -> Any? {
+    func getChild(named name: String, from object: Any, method: String?) -> Any? {
         func _getChild(named names: ArraySlice<String>, from object: Any) -> Any? {
             guard let name = names.first else { return object }
             let childObject: Any?
@@ -82,9 +76,20 @@ extension HBMustacheTemplate {
             return _getChild(named: names2, from: childObject!)
         }
 
-        if name == "." { return object }
-        let nameSplit = name.split(separator: ".").map { String($0) }
-        return _getChild(named: nameSplit[...], from: object)
+        let child: Any?
+        if name == "." {
+            child = object
+        } else {
+            let nameSplit = name.split(separator: ".").map { String($0) }
+            child = _getChild(named: nameSplit[...], from: object)
+        }
+        if let method = method,
+           let runnable = child as? HBMustacheBaseMethods {
+            if let result = runnable.runMethod(method) {
+                return result
+            }
+        }
+        return child
     }
 
     private static let htmlEscapedCharacters: [Character: String] = [
@@ -140,3 +145,37 @@ extension Array: HBSequence {
         return ""
     }
 }
+
+extension ReversedCollection: HBSequence {
+    func renderSection(with template: HBMustacheTemplate, library: HBMustacheLibrary?) -> String {
+        var string = ""
+        for obj in self {
+            string += template.render(obj, library: library)
+        }
+        return string
+    }
+
+    func renderInvertedSection(with template: HBMustacheTemplate, library: HBMustacheLibrary?) -> String {
+        if count == 0 {
+            return template.render(self, library: library)
+        }
+        return ""
+    }
+}
+
+extension EnumeratedSequence: HBSequence {
+    func renderSection(with template: HBMustacheTemplate, library: HBMustacheLibrary?) -> String {
+        var string = ""
+        for obj in self {
+            string += template.render(obj, library: library)
+        }
+        return string
+    }
+
+    func renderInvertedSection(with template: HBMustacheTemplate, library: HBMustacheLibrary?) -> String {
+        if self.underestimatedCount == 0 {
+            return template.render(self, library: library)
+        }
+        return ""
+    }
+}

Sources/HummingbirdMustache/Template.swift

@@ -10,10 +10,10 @@ public class HBMustacheTemplate {
     
     enum Token {
         case text(String)
-        case variable(String, String? = nil)
-        case unescapedVariable(String)
-        case section(String, HBMustacheTemplate)
-        case invertedSection(String, HBMustacheTemplate)
+        case variable(name: String, method: String? = nil)
+        case unescapedVariable(name: String, method: String? = nil)
+        case section(name: String, method: String? = nil, template: HBMustacheTemplate)
+        case invertedSection(name: String, method: String? = nil, template: HBMustacheTemplate)
         case partial(String)
     }