320 lines
9.5 KiB
Swift
320 lines
9.5 KiB
Swift
//
|
|
// Stencil
|
|
// Copyright © 2022 Stencil
|
|
// MIT Licence
|
|
//
|
|
|
|
enum Operator {
|
|
case infix(String, Int, InfixOperator.Type)
|
|
case prefix(String, Int, PrefixOperator.Type)
|
|
|
|
var name: String {
|
|
switch self {
|
|
case .infix(let name, _, _):
|
|
return name
|
|
case .prefix(let name, _, _):
|
|
return name
|
|
}
|
|
}
|
|
|
|
static let all: [Operator] = [
|
|
.infix("in", 5, InExpression.self),
|
|
.infix("or", 6, OrExpression.self),
|
|
.infix("and", 7, AndExpression.self),
|
|
.prefix("not", 8, NotExpression.self),
|
|
.infix("==", 10, EqualityExpression.self),
|
|
.infix("!=", 10, InequalityExpression.self),
|
|
.infix(">", 10, MoreThanExpression.self),
|
|
.infix(">=", 10, MoreThanEqualExpression.self),
|
|
.infix("<", 10, LessThanExpression.self),
|
|
.infix("<=", 10, LessThanEqualExpression.self)
|
|
]
|
|
}
|
|
|
|
func findOperator(name: String) -> Operator? {
|
|
for `operator` in Operator.all where `operator`.name == name {
|
|
return `operator`
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
indirect enum IfToken {
|
|
case infix(name: String, bindingPower: Int, operatorType: InfixOperator.Type)
|
|
case prefix(name: String, bindingPower: Int, operatorType: PrefixOperator.Type)
|
|
case variable(Resolvable)
|
|
case subExpression(Expression)
|
|
case end
|
|
|
|
var bindingPower: Int {
|
|
switch self {
|
|
case .infix(_, let bindingPower, _):
|
|
return bindingPower
|
|
case .prefix(_, let bindingPower, _):
|
|
return bindingPower
|
|
case .variable:
|
|
return 0
|
|
case .subExpression:
|
|
return 0
|
|
case .end:
|
|
return 0
|
|
}
|
|
}
|
|
|
|
func nullDenotation(parser: IfExpressionParser) throws -> Expression {
|
|
switch self {
|
|
case .infix(let name, _, _):
|
|
throw TemplateSyntaxError("'if' expression error: infix operator '\(name)' doesn't have a left hand side")
|
|
case .prefix(_, let bindingPower, let operatorType):
|
|
let expression = try parser.expression(bindingPower: bindingPower)
|
|
return operatorType.init(expression: expression)
|
|
case .variable(let variable):
|
|
return VariableExpression(variable: variable)
|
|
case .subExpression(let expression):
|
|
return expression
|
|
case .end:
|
|
throw TemplateSyntaxError("'if' expression error: end")
|
|
}
|
|
}
|
|
|
|
func leftDenotation(left: Expression, parser: IfExpressionParser) throws -> Expression {
|
|
switch self {
|
|
case .infix(_, let bindingPower, let operatorType):
|
|
let right = try parser.expression(bindingPower: bindingPower)
|
|
return operatorType.init(lhs: left, rhs: right)
|
|
case .prefix(let name, _, _):
|
|
throw TemplateSyntaxError("'if' expression error: prefix operator '\(name)' was called with a left hand side")
|
|
case .variable(let variable):
|
|
throw TemplateSyntaxError("'if' expression error: variable '\(variable)' was called with a left hand side")
|
|
case .subExpression:
|
|
throw TemplateSyntaxError("'if' expression error: sub expression was called with a left hand side")
|
|
case .end:
|
|
throw TemplateSyntaxError("'if' expression error: end")
|
|
}
|
|
}
|
|
|
|
var isEnd: Bool {
|
|
switch self {
|
|
case .end:
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
}
|
|
|
|
final class IfExpressionParser {
|
|
let tokens: [IfToken]
|
|
var position: Int = 0
|
|
|
|
private init(tokens: [IfToken]) {
|
|
self.tokens = tokens
|
|
}
|
|
|
|
static func parser(components: [String], environment: Environment, token: Token) throws -> IfExpressionParser {
|
|
try IfExpressionParser(components: ArraySlice(components), environment: environment, token: token)
|
|
}
|
|
|
|
private init(components: ArraySlice<String>, environment: Environment, token: Token) throws {
|
|
var parsedComponents = Set<Int>()
|
|
var bracketsBalance = 0
|
|
self.tokens = try zip(components.indices, components).compactMap { index, component in
|
|
guard !parsedComponents.contains(index) else { return nil }
|
|
|
|
if component == "(" {
|
|
bracketsBalance += 1
|
|
let (expression, parsedCount) = try Self.subExpression(
|
|
from: components.suffix(from: index + 1),
|
|
environment: environment,
|
|
token: token
|
|
)
|
|
parsedComponents.formUnion(Set(index...(index + parsedCount)))
|
|
return .subExpression(expression)
|
|
} else if component == ")" {
|
|
bracketsBalance -= 1
|
|
if bracketsBalance < 0 {
|
|
throw TemplateSyntaxError("'if' expression error: missing opening bracket")
|
|
}
|
|
parsedComponents.insert(index)
|
|
return nil
|
|
} else {
|
|
parsedComponents.insert(index)
|
|
if let `operator` = findOperator(name: component) {
|
|
switch `operator` {
|
|
case .infix(let name, let bindingPower, let operatorType):
|
|
return .infix(name: name, bindingPower: bindingPower, operatorType: operatorType)
|
|
case .prefix(let name, let bindingPower, let operatorType):
|
|
return .prefix(name: name, bindingPower: bindingPower, operatorType: operatorType)
|
|
}
|
|
}
|
|
return .variable(try environment.compileResolvable(component, containedIn: token))
|
|
}
|
|
}
|
|
}
|
|
|
|
private static func subExpression(
|
|
from components: ArraySlice<String>,
|
|
environment: Environment,
|
|
token: Token
|
|
) throws -> (Expression, Int) {
|
|
var bracketsBalance = 1
|
|
let subComponents = components.prefix { component in
|
|
if component == "(" {
|
|
bracketsBalance += 1
|
|
} else if component == ")" {
|
|
bracketsBalance -= 1
|
|
}
|
|
return bracketsBalance != 0
|
|
}
|
|
if bracketsBalance > 0 {
|
|
throw TemplateSyntaxError("'if' expression error: missing closing bracket")
|
|
}
|
|
|
|
let expressionParser = try IfExpressionParser(components: subComponents, environment: environment, token: token)
|
|
let expression = try expressionParser.parse()
|
|
return (expression, subComponents.count)
|
|
}
|
|
|
|
var currentToken: IfToken {
|
|
if tokens.count > position {
|
|
return tokens[position]
|
|
}
|
|
|
|
return .end
|
|
}
|
|
|
|
var nextToken: IfToken {
|
|
position += 1
|
|
return currentToken
|
|
}
|
|
|
|
func parse() throws -> Expression {
|
|
let expression = try self.expression()
|
|
|
|
if !currentToken.isEnd {
|
|
throw TemplateSyntaxError("'if' expression error: dangling token")
|
|
}
|
|
|
|
return expression
|
|
}
|
|
|
|
func expression(bindingPower: Int = 0) throws -> Expression {
|
|
var token = currentToken
|
|
position += 1
|
|
|
|
var left = try token.nullDenotation(parser: self)
|
|
|
|
while bindingPower < currentToken.bindingPower {
|
|
token = currentToken
|
|
position += 1
|
|
left = try token.leftDenotation(left: left, parser: self)
|
|
}
|
|
|
|
return left
|
|
}
|
|
}
|
|
|
|
/// Represents an if condition and the associated nodes when the condition
|
|
/// evaluates
|
|
final class IfCondition {
|
|
let expression: Expression?
|
|
let nodes: [NodeType]
|
|
|
|
init(expression: Expression?, nodes: [NodeType]) {
|
|
self.expression = expression
|
|
self.nodes = nodes
|
|
}
|
|
|
|
func render(_ context: Context) throws -> String {
|
|
try context.push {
|
|
try renderNodes(nodes, context)
|
|
}
|
|
}
|
|
}
|
|
|
|
class IfNode: NodeType {
|
|
let conditions: [IfCondition]
|
|
let token: Token?
|
|
|
|
class func parse(_ parser: TokenParser, token: Token) throws -> NodeType {
|
|
var components = token.components
|
|
components.removeFirst()
|
|
|
|
let expression = try parser.compileExpression(components: components, token: token)
|
|
let nodes = try parser.parse(until(["endif", "elif", "else"]))
|
|
var conditions: [IfCondition] = [
|
|
IfCondition(expression: expression, nodes: nodes)
|
|
]
|
|
|
|
var nextToken = parser.nextToken()
|
|
while let current = nextToken, current.contents.hasPrefix("elif") {
|
|
var components = current.components
|
|
components.removeFirst()
|
|
let expression = try parser.compileExpression(components: components, token: current)
|
|
|
|
let nodes = try parser.parse(until(["endif", "elif", "else"]))
|
|
nextToken = parser.nextToken()
|
|
conditions.append(IfCondition(expression: expression, nodes: nodes))
|
|
}
|
|
|
|
if let current = nextToken, current.contents == "else" {
|
|
conditions.append(IfCondition(expression: nil, nodes: try parser.parse(until(["endif"]))))
|
|
nextToken = parser.nextToken()
|
|
}
|
|
|
|
guard let current = nextToken, current.contents == "endif" else {
|
|
throw TemplateSyntaxError("`endif` was not found.")
|
|
}
|
|
|
|
return IfNode(conditions: conditions, token: token)
|
|
}
|
|
|
|
class func parse_ifnot(_ parser: TokenParser, token: Token) throws -> NodeType {
|
|
var components = token.components
|
|
guard components.count == 2 else {
|
|
throw TemplateSyntaxError("'ifnot' statements should use the following syntax 'ifnot condition'.")
|
|
}
|
|
components.removeFirst()
|
|
var trueNodes = [NodeType]()
|
|
var falseNodes = [NodeType]()
|
|
|
|
let expression = try parser.compileExpression(components: components, token: token)
|
|
falseNodes = try parser.parse(until(["endif", "else"]))
|
|
|
|
guard let token = parser.nextToken() else {
|
|
throw TemplateSyntaxError("`endif` was not found.")
|
|
}
|
|
|
|
if token.contents == "else" {
|
|
trueNodes = try parser.parse(until(["endif"]))
|
|
_ = parser.nextToken()
|
|
}
|
|
|
|
return IfNode(conditions: [
|
|
IfCondition(expression: expression, nodes: trueNodes),
|
|
IfCondition(expression: nil, nodes: falseNodes)
|
|
], token: token)
|
|
}
|
|
|
|
init(conditions: [IfCondition], token: Token? = nil) {
|
|
self.conditions = conditions
|
|
self.token = token
|
|
}
|
|
|
|
func render(_ context: Context) throws -> String {
|
|
for condition in conditions {
|
|
if let expression = condition.expression {
|
|
let truthy = try expression.evaluate(context: context)
|
|
|
|
if truthy {
|
|
return try condition.render(context)
|
|
}
|
|
} else {
|
|
return try condition.render(context)
|
|
}
|
|
}
|
|
|
|
return ""
|
|
}
|
|
}
|