[Tests] Refactored parsing of scheme from repo URL, moved Array utils to Collection utils, added Collection tests, moved all allTests functions into one file, previously they were in FileTests which was hard to find

Author: czechboy0

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,102 +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)
-        ]
-    }
-}
-
-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"))
     }
 }