Fixed the error in newer Xcode 10 (#10)

* #9 Update with new initializer for Range<Index>

* #9 Remove warnings corresponding to Swift 3 characters property access

Author: ludoded

Fuse/Classes/Fuse.swift

@@ -74,7 +74,7 @@ public class Fuse {
     /// - Returns: A tuple containing pattern metadata
     public func createPattern (from aString: String) -> Pattern? {
         let pattern = self.isCaseSensitive ? aString : aString.lowercased()
-        let len = pattern.characters.count
+        let len = pattern.count
 
         if len == 0 {
             return nil
@@ -109,7 +109,7 @@ public class Fuse {
             text = text.lowercased()
         }
 
-        let textLength = text.characters.count
+        let textLength = text.count
 
         // Exact match
         if (pattern.text == text) {
@@ -122,7 +122,7 @@ public class Fuse {
 
         var bestLocation: Int? = {
             if let index = text.index(of: pattern.text, startingFrom: location) {
-                return text.characters.distance(from: text.startIndex, to: index)
+                return text.distance(from: text.startIndex, to: index)
             }
             return nil
         }()
@@ -137,7 +137,7 @@ public class Fuse {
             // What about in the other direction? (speed up)
             bestLocation = {
                 if let index = text.lastIndexOf(pattern.text, position: location + pattern.len) {
-                    return text.characters.distance(from: text.startIndex, to: index)
+                    return text.distance(from: text.startIndex, to: index)
                 }
                 return nil
             }()

Fuse/Classes/FuseUtilities.swift

@@ -19,7 +19,7 @@ class FuseUtilities {
     /// - Parameter scoreTextLength: Coerced version of text's length.
     /// - Returns: Overall score for match (0.0 = good, 1.0 = bad).
     static func calculateScore(_ pattern: String, e: Int, x: Int, loc: Int, distance: Int) -> Double {
-        let len = pattern.characters.count
+        let len = pattern.count
         let accuracy = Double(e) / Double(len)
         let proximity = abs(x - loc)
         if (distance == 0) {
@@ -33,13 +33,13 @@ class FuseUtilities {
     /// - Parameter pattern: The text to encode.
     /// - Returns: Hash of character locations.
     static func calculatePatternAlphabet(_ pattern: String) -> [Character: Int] {
-        let len = pattern.characters.count
+        let len = pattern.count
         var mask = [Character: Int]()
-        for char in pattern.characters {
+        for char in pattern {
             mask[char] = 0
         }
         for i in 0...len-1 {
-            let c = pattern[pattern.characters.index(pattern.startIndex, offsetBy: i)]
+            let c = pattern[pattern.index(pattern.startIndex, offsetBy: i)]
             mask[c] =  mask[c]! | (1 << (len - i - 1))
         }
         return mask

Fuse/Classes/String+Fuse.swift

@@ -14,10 +14,10 @@ extension String {
     /// - Parameter index: some index
     /// - Returns: the character at the provided index
     func char(at index: Int) -> Character? {
-        if index >= self.characters.count {
+        if index >= self.count {
             return nil
         }
-        return self[self.characters.index(self.startIndex, offsetBy: index)]
+        return self[self.index(self.startIndex, offsetBy: index)]
     }
 
     /// Searches and returns the index within the string of the first occurrence of `searchStr`.
@@ -27,8 +27,8 @@ extension String {
     ///
     ///  - Returns: The index within the calling String object of the first occurrence of `searchStr`, starting the search at `position`. Returns `nil` if the value is not found.
     func index(of aString: String, startingFrom position: Int? = 0) -> String.Index? {
-        let start: String.Index = self.characters.index(self.startIndex, offsetBy: position!)
-        let range: Range<Index> = Range<Index>(start..<self.endIndex)
+        let start: String.Index = self.index(self.startIndex, offsetBy: position!)
+        let range: Range<Index> = Range<Index>.init(uncheckedBounds: (lower: start, upper: self.endIndex))
         return self.range(of: aString, options: .literal, range: range, locale: nil)?.lowerBound
     }
 
@@ -39,10 +39,10 @@ extension String {
     ///
     /// - Returns: The index of last occurrence of `searchStr`, searching backwards from `position`. Returns `nil` if the value is not found.
     func lastIndexOf(_ searchStr: String, position: Int? = 0) -> String.Index? {
-        let len = self.characters.count
+        let len = self.count
         let start = min(max(position!, 0), len)
-        let searchLen = searchStr.characters.count
-        let r: Range<Index> = Range<Index>(self.startIndex..<self.characters.index(self.startIndex, offsetBy: min(start + searchLen, len)))
+        let searchLen = searchStr.count
+        let r: Range<Index> = Range<Index>.init(uncheckedBounds: (lower: self.startIndex, upper: self.index(self.startIndex, offsetBy: min(start + searchLen, len))))
         if let range = self.range(of: searchStr, options: [.backwards, .literal], range: r) {
             return range.lowerBound
         } else {