From 652dcd246dcb8a9779617b950f5a42d9c8abee6c Mon Sep 17 00:00:00 2001
From: David Jennes <david.jennes@gmail.com>
Date: Sat, 22 Sep 2018 03:33:40 +0200
Subject: [PATCH] Add lexer test for escape sequence

---
 Tests/StencilTests/LexerSpec.swift | 43 ++++++++++++++++++++----------
 1 file changed, 29 insertions(+), 14 deletions(-)

diff --git a/Tests/StencilTests/LexerSpec.swift b/Tests/StencilTests/LexerSpec.swift
index 02f6d5e..c772d30 100644
--- a/Tests/StencilTests/LexerSpec.swift
+++ b/Tests/StencilTests/LexerSpec.swift
@@ -5,6 +5,11 @@ import Spectre
 class LexerTests: XCTestCase {
   func testLexer() {
     describe("Lexer") {
+      func makeSourceMap(_ token: String, for lexer: Lexer, options: String.CompareOptions = []) -> SourceMap {
+        guard let range = lexer.templateString.range(of: token, options: options) else { fatalError("Token not found") }
+        return SourceMap(location: lexer.rangeLocation(range))
+      }
+
       $0.it("can tokenize text") {
         let lexer = Lexer(templateString: "Hello World")
         let tokens = lexer.tokenize()
@@ -44,9 +49,9 @@ class LexerTests: XCTestCase {
         let tokens = lexer.tokenize()
 
         try expect(tokens.count) == 3
-        try expect(tokens[0]) == Token.text(value: "My name is ", at: SourceMap(location: lexer.rangeLocation(templateString.range(of: "My name is ")!)))
-        try expect(tokens[1]) == Token.variable(value: "myname", at: SourceMap(location: lexer.rangeLocation(templateString.range(of: "myname")!)))
-        try expect(tokens[2]) == Token.text(value: ".", at: SourceMap(location: lexer.rangeLocation(templateString.range(of: ".")!)))
+        try expect(tokens[0]) == Token.text(value: "My name is ", at: makeSourceMap("My name is ", for: lexer))
+        try expect(tokens[1]) == Token.variable(value: "myname", at: makeSourceMap("myname", for: lexer))
+        try expect(tokens[2]) == Token.text(value: ".", at: makeSourceMap(".", for: lexer))
       }
 
       $0.it("can tokenize two variables without being greedy") {
@@ -55,8 +60,8 @@ class LexerTests: XCTestCase {
         let tokens = lexer.tokenize()
 
         try expect(tokens.count) == 2
-        try expect(tokens[0]) == Token.variable(value: "thing", at: SourceMap(location: lexer.rangeLocation(templateString.range(of: "thing")!)))
-        try expect(tokens[1]) == Token.variable(value: "name", at: SourceMap(location: lexer.rangeLocation(templateString.range(of: "name")!)))
+        try expect(tokens[0]) == Token.variable(value: "thing", at: makeSourceMap("thing", for: lexer))
+        try expect(tokens[1]) == Token.variable(value: "name", at: makeSourceMap("name", for: lexer))
       }
 
       $0.it("can tokenize an unclosed block") {
@@ -85,18 +90,28 @@ class LexerTests: XCTestCase {
           }}{%
           endif %}.
           """
+        let lexer = Lexer(templateString: templateString)
+        let tokens = lexer.tokenize()
 
-          let lexer = Lexer(templateString: templateString)
+        try expect(tokens.count) == 5
+        try expect(tokens[0]) == Token.text(value: "My name is ", at: makeSourceMap("My name is", for: lexer))
+        try expect(tokens[1]) == Token.block(value: "if name and name", at: makeSourceMap("{%", for: lexer))
+        try expect(tokens[2]) == Token.variable(value: "name", at: makeSourceMap("name", for: lexer, options: .backwards))
+        try expect(tokens[3]) == Token.block(value: "endif", at: makeSourceMap("endif", for: lexer))
+        try expect(tokens[4]) == Token.text(value: ".", at: makeSourceMap(".", for: lexer))
+      }
 
-          let tokens = lexer.tokenize()
+      $0.it("can tokenize escape sequences") {
+        let templateString = "class Some {{ '{' }}{% if true %}{{ stuff }}{% endif %}"
+        let lexer = Lexer(templateString: templateString)
+        let tokens = lexer.tokenize()
 
-          try expect(tokens.count) == 5
-          try expect(tokens[0]) == Token.text(value: "My name is ", at: SourceMap(location: lexer.rangeLocation(templateString.range(of: "My name is")!)))
-          try expect(tokens[1]) == Token.block(value: "if name and name", at: SourceMap(location: lexer.rangeLocation(templateString.range(of: "{%")!)))
-          try expect(tokens[2]) == Token.variable(value: "name", at: SourceMap(location: lexer.rangeLocation(templateString.range(of: "name", options: [.backwards])!)))
-          try expect(tokens[3]) == Token.block(value: "endif", at: SourceMap(location: lexer.rangeLocation(templateString.range(of: "endif")!)))
-          try expect(tokens[4]) == Token.text(value: ".", at: SourceMap(location: lexer.rangeLocation(templateString.range(of: ".")!)))
-        }
+        try expect(tokens.count) == 5
+        try expect(tokens[0]) == Token.text(value: "class Some ", at: makeSourceMap("class Some ", for: lexer))
+        try expect(tokens[1]) == Token.variable(value: "'{'", at: makeSourceMap("'{'", for: lexer))
+        try expect(tokens[2]) == Token.block(value: "if true", at: makeSourceMap("if true", for: lexer))
+        try expect(tokens[3]) == Token.variable(value: "stuff", at: makeSourceMap("stuff", for: lexer))
+        try expect(tokens[4]) == Token.block(value: "endif", at: makeSourceMap("endif", for: lexer))
       }
     }
   }