Merge pull request #209 from czechboy0/hd/tests/string_utils

[Tests] Refactored parsing of scheme from repo URL, added Collection tests

Author: mxcl

Sources/Utility/ArrayExtensions.swift

@@ -0,0 +1,71 @@
+/*
+ This source file is part of the Swift.org open source project
+ 
+ Copyright 2015 - 2016 Apple Inc. and the Swift project authors
+ Licensed under Apache License v2.0 with Runtime Library Exception
+ 
+ See http://swift.org/LICENSE.txt for license information
+ See http://swift.org/CONTRIBUTORS.txt for Swift project authors
+ */
+
+extension Collection {
+    
+    public func pick(body: (Iterator.Element) -> Bool) -> Iterator.Element? {
+        for x in self where body(x) {
+            return x
+        }
+        return nil
+    }
+    
+    public func partition<T, U>() -> ([T], [U]) {
+        var t = [T]()
+        var u = [U]()
+        for e in self {
+            if let e = e as? T {
+                t.append(e)
+            } else if let e = e as? U {
+                u.append(e)
+            }
+        }
+        return (t, u)
+    }
+    
+    public func partition(body: (Iterator.Element) -> Bool) -> ([Iterator.Element], [Iterator.Element]) {
+        var a: [Iterator.Element] = []
+        var b: [Iterator.Element] = []
+        for e in self {
+            if body(e) {
+                a.append(e)
+            } else {
+                b.append(e)
+            }
+        }
+        return (a, b)
+    }
+}
+
+extension Collection where Iterator.Element : Equatable {
+    
+    /// Split around a delimiting subsequence with maximum number of splits == 2
+    func splitAround(delimiter: [Iterator.Element]) -> ([Iterator.Element], [Iterator.Element]?) {
+        
+        let orig = Array(self)
+        let end = orig.endIndex
+        let delimCount = delimiter.count
+        
+        var index = orig.startIndex
+        while index+delimCount <= end {
+            let cur = Array(orig[index..<index+delimCount])
+            if cur == delimiter {
+                //found
+                let leading = Array(orig[0..<index])
+                let trailing = Array(orig.suffix(orig.count-leading.count-delimCount))
+                return (leading, trailing)
+            } else {
+                //not found, move index down
+                index = index.successor()
+            }
+        }
+        return (orig, nil)
+    }
+}

Sources/Utility/CollectionExtensions.swift

@@ -70,4 +70,16 @@ extension String {
 
         return String(cc)
     }
+    
+    /// Splits string around a delimiter string into up to two substrings
+    /// If delimiter is not found, the second returned substring is nil
+    func splitAround(delimiter: String) -> (String, String?) {
+        let comps = self.characters.splitAround(Array(delimiter.characters))
+        let head = String(comps.0)
+        if let tail = comps.1 {
+            return (head, String(tail))
+        } else {
+            return (head, nil)
+        }
+    }
 }

Sources/Utility/StringExtensions.swift

