98 lines
2.9 KiB
Swift
98 lines
2.9 KiB
Swift
import Foundation
|
|
|
|
class ForNode : NodeType {
|
|
let resolvable: Resolvable
|
|
let loopVariables: [String]
|
|
let nodes:[NodeType]
|
|
let emptyNodes: [NodeType]
|
|
let `where`: Expression?
|
|
|
|
class func parse(_ parser:TokenParser, token:Token) throws -> NodeType {
|
|
let components = token.components()
|
|
|
|
guard components.count >= 2 && components[2] == "in" &&
|
|
(components.count == 4 || (components.count >= 6 && components[4] == "where")) else {
|
|
throw TemplateSyntaxError("'for' statements should use the following 'for x in y where condition' `\(token.contents)`.")
|
|
}
|
|
|
|
let loopVariables = components[1].characters
|
|
.split(separator: ",")
|
|
.map(String.init)
|
|
.map { $0.trimmingCharacters(in: CharacterSet.whitespaces) }
|
|
|
|
let variable = components[3]
|
|
|
|
var emptyNodes = [NodeType]()
|
|
|
|
let forNodes = try parser.parse(until(["endfor", "empty"]))
|
|
|
|
guard let token = parser.nextToken() else {
|
|
throw TemplateSyntaxError("`endfor` was not found.")
|
|
}
|
|
|
|
if token.contents == "empty" {
|
|
emptyNodes = try parser.parse(until(["endfor"]))
|
|
_ = parser.nextToken()
|
|
}
|
|
|
|
let filter = try parser.compileFilter(variable)
|
|
let `where`: Expression?
|
|
if components.count >= 6 {
|
|
`where` = try parseExpression(components: Array(components.suffix(from: 5)), tokenParser: parser)
|
|
} else {
|
|
`where` = nil
|
|
}
|
|
return ForNode(resolvable: filter, loopVariables: loopVariables, nodes: forNodes, emptyNodes:emptyNodes, where: `where`)
|
|
}
|
|
|
|
init(resolvable: Resolvable, loopVariables: [String], nodes:[NodeType], emptyNodes:[NodeType], where: Expression? = nil) {
|
|
self.resolvable = resolvable
|
|
self.loopVariables = loopVariables
|
|
self.nodes = nodes
|
|
self.emptyNodes = emptyNodes
|
|
self.where = `where`
|
|
}
|
|
|
|
func render(_ context: Context) throws -> String {
|
|
let resolved = try resolvable.resolve(context)
|
|
|
|
var values: [Any]
|
|
|
|
if let dictionary = resolved as? [String: Any], !dictionary.isEmpty {
|
|
values = Array(dictionary.keys)
|
|
} else if let array = resolved as? [Any] {
|
|
values = array
|
|
} else {
|
|
values = []
|
|
}
|
|
|
|
if let `where` = self.where {
|
|
values = try values.filter({ item -> Bool in
|
|
return try context.push(dictionary: [loopVariables.first!: item]) { () -> Bool in
|
|
try `where`.evaluate(context: context)
|
|
}
|
|
})
|
|
}
|
|
|
|
if !values.isEmpty {
|
|
let count = values.count
|
|
|
|
return try values.enumerated().map { index, item in
|
|
let forContext: [String: Any] = [
|
|
"first": index == 0,
|
|
"last": index == (count - 1),
|
|
"counter": index + 1,
|
|
]
|
|
|
|
return try context.push(dictionary: [loopVariables.first!: item, "forloop": forContext]) {
|
|
try renderNodes(nodes, context)
|
|
}
|
|
}.joined(separator: "")
|
|
}
|
|
|
|
return try context.push {
|
|
try renderNodes(emptyNodes, context)
|
|
}
|
|
}
|
|
}
|