Merge pull request #77 from ConfusedVorlon/find_hidden_modifier

Find hidden modifier

.github/codecov.yml

@@ -1,2 +1,3 @@
 ignore:
-  - Tests
+  - Tests/PathTests/etc.swift
+  - Tests/PathTests/TemporaryDirectory.swift

.github/workflows/cd.yml

@@ -0,0 +1,24 @@
+name: CD
+on:
+  release:
+    types: published
+jobs:
+  docs:
+    runs-on: macos-latest
+    steps:
+    - uses: actions/checkout@v2
+    - uses: steven0351/publish-jazzy-docs@v1
+      with:
+        personal_access_token: ${{ secrets.PAT }}
+        config: .github/jazzy.yml
+        version: ${{ github.event.release.tag_name }}
+        history: false
+
+  pods:
+    runs-on: macos-latest
+    steps:
+    - uses: actions/checkout@v2
+    - run: pod trunk push --allow-warnings
+      env:
+        COCOAPODS_TRUNK_TOKEN: ${{ secrets.COCOAPODS_TRUNK_TOKEN }}
+        VERSION: ${{ github.event.release.tag_name }}

.github/workflows/checks.yml

@@ -0,0 +1,14 @@
+on:
+  push:
+    branches:
+      - master
+    paths:
+      - '**/*.swift'
+      - .github/workflows/checks.yml
+jobs:
+  smoke:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - run: swift --version
+    - run: swift test --parallel

.github/workflows/ci.yml