@@ -9,24 +9,30 @@
 */
 
 public struct URL {
+    
+    /// Parses the URL type of a git repository
+    /// e.g. https://github.com/apple/swift returns "https"
+    /// e.g. [email protected]:apple/swift returns "git"
+    ///
+    /// This is *not* a generic URI scheme parser!
     public static func scheme(url: String) -> String? {
-        // this is not fully RFC compliant, so it either has to be
-        // or we need to use CFLite FIXME
 
-        let count = url.characters.count
-
-        func foo(start: Int) -> String? {
-            guard count > start + 3 else { return nil }
-
-            let a = url.startIndex
-            let b = a.advanced(by: start)
-            let c = b.advanced(by: 3)
-            if url[b..<c] == "://" || url[b] == "@" {
-                return url[a..<b]
-            } else {
+        func prefixOfSplitBy(delimiter: String) -> String? {
+            let (head, tail) = url.splitAround(delimiter)
+            if tail == nil {
+                //not found
                 return nil
             }
+            //found, return head
+            //lowercase the "scheme", as specified by the URI RFC (just in case)
+            return head.lowercased()
+        }
+        
+        for delim in ["://", "@"] {
+            if let found = prefixOfSplitBy(delim) {
+                return found
+            }
         }
-        return foo(4) ?? foo(5) ?? foo(3)
+        return nil
     }
 }

Sources/Utility/URL.swift

@@ -0,0 +1,68 @@
+/*
+ This source file is part of the Swift.org open source project
+ 
+ Copyright 2015 - 2016 Apple Inc. and the Swift project authors
+ Licensed under Apache License v2.0 with Runtime Library Exception
+ 
+ See http://swift.org/LICENSE.txt for license information
+ See http://swift.org/CONTRIBUTORS.txt for Swift project authors
+ */
+
+@testable import Utility
+import XCTest
+
+class CollectionTests: XCTestCase {
+    
+    func testPick() {
+        
+        let body = { (num: Int) -> Bool in num > 5 }
+        
+        XCTAssertNil([].pick(body))
+        XCTAssertNil([3, 4].pick(body))
+        XCTAssertEqual([3, 7].pick(body), 7)
+        XCTAssertEqual([3, 8, 7].pick(body), 8)
+    }
+    
+    func testPartitionByType() {
+        
+        let input0: [Any] = []
+        let output0: ([String], [Int]) = input0.partition()
+        XCTAssertEqual(output0.0, [String]())
+        XCTAssertEqual(output0.1, [Int]())
+        
+        let input1: [Any] = [1, "two", 3, "four"]
+        let output1: ([String], [Int]) = input1.partition()
+        XCTAssertEqual(output1.0, ["two", "four"])
+        XCTAssertEqual(output1.1, [1, 3])
+    }
+    
+    func testPartitionByClosure() {
+        
+        func eq(lhs: ([Int], [Int]), _ rhs: ([Int], [Int]), file: StaticString = #file, line: UInt = #line) {
+            XCTAssertEqual(lhs.0, rhs.0, file: file, line: line)
+            XCTAssertEqual(lhs.1, rhs.1, file: file, line: line)
+        }
+        
+        let body = { (num: Int) -> Bool in num > 5 }
+        
+        eq([Int]().partition(body), ([], []))
+        eq([2].partition(body), ([], [2]))
+        eq([7].partition(body), ([7], []))
+        eq([7, 4, 2, 9].partition(body), ([7, 9], [4, 2]))
+    }
+    
+    func testSplitAround() {
+        
+        func eq(lhs: ([Character], [Character]?), _ rhs: ([Character], [Character]?), file: StaticString = #file, line: UInt = #line) {
+            XCTAssertEqual(lhs.0, rhs.0, file: file, line: line)
+            XCTAssertEqual(lhs.1 ?? [], rhs.1 ?? [], file: file, line: line)
+        }
+        
+        eq([].splitAround([":"]), ([], nil))
+        eq(["f", "o", "o"].splitAround([":"]), (["f", "o", "o"], nil))
+        eq(["f", "o", "o", ":"].splitAround([":"]), (["f", "o", "o"], []))
+        eq([":", "b", "a", "r"].splitAround([":"]), ([], ["b", "a", "r"]))
+        eq(["f", "o", "o", ":", "b", "a", "r"].splitAround([":"]), (["f", "o", "o"], ["b", "a", "r"]))
+
+    }
+}

Tests/Utility/CollectionTests.swift

@@ -67,103 +67,3 @@ class FileTests: XCTestCase {
         }
     }
 }
