Swift 4 String API changes

Author: dingosky

Sources/CharSet.swift

@@ -73,7 +73,7 @@ public struct CharSet {
   /// - throws: `.invalidCharCount` if String length not a multiple of 2
   /// - throws: `.charsNotUnique` if any character repeats
   public init(_ chars: String) throws {
-    let length = chars.characters.count
+    let length = chars.count
     guard [2,4,8,16,32,64].contains(length) else { throw EntropyStringError.invalidCharCount }
     guard CharSet.unique(chars) else { throw EntropyStringError.charsNotUnique }
 
@@ -161,7 +161,7 @@ public struct CharSet {
   private static func unique(_ string: String) -> Bool {
     var charSet = Set<Character>()
     var unique = true
-    for char in string.characters {
+    for char in string {
       let (inserted, _) = charSet.insert(char)
       unique = unique && inserted
       if !unique {

Sources/Entropy.swift

@@ -325,7 +325,7 @@ public class Entropy {
   /// - return: The character
   private func char(_ ndx: CharSet.Ndx, _ charSet: CharSet) -> Character {
     let chars = charSet.chars
-    guard Int(ndx) < chars.characters.count else { fatalError("Index out of bounds") }
+    guard Int(ndx) < chars.count else { fatalError("Index out of bounds") }
     let charIndex = chars.index(chars.startIndex, offsetBy: Int(ndx))
     return chars[charIndex]
   }

Tests/EntropyStringTests/EntropyTests.swift

@@ -161,96 +161,96 @@ class EntropyTests: XCTestCase {
   // Test various ID generation
   func testSmallID() {
     random = Entropy()
-    XCTAssertEqual( 6, random.smallID().characters.count)
-    XCTAssertEqual( 5, random.smallID(.charSet64).characters.count)
-    XCTAssertEqual( 6, random.smallID(.charSet32).characters.count)
-    XCTAssertEqual( 8, random.smallID(.charSet16).characters.count)
-    XCTAssertEqual(10, random.smallID(.charSet8).characters.count)
-    XCTAssertEqual(15, random.smallID(.charSet4).characters.count)
-    XCTAssertEqual(29, random.smallID(.charSet2).characters.count)
+    XCTAssertEqual( 6, random.smallID().count)
+    XCTAssertEqual( 5, random.smallID(.charSet64).count)
+    XCTAssertEqual( 6, random.smallID(.charSet32).count)
+    XCTAssertEqual( 8, random.smallID(.charSet16).count)
+    XCTAssertEqual(10, random.smallID(.charSet8).count)
+    XCTAssertEqual(15, random.smallID(.charSet4).count)
+    XCTAssertEqual(29, random.smallID(.charSet2).count)
 
     for charSet in charSets {
       let smallIDBits = Float(29)
       let random = Entropy(charSet)
       let id = random.smallID()
       let count = Int(ceilf(smallIDBits / Float(charSet.bitsPerChar)))
-      XCTAssertEqual(id.characters.count, count)
+      XCTAssertEqual(id.count, count)
     }
   }
 
   func testMediumID() {
     random = Entropy()
-    XCTAssertEqual(14, random.mediumID().characters.count)
-    XCTAssertEqual(12, random.mediumID(.charSet64).characters.count)
-    XCTAssertEqual(14, random.mediumID(.charSet32).characters.count)
-    XCTAssertEqual(18, random.mediumID(.charSet16).characters.count)
-    XCTAssertEqual(23, random.mediumID(.charSet8).characters.count)
-    XCTAssertEqual(35, random.mediumID(.charSet4).characters.count)
-    XCTAssertEqual(69, random.mediumID(.charSet2).characters.count)
+    XCTAssertEqual(14, random.mediumID().count)
+    XCTAssertEqual(12, random.mediumID(.charSet64).count)
+    XCTAssertEqual(14, random.mediumID(.charSet32).count)
+    XCTAssertEqual(18, random.mediumID(.charSet16).count)
+    XCTAssertEqual(23, random.mediumID(.charSet8).count)
+    XCTAssertEqual(35, random.mediumID(.charSet4).count)
+    XCTAssertEqual(69, random.mediumID(.charSet2).count)
 
     for charSet in charSets {
       let mediumIDBits = Float(69)
       let random = Entropy(charSet)
       let id = random.mediumID()
       let count = Int(ceilf(mediumIDBits / Float(charSet.bitsPerChar)))
-      XCTAssertEqual(id.characters.count, count)
+      XCTAssertEqual(id.count, count)
     }
   }
 
   func testLargeID() {
     random = Entropy()
-    XCTAssertEqual(20, random.largeID().characters.count)
-    XCTAssertEqual(17, random.largeID(.charSet64).characters.count)
-    XCTAssertEqual(20, random.largeID(.charSet32).characters.count)
-    XCTAssertEqual(25, random.largeID(.charSet16).characters.count)
-    XCTAssertEqual(33, random.largeID(.charSet8).characters.count)
-    XCTAssertEqual(50, random.largeID(.charSet4).characters.count)
-    XCTAssertEqual(99, random.largeID(.charSet2).characters.count)
+    XCTAssertEqual(20, random.largeID().count)
+    XCTAssertEqual(17, random.largeID(.charSet64).count)
+    XCTAssertEqual(20, random.largeID(.charSet32).count)
+    XCTAssertEqual(25, random.largeID(.charSet16).count)
+    XCTAssertEqual(33, random.largeID(.charSet8).count)
+    XCTAssertEqual(50, random.largeID(.charSet4).count)
+    XCTAssertEqual(99, random.largeID(.charSet2).count)
 
     for charSet in charSets {
       let largeIDBits = Float(99)
       let random = Entropy(charSet)
       let id = random.largeID()
       let count = Int(ceilf(largeIDBits / Float(charSet.bitsPerChar)))
-      XCTAssertEqual(id.characters.count, count)
+      XCTAssertEqual(id.count, count)
     }
   }
 
   func testSessionID() {
     random = Entropy()
-    XCTAssertEqual( 26, random.sessionID().characters.count)
-    XCTAssertEqual( 22, random.sessionID(.charSet64).characters.count)
-    XCTAssertEqual( 26, random.sessionID(.charSet32).characters.count)
-    XCTAssertEqual( 32, random.sessionID(.charSet16).characters.count)
-    XCTAssertEqual( 43, random.sessionID(.charSet8).characters.count)
-    XCTAssertEqual( 64, random.sessionID(.charSet4).characters.count)
-    XCTAssertEqual(128, random.sessionID(.charSet2).characters.count)
+    XCTAssertEqual( 26, random.sessionID().count)
+    XCTAssertEqual( 22, random.sessionID(.charSet64).count)
+    XCTAssertEqual( 26, random.sessionID(.charSet32).count)
+    XCTAssertEqual( 32, random.sessionID(.charSet16).count)
+    XCTAssertEqual( 43, random.sessionID(.charSet8).count)
+    XCTAssertEqual( 64, random.sessionID(.charSet4).count)
+    XCTAssertEqual(128, random.sessionID(.charSet2).count)
 
     for charSet in charSets {
       let sessionIDBits = Float(128)
       let random = Entropy(charSet)
       let id = random.sessionID()
       let count = Int(ceilf(sessionIDBits / Float(charSet.bitsPerChar)))
-      XCTAssertEqual(id.characters.count, count)
+      XCTAssertEqual(id.count, count)
     }
   }
 
   func testToken() {
     random = Entropy()
-    XCTAssertEqual( 52, random.token().characters.count)
-    XCTAssertEqual( 43, random.token(.charSet64).characters.count)
-    XCTAssertEqual( 52, random.token(.charSet32).characters.count)
-    XCTAssertEqual( 64, random.token(.charSet16).characters.count)
-    XCTAssertEqual( 86, random.token(.charSet8).characters.count)
-    XCTAssertEqual(128, random.token(.charSet4).characters.count)
-    XCTAssertEqual(256, random.token(.charSet2).characters.count)
+    XCTAssertEqual( 52, random.token().count)
+    XCTAssertEqual( 43, random.token(.charSet64).count)
+    XCTAssertEqual( 52, random.token(.charSet32).count)
+    XCTAssertEqual( 64, random.token(.charSet16).count)
+    XCTAssertEqual( 86, random.token(.charSet8).count)
+    XCTAssertEqual(128, random.token(.charSet4).count)
+    XCTAssertEqual(256, random.token(.charSet2).count)
 
     for charSet in charSets {
       let tokenBits = Float(256)
       let random = Entropy(charSet)
       let id = random.token()
       let count = Int(ceilf(tokenBits / Float(charSet.bitsPerChar)))
-      XCTAssertEqual(id.characters.count, count)
+      XCTAssertEqual(id.count, count)
     }
   }
 
@@ -340,7 +340,7 @@ class EntropyTests: XCTestCase {
       let iters = 128
       for i in 0 ..< iters {
         let string = random.string(bits: Float(i))
-        let count = string.characters.count
+        let count = string.count
         let expected: Int = Int(ceil(Float(i) / Float(charSet.bitsPerChar)))
         XCTAssertEqual(count, expected)
       }