Swift3 enum casing

Author: jberkel

Documentation/Index.md

@@ -192,7 +192,7 @@ On iOS, you can create a writable database in your app’s **Documents** directo
 
 ``` swift
 let path = NSSearchPathForDirectoriesInDomains(
-    .DocumentDirectory, .UserDomainMask, true
+    .documentDirectory, .userDomainMask, true
 ).first!
 
 let db = try Connection("\(path)/db.sqlite3")
@@ -202,7 +202,7 @@ On OS X, you can use your app’s **Application Support** directory:
 
 ``` swift
 var path = NSSearchPathForDirectoriesInDomains(
-    .ApplicationSupportDirectory, .UserDomainMask, true
+    .applicationSupportDirectory, .userDomainMask, true
 ).first! + NSBundle.mainBundle().bundleIdentifier!
 
 // create parent directory iff it doesn’t exist
@@ -225,21 +225,21 @@ let db = try Connection(path, readonly: true)
 ```
 
 > _Note:_ Signed applications cannot modify their bundle resources. If you bundle a database file with your app for the purpose of bootstrapping, copy it to a writable location _before_ establishing a connection (see [Read-Write Databases](#read-write-databases), above, for typical, writable locations).
-> 
+>
 > See these two Stack Overflow questions for more information about iOS apps with SQLite databases: [1](https://stackoverflow.com/questions/34609746/what-different-between-store-database-in-different-locations-in-ios), [2](https://stackoverflow.com/questions/34614968/ios-how-to-copy-pre-seeded-database-at-the-first-running-app-with-sqlite-swift). We welcome sample code to show how to successfully copy and use a bundled "seed" database for writing in an app.
 
 #### In-Memory Databases
 
 If you omit the path, SQLite.swift will provision an [in-memory database](https://www.sqlite.org/inmemorydb.html).
 
 ``` swift
-let db = try Connection() // equivalent to `Connection(.InMemory)`
+let db = try Connection() // equivalent to `Connection(.inMemory)`
 ```
 
 To create a temporary, disk-backed database, pass an empty file name.
 
 ``` swift
