Split files (#11)

Sources/Diffable.diff.swift

@@ -0,0 +1,57 @@
+import Foundation
+
+
+
+extension Diffable {
+    static func diff (between a: Diffable, and b: Diffable) -> Differentia {
+        guard a != b else {
+            return Differentia(units: [.notChanged(a)])
+        }
+
+        switch (a, b) {
+        case let (.array(l), .array(r)):
+            return DiffableSequence.diff(
+                between: DiffableSequence(l),
+                and: DiffableSequence(r)
+            )
+
+        case let (.set(l), .set(r)):
+            return DiffableSet.diff(
+                between: DiffableSet(l),
+                and: DiffableSet(r)
+            )
+
+        case let (.dictionary(l), .dictionary(r)):
+            return DiffableDictionary.diff(
+                between: DiffableDictionary.from(diffableTuples: l),
+                and: DiffableDictionary.from(diffableTuples: r),
+                forKind: .dictionary
+            )
+
+        case let (.anyStruct(type: lt, entries: ld), .anyStruct(type: rt, entries: rd)):
+            guard lt == rt else {
+                return Differentia(units: [.deleted(a), .inserted(b)])
+            }
+
+            return DiffableDictionary.diff(
+                between: DiffableDictionary(ld),
+                and: DiffableDictionary(rd),
+                forKind: .anyStruct(type: lt)
+            )
+
+        case let (.anyClass(type: lt, entries: ld), .anyClass(type: rt, entries: rd)):
+            guard lt == rt else {
+                return Differentia(units: [.deleted(a), .inserted(b)])
+            }
+
+            return DiffableDictionary.diff(
+                between: DiffableDictionary(ld),
+                and: DiffableDictionary(rd),
+                forKind: .anyClass(type: lt)
+            )
+
+        default:
+            return Differentia(units: [.deleted(a), .inserted(b)])
+        }
+    }
+}

Sources/DiffableDictionary.swift

@@ -40,11 +40,11 @@ struct DiffableDictionary {
     }
 
 
-    static func diff(between lhs: DiffableDictionary, and rhs: DiffableDictionary, forKind kind: Diffable.ChildKind) -> Diffable.Diff {
+    static func diff(between lhs: DiffableDictionary, and rhs: DiffableDictionary, forKind kind: DifferentiaUnit.ChildKind) -> Differentia {
         // note: elements of [diffable] may not conform to hashable.
         // so we cannot use o(1) algorithm such as hash map.
 
-        var result: [String: Diffable.Diff] = [:]
+        var result: [String: Differentia] = [:]
 
         let keys = Set(lhs.dictionary.keys)
             .union(Set(rhs.dictionary.keys))
@@ -55,25 +55,25 @@ struct DiffableDictionary {
                 fatalError("This case cannot be executed.")
 
             case let (.some(lv), .none):
-                result[key] = Diffable.Diff(units: [.inserted(lv)])
+                result[key] = Differentia(units: [.inserted(lv)])
 
             case let (.none, .some(rv)):
-                result[key] = Diffable.Diff(units: [.deleted(rv)])
+                result[key] = Differentia(units: [.deleted(rv)])
 
             case let (.some(lv), .some(rv)):
                 guard lv != rv else {
-                    result[key] = Diffable.Diff(units: [.notChanged(lv)])
+                    result[key] = Differentia(units: [.notChanged(lv)])
                     return
                 }
 
-                result[key] = Diffable.Diff(units: [
+                result[key] = Differentia(units: [
                     .deleted(lv),
                     .inserted(rv),
                 ])
             }
         }
 
-        return Diffable.Diff(units: [
+        return Differentia(units: [
             .child(kind: kind, result)
         ])
     }

Sources/DiffableSequence.swift

@@ -11,7 +11,7 @@ class DiffableSequence {
     }
 
 
-    static func diff(between: DiffableSequence, and: DiffableSequence) -> Diffable.Diff {
+    static func diff(between: DiffableSequence, and: DiffableSequence) -> Differentia {
         var lcs = between.elements.LCS(and.elements)
         let diff = between.elements.diff(and.elements)
 
@@ -32,7 +32,7 @@ class DiffableSequence {
         var deletions = diff.deletions.sorted { $0.idx < $1.idx }
 
         var index = -1
-        var result: [Diffable.DiffUnit] = []
+        var result: [DifferentiaUnit] = []
         var wasDeleted = false
         var wasInserted = false
 
@@ -113,7 +113,7 @@ class DiffableSequence {
             }
         }
 
-        return Diffable.Diff(units: result)
+        return Differentia(units: result)
     }
 
 

Sources/DiffableSet.swift

@@ -11,7 +11,7 @@ struct DiffableSet {
     }
 
 
-    static func diff(between a: DiffableSet, and b: DiffableSet) -> Diffable.Diff {
+    static func diff(between a: DiffableSet, and b: DiffableSet) -> Differentia {
         // NOTE: Elements of [Diffable] may not conform to Hashable.
         // So we cannot use O(1) algorithm such as hash map.
 
@@ -27,7 +27,7 @@ struct DiffableSet {
             }
         }
 
-        return Diffable.Diff(units:
+        return Differentia(units:
             (deleted
                 .sorted { String(describing: $0) < String(describing: $1) }
                 .map { .deleted($0) })

Sources/Differentia+PrettyPrintable.swift

@@ -0,0 +1,10 @@
+import Foundation
+
+
+
+extension Differentia: PrettyPrintable {
+    var prettyLines: [PrettyLine] {
+        return self.units
+            .flatMap { unit -> [PrettyLine] in unit.prettyLines }
+    }
+}

Sources/Differentia.swift

@@ -0,0 +1,15 @@
+import Foundation
+
+
+
+struct Differentia {
+    let units: [DifferentiaUnit]
+}
+
+
+
+extension Differentia: Equatable {
+    static func == (_ lhs: Differentia, _ rhs: Differentia) -> Bool {
+        return lhs.units == rhs.units
+    }
+}