-
-
-extension FileTests {
-    static var allTests : [(String, FileTests -> () throws -> Void)] {
-        return [
-            ("testOpenFile", testOpenFile),
-            ("testOpenFileFail", testOpenFileFail),
-            ("testReadRegularTextFile", testReadRegularTextFile),
-            ("testReadRegularTextFileWithSeparator", testReadRegularTextFileWithSeparator)
-        ]
-    }
-}
-
-
-extension RmtreeTests {
-    static var allTests : [(String, RmtreeTests -> () throws -> Void)] {
-        return [
-            ("testDoesNotFollowSymlinks", testDoesNotFollowSymlinks),
-        ]
-    }
-}
-
-extension PathTests {
-    static var allTests : [(String, PathTests -> () throws -> Void)] {
-        return [
-            ("test", test),
-            ("testPrecombined", testPrecombined),
-            ("testExtraSeparators", testExtraSeparators),
-            ("testEmpties", testEmpties),
-            ("testNormalizePath", testNormalizePath),
-            ("testJoinWithAbsoluteReturnsLastAbsoluteComponent", testJoinWithAbsoluteReturnsLastAbsoluteComponent),
-            ("testParentDirectory", testParentDirectory),
-        ]
-    }
-}
-
-extension WalkTests {
-    static var allTests : [(String, WalkTests -> () throws -> Void)] {
-        return [
-            ("testNonRecursive", testNonRecursive),
-            ("testRecursive", testRecursive),
-            ("testSymlinksNotWalked", testSymlinksNotWalked),
-            ("testWalkingADirectorySymlinkResolvesOnce", testWalkingADirectorySymlinkResolvesOnce),
-        ]
-    }
-}
-
-extension StatTests {
-    static var allTests : [(String, StatTests -> () throws -> Void)] {
-        return [
-            ("test_isdir", test_isdir),
-            ("test_isfile", test_isfile),
-            ("test_realpath", test_realpath),
-            ("test_basename", test_basename),
-        ]
-    }
-}
-
-extension RelativePathTests {
-    static var allTests : [(String, RelativePathTests -> () throws -> Void)] {
-        return [
-            ("testAbsolute", testAbsolute),
-            ("testRelative", testRelative),
-            ("testMixed", testMixed),
-            ("testRelativeCommonSubprefix", testRelativeCommonSubprefix),
-            ("testCombiningRelativePaths", testCombiningRelativePaths)
-        ]
-    }
-}
-
-extension ShellTests {
-    static var allTests : [(String, ShellTests -> () throws -> Void)] {
-        return [
-            ("testPopen", testPopen),
-            ("testPopenWithBufferLargerThanThatAllocated", testPopenWithBufferLargerThanThatAllocated),
-            ("testPopenWithBinaryOutput", testPopenWithBinaryOutput)
-        ]
-    }
-}
-
-
-extension StringTests {
-    static var allTests : [(String, StringTests -> () throws -> Void)] {
-        return [
-            ("testTrailingChomp", testTrailingChomp),
-            ("testEmptyChomp", testEmptyChomp),
-            ("testSeparatorChomp", testSeparatorChomp),
-            ("testChuzzle", testChuzzle),
-        ]
-    }
-    
-}
-
-extension URLTests {
-    static var allTests : [(String, URLTests -> () throws -> Void)] {
-        return [
-            ("testSchema", testSchema),
-        ]
-    }
-}

Tests/Utility/FileTests.swift

@@ -42,17 +42,31 @@ class StringTests: XCTestCase {
         XCTAssertEqual(" a\t\r\n".chuzzle(), "a")
         XCTAssertEqual("b".chuzzle(), "b")
     }
+    
+    func testSplitAround() {
+        
+        func eq(lhs: (String, String?), _ rhs: (String, String?), file: StaticString = #file, line: UInt = #line) {
+            XCTAssertEqual(lhs.0, rhs.0, file: file, line: line)
+            XCTAssertEqual(lhs.1, rhs.1, file: file, line: line)
+        }
+        
+        eq("".splitAround("::"), ("", nil))
+        eq("foo".splitAround("::"), ("foo", nil))
+        eq("foo::".splitAround("::"), ("foo", ""))
+        eq("::bar".splitAround("::"), ("", "bar"))
+        eq("foo::bar".splitAround("::"), ("foo", "bar"))
+    }
 }
 
-
 class URLTests: XCTestCase {
 
     func testSchema() {
-        let a = "http://github.com/foo/bar"
-        let b = "https://github.com/foo/bar"
-        let c = "[email protected]/foo/bar"
-        XCTAssertEqual(Utility.URL.scheme(a), "http")
-        XCTAssertEqual(Utility.URL.scheme(b), "https")
-        XCTAssertEqual(Utility.URL.scheme(c), "git")
+        XCTAssertEqual(Utility.URL.scheme("http://github.com/foo/bar"), "http")
+        XCTAssertEqual(Utility.URL.scheme("https://github.com/foo/bar"), "https")
+        XCTAssertEqual(Utility.URL.scheme("HTTPS://github.com/foo/bar"), "https")
+        XCTAssertEqual(Utility.URL.scheme("[email protected]/foo/bar"), "git")
+        XCTAssertEqual(Utility.URL.scheme("[email protected]/foo/bar"), "ssh")
+        XCTAssertNil(Utility.URL.scheme("github.com/foo/bar"))
+        XCTAssertNil(Utility.URL.scheme("user:/github.com/foo/bar"))
     }
 }