Initial commit

Author: soffes

.gitignore

@@ -0,0 +1 @@
+*.xcodeproj

Package.swift

@@ -0,0 +1,13 @@
+//
+//  Package.swift
+//  Diff
+//
+//  Created by Sam Soffes on 4/12/16.
+//  Copyright © 2016 Sam Soffes. All rights reserved.
+//
+
+import PackageDescription
+
+let package = Package(
+    name: "Diff"
+)

Readme.markdown

@@ -0,0 +1,61 @@
+# Diff
+
+Simple diffing library in pure Swift.
+
+
+## Usage
+
+Start by importing the package:
+
+```swift
+import Diff
+```
+
+### Same
+
+If there is no difference, the diff will be `nil`.
+
+``` swift
+diff("Hello", "Hello") // nil
+```
+
+For the sake of brevity, we'll `!` the rest of the examples since we know they're different.
+
+
+### Insert
+
+``` swift
+let (range, string) = diff("Hello world", "Hello there world")!
+// range: 6...6
+// string: "there "
+```
+
+
+### Remove
+
+``` swift
+let (range, string) = diff("Hello there world", "Hello world")!
+// range: 6..<12
+// string: ""
+```
+
+
+### Other Types
+
+Diff can diff any array. Here's an array of things that conform to `Equatable`:
+
+``` swift
+let (range, replacement) = diff([1, 2, 3], [1, 2, 3, 4])!
+// range: 3...3
+// replacement: [4]
+```
+
+You can even use arrays of anything as long as you can compare them:
+
+```swift
+let before: [Foo] = [a, b]
+let after: [Foo] = [b]
+let (range, replacement) = diff(before, after, compare: Foo.compare)!
+// range: 0...0
+// replacement: []
+```

Sources/Diff/Diff.swift

@@ -0,0 +1,48 @@
+//
+//  Diff.swift
+//  Diff
+//
+//  Created by Sam Soffes on 4/12/16.
+//  Copyright © 2016 Sam Soffes. All rights reserved.
+//
+
+public func diff(lhs: String, _ rhs: String) -> (Range<Int>, String)? {
+	let result = diff(Array(lhs.characters), Array(rhs.characters))
+	return result.flatMap { ($0.0, String($0.1)) }
+}
+
+public func diff<T: Equatable>(lhs: [T], _ rhs: [T]) -> (Range<Int>, [T])? {
+	return diff(lhs, rhs, compare: ==)
+}
+
+public func diff<T>(lhs: [T], _ rhs: [T], compare: (T, T) -> Bool) -> (Range<Int>, [T])? {
+	let lhsCount = lhs.count
+	let rhsCount = rhs.count
+
+	// Find start
+	var commonStart = 0
+	while commonStart < lhsCount && commonStart < rhsCount && compare(lhs[commonStart], rhs[commonStart]) {
+		commonStart += 1
+	}
+
+	// Find end
+	var commonEnd = 0
+	while commonEnd + commonStart < lhsCount && commonEnd + commonStart < rhsCount && compare(lhs[lhsCount - 1 - commonEnd], rhs[rhsCount - 1 - commonEnd]) {
+		commonEnd += 1
+	}
+
+	// Remove
+	if lhsCount != commonStart + commonEnd {
+		let range = commonStart..<(lhsCount - commonEnd)
+		return (range, [])
+	}
+
+	// Insert
+	if rhsCount != commonStart + commonEnd {
+		let range = commonStart..<(rhsCount - commonEnd)
+		return (commonStart...commonStart, Array(rhs[range]))
+	}
+
+	// Already equal
+	return nil
+}

Tests/Diff/DiffTests.swift

@@ -0,0 +1,49 @@
+//
+//  DiffTests.swift
+//  Diff
+//
+//  Created by Sam Soffes on 4/12/16.
+//  Copyright © 2016 Sam Soffes. All rights reserved.
+//
+
+import XCTest
+import Diff
+
+class DiffTests: XCTestCase {
+	func testInsert() {
+		let (range, string) = diff("Hello world", "Hello there world")!
+		XCTAssertEqual(6...6, range)
+		XCTAssertEqual("there ", string)
+	}
+
+	func testRemove() {
+		let (range, string) = diff("Hello there world", "Hello world")!
+		XCTAssertEqual(6..<12, range)
+		XCTAssertEqual("", string)
+	}
+
+	func testRemoveFront() {
+		let (range, string) = diff("Hello world", "world")!
+		XCTAssertEqual(0..<6, range)
+		XCTAssertEqual("", string)
+	}
+
+	func testSame() {
+		XCTAssertNil(diff("Hello", "Hello"))
+	}
+
+	func testIntArray() {
+		let (range, replacement) = diff([1, 2, 3], [1, 2, 3, 4])!
+		XCTAssertEqual(3...3, range)
+		XCTAssertEqual([4], replacement)
+	}
+
+	func testOtherType() {
+		let before: [Foo] = [Foo(value: 1), Foo(value: 2)]
+		let after: [Foo] = [Foo(value: 2)]
+
+		let (range, replacement) = diff(before, after, compare: Foo.compare)!
+		XCTAssertEqual(0...0, range)
+		XCTAssertEqual(0, replacement.count)
+	}
+}

Tests/Diff/Foo.swift

@@ -0,0 +1,11 @@
+struct Foo {
+	let value: Int
+
+	static func compare(lhs: Foo, rhs: Foo) -> Bool {
+		return lhs.value == rhs.value
+	}
+
+	init(value: Int) {
+		self.value = value
+	}
+}