Add support for Swift 3.0

Sources/Lexer.swift

@@ -7,18 +7,20 @@ public struct Lexer {
 
   func createToken(string:String) -> Token {
     func strip() -> String {
-      return string[string.startIndex.successor().successor()..<string.endIndex.predecessor().predecessor()].trim(" ")
+      let start = string.index(string.startIndex, offsetBy: 2)
+      let end = string.index(string.endIndex, offsetBy: -2)
+      return string[start..<end].trim(character: " ")
     }
 
     if string.hasPrefix("{{") {
-      return Token.Variable(value: strip())
+      return .variable(value: strip())
     } else if string.hasPrefix("{%") {
-      return Token.Block(value: strip())
+      return .block(value: strip())
     } else if string.hasPrefix("{#") {
-      return Token.Comment(value: strip())
+      return .comment(value: strip())
     }
 
-    return Token.Text(value: string)
+    return .text(value: string)
   }
 
   /// Returns an array of tokens from a given template string.
@@ -36,14 +38,14 @@ public struct Lexer {
     while !scanner.isEmpty {
       if let text = scanner.scan(until: ["{{", "{%", "{#"]) {
         if !text.1.isEmpty {
-          tokens.append(createToken(text.1))
+          tokens.append(createToken(string: text.1))
         }
 
         let end = map[text.0]!
         let result = scanner.scan(until: end, returnUntil: true)
-        tokens.append(createToken(result))
+        tokens.append(createToken(string: result))
       } else {
-        tokens.append(createToken(scanner.content))
+        tokens.append(createToken(string: scanner.content))
         scanner.content = ""
       }
     }
@@ -64,49 +66,50 @@ class Scanner {
     return content.isEmpty
   }
 
-  func scan(until until: String, returnUntil: Bool = false) -> String {
+  func scan(until: String, returnUntil: Bool = false) -> String {
     if until.isEmpty {
       return ""
     }
 
     var index = content.startIndex
     while index != content.endIndex {
-      let substring = content.substringFromIndex(index)
+      let substring = content.substring(from: index)
+
       if substring.hasPrefix(until) {
-        let result = content.substringToIndex(index)
+        let result = content.substring(to: index)
         content = substring
 
         if returnUntil {
-          content = content.substringFromIndex(until.endIndex)
+          content = content.substring(from: until.endIndex)
           return result + until
         }
 
         return result
       }
 
-      index = index.successor()
+      index = content.index(after: index)
     }
 
     return ""
   }
 
-  func scan(until until: [String]) -> (String, String)? {
+  func scan(until: [String]) -> (String, String)? {
     if until.isEmpty {
       return nil
     }
 
     var index = content.startIndex
     while index != content.endIndex {
-      let substring = content.substringFromIndex(index)
+      let substring = content.substring(from: index)
       for string in until {
         if substring.hasPrefix(string) {
-          let result = content.substringToIndex(index)
+          let result = content.substring(to: index)
           content = substring
           return (string, result)
         }
       }
 
-      index = index.successor()
+      index = content.index(after: index)
     }
 
     return nil
@@ -117,31 +120,33 @@ class Scanner {
 extension String {
   func findFirstNot(character: Character) -> String.Index? {
     var index = startIndex
+
     while index != endIndex {
       if character != self[index] {
         return index
       }
-      index = index.successor()
+      index = self.index(after: index)
     }
 
     return nil
   }
 
   func findLastNot(character: Character) -> String.Index? {
-    var index = endIndex.predecessor()
+    var index = self.index(before: endIndex)
+
     while index != startIndex {
       if character != self[index] {
-        return index.successor()
+        return self.index(after: index)
       }
-      index = index.predecessor()
+      index = self.index(before: index)
     }
 
     return nil
   }
 
   func trim(character: Character) -> String {
-    let first = findFirstNot(character) ?? startIndex
-    let last = findLastNot(character) ?? endIndex
+    let first = findFirstNot(character: character) ?? startIndex
+    let last = findLastNot(character: character) ?? endIndex
     return self[first..<last]
   }
 }