-let db = try Connection(.Temporary)
+let db = try Connection(.temporary)
 ```
 
 In-memory databases are automatically deleted when the database connection is closed.
@@ -367,15 +367,15 @@ The `column` function is used for a single column definition. It takes an [expre
     t.column(id, primaryKey: true)
     // "id" INTEGER PRIMARY KEY NOT NULL
 
-    t.column(id, primaryKey: .Autoincrement)
+    t.column(id, primaryKey: .autoincrement)
     // "id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL
     ```
 
     > _Note:_ The `primaryKey` parameter cannot be used alongside `references`. If you need to create a column that has a default value and is also a primary and/or foreign key, use the `primaryKey` and `foreignKey` functions mentioned under [Table Constraints](#table-constraints).
     >
     > Primary keys cannot be optional (_e.g._, `Expression<Int64?>`).
     >
-    > Only an `INTEGER PRIMARY KEY` can take `.Autoincrement`.
+    > Only an `INTEGER PRIMARY KEY` can take `.autoincrement`.
 
   - `unique` adds a `UNIQUE` constraint to the column. (See the `unique` function under [Table Constraints](#table-constraints) for uniqueness over multiple columns).
 
@@ -403,10 +403,10 @@ The `column` function is used for a single column definition. It takes an [expre
   - `collate` adds a `COLLATE` clause to `Expression<String>` (and `Expression<String?>`) column definitions with [a collating sequence](https://www.sqlite.org/datatype3.html#collation) defined in the `Collation` enumeration.
 
     ``` swift
-    t.column(email, collate: .Nocase)
+    t.column(email, collate: .nocase)
     // "email" TEXT NOT NULL COLLATE "NOCASE"
 
-    t.column(name, collate: .Rtrim)
+    t.column(name, collate: .rtrim)
     // "name" TEXT COLLATE "RTRIM"
     ```
 
@@ -454,7 +454,7 @@ Additional constraints may be provided outside the scope of a single column usin
   - `foreignKey` adds a `FOREIGN KEY` constraint to the table. Unlike [the `references` constraint, above](#column-constraints), it supports all SQLite types, both [`ON UPDATE` and `ON DELETE` actions](https://www.sqlite.org/foreignkeys.html#fk_actions), and composite (multiple column) keys.
 
     ``` swift
-    t.foreignKey(user_id, references: users, id, delete: .SetNull)
+    t.foreignKey(user_id, references: users, id, delete: .setNull)
     // FOREIGN KEY("user_id") REFERENCES "users"("id") ON DELETE SET NULL
     ```
 
@@ -471,7 +471,7 @@ We can insert rows into a table by calling a [query’s](#queries) `insert` func
 try db.run(users.insert(email <- "alice@mac.com", name <- "Alice"))
 // INSERT INTO "users" ("email", "name") VALUES ('alice@mac.com', 'Alice')
 
-try db.run(users.insert(or: .Replace, email <- "alice@mac.com", name <- "Alice B."))
+try db.run(users.insert(or: .replace, email <- "alice@mac.com", name <- "Alice B."))
 // INSERT OR REPLACE INTO "users" ("email", "name") VALUES ('alice@mac.com', 'Alice B.')
 ```
 
@@ -637,7 +637,7 @@ users.join(posts, on: user_id == users[id])
 // SELECT * FROM "users" INNER JOIN "posts" ON ("user_id" = "users"."id")
 ```
 
-The `join` function takes a [query](#queries) object (for the table being joined on), a join condition (`on`), and is prefixed with an optional join type (default: `.Inner`). Join conditions can be built using [filter operators and functions](#filter-operators-and-functions), generally require [namespacing](#column-namespacing), and sometimes require [aliasing](#table-aliasing).
+The `join` function takes a [query](#queries) object (for the table being joined on), a join condition (`on`), and is prefixed with an optional join type (default: `.inner`). Join conditions can be built using [filter operators and functions](#filter-operators-and-functions), generally require [namespacing](#column-namespacing), and sometimes require [aliasing](#table-aliasing).
 
 
 ##### Column Namespacing
@@ -996,10 +996,10 @@ The `addColumn` function shares several of the same [`column` function parameter
   - `collate` adds a `COLLATE` clause to `Expression<String>` (and `Expression<String?>`) column definitions with [a collating sequence](https://www.sqlite.org/datatype3.html#collation) defined in the `Collation` enumeration.
 
     ``` swift
-    try db.run(users.addColumn(email, collate: .Nocase))
+    try db.run(users.addColumn(email, collate: .nocase))
     // ALTER TABLE "users" ADD COLUMN "email" TEXT NOT NULL COLLATE "NOCASE"
 
-    try db.run(users.addColumn(name, collate: .Rtrim))
+    try db.run(users.addColumn(name, collate: .rtrim))
     // ALTER TABLE "users" ADD COLUMN "name" TEXT COLLATE "RTRIM"
     ```
 
@@ -1367,14 +1367,14 @@ We can create custom collating sequences by calling `createCollation` on a datab
 
 ``` swift
 try db.createCollation("NODIACRITIC") { lhs, rhs in
-    return lhs.compare(rhs, options: .DiacriticInsensitiveSearch)
+    return lhs.compare(rhs, options: .diacriticInsensitiveSearch)
 }
 ```
 
 We can reference a custom collation using the `Custom` member of the `Collation` enumeration.
 
 ``` swift
-restaurants.order(collate(.Custom("NODIACRITIC"), name))
+restaurants.order(collate(.custom("NODIACRITIC"), name))
 // SELECT * FROM "restaurants" ORDER BY "name" COLLATE "NODIACRITIC"
 ```
 
@@ -1409,7 +1409,7 @@ let config = FTS4Config()
     .column(subject)
     .column(body, [.unindexed])
     .languageId("lid")
-    .order(.Desc)
+    .order(.desc)
 
 try db.run(emails.create(.FTS4(config))
 // CREATE VIRTUAL TABLE "emails" USING fts4("subject", "body", notindexed="body", languageid="lid", order="desc")

SQLite/Core/Connection.swift

@@ -274,13 +274,13 @@ public final class Connection {
     public enum TransactionMode : String {
 
         /// Defers locking the database till the first read/write executes.
-        case Deferred = "DEFERRED"
+        case deferred = "DEFERRED"
 
         /// Immediately acquires a reserved lock on the database.
-        case Immediate = "IMMEDIATE"
+        case immediate = "IMMEDIATE"
 
         /// Immediately acquires an exclusive lock on all databases.
-        case Exclusive = "EXCLUSIVE"
+        case exclusive = "EXCLUSIVE"
 
     }
 
@@ -301,7 +301,7 @@ public final class Connection {
     ///     must throw to roll the transaction back.
     ///
     /// - Throws: `Result.Error`, and rethrows.
-    public func transaction(_ mode: TransactionMode = .Deferred, block: @escaping () throws -> Void) throws {
+    public func transaction(_ mode: TransactionMode = .deferred, block: @escaping () throws -> Void) throws {
         try transaction("BEGIN \(mode.rawValue) TRANSACTION", block, "COMMIT TRANSACTION", or: "ROLLBACK TRANSACTION")
     }
 

SQLite/Typed/Query.swift

@@ -221,7 +221,7 @@ extension QueryType {
     ///
     /// - Returns: A query with the given `JOIN` clause applied.
     public func join(_ table: QueryType, on condition: Expression<Bool?>) -> Self {
-        return join(.Inner, table, on: condition)
+        return join(.inner, table, on: condition)
     }
 
     /// Adds a `JOIN` clause to the query.
@@ -401,7 +401,7 @@ extension QueryType {
     public func order(_ by: Expressible...) -> Self {
         return order(by)
     }
-    
+
     /// Sets an `ORDER BY` clause on the query.
     ///
     ///     let users = Table("users")
@@ -1100,28 +1100,28 @@ public struct Row {
 public enum JoinType : String {
 
     /// A `CROSS` join.
-    case Cross = "CROSS"
+    case cross = "CROSS"
 
     /// An `INNER` join.
-    case Inner = "INNER"
+    case inner = "INNER"
 
     /// A `LEFT OUTER` join.
-    case LeftOuter = "LEFT OUTER"
+    case leftOuter = "LEFT OUTER"
 
 }
 
 /// ON CONFLICT resolutions.
 public enum OnConflict: String {
 
-    case Replace = "REPLACE"
+    case replace = "REPLACE"
 
-    case Rollback = "ROLLBACK"
+    case rollback = "ROLLBACK"
 
-    case Abort = "ABORT"
+    case abort = "ABORT"
 
-    case Fail = "FAIL"
+    case fail = "FAIL"
 
-    case Ignore = "IGNORE"
+    case ignore = "IGNORE"
 
 }
 

SQLite/Typed/Schema.swift

@@ -369,16 +369,16 @@ public final class TableBuilder {
 
     public enum Dependency: String {
 
-        case NoAction = "NO ACTION"
+        case noAction = "NO ACTION"
 
-        case Restrict = "RESTRICT"
+        case restrict = "RESTRICT"
 
-        case SetNull = "SET NULL"
+        case setNull = "SET NULL"
 
-        case SetDefault = "SET DEFAULT"
+        case setDefault = "SET DEFAULT"
+
+        case cascade = "CASCADE"
 
-        case Cascade = "CASCADE"
-        
     }
 
     public func foreignKey<T : Value>(_ column: Expression<T>, references table: QueryType, _ other: Expression<T>, update: Dependency? = nil, delete: Dependency? = nil) {

SQLiteTests/ConnectionTests.swift

@@ -95,19 +95,19 @@ class ConnectionTests : SQLiteTestCase {
     }
 
     func test_transaction_executesBeginDeferred() {
-        try! db.transaction(.Deferred) {}
+        try! db.transaction(.deferred) {}
 
         AssertSQL("BEGIN DEFERRED TRANSACTION")
     }
 
     func test_transaction_executesBeginImmediate() {
-        try! db.transaction(.Immediate) {}
+        try! db.transaction(.immediate) {}
 
         AssertSQL("BEGIN IMMEDIATE TRANSACTION")
     }
 
     func test_transaction_executesBeginExclusive() {
-        try! db.transaction(.Exclusive) {}
+        try! db.transaction(.exclusive) {}
 
         AssertSQL("BEGIN EXCLUSIVE TRANSACTION")
     }

SQLiteTests/QueryTests.swift

@@ -20,11 +20,11 @@ class QueryTests : XCTestCase {
     func test_select_withExpression_compilesSelectClause() {
         AssertSQL("SELECT \"email\" FROM \"users\"", users.select(email))
     }
-    
+
     func test_select_withStarExpression_compilesSelectClause() {
         AssertSQL("SELECT * FROM \"users\"", users.select(*))
     }
-    
+
     func test_select_withNamespacedStarExpression_compilesSelectClause() {
         AssertSQL("SELECT \"users\".* FROM \"users\"", users.select(users[*]))
     }
@@ -59,12 +59,12 @@ class QueryTests : XCTestCase {
     func test_join_withExplicitType_compilesJoinClauseWithType() {
         AssertSQL(
             "SELECT * FROM \"users\" LEFT OUTER JOIN \"posts\" ON (\"posts\".\"user_id\" = \"users\".\"id\")",
-            users.join(.LeftOuter, posts, on: posts[userId] == users[id])
+            users.join(.leftOuter, posts, on: posts[userId] == users[id])
         )
 
         AssertSQL(
             "SELECT * FROM \"users\" CROSS JOIN \"posts\" ON (\"posts\".\"user_id\" = \"users\".\"id\")",
-            users.join(.Cross, posts, on: posts[userId] == users[id])
+            users.join(.cross, posts, on: posts[userId] == users[id])
         )
     }
 
@@ -192,7 +192,7 @@ class QueryTests : XCTestCase {
     func test_insert_withOnConflict_compilesInsertOrOnConflictExpression() {
         AssertSQL(
             "INSERT OR REPLACE INTO \"users\" (\"email\", \"age\") VALUES ('alice@example.com', 30)",
-            users.insert(or: .Replace, email <- "alice@example.com", age <- 30)
+            users.insert(or: .replace, email <- "alice@example.com", age <- 30)
         )
     }
 

SQLiteTests/SchemaTests.swift

@@ -568,7 +568,7 @@ class SchemaTests : XCTestCase {
 
         XCTAssertEqual(
             "CREATE TABLE \"table\" (FOREIGN KEY (\"string\") REFERENCES \"table\" (\"string\") ON UPDATE CASCADE ON DELETE SET NULL)",
-            table.create { t in t.foreignKey(string, references: table, string, update: .Cascade, delete: .SetNull) }
+            table.create { t in t.foreignKey(string, references: table, string, update: .cascade, delete: .setNull) }
         )
 
         XCTAssertEqual(