@@ -0,0 +1,87 @@
+name: CI
+on:
+  pull_request:
+    paths:
+      - '**/*.swift'
+      - .github/workflows/ci.yml
+  schedule:
+    - cron: '3 3 * * 5'  # 3:03 AM, every Friday
+
+concurrency:
+  group: ${{ github.head_ref || 'push' }}
+  cancel-in-progress: true
+
+jobs:
+  verify-linuxmain:
+    runs-on: macos-10.15
+    steps:
+    - uses: actions/checkout@v2
+    - run: swift test --generate-linuxmain
+    - run: git diff --exit-code
+
+  apple:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os:
+          - macos-10.15
+          - macos-11
+        platform:
+          - iOS
+          - tvOS
+          - macOS
+          - watchOS
+    steps:
+    - uses: actions/checkout@v2
+    - uses: mxcl/xcodebuild@v1
+      with:
+        platform: ${{ matrix.platform }}
+        code-coverage: true
+        warnings-as-errors: true
+    - uses: codecov/codecov-action@v1
+
+  linux:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        swift:
+        - swift:4.2
+        - swift:5.0
+        - swift:5.1
+        - swift:5.2
+        - swift:5.3
+        - swift:5.4
+        - swiftlang/swift:nightly-5.5
+    container:
+      image: ${{ matrix.swift }}
+    steps:
+    - uses: mxcl/get-swift-version@v1
+      id: swift
+
+    - uses: actions/checkout@v2
+
+    - run: useradd -ms /bin/bash mxcl
+    - run: chown -R mxcl .
+    # ^^ we need to be a normal user and not root for the tests to be valid
+
+    - run: echo ARGS=--enable-code-coverage >> $GITHUB_ENV
+      if: ${{ steps.swift.outputs.marketing-version > 5 }}
+
+    - run: su mxcl -c "swift test --parallel $ARGS"
+
+    - name: Generate `.lcov`
+      if: ${{ steps.swift.outputs.marketing-version > 5 }}
+      run: |
+        apt-get -qq update && apt-get -qq install curl
+        b=$(swift build --show-bin-path)
+        llvm-cov export \
+          -format lcov \
+          -instr-profile="$b"/codecov/default.profdata \
+          --ignore-filename-regex='\.build|Tests' \
+          "$b"/*.xctest \
+          > info.lcov
+
+    - uses: codecov/codecov-action@v1
+      if: ${{ steps.swift.outputs.marketing-version > 5 }}
+      with:
+        file: ./info.lcov

.travis.yml

@@ -1,108 +1,37 @@
-# only run for: merge commits, releases and pull-requests
-if: type != push OR branch = master OR branch =~ /^deploy-\d+\.\d+\.\d+(-.*)?$/ OR branch =~ /^\d+\.\d+\.\d+(-.*)?$/
+# Travis does CD, GHA does CI
+if: branch =~ /^deploy-\d+\.\d+\.\d+(-.*)?$/ OR branch =~ /^\d+\.\d+\.\d+(-.*)?$/
 
 stages:
-  - name: pretest
-    if: NOT branch =~ /^deploy-\d+\.\d+\.\d+(-.*)?$/
-  - name: test
-    if: NOT branch =~ /^deploy-\d+\.\d+\.\d+(-.*)?$/
   - name: deploy
     if: branch =~ /^deploy-\d+\.\d+\.\d+(-.*)?$/
   - name: publish
     if: branch =~ /^\d+\.\d+\.\d+(-.*)?$/
 
 os: osx
-language: swift
-osx_image: xcode10.1
-xcode_project: Path.swift.xcodeproj
-xcode_scheme: Path.swift-Package
 
 jobs:
   include:
-    - name: macOS / Swift 4.0.3
-      before_script: swift build -Xswiftc -warnings-as-errors
-      script: swift test --parallel -Xswiftc -swift-version -Xswiftc 4
-
-    - &std
-      name: macOS / Swift 4.2.1
-      before_script: swift build -Xswiftc -warnings-as-errors
-      script: swift test --parallel
-
-    - <<: *std
-      name: macOS / Swift 5.0
-      osx_image: xcode10.2
-
-    - <<: *std
-      name: macOS / Swift 5.1
-      osx_image: xcode11
-
-    - &xcodebuild
-      before_install: swift package generate-xcodeproj --enable-code-coverage
-      xcode_destination: platform=iOS Simulator,OS=latest,name=iPhone XS
-      name: iOS / Swift 4.2.1
-      after_success: bash <(curl -s https://codecov.io/bash)
-
-    - <<: *xcodebuild
-      xcode_destination: platform=tvOS Simulator,OS=latest,name=Apple TV
-      name: tvOS / Swift 4.2.1
-
-    - <<: *xcodebuild
-      name: watchOS / Swift 4.2.1
-      script: |
-        set -o pipefail
-        xcodebuild \
-          -project Path.swift.xcodeproj \
-          -scheme Path.swift-Package \
-          -destination 'platform=watchOS Simulator,OS=latest,name=Apple Watch Series 4 - 40mm' \
-          build | xcpretty
-      after_success: false
-
-    - &linux
-      env: SWIFT_VERSION=4.2.4
-      os: linux
-      name: Linux / Swift 4.2.4
-      language: generic
-      sudo: false
-      install: eval "$(curl -sL https://swiftenv.fuller.li/install.sh)"
-      before_script: swift build -Xswiftc -warnings-as-errors
-      script: swift test --parallel
-
-    - <<: *linux
-      env: SWIFT_VERSION=5.0.3
-      name: Linux / Swift 5.0.3
-
-    - <<: *linux
-      env: SWIFT_VERSION=5.1.3
-      name: Linux / Swift 5.1.3
-      
-    - <<: *linux
-      env: SWIFT_VERSION=5.2-DEVELOPMENT-SNAPSHOT-2020-01-22-a
-      name: Linux / Swift 5.2.0-dev+2020-01-22-a
-
-    - stage: pretest
-      name: Check Linux tests are sync’d
-      install: swift test --generate-linuxmain
-      script: git diff --exit-code
-      osx_image: xcode10.2
-
     - stage: deploy
       name: Deploy
       osx_image: xcode11
       env: HOMEBREW_NO_INSTALL_CLEANUP=1
       install: brew install mxcl/made/swift-sh
+      git.depth: false
       script:
         - set -e
         - export VERSION=$(echo $TRAVIS_TAG | cut -c 8-)
-        - git tag "$VERSION"
+        - git tag "$VERSION" --force
         - git remote set-url origin "https://$GITHUB_TOKEN@github.com/$TRAVIS_REPO_SLUG.git"
-        - git fetch --unshallow origin
         - git push origin "$VERSION"
         - swift sh <(curl https://raw.githubusercontent.com/mxcl/ops/master/deploy) publish-release
         - git push origin :$TRAVIS_TAG
+      after_failure: |
+        export VERSION=$(echo $TRAVIS_TAG | cut -c 8-)
+        git push origin :$VERSION
 
     - stage: publish
       name: Jazzy
-      osx_image: xcode10.2
+      osx_image: xcode11
       install: gem install jazzy
       before_script: swift package generate-xcodeproj
       script: |
@@ -118,11 +47,11 @@ jobs:
           tags: true
 
     - name: CocoaPods
-      osx_image: xcode10.2
-      install: |
-        brew install mxcl/made/swift-sh
-        curl -O https://raw.githubusercontent.com/mxcl/ops/master/deploy
-        chmod u+x deploy
+      env: HOMEBREW_NO_INSTALL_CLEANUP=1
+      osx_image: xcode11
+      install:
+        - brew install mxcl/made/swift-sh
+        - curl -O https://raw.githubusercontent.com/mxcl/ops/master/deploy
+        - chmod u+x deploy
       before_script: ./deploy generate-podspec
       script: pod trunk push
-      after_success: ./deploy publish-release

Path.swift.podspec

@@ -0,0 +1,16 @@
+Pod::Spec.new do |spec|
+  spec.name           = "Path.swift"
+  spec.version        = ENV['VERSION'] || "0.0.1"
+  spec.summary        = "Delightful, robust, cross-platform and chainable file-pathing functions."
+  spec.homepage       = "https://github.com/mxcl/Path.swift"
+  spec.license        = "Unlicense"
+  spec.author         = { "Max Howell" => "mxcl@me.com" }
+  spec.source         = { :git => "https://github.com/mxcl/Path.swift.git", :tag => "#{spec.version}" }
+  spec.source_files   = "Sources/*.swift"
+  spec.swift_versions = ['4.2', '5']
+  spec.module_name    = 'Path'
+  spec.osx.deployment_target     = '10.10'
+  spec.ios.deployment_target     = '8.0'
+  spec.tvos.deployment_target    = '9.0'
+  spec.watchos.deployment_target = '2.0'
+end

README.md

@@ -31,6 +31,9 @@ print(bar.isFile)  // => true
 let foo = try Path.root.join("foo").copy(into: Path.root.join("bar").mkdir())
 print(foo)         // => /bar/foo
 print(foo.isFile)  // => true
+// ^^ the `into:` version will only copy *into* a directory, the `to:` version copies
+// to a file at that path, thus you will not accidentally copy into directories you
+// may not have realized existed.
 
 // we support dynamic-member-syntax when joining named static members, eg:
 let prefs = Path.home.Library.Preferences  // => /Users/mxcl/Library/Preferences
@@ -42,16 +45,13 @@ try Bundle.resources.helper.copy(into: Path.root.usr.local.bin).chmod(0o500)
 We emphasize safety and correctness, just like Swift, and also (again like
 Swift), we provide a thoughtful and comprehensive (yet concise) API.
 
-# Support mxcl
+# Sponsor @mxcl
 
 Hi, I’m Max Howell and I have written a lot of open source software—generally
-a good deal of my free time 👨🏻‍💻.
+a good deal of my free time 👨🏻‍💻. Sponsorship helps me justify creating new open
+source and maintaining it. Thank you.
 
-<a href="https://www.patreon.com/mxcl">
-	<img src="https://c5.patreon.com/external/logo/become_a_patron_button@2x.png" width="160">
-</a>
-
-[Other donation/tipping options](http://mxcl.dev/#donate)
+[Sponsor @mxcl].
 
 # Handbook
 
@@ -73,30 +73,36 @@ try JSONEncoder().encode([Path.home, Path.home/"foo"])
 ]
 ```
 
-However, often you want to encode relative paths:
+Though we recommend encoding *relative* paths‡:
 
 ```swift
 let encoder = JSONEncoder()
 encoder.userInfo[.relativePath] = Path.home
-encoder.encode([Path.home, Path.home/"foo"])
+encoder.encode([Path.home, Path.home/"foo", Path.home/"../baz"])
 ```
 
 ```json
 [
     "",
     "foo",
+    "../baz"
 ]
 ```
 
-**Note** make sure you decode with this key set *also*, otherwise we `fatal`
-(unless the paths are absolute obv.)
+**Note** if you encode with this key set you *must* decode with the key
+set also:
 
 ```swift
 let decoder = JSONDecoder()
 decoder.userInfo[.relativePath] = Path.home
-decoder.decode(from: data)
+try decoder.decode(from: data)  // would throw if `.relativePath` not set
 ```
 
+> ‡ If you are saving files to a system provided location, eg. Documents then
+> the directory could change at Apple’s choice, or if say the user changes their
+> username. Using relative paths also provides you with the flexibility in
+> future to change where you are storing your files without hassle.
+
 ## Dynamic members
 
 We support `@dynamicMemberLookup`:
@@ -109,7 +115,26 @@ We only provide this for “starting” function, eg. `Path.home` or `Bundle.pat
 This is because we found in practice it was easy to write incorrect code, since
 everything would compile if we allowed arbituary variables to take *any* named
 property as valid syntax. What we have is what you want most of the time but
-much less dangerous.
+much less (potentially) dangerous (at runtime).
+
+### Pathish
+
+`Path`, and `DynamicPath` (the result of eg. `Path.root`) both conform to
+`Pathish` which is a protocol that contains all pathing functions. Thus if
+you create objects from a mixture of both you need to create generic
+functions or convert any `DynamicPath`s to `Path` first:
+
+```swift
+let path1 = Path("/usr/lib")!
+let path2 = Path.root.usr.bin
+var paths = [Path]()
+paths.append(path1)        // fine
+paths.append(path2)        // error
+paths.append(Path(path2))  // ok
+```
+
+This is inconvenient but as Swift stands there’s nothing we can think of
+that would help.
 
 ## Initializing from user-input
 
@@ -127,6 +152,28 @@ expect to be relative.
 Our initializer is nameless to be consistent with the equivalent operation for
 converting strings to `Int`, `Float` etc. in the standard library.
 
+## Initializing from known strings
+
+There’s no need to use the optional initializer in general if you have known
+strings that you need to be paths:
+
+```swift
+let absolutePath = "/known/path"
+let path1 = Path.root/absolutePath
+
+let pathWithoutInitialSlash = "known/path"
+let path2 = Path.root/pathWithoutInitialSlash
+
+assert(path1 == path2)
+
+let path3 = Path(absolutePath)!  // at your options
+
+assert(path2 == path3)
+
+// be cautious:
+let path4 = Path(pathWithoutInitialSlash)!  // CRASH!
+```
+
 ## Extensions
 
 We have some extensions to Apple APIs:
@@ -168,38 +215,46 @@ let files = Path.home.ls().files
 // ^^ files that both *exist* and are *not* directories
 
 let swiftFiles = Path.home.ls().files.filter{ $0.extension == "swift" }
+
+let includingHiddenFiles = Path.home.ls(.a)
 ```
 
+**Note** `ls()` does not throw, instead outputing a warning to the console if it
+fails to list the directory. The rationale for this is weak, please open a
+ticket for discussion.
+
 We provide `find()` for recursive listing:
 
 ```swift
-Path.home.find().execute { path in
+for path in Path.home.find() {
+    // descends all directories, and includes hidden files by default
+    // so it behaves the same as the terminal command `find`
+}
+```
+
+It is configurable:
+
+```swift
+for path in Path.home.find().depth(max: 1).extension("swift").type(.file).hidden(false) {
     //…
 }
 ```
 
-Which is configurable:
+It can be controlled with a closure syntax:
 
 ```swift
-Path.home.find().depth(max: 1).extension("swift").type(.file) { path in
+Path.home.find().depth(2...3).execute { path in
+    guard path.basename() != "foo.lock" else { return .abort }
+    if path.basename() == ".build", path.isDirectory { return .skip }
     //…
-}
-```
-
-And can be controlled:
-
-```swift
-Path.home.find().execute { path in
-    guard foo else { return .skip }
-    guard bar else { return .abort }
     return .continue
 }
 ```
 
-Or just get all paths at once:
+Or get everything at once as an array:
 
 ```swift
-let paths = Path.home.find().execute()
+let paths = Path.home.find().map(\.self)
 ```
 
 # `Path.swift` is robust
@@ -208,8 +263,8 @@ Some parts of `FileManager` are not exactly idiomatic. For example
 `isExecutableFile` returns `true` even if there is no file there, it is instead
 telling you that *if* you made a file there it *could* be executable. Thus we
 check the POSIX permissions of the file first, before returning the result of
-`isExecutableFile`. `Path.swift` has done the leg-work for you so you can get on
-with your work without worries.
+`isExecutableFile`. `Path.swift` has done the leg-work for you so you can just
+get on with it and not have to worry.
 
 There is also some magic going on in Foundation’s filesystem APIs, which we look
 for and ensure our API is deterministic, eg. [this test].
@@ -223,7 +278,8 @@ round them where necessary.
 
 # Rules & Caveats
 
-Paths are just string representations, there *might not* be a real file there.
+Paths are just (normalized) string representations, there *might not* be a real
+file there.
 
 ```swift
 Path.home/"b"      // => /Users/mxcl/b
@@ -231,7 +287,7 @@ Path.home/"b"      // => /Users/mxcl/b
 // joining multiple strings works as you’d expect
 Path.home/"b"/"c"  // => /Users/mxcl/b/c
 
-// joining multiple parts at a time is fine
+// joining multiple parts simultaneously is fine
 Path.home/"b/c"    // => /Users/mxcl/b/c
 
 // joining with absolute paths omits prefixed slash
@@ -241,6 +297,9 @@ Path.home/"/b"     // => /Users/mxcl/b
 Path.home.foo.bar.join("..")  // => /Users/mxcl/foo
 Path.home.foo.bar.join(".")   // => /Users/mxcl/foo/bar
 
+// though note that we provide `.parent`:
+Path.home.foo.bar.parent      // => /Users/mxcl/foo
+
 // of course, feel free to join variables:
 let b = "b"
 let c = "c"
@@ -264,13 +323,13 @@ Path("/foo/bar/../baz")  // => /foo/baz
 
 // symlinks are not resolved
 Path.root.bar.symlink(as: "foo")
-Path("foo")        // => /foo
-Path.foo           // => /foo
+Path("/foo")        // => /foo
+Path.root.foo       // => /foo
 
 // unless you do it explicitly
-try Path.foo.readlink()  // => /bar
-                         // `readlink` only resolves the *final* path component,
-                         // thus use `realpath` if there are multiple symlinks
+try Path.root.foo.readlink()  // => /bar
+                              // `readlink` only resolves the *final* path component,
+                              // thus use `realpath` if there are multiple symlinks
 ```
 
 *Path.swift* has the general policy that if the desired end result preexists,
@@ -280,7 +339,7 @@ then it’s a noop:
 * If you try to make a directory and it already exists, we do nothing.
 * If you call `readlink` on a non-symlink, we return `self`
 
-However notably if you try to copy or move a file with specifying `overwrite`
+However notably if you try to copy or move a file without specifying `overwrite`
 and the file already exists at the destination and is identical, we don’t check
 for that as the check was deemed too expensive to be worthwhile.
 
@@ -291,9 +350,9 @@ for that as the check was deemed too expensive to be worthwhile.
     equality check is required.
 * There are several symlink paths on Mac that are typically automatically
     resolved by Foundation, eg. `/private`, we attempt to do the same for
-    functions that you would expect it (notably `realpath`), we *do* the same for
-    `Path.init`, but *do not* if you are joining a path that ends up being one of
-    these paths, (eg. `Path.root.join("var/private')`).
+    functions that you would expect it (notably `realpath`), we *do* the same
+    for `Path.init`, but *do not* if you are joining a path that ends up being
+    one of these paths, (eg. `Path.root.join("var/private')`).
 
 If a `Path` is a symlink but the destination of the link does not exist `exists`
 returns `false`. This seems to be the correct thing to do since symlinks are
@@ -305,9 +364,13 @@ no filesystem entry there at all check if `type` is `nil`.
 
 Changing directory is dangerous, you should *always* try to avoid it and thus
 we don’t even provide the method. If you are executing a sub-process then
-use `Process.currentDirectoryURL`.
+use `Process.currentDirectoryURL` to change *its* working directory when it
+executes.
 
-If you must then use `FileManager.changeCurrentDirectory`.
+If you must change directory then use `FileManager.changeCurrentDirectory` as
+early in your process as *possible*. Altering the global state of your app’s
+environment is fundamentally dangerous creating hard to debug issues that
+you won‘t find for potentially *years*.
 
 # I thought I should only use `URL`s?
 
@@ -316,8 +379,8 @@ Apple recommend this because they provide a magic translation for
 
     file:///.file/id=6571367.15106761
 
-Therefore, if you are not using this feature you are fine. If you have URLs the correct
-way to get a `Path` is:
+Therefore, if you are not using this feature you are fine. If you have URLs the
+correct way to get a `Path` is:
 
 ```swift
 if let path = Path(url: url) {
@@ -330,12 +393,27 @@ actual filesystem path, however we also check the URL has a `file` scheme first.
 
 [file-refs]: https://developer.apple.com/documentation/foundation/nsurl/1408631-filereferenceurl
 
+# In defense of our naming scheme
+
+Chainable syntax demands short method names, thus we adopted the naming scheme
+of the terminal, which is absolutely not very “Apple” when it comes to how they
+design their APIs, however for users of the terminal (which *surely* is most
+developers) it is snappy and familiar.
+
 # Installation
 
 SwiftPM:
 
 ```swift
-package.append(.package(url: "https://github.com/mxcl/Path.swift.git", from: "1.0.0"))
+package.append(
+    .package(url: "https://github.com/mxcl/Path.swift.git", from: "1.0.0")
+)
+
+package.targets.append(
+    .target(name: "Foo", dependencies: [
+        .product(name: "Path", package: "Path.swift")
+    ])
+)
 ```
 
 CocoaPods:
@@ -357,12 +435,13 @@ Carthage:
 
 
 [badge-platforms]: https://img.shields.io/badge/platforms-macOS%20%7C%20Linux%20%7C%20iOS%20%7C%20tvOS%20%7C%20watchOS-lightgrey.svg
-[badge-languages]: https://img.shields.io/badge/swift-4.2%20%7C%205.0%20%7C%205.1%20%7C%205.2-orange.svg
+[badge-languages]: https://img.shields.io/badge/swift-4.2%20%7C%205.x-orange.svg
 [docs]: https://mxcl.dev/Path.swift/Structs/Path.html
 [badge-jazzy]: https://raw.githubusercontent.com/mxcl/Path.swift/gh-pages/badge.svg?sanitize=true
 [badge-codecov]: https://codecov.io/gh/mxcl/Path.swift/branch/master/graph/badge.svg
-[badge-ci]: https://travis-ci.com/mxcl/Path.swift.svg
+[badge-ci]: https://github.com/mxcl/Path.swift/workflows/Checks/badge.svg
 [travis]: https://travis-ci.com/mxcl/Path.swift
 [codecov]: https://codecov.io/gh/mxcl/Path.swift
 [badge-version]: https://img.shields.io/cocoapods/v/Path.swift.svg?label=version
 [cocoapods]: https://cocoapods.org/pods/Path.swift
+[Sponsor @mxcl]: https://github.com/sponsors/mxcl

Sources/Path+CommonDirectories.swift

@@ -1,21 +1,33 @@
 import Foundation
 
 /// The `extension` that provides static properties that are common directories.
-extension Path {
+private enum Foo {
     //MARK: Common Directories
 
     /// Returns a `Path` containing `FileManager.default.currentDirectoryPath`.
-    public static var cwd: DynamicPath {
+    static var cwd: DynamicPath {
         return .init(string: FileManager.default.currentDirectoryPath)
     }
 
     /// Returns a `Path` representing the root path.
-    public static var root: DynamicPath {
+    static var root: DynamicPath {
         return .init(string: "/")
     }
 
+#if swift(>=5.3)
+    public static func source(for filePath: String = #filePath) -> (file: DynamicPath, directory: DynamicPath) {
+        let file = DynamicPath(string: filePath)
+        return (file: file, directory: .init(file.parent))
+    }
+#else
+    public static func source(for filePath: String = #file) -> (file: DynamicPath, directory: DynamicPath) {
+        let file = DynamicPath(string: filePath)
+        return (file: file, directory: .init(file.parent))
+    }
+#endif
+
     /// Returns a `Path` representing the user’s home directory
-    public static var home: DynamicPath {
+    static var home: DynamicPath {
         let string: String
       #if os(macOS)
         if #available(OSX 10.12, *) {
@@ -58,7 +70,7 @@ extension Path {
      - Note: There is no standard location for documents on Linux, thus we return `~/Documents`.
      - Note: You should create a subdirectory before creating any files.
      */
-    public static var documents: DynamicPath {
+    static var documents: DynamicPath {
         return path(for: .documentDirectory)
     }
 
@@ -67,7 +79,7 @@ extension Path {
      - Note: On Linux this is `XDG_CACHE_HOME`.
      - Note: You should create a subdirectory before creating any files.
      */
-    public static var caches: DynamicPath {
+    static var caches: DynamicPath {
         return path(for: .cachesDirectory)
     }
 
@@ -76,7 +88,7 @@ extension Path {
      - Note: On Linux is `XDG_DATA_HOME`.
      - Note: You should create a subdirectory before creating any files.
      */
-    public static var applicationSupport: DynamicPath {
+    static var applicationSupport: DynamicPath {
         return path(for: .applicationSupportDirectory)
     }
 }
@@ -96,3 +108,35 @@ func defaultUrl(for searchPath: FileManager.SearchPathDirectory) -> DynamicPath
 }
 #endif
 
+/// The `extension` that provides static properties that are common directories.
+#if swift(>=5.5)
+public extension Pathish where Self == Path {
+    static var home: DynamicPath { return Foo.home }
+    static var root: DynamicPath { return Foo.root }
+    static var cwd: DynamicPath { return Foo.cwd }
+    static var documents: DynamicPath { return Foo.documents }
+    static var caches: DynamicPath { return Foo.caches }
+    static var applicationSupport: DynamicPath { return Foo.applicationSupport }
+    static func source(for filePath: String = #filePath) -> (file: DynamicPath, directory: DynamicPath) {
+        return Foo.source(for: filePath)
+    }
+}
+#else
+public extension Path {
+    static var home: DynamicPath { return Foo.home }
+    static var root: DynamicPath { return Foo.root }
+    static var cwd: DynamicPath { return Foo.cwd }
+    static var documents: DynamicPath { return Foo.documents }
+    static var caches: DynamicPath { return Foo.caches }
+    static var applicationSupport: DynamicPath { return Foo.applicationSupport }
+#if swift(>=5.3)
+    static func source(for filePath: String = #filePath) -> (file: DynamicPath, directory: DynamicPath) {
+        return Foo.source(for: filePath)
+    }
+#else
+    static func source(for file: String = #file) -> (file: DynamicPath, directory: DynamicPath) {
+        return Foo.source(for: file)
+    }
+#endif
+}
+#endif

Sources/Path+FileManager.swift

@@ -29,7 +29,8 @@ public extension Pathish {
         if overwrite, let tokind = to.type, tokind != .directory, type != .directory {
             try FileManager.default.removeItem(at: to.url)
         }
-    #if os(Linux) && !swift(>=5.3) // check if fixed
+    #if os(Linux)
+        //NOTE doing manually due to inconsistency in Linux Foundation behavior
         if !overwrite, to.type != nil {
             throw CocoaError.error(.fileWriteFileExists)
         }
@@ -69,7 +70,8 @@ public extension Pathish {
         if overwrite, let kind = rv.type, kind != .directory {
             try FileManager.default.removeItem(at: rv.url)
         }
-    #if os(Linux) && !swift(>=5.3) // check if fixed
+    #if os(Linux)
+        //NOTE doing manually due to inconsistency in Linux Foundation behavior
         if !overwrite, rv.type != nil {
             throw CocoaError.error(.fileWriteFileExists)
         }

Sources/Path+ls.swift

@@ -14,7 +14,13 @@ public extension Path {
         private let enumerator: FileManager.DirectoryEnumerator!
 
         /// The range of directory depths for which the find operation will return entries.
-        private(set) public var depth: ClosedRange<Int> = 1...Int.max
+        private(set) public var depth: ClosedRange<Int> = 1...Int.max {
+            didSet {
+                if depth.lowerBound < 0 {
+                    depth = 0...depth.upperBound
+                }
+            }
+        }
 
         /// The kinds of filesystem entries find operations will return.
         public var types: Set<EntryType> {
@@ -25,6 +31,9 @@ public extension Path {
 
         /// The file extensions find operations will return. Files *and* directories unless you filter for `kinds`.
         private(set) public var extensions: Set<String>?
+        
+        /// Whether to return hidden files
+        public var hidden:Bool = true
     }
 }
 
@@ -42,14 +51,14 @@ extension Path.Finder: Sequence, IteratorProtocol {
                 continue
             }
             if enumerator.level < depth.lowerBound {
-                if path == self.path, depth.lowerBound == 0 {
-                    return path
-                } else {
-                    continue
-                }
+                continue
+            }
+          
+            if !hidden, path.basename().hasPrefix(".") {
+                enumerator.skipDescendants()
+                continue
             }
           #endif
-
             if let type = path.type, !types.contains(type) { continue }
             if let exts = extensions, !exts.contains(path.extension) { continue }
             return path
@@ -113,6 +122,15 @@ public extension Path.Finder {
         return self
     }
     
+    /// Whether to skip hidden files and folders.
+    func hidden(_ hidden: Bool) -> Path.Finder {
+        #if os(Linux) && !swift(>=5.0)
+          fputs("warning: hidden not implemented for Swift < 5\n", stderr)
+        #endif
+        self.hidden = hidden
+        return self
+    }
+
     /// The return type for `Path.Finder`
     enum ControlFlow {
         /// Stop enumerating this directory, return to the parent.
@@ -128,7 +146,11 @@ public extension Path.Finder {
         while let path = next() {
             switch try closure(path) {
             case .skip:
+              #if !os(Linux) || swift(>=5.0)
                 enumerator.skipDescendants()
+              #else
+                fputs("warning: skip is not implemented for Swift < 5.0\n", stderr)
+              #endif
             case .abort:
                 return
             case .continue:
@@ -158,7 +180,7 @@ public extension Pathish {
             if options != .a, path.basename().hasPrefix(".") { return nil }
             // ^^ we don’t use the Foundation `skipHiddenFiles` because it considers weird things hidden and we are mirroring `ls`
             return path
-        }
+        }.sorted()
     }
 
     /// Recursively find files under this path. If the path is a file, no files will be found.
@@ -192,6 +214,6 @@ public extension Array where Element == Path {
 
 /// Options for `Path.ls(_:)`
 public enum ListDirectoryOptions {
-    /// Creates intermediary directories; works the same as `mkdir -p`.
+    /// Lists hidden files also
     case a
 }

Sources/Path.swift

@@ -7,6 +7,8 @@ import func Glibc.realpath
 let _realpath = Glibc.realpath
 #endif
 
+public typealias PathStruct = Path
+
 /**
  A `Path` represents an absolute path on a filesystem.
 
@@ -168,6 +170,7 @@ public extension Pathish {
      */
     var parent: Path {
         let index = string.lastIndex(of: "/")!
+        guard index != string.indices.startIndex else { return Path(string: "/") }
         let substr = string[string.indices.startIndex..<index]
         return Path(string: String(substr))
     }

Tests/PathTests/PathTests+ls().swift

@@ -52,6 +52,112 @@ extension PathTests {
         }
     }
 
+    func testFindMinDepth() throws {
+        try Path.mktemp { tmpdir in
+            try tmpdir.a.touch()
+            try tmpdir.b.mkdir().join("c").touch()
+            try tmpdir.b.d.mkdir().join("e").touch()
+            try tmpdir.b.d.f.mkdir().join("g").touch()
+
+            do {
+                let finder = tmpdir.find().depth(min: 2)
+                XCTAssertEqual(finder.depth, 2...Int.max)
+              #if !os(Linux) || swift(>=5)
+                XCTAssertEqual(
+                    Set(finder),
+                    Set([tmpdir.b.c, tmpdir.b.d, tmpdir.b.d.e, tmpdir.b.d.f, tmpdir.b.d.f.g].map(Path.init)),
+                    relativeTo: tmpdir)
+              #endif
+            }
+        }
+    }
+
+    func testFindDepth0() throws {
+        try Path.mktemp { tmpdir in
+            try tmpdir.a.touch()
+            try tmpdir.b.mkdir().join("c").touch()
+            try tmpdir.b.d.mkdir().join("e").touch()
+            try tmpdir.b.d.f.mkdir().join("g").touch()
+
+            do {
+                let finder = tmpdir.find().depth(min: 0)
+                XCTAssertEqual(finder.depth, 0...Int.max)
+              #if !os(Linux) || swift(>=5)
+                XCTAssertEqual(
+                    Set(finder),
+                    Set([tmpdir.a, tmpdir.b, tmpdir.b.c, tmpdir.b.d, tmpdir.b.d.e, tmpdir.b.d.f, tmpdir.b.d.f.g].map(Path.init)),
+                    relativeTo: tmpdir)
+              #endif
+            }
+            do {
+                // this should work, even though it’s weird
+                let finder = tmpdir.find().depth(min: -1)
+                XCTAssertEqual(finder.depth, 0...Int.max)
+              #if !os(Linux) || swift(>=5)
+                XCTAssertEqual(
+                    Set(finder),
+                    Set([tmpdir.a, tmpdir.b, tmpdir.b.c, tmpdir.b.d, tmpdir.b.d.e, tmpdir.b.d.f, tmpdir.b.d.f.g].map(Path.init)),
+                    relativeTo: tmpdir)
+              #endif
+            }
+        }
+    }
+
+    func testFindDepthRange() throws {
+        try Path.mktemp { tmpdir in
+            try tmpdir.a.touch()
+            try tmpdir.b.mkdir().join("c").touch()
+            try tmpdir.b.d.mkdir().join("e").touch()
+            try tmpdir.b.d.f.mkdir().join("g").touch()
+
+            do {
+                let range = 2...3
+                let finder = tmpdir.find().depth(range)
+                XCTAssertEqual(finder.depth, range)
+              #if !os(Linux) || swift(>=5)
+                XCTAssertEqual(
+                    Set(finder),
+                    Set([tmpdir.b.d, tmpdir.b.c, tmpdir.b.d.e, tmpdir.b.d.f].map(Path.init)),
+                    relativeTo: tmpdir)
+              #endif
+            }
+
+            do {
+                let range = 2..<4
+                let finder = tmpdir.find().depth(range)
+                XCTAssertEqual(finder.depth, 2...3)
+              #if !os(Linux) || swift(>=5)
+                XCTAssertEqual(
+                    Set(finder),
+                    Set([tmpdir.b.d, tmpdir.b.c, tmpdir.b.d.e, tmpdir.b.d.f].map(Path.init)),
+                    relativeTo: tmpdir)
+              #endif
+            }
+        }
+    }
+
+    func testFindHidden() throws {
+        try Path.mktemp { tmpdir in
+            let dotFoo = try tmpdir.join(".foo.txt").touch()
+            let tmpDotA = try tmpdir.join(".a").mkdir()
+            let tmpDotAFoo = try tmpdir.join(".a").join("foo.txt").touch()
+            let tmpB = try tmpdir.b.mkdir()
+            let tmpBFoo = try tmpdir.b.join("foo.txt").touch()
+
+            XCTAssertEqual(
+                Set(tmpdir.find().hidden(true)),
+                Set([dotFoo,tmpDotA,tmpDotAFoo,tmpB,tmpBFoo]),
+                relativeTo: tmpdir)
+            
+            #if !os(Linux) || swift(>=5)
+            XCTAssertEqual(
+                Set(tmpdir.find().hidden(false)),
+                Set([tmpB,tmpBFoo]),
+                relativeTo: tmpdir)
+            #endif
+        }
+    }
+    
     func testFindExtension() throws {
         try Path.mktemp { tmpdir in
             try tmpdir.join("foo.json").touch()
@@ -66,6 +172,54 @@ extension PathTests {
         }
     }
 
+    //NOTE this is how iterators work, so we have a test to validate that behavior
+    func testFindCallingExecuteTwice() throws {
+        try Path.mktemp { tmpdir in
+            try tmpdir.join("foo.json").touch()
+            try tmpdir.join("bar.txt").touch()
+
+            let finder = tmpdir.find()
+
+            XCTAssertEqual(finder.map{ $0 }.count, 2)
+            XCTAssertEqual(finder.map{ $0 }.count, 0)
+        }
+    }
+
+    func testFindExecute() throws {
+        try Path.mktemp { tmpdir in
+            try tmpdir.a.touch()
+            try tmpdir.b.mkdir().join("c").touch()
+            try tmpdir.b.d.mkdir().join("e").touch()
+            try tmpdir.b.d.f.mkdir().join("g").touch()
+          #if !os(Linux) || swift(>=5)
+            do {
+                var rv = Set<Path>()
+
+                tmpdir.find().execute {
+                    switch $0 {
+                        case Path(tmpdir.b.d): return .skip
+                        default:
+                            rv.insert($0)
+                            return .continue
+                    }
+                }
+
+                XCTAssertEqual(rv, Set([tmpdir.a, tmpdir.b, tmpdir.b.c].map(Path.init)))
+            }
+          #endif
+            do {
+                var x = 0
+
+                tmpdir.find().execute { _ in
+                    x += 1
+                    return .abort
+                }
+
+                XCTAssertEqual(x, 1)
+            }
+        }
+    }
+
     func testFindTypes() throws {
         try Path.mktemp { tmpdir in
             try tmpdir.foo.mkdir()
@@ -82,4 +236,16 @@ extension PathTests {
                 Set(["foo", "bar"].map(tmpdir.join)))
         }
     }
+
+    func testLsOnNonexistentDirectoryReturnsEmptyArray() throws {
+        try Path.mktemp { tmpdir in
+            XCTAssertEqual(tmpdir.a.ls(), [])
+        }
+    }
+
+    func testFindOnNonexistentDirectoryHasNoContent() throws {
+        try Path.mktemp { tmpdir in
+            XCTAssertNil(tmpdir.a.find().next())
+        }
+    }
 }

Tests/PathTests/PathTests.swift

@@ -3,7 +3,20 @@ import func XCTest.XCTAssertEqual
 import Foundation
 import XCTest
 
+extension PathStruct {
+    var foo: Int { fatalError()}
+}
+
 class PathTests: XCTestCase {
+    func testNewStuff() {
+    #if swift(>=5.5)
+        func foo<P: Pathish>(_ path: P) {}
+
+        foo(.home)
+        foo(.root)
+    #endif
+    }
+
     func testConcatenation() {
         XCTAssertEqual((Path.root/"bar").string, "/bar")
         XCTAssertEqual(Path.cwd.string, FileManager.default.currentDirectoryPath)
@@ -146,15 +159,21 @@ class PathTests: XCTestCase {
         ].map(Path.init)
 
         let encoder = JSONEncoder()
-        encoder.userInfo[.relativePath] = root
-        let data = try encoder.encode(input)
 
-        XCTAssertEqual(try JSONSerialization.jsonObject(with: data) as? [String], ["..", "", "bar"])
+        func test<P: Pathish>(relativePath: P, line: UInt = #line) throws {
+            encoder.userInfo[.relativePath] = relativePath
+            let data = try encoder.encode(input)
 
-        let decoder = JSONDecoder()
-        XCTAssertThrowsError(try decoder.decode([Path].self, from: data))
-        decoder.userInfo[.relativePath] = root
-        XCTAssertEqual(try decoder.decode([Path].self, from: data), input)
+            XCTAssertEqual(try JSONSerialization.jsonObject(with: data) as? [String], ["..", "", "bar"], line: line)
+
+            let decoder = JSONDecoder()
+            XCTAssertThrowsError(try decoder.decode([Path].self, from: data), line: line)
+            decoder.userInfo[.relativePath] = relativePath
+            XCTAssertEqual(try decoder.decode([Path].self, from: data), input, line: line)
+        }
+
+        try test(relativePath: root)       // DynamicPath
+        try test(relativePath: Path(root)) // Path
     }
 
     func testJoin() {
@@ -186,6 +205,14 @@ class PathTests: XCTestCase {
         XCTAssertEqual(Path.root/"a/foo"/"../../../bar", Path.root/"bar")
     }
 
+    func testParent() {
+        XCTAssertEqual(Path("/root/boot")!.parent.string, "/root")
+        XCTAssertEqual(Path("/root/boot")!.parent.parent.string, "/")
+        XCTAssertEqual(Path("/root/boot")!.parent.parent.parent.string, "/")
+        XCTAssertEqual(Path("/root")!.parent.string, "/")
+        XCTAssertEqual(Path("/root")!.parent.parent.string, "/")
+    }
+
     func testDynamicMember() {
         XCTAssertEqual(Path.root.Documents, Path.root/"Documents")
 
@@ -193,7 +220,7 @@ class PathTests: XCTestCase {
         XCTAssertEqual(a.Documents, Path.home/"foo/Documents")
 
         // verify use of the dynamic-member-subscript works according to our rules
-        XCTAssertEqual(Path.home[dynamicMember: "../~foo"].string, "\(Path.home.parent.string)/~foo")
+        XCTAssertEqual(Path.home[dynamicMember: "../~foo"].string, Path(Path.home).parent.join("~foo").string)
     }
 
     func testCopyTo() throws {
@@ -299,6 +326,13 @@ class PathTests: XCTestCase {
         XCTAssertEqual(Path.root.string, "/")
         XCTAssertEqual(Path.home.string, NSHomeDirectory())
         XCTAssertEqual(Path.documents.string, NSHomeDirectory() + "/Documents")
+    #if swift(>=5.3)
+        let filePath = Path(#filePath)!
+    #else
+        let filePath = Path(#file)!
+    #endif
+        XCTAssertEqual(Path.source().file, filePath)
+        XCTAssertEqual(Path.source().directory, filePath.parent)
     #if !os(Linux)
         XCTAssertEqual(Path.caches.string, NSHomeDirectory() + "/Library/Caches")
         XCTAssertEqual(Path.cwd.string, FileManager.default.currentDirectoryPath)
@@ -313,6 +347,8 @@ class PathTests: XCTestCase {
     func testStringConvertibles() {
         XCTAssertEqual(Path.root.description, "/")
         XCTAssertEqual(Path.root.debugDescription, "Path(/)")
+        XCTAssertEqual(Path(Path.root).description, "/")
+        XCTAssertEqual(Path(Path.root).debugDescription, "Path(/)")
     }
 
     func testFilesystemAttributes() throws {
@@ -365,17 +401,13 @@ class PathTests: XCTestCase {
 
     func testTimes() throws {
         try Path.mktemp { tmpdir in
-            let foo = try tmpdir.foo.touch()
             let now1 = Date().timeIntervalSince1970.rounded(.down)
-        #if !os(Linux)
-            XCTAssertEqual(foo.ctime?.timeIntervalSince1970.rounded(.down), now1)  //FIXME flakey
-        #endif
-            XCTAssertEqual(foo.mtime?.timeIntervalSince1970.rounded(.down), now1)  //FIXME flakey
             sleep(1)
-            try foo.touch()
-            let now2 = Date().timeIntervalSince1970.rounded(.down)
-            XCTAssertNotEqual(now1, now2)
-            XCTAssertEqual(foo.mtime?.timeIntervalSince1970.rounded(.down), now2)  //FIXME flakey
+            let foo = try tmpdir.foo.touch()
+        #if !os(Linux)
+            XCTAssertGreaterThan(foo.ctime?.timeIntervalSince1970.rounded(.down) ?? 0, now1)  //FIXME flakey
+        #endif
+            XCTAssertGreaterThan(foo.mtime?.timeIntervalSince1970.rounded(.down) ?? 0, now1)  //FIXME flakey
 
             XCTAssertNil(tmpdir.void.mtime)
             XCTAssertNil(tmpdir.void.ctime)
@@ -405,6 +437,9 @@ class PathTests: XCTestCase {
             XCTAssertNoThrow(try bar7.delete())
             XCTAssertEqual(bar7.type, nil)
             XCTAssertEqual(tmpdir.bar6.type, .file)
+
+            // for code-coverage
+            XCTAssertEqual(tmpdir.bar6.kind, .file)
         }
     }
 
@@ -436,7 +471,7 @@ class PathTests: XCTestCase {
         #if os(macOS)
             XCTAssertEqual(bndl.defaultSharedFrameworksPath, tmpdir.Contents.Frameworks)
             XCTAssertEqual(bndl.defaultResourcesPath, tmpdir.Contents.Resources)
-        #elseif os(tvOS) || os(iOS)
+        #elseif os(tvOS) || os(iOS) || os(watchOS)
             XCTAssertEqual(bndl.defaultSharedFrameworksPath, tmpdir.Frameworks)
             XCTAssertEqual(bndl.defaultResourcesPath, tmpdir)
         #else
@@ -488,8 +523,19 @@ class PathTests: XCTestCase {
 
     func testTouchThrowsIfCannotWrite() throws {
         try Path.mktemp { tmpdir in
+
+            print(try FileManager.default.attributesOfItem(atPath: tmpdir.string)[.posixPermissions])
+
+            //FIXME fails in Docker image (only)
             try tmpdir.chmod(0o000)
+
+            let attrs = try FileManager.default.attributesOfItem(atPath: tmpdir.string)
+            XCTAssertEqual(attrs[.posixPermissions] as? Int, 0)
+
+            print(attrs[.posixPermissions])
+
             XCTAssertThrowsError(try tmpdir.bar.touch())
+            XCTAssertFalse(tmpdir.bar.exists)
         }
     }
 
@@ -642,12 +688,10 @@ class PathTests: XCTestCase {
             XCTAssertEqual(bar.type, .symlink)
         }
     }
-}
     
-private func XCTAssertEqual<P: Pathish, Q: Pathish>(_ p: P, _ q: Q, file: StaticString = #file, line: UInt = #line) {
-    XCTAssertEqual(p.string, q.string, file: file, line: line)
-}
-
-private func XCTAssertEqual<P: Pathish, Q: Pathish>(_ p: P?, _ q: Q?, file: StaticString = #file, line: UInt = #line) {
-    XCTAssertEqual(p?.string, q?.string, file: file, line: line)
+    func testOptionalInitializer() throws {
+        XCTAssertNil(Path(""))
+        XCTAssertNil(Path("./foo"))
+        XCTAssertEqual(Path("/foo"), Path.root.foo)
+    }
 }

Tests/PathTests/XCTestManifests.swift

@@ -24,9 +24,16 @@ extension PathTests {
         ("testFileHandleExtensions", testFileHandleExtensions),
         ("testFileReference", testFileReference),
         ("testFilesystemAttributes", testFilesystemAttributes),
+        ("testFindCallingExecuteTwice", testFindCallingExecuteTwice),
+        ("testFindDepth0", testFindDepth0),
+        ("testFindDepthRange", testFindDepthRange),
+        ("testFindExecute", testFindExecute),
         ("testFindExtension", testFindExtension),
+        ("testFindHidden", testFindHidden),
         ("testFindMaxDepth1", testFindMaxDepth1),
         ("testFindMaxDepth2", testFindMaxDepth2),
+        ("testFindMinDepth", testFindMinDepth),
+        ("testFindOnNonexistentDirectoryHasNoContent", testFindOnNonexistentDirectoryHasNoContent),
         ("testFindTypes", testFindTypes),
         ("testFlatMap", testFlatMap),
         ("testInitializerForRelativePath", testInitializerForRelativePath),
@@ -34,11 +41,15 @@ extension PathTests {
         ("testJoin", testJoin),
         ("testKind", testKind),
         ("testLock", testLock),
+        ("testLsOnNonexistentDirectoryReturnsEmptyArray", testLsOnNonexistentDirectoryReturnsEmptyArray),
         ("testMkpathIfExists", testMkpathIfExists),
         ("testMktemp", testMktemp),
         ("testMoveInto", testMoveInto),
         ("testMoveTo", testMoveTo),
+        ("testNewStuff", testNewStuff),
         ("testNoUndesiredSymlinkResolution", testNoUndesiredSymlinkResolution),
+        ("testOptionalInitializer", testOptionalInitializer),
+        ("testParent", testParent),
         ("testPathComponents", testPathComponents),
         ("testReadlinkOnFileReturnsSelf", testReadlinkOnFileReturnsSelf),
         ("testReadlinkOnNonExistantFileThrows", testReadlinkOnNonExistantFileThrows),

Tests/PathTests/etc.swift

@@ -0,0 +1,43 @@
+import XCTest
+import Path
+
+#if swift(>=5.3)
+func XCTAssertEqual<P: Pathish>(_ set1: Set<Path>, _ set2: Set<Path>, _ message: @autoclosure () -> String = "", file: StaticString = #filePath, line: UInt = #line, relativeTo: P) {
+    logic(set1, set2, relativeTo: relativeTo) {
+        XCTFail($0, file: file, line: line)
+    }
+}
+#else
+func XCTAssertEqual<P: Pathish>(_ set1: Set<Path>, _ set2: Set<Path>, _ message: @autoclosure () -> String = "", file: StaticString = #file, line: UInt = #line, relativeTo: P) {
+    logic(set1, set2, relativeTo: relativeTo) {
+        XCTFail($0, file: file, line: line)
+    }
+}
+#endif
+
+private func logic<P: Pathish>(_ set1: Set<Path>, _ set2: Set<Path>, relativeTo: P, fail: (String) -> Void) {
+    if set1 != set2 {
+        let cvt: (Path) -> String = { $0.relative(to: relativeTo) }
+        let out1 = set1.map(cvt).sorted()
+        let out2 = set2.map(cvt).sorted()
+        fail("Set(\(out1)) is not equal to Set(\(out2))")
+    }
+}
+
+#if swift(>=5.3)
+func XCTAssertEqual<P: Pathish, Q: Pathish>(_ p: P, _ q: Q, file: StaticString = #filePath, line: UInt = #line) {
+    XCTAssertEqual(p.string, q.string, file: file, line: line)
+}
+
+func XCTAssertEqual<P: Pathish, Q: Pathish>(_ p: P?, _ q: Q?, file: StaticString = #filePath, line: UInt = #line) {
+    XCTAssertEqual(p?.string, q?.string, file: file, line: line)
+}
+#else
+func XCTAssertEqual<P: Pathish, Q: Pathish>(_ p: P, _ q: Q, file: StaticString = #file, line: UInt = #line) {
+    XCTAssertEqual(p.string, q.string, file: file, line: line)
+}
+
+func XCTAssertEqual<P: Pathish, Q: Pathish>(_ p: P?, _ q: Q?, file: StaticString = #file, line: UInt = #line) {
+    XCTAssertEqual(p?.string, q?.string, file: file, line: line)
+}
+#endif