Add some general-purpose path utilities from swift-driver (#173)

* Add array-accepting overloads of appending(components:) to path types

* Add basenameWithoutExt to RelativePath to match the AbsolutePath version

Author: owenv

Sources/TSCBasic/Path.swift

@@ -157,13 +157,17 @@ public struct AbsolutePath: Hashable {
     /// This method should only be used in cases where the input is guaranteed
     /// to be a valid path component (i.e., it cannot be empty, contain a path
     /// separator, or be a pseudo-path like '.' or '..').
-    public func appending(components names: String...) -> AbsolutePath {
+    public func appending(components names: [String]) -> AbsolutePath {
         // FIXME: This doesn't seem a particularly efficient way to do this.
         return names.reduce(self, { path, name in
             path.appending(component: name)
         })
     }
 
+    public func appending(components names: String...) -> AbsolutePath {
+        appending(components: names)
+    }
+
     /// NOTE: We will most likely want to add other `appending()` methods, such
     ///       as `appending(suffix:)`, and also perhaps `replacing()` methods,
     ///       such as `replacing(suffix:)` or `replacing(basename:)` for some
@@ -243,6 +247,14 @@ public struct RelativePath: Hashable {
         return _impl.basename
     }
 
+    /// Returns the basename without the extension.
+    public var basenameWithoutExt: String {
+        if let ext = self.extension {
+            return String(basename.dropLast(ext.count + 1))
+        }
+        return basename
+    }
+
     /// Suffix (including leading `.` character) if any.  Note that a basename
     /// that starts with a `.` character is not considered a suffix, nor is a
     /// trailing `.` character.
@@ -288,12 +300,16 @@ public struct RelativePath: Hashable {
     /// This method should only be used in cases where the input is guaranteed
     /// to be a valid path component (i.e., it cannot be empty, contain a path
     /// separator, or be a pseudo-path like '.' or '..').
-    public func appending(components names: String...) -> RelativePath {
+    public func appending(components names: [String]) -> RelativePath {
         // FIXME: This doesn't seem a particularly efficient way to do this.
         return names.reduce(self, { path, name in
             path.appending(component: name)
         })
     }
+
+    public func appending(components names: String...) -> RelativePath {
+        appending(components: names)
+    }
 }
 
 extension AbsolutePath: Codable {

Tests/TSCBasicTests/PathTests.swift

@@ -149,6 +149,29 @@ class PathTests: XCTestCase {
         XCTAssertEqual(RelativePath(".").basename, ".")
     }
 
+    func testBaseNameWithoutExt() {
+        XCTAssertEqual(AbsolutePath("/").basenameWithoutExt, "/")
+        XCTAssertEqual(AbsolutePath("/a").basenameWithoutExt, "a")
+        XCTAssertEqual(AbsolutePath("/./a").basenameWithoutExt, "a")
+        XCTAssertEqual(AbsolutePath("/../..").basenameWithoutExt, "/")
+        XCTAssertEqual(RelativePath("../..").basenameWithoutExt, "..")
+        XCTAssertEqual(RelativePath("../a").basenameWithoutExt, "a")
+        XCTAssertEqual(RelativePath("../a/..").basenameWithoutExt, "..")
+        XCTAssertEqual(RelativePath("a/..").basenameWithoutExt, ".")
+        XCTAssertEqual(RelativePath("./..").basenameWithoutExt, "..")
+        XCTAssertEqual(RelativePath("a/../////../////./////").basenameWithoutExt, "..")
+        XCTAssertEqual(RelativePath("abc").basenameWithoutExt, "abc")
+        XCTAssertEqual(RelativePath("").basenameWithoutExt, ".")
+        XCTAssertEqual(RelativePath(".").basenameWithoutExt, ".")
+
+        XCTAssertEqual(AbsolutePath("/a.txt").basenameWithoutExt, "a")
+        XCTAssertEqual(AbsolutePath("/./a.txt").basenameWithoutExt, "a")
+        XCTAssertEqual(RelativePath("../a.bc").basenameWithoutExt, "a")
+        XCTAssertEqual(RelativePath("abc.swift").basenameWithoutExt, "abc")
+        XCTAssertEqual(RelativePath("../a.b.c").basenameWithoutExt, "a.b")
+        XCTAssertEqual(RelativePath("abc.xyz.123").basenameWithoutExt, "abc.xyz")
+    }
+
     func testSuffixExtraction() {
         XCTAssertEqual(RelativePath("a").suffix, nil)
         XCTAssertEqual(RelativePath("a").extension, nil)