From dbb5e14e9f04e3bd5bc287012379f608c879f15e Mon Sep 17 00:00:00 2001 From: Ilya Puchka Date: Mon, 1 Oct 2018 21:59:03 +0100 Subject: [PATCH] solve merge conflict issues --- Sources/Extension.swift | 1 + Sources/ForTag.swift | 2 +- Sources/IfTag.swift | 20 ++++++------- Sources/Node.swift | 4 +-- Sources/Parser.swift | 36 +++++++++++----------- Sources/Variable.swift | 13 ++++---- Tests/StencilTests/ExpressionSpec.swift | 3 +- Tests/StencilTests/FilterSpec.swift | 40 ++++++++++++------------- Tests/StencilTests/ForNodeSpec.swift | 6 ++-- Tests/StencilTests/VariableSpec.swift | 3 +- 10 files changed, 63 insertions(+), 65 deletions(-) diff --git a/Sources/Extension.swift b/Sources/Extension.swift index 2aac1d9..5af819e 100644 --- a/Sources/Extension.swift +++ b/Sources/Extension.swift @@ -38,6 +38,7 @@ open class Extension { filters[name] = .arguments({ value, args, _ in try filter(value, args) }) } + /// Registers a template filter with the given name public func registerFilter(_ name: String, filter: @escaping (Any?, [Any?], Context) throws -> Any?) { filters[name] = .arguments(filter) } diff --git a/Sources/ForTag.swift b/Sources/ForTag.swift index 0bc8775..3f2a753 100644 --- a/Sources/ForTag.swift +++ b/Sources/ForTag.swift @@ -31,7 +31,7 @@ class ForNode : NodeType { let resolvable = try parser.compileResolvable(components[3], containedIn: token) let `where` = hasToken("where", at: 4) - ? try parseExpression(components: Array(components.suffix(from: 5)), tokenParser: parser, token: token) + ? try parser.compileExpression(components: Array(components.suffix(from: 5)), token: token) : nil let forNodes = try parser.parse(until(["endfor", "empty"])) diff --git a/Sources/IfTag.swift b/Sources/IfTag.swift index 0b56622..16fd0ee 100644 --- a/Sources/IfTag.swift +++ b/Sources/IfTag.swift @@ -111,11 +111,11 @@ final class IfExpressionParser { self.tokens = tokens } - static func parser(components: [String], tokenParser: TokenParser, token: Token) throws -> IfExpressionParser { - return try IfExpressionParser(components: ArraySlice(components), tokenParser: tokenParser, token: token) + static func parser(components: [String], environment: Environment, token: Token) throws -> IfExpressionParser { + return try IfExpressionParser(components: ArraySlice(components), environment: environment, token: token) } - private init(components: ArraySlice, tokenParser: TokenParser, token: Token) throws { + private init(components: ArraySlice, environment: Environment, token: Token) throws { var parsedComponents = Set() var bracketsBalance = 0 self.tokens = try zip(components.indices, components).compactMap { (index, component) in @@ -125,7 +125,7 @@ final class IfExpressionParser { bracketsBalance += 1 let (expression, parsedCount) = try IfExpressionParser.subExpression( from: components.suffix(from: index + 1), - tokenParser: tokenParser, + environment: environment, token: token ) parsedComponents.formUnion(Set(index...(index + parsedCount))) @@ -147,12 +147,12 @@ final class IfExpressionParser { return .prefix(name: name, bindingPower: bindingPower, operatorType: operatorType) } } - return .variable(try tokenParser.compileResolvable(component, containedIn: token)) + return .variable(try environment.compileResolvable(component, containedIn: token)) } } } - private static func subExpression(from components: ArraySlice, tokenParser: TokenParser, token: Token) throws -> (Expression, Int) { + private static func subExpression(from components: ArraySlice, environment: Environment, token: Token) throws -> (Expression, Int) { var bracketsBalance = 1 let subComponents = components .prefix(while: { @@ -167,7 +167,7 @@ final class IfExpressionParser { throw TemplateSyntaxError("'if' expression error: missing closing bracket") } - let expressionParser = try IfExpressionParser(components: subComponents, tokenParser: tokenParser, token: token) + let expressionParser = try IfExpressionParser(components: subComponents, environment: environment, token: token) let expression = try expressionParser.parse() return (expression, subComponents.count) } @@ -239,7 +239,7 @@ class IfNode : NodeType { var components = token.components() components.removeFirst() - let expression = try parseExpression(components: components, tokenParser: parser, token: token) + 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) @@ -249,7 +249,7 @@ class IfNode : NodeType { while let current = nextToken, current.contents.hasPrefix("elif") { var components = current.components() components.removeFirst() - let expression = try parseExpression(components: components, tokenParser: parser, token: current) + let expression = try parser.compileExpression(components: components, token: current) let nodes = try parser.parse(until(["endif", "elif", "else"])) nextToken = parser.nextToken() @@ -277,7 +277,7 @@ class IfNode : NodeType { var trueNodes = [NodeType]() var falseNodes = [NodeType]() - let expression = try parseExpression(components: components, tokenParser: parser, token: token) + let expression = try parser.compileExpression(components: components, token: token) falseNodes = try parser.parse(until(["endif", "else"])) guard let token = parser.nextToken() else { diff --git a/Sources/Node.swift b/Sources/Node.swift index dc7a72c..9094820 100644 --- a/Sources/Node.swift +++ b/Sources/Node.swift @@ -74,11 +74,11 @@ public class VariableNode : NodeType { if hasToken("if", at: 1) { let components = components.suffix(from: 2) if let elseIndex = components.index(of: "else") { - condition = try parseExpression(components: Array(components.prefix(upTo: elseIndex)), tokenParser: parser, token: token) + condition = try parser.compileExpression(components: Array(components.prefix(upTo: elseIndex)), token: token) let elseToken = components.suffix(from: elseIndex.advanced(by: 1)).joined(separator: " ") elseExpression = try parser.compileResolvable(elseToken, containedIn: token) } else { - condition = try parseExpression(components: Array(components), tokenParser: parser, token: token) + condition = try parser.compileExpression(components: Array(components), token: token) elseExpression = nil } } else { diff --git a/Sources/Parser.swift b/Sources/Parser.swift index 0133531..6be6632 100644 --- a/Sources/Parser.swift +++ b/Sources/Parser.swift @@ -49,7 +49,7 @@ public class TokenParser { if let tag = token.components().first { do { - let parser = try findTag(name: tag) + let parser = try environment.findTag(name: tag) let node = try parser(self, token) nodes.append(node) } catch { @@ -76,16 +76,16 @@ public class TokenParser { tokens.insert(token, at: 0) } - public func compileFilter(_ token: String) throws -> Resolvable { - return try environment.compileFilter(token) + public func compileFilter(_ filterToken: String, containedIn token: Token) throws -> Resolvable { + return try environment.compileFilter(filterToken, containedIn: token) } - public func compileExpression(components: [String]) throws -> Expression { - return try environment.compileExpression(components: components) + public func compileExpression(components: [String], token: Token) throws -> Expression { + return try environment.compileExpression(components: components, containedIn: token) } - public func compileResolvable(_ token: String) throws -> Resolvable { - return try environment.compileResolvable(token) + public func compileResolvable(_ token: String, containedIn containingToken: Token) throws -> Resolvable { + return try environment.compileResolvable(token, containedIn: containingToken) } } @@ -134,9 +134,13 @@ extension Environment { return filtersWithDistance.filter({ $0.distance == minDistance }).map({ $0.filterName }) } + public func compileFilter(_ token: String) throws -> Resolvable { + return try FilterExpression(token: token, environment: self) + } + public func compileFilter(_ filterToken: String, containedIn containingToken: Token) throws -> Resolvable { do { - return try FilterExpression(token: filterToken, parser: self) + return try FilterExpression(token: filterToken, environment: self) } catch { guard var syntaxError = error as? TemplateSyntaxError, syntaxError.token == nil else { throw error @@ -153,26 +157,20 @@ extension Environment { } } - @available(*, deprecated, message: "Use compileFilter(_:containedIn:)") - public func compileFilter(_ token: String) throws -> Resolvable { - return try FilterExpression(token: token, environment: self) - } - - public func compileExpression(components: [String]) throws -> Expression { - return try IfExpressionParser(components: components, environment: self).parse() - } - - @available(*, deprecated, message: "Use compileResolvable(_:containedIn:)") public func compileResolvable(_ token: String) throws -> Resolvable { return try RangeVariable(token, environment: self) ?? compileFilter(token) } public func compileResolvable(_ token: String, containedIn containingToken: Token) throws -> Resolvable { - return try RangeVariable(token, parser: self, containedIn: containingToken) + return try RangeVariable(token, environment: self, containedIn: containingToken) ?? compileFilter(token, containedIn: containingToken) } + public func compileExpression(components: [String], containedIn token: Token) throws -> Expression { + return try IfExpressionParser.parser(components: components, environment: self, token: token).parse() + } + } // https://en.wikipedia.org/wiki/Levenshtein_distance#Iterative_with_two_matrix_rows diff --git a/Sources/Variable.swift b/Sources/Variable.swift index d621289..b2531b9 100644 --- a/Sources/Variable.swift +++ b/Sources/Variable.swift @@ -8,8 +8,8 @@ class FilterExpression : Resolvable { let filters: [(FilterType, [Variable])] let variable: Variable - init(token: String, parser: TokenParser) throws { - let bits = token.split(separator: "|").map({ String($0).trim(character: " ") }) + init(token: String, environment: Environment) throws { + let bits = token.smartSplit(separator: "|").map({ String($0).trim(character: " ") }) if bits.isEmpty { throw TemplateSyntaxError("Variable tags must include at least 1 argument") } @@ -144,8 +144,7 @@ public struct RangeVariable: Resolvable { public let from: Resolvable public let to: Resolvable - @available(*, deprecated, message: "Use init?(_:parser:containedIn:)") - public init?(_ token: String, parser: TokenParser) throws { + public init?(_ token: String, environment: Environment) throws { let components = token.components(separatedBy: "...") guard components.count == 2 else { return nil @@ -155,14 +154,14 @@ public struct RangeVariable: Resolvable { self.to = try environment.compileFilter(components[1]) } - public init?(_ token: String, parser: TokenParser, containedIn containingToken: Token) throws { + public init?(_ token: String, environment: Environment, containedIn containingToken: Token) throws { let components = token.components(separatedBy: "...") guard components.count == 2 else { return nil } - self.from = try parser.compileFilter(components[0], containedIn: containingToken) - self.to = try parser.compileFilter(components[1], containedIn: containingToken) + self.from = try environment.compileFilter(components[0], containedIn: containingToken) + self.to = try environment.compileFilter(components[1], containedIn: containingToken) } public func resolve(_ context: Context) throws -> Any? { diff --git a/Tests/StencilTests/ExpressionSpec.swift b/Tests/StencilTests/ExpressionSpec.swift index 0109665..a115555 100644 --- a/Tests/StencilTests/ExpressionSpec.swift +++ b/Tests/StencilTests/ExpressionSpec.swift @@ -5,10 +5,9 @@ import Spectre class ExpressionsTests: XCTestCase { func testExpressions() { describe("Expression") { - let parser = TokenParser(tokens: [], environment: Environment()) func parseExpression(components: [String]) throws -> Expression { - let parser = try IfExpressionParser.parser(components: components, tokenParser: parser, token: .text(value: "", at: .unknown)) + let parser = try IfExpressionParser.parser(components: components, environment: Environment(), token: .text(value: "", at: .unknown)) return try parser.parse() } diff --git a/Tests/StencilTests/FilterSpec.swift b/Tests/StencilTests/FilterSpec.swift index 9028829..4a6dedf 100644 --- a/Tests/StencilTests/FilterSpec.swift +++ b/Tests/StencilTests/FilterSpec.swift @@ -386,28 +386,28 @@ class FilterTests: XCTestCase { """ } } - } - - describe("dynamic filter") { - $0.it("can apply dynamic filter") { - let template = Template(templateString: "{{ name|filter:somefilter }}") - let result = try template.render(Context(dictionary: ["name": "Jhon", "somefilter": "uppercase"])) - try expect(result) == "JHON" - } - - $0.it("can apply dynamic filter on array") { - let template = Template(templateString: "{{ values|filter:joinfilter }}") - let result = try template.render(Context(dictionary: ["values": [1, 2, 3], "joinfilter": "join:\", \""])) - try expect(result) == "1, 2, 3" - } - - $0.it("throws on unknown dynamic filter") { - let template = Template(templateString: "{{ values|filter:unknown }}") - let context = Context(dictionary: ["values": [1, 2, 3], "unknown": "absurd"]) - try expect(try template.render(context)).toThrow() + describe("dynamic filter") { + + $0.it("can apply dynamic filter") { + let template = Template(templateString: "{{ name|filter:somefilter }}") + let result = try template.render(Context(dictionary: ["name": "Jhon", "somefilter": "uppercase"])) + try expect(result) == "JHON" + } + + $0.it("can apply dynamic filter on array") { + let template = Template(templateString: "{{ values|filter:joinfilter }}") + let result = try template.render(Context(dictionary: ["values": [1, 2, 3], "joinfilter": "join:\", \""])) + try expect(result) == "1, 2, 3" + } + + $0.it("throws on unknown dynamic filter") { + let template = Template(templateString: "{{ values|filter:unknown }}") + let context = Context(dictionary: ["values": [1, 2, 3], "unknown": "absurd"]) + try expect(try template.render(context)).toThrow() + } + } } - } diff --git a/Tests/StencilTests/ForNodeSpec.swift b/Tests/StencilTests/ForNodeSpec.swift index 8cd7846..d3bfa8c 100644 --- a/Tests/StencilTests/ForNodeSpec.swift +++ b/Tests/StencilTests/ForNodeSpec.swift @@ -99,7 +99,8 @@ class ForNodeTests: XCTestCase { $0.it("renders the given nodes while filtering items using where expression") { let nodes: [NodeType] = [VariableNode(variable: "item"), VariableNode(variable: "forloop.counter")] - let `where` = try parseExpression(components: ["item", ">", "1"], tokenParser: TokenParser(tokens: [], environment: Environment()), token: .text(value: "", at: .unknown)) + let parser = TokenParser(tokens: [], environment: Environment()) + let `where` = try parser.compileExpression(components: ["item", ">", "1"], token: .text(value: "", at: .unknown)) let node = ForNode(resolvable: Variable("items"), loopVariables: ["item"], nodes: nodes, emptyNodes: [], where: `where`) try expect(try node.render(context)) == "2132" } @@ -107,7 +108,8 @@ class ForNodeTests: XCTestCase { $0.it("renders the given empty nodes when all items filtered out with where expression") { let nodes: [NodeType] = [VariableNode(variable: "item")] let emptyNodes: [NodeType] = [TextNode(text: "empty")] - let `where` = try parseExpression(components: ["item", "==", "0"], tokenParser: TokenParser(tokens: [], environment: Environment()), token: .text(value: "", at: .unknown)) + let parser = TokenParser(tokens: [], environment: Environment()) + let `where` = try parser.compileExpression(components: ["item", "==", "0"], token: .text(value: "", at: .unknown)) let node = ForNode(resolvable: Variable("emptyItems"), loopVariables: ["item"], nodes: nodes, emptyNodes: emptyNodes, where: `where`) try expect(try node.render(context)) == "empty" } diff --git a/Tests/StencilTests/VariableSpec.swift b/Tests/StencilTests/VariableSpec.swift index ef2632d..2f5933d 100644 --- a/Tests/StencilTests/VariableSpec.swift +++ b/Tests/StencilTests/VariableSpec.swift @@ -351,8 +351,7 @@ class VariableTests: XCTestCase { func makeVariable(_ token: String) throws -> RangeVariable? { let token = Token.variable(value: token, at: .unknown) - let parser = TokenParser(tokens: [token], environment: context.environment) - return try RangeVariable(token.contents, parser: parser, containedIn: token) + return try RangeVariable(token.contents, environment: context.environment, containedIn: token) } $0.it("can resolve closed range as array") {