Adapt for new repository

participate in tea protocol
Rename Path->Bool.swift to PathToBool.swift
2025-09-30 17:25:19 +02:00 · 2024-02-22 05:59:31 -05:00 · 2023-10-24 10:24:59 -04:00 · 2023-06-27 10:13:35 -04:00 · 2021-07-30 12:28:04 -04:00 · 2021-07-30 17:09:37 +01:00
27 changed files with 1595 additions and 653 deletions
--- a/.github/codecov.yml
+++ b/.github/codecov.yml
@@ -1,2 +1,3 @@
 ignore:
-  - Tests
+  - Tests/PathTests/etc.swift
  - Tests/PathTests/TemporaryDirectory.swift
--- a/.github/deploy
+++ b/.github/deploy
@@ -1,174 +0,0 @@
 #!/usr/bin/swift sh
 import func Darwin.fputs
 import var Darwin.stderr
 import PMKFoundation  // PromiseKit/Foundation ~> 3.3
 import LegibleError   // @mxcl ~> 1.0
 import Foundation
 import PromiseKit     // @mxcl ~> 6.8
 import Path           // mxcl/Path.swift == master
 let env = ProcessInfo.processInfo.environment
 let token = env["GITHUB_TOKEN"] ?? env["GITHUB_ACCESS_TOKEN"]!
 let slug = env["TRAVIS_REPO_SLUG"]!
 let tag = env["TRAVIS_TAG"]!
 func fatal(message: String) -> Never {
    fputs("error: \(message)\n", stderr)
    exit(1)
 }
 func fatal(error: Error) -> Never {
    fatal(message: error.legibleLocalizedDescription)
 }
 guard let licenseFile = try Path.cwd.ls().files.first(where: {
    $0.basename().hasPrefix("LICENSE")
 })?.basename() else {
    fatal(message: "no LICENSE file found")
 }
 struct Repo: Decodable {
    let description: String
    let license: License
    struct License: Decodable {
        let spdx_id: String
    }
 }
 struct Package: Decodable {
    let swiftLanguageVersions: [String]
    let targets: [Target]
    struct Target: Decodable {
        let path: String?
        let type: Kind
        enum Kind: String, Decodable {
            case regular
            case test
        }
    }
 }
 extension URLRequest {
    init(github path: String) {
        let url = URL(string: "https://api.github.com\(path)")!
        self.init(url: url)
        setValue("token \(token)", forHTTPHeaderField: "Authorization")
        setValue("application/json", forHTTPHeaderField: "Content-Type")
        setValue("application/json", forHTTPHeaderField: "Accept")
    }
 }
 func description() -> Promise<Repo> {
    let rq = URLRequest(github: "/repos/\(slug)")
    return firstly {
        URLSession.shared.dataTask(.promise, with: rq).validate()
    }.map { data, _ in
        try JSONDecoder().decode(Repo.self, from: data)
    }
 }
 struct User: Decodable {
    let name: String
    let email: String
 }
 func email() -> Promise<User> {
    let rq = URLRequest(github: "/user")
    return firstly {
        URLSession.shared.dataTask(.promise, with: rq).validate()
    }.map { data, _ in
        try JSONDecoder().decode(User.self, from: data)
    }
 }
 func dumpPackage() -> Promise<Package> {
    let task = Process()
    task.launchPath = "/usr/bin/swift"
    task.arguments = ["package", "dump-package"]
    return firstly {
        task.launch(.promise)
    }.map { out, _ in
        out.fileHandleForReading.readDataToEndOfFile()
    }.map { data in
        try JSONDecoder().decode(Package.self, from: data)
    }
 }
 var defaultSwiftVersion: String {
    let task = Process()
    task.launchPath = "/usr/bin/swift"
    task.arguments = ["--version"]
    func extract(input: String) -> String {
        let range = input.range(of: #"Apple Swift version \d+\.\d+"#, options: .regularExpression)!
        return String(input[range].split(separator: " ").last!)
    }
    return try! firstly {
        task.launch(.promise)
    }.compactMap { out, _ in
        String(data: out.fileHandleForReading.readDataToEndOfFile(), encoding: .utf8)
    }.map { out in
        extract(input: out)
    }.wait()
 }
 func podspec(repo: Repo, user: User, pkg: Package) -> (Substring, String) {
    let (owner, name) = { ($0[0], $0[1]) }(slug.split(separator: "/"))
    let swiftVersion = pkg.swiftLanguageVersions.min() ?? defaultSwiftVersion
    let targets = pkg.targets.filter{ $0.type == .regular }
    guard targets.count == 1 else { fatal(message: "Too many targets for this script!") }
    guard let sources = targets[0].path else { fatal(message: "Target has no path!") }
    return (name, """
    Pod::Spec.new do |s|
      s.name = '\(name)'
      s.version = '\(tag)'
      s.summary = '\(repo.description)'
      s.homepage = "https://github.com/\(slug)"
      s.license = { type: '\(repo.license.spdx_id)', file: '\(licenseFile)' }
      s.author = { '\(user.name)': '\(user.email)' }
      s.source = { git: "https://github.com/\(slug).git", tag: '\(tag)' }
      s.social_media_url = 'https://twitter.com/\(owner)'
      s.osx.deployment_target = '10.10'
      s.ios.deployment_target = '8.0'
      s.tvos.deployment_target = '9.0'
      s.watchos.deployment_target = '2.0'
      s.source_files = '\(sources)/*.swift'
      s.swift_version = '\(swiftVersion)'
    end
    """)
 }
 func publishRelease() throws -> Promise<Void> {
    struct Input: Encodable {
        var tag_name: String { return tag }
        var name: String { return tag }
        let body = ""
    }
    var rq = URLRequest(github: "/repos/\(slug)/releases")
    rq.httpMethod = "POST"
    rq.httpBody = try JSONEncoder().encode(Input())
    return URLSession.shared.dataTask(.promise, with: rq).validate().asVoid()
 }
 switch CommandLine.arguments[1] {
 case "generate-podspec":
    firstly {
        when(fulfilled: description(), email(), dumpPackage())
    }.map(podspec).done { name, podspec in
        try podspec.write(toFile: "\(name).podspec", atomically: false, encoding: .utf8)
        exit(0)
    }.catch {
        fatal(error: $0)
    }
 case "publish-release":
    try publishRelease().done {
        exit(0)
    }.catch {
        fatal(error: $0)
    }
 default:
    fatal(message: "invalid usage")
 }
 RunLoop.main.run()
--- a/.github/jazzy.yml
+++ b/.github/jazzy.yml
@@ -3,7 +3,7 @@ custom_categories:
  - name: Path
    children:
      - Path
-      - /(_:_:)
+      - Pathish
 xcodebuild_arguments:
  - UseModernBuildSystem=NO
 output:
--- a/.github/workflows/cd.yml
+++ b/.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 }}
--- a/.github/workflows/checks.yml
+++ b/.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
--- a/.github/workflows/ci.yml
+++ b/.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
--- a/.gitignore
+++ b/.gitignore
@@ -3,3 +3,4 @@
 /*.xcodeproj
 /build
 /docs
 /.swiftpm
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,83 +0,0 @@
 # only run for: merge commits, releases and pull-requests
 if: type != push OR branch = master OR branch =~ /^\d+\.\d+(\.\d+)?(-\S*)?$/
 stages:
  - name: pretest
  - name: test
  - name: deploy
    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.2.1
      script: swift test --parallel
    - name: macOS / Swift 5.0
      osx_image: xcode10.2
      script: swift test --parallel
    - &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.1
      os: linux
      name: Linux / Swift 4.2.1
      language: generic
      dist: trusty
      sudo: false
      install: eval "$(curl -sL https://swiftenv.fuller.li/install.sh)"
      script: swift test --parallel
    - <<: *linux
      env: SWIFT_VERSION='5.0-DEVELOPMENT-SNAPSHOT-2019-01-22-a'
      name: Linux / Swift 5.0.0-dev+2019-01-22
    - stage: pretest
      name: Check Linux tests are sync’d
      install: swift test --generate-linuxmain
      script: git diff --exit-code
    - stage: deploy
      name: Jazzy
      install: gem install jazzy
      before_script: swift package generate-xcodeproj
      script: |
        jazzy --config .github/jazzy.yml \
              --module-version $TRAVIS_TAG \
              --github_url "https://github.com/$TRAVIS_REPO_SLUG"
      deploy:
        provider: pages
        skip-cleanup: true
        github-token: $GITHUB_TOKEN
        local-dir: output
        on:
          tags: true
    - name: CocoaPods
      osx_image: xcode10.2
      install: brew install mxcl/made/swift-sh
      before_script: .github/deploy generate-podspec
      script: pod trunk push
      after_success: .github/deploy publish-release
--- a/LICENSE.md
+++ b/LICENSE.md
@@ -1,27 +1,287 @@
-Unlicense (Public Domain)
+											EUROPEAN UNION PUBLIC LICENCE v. 1.2
-============================
+											EUPL © the European Union 2007, 2016
-This is free and unencumbered software released into the public domain.
+This European Union Public Licence (the ‘EUPL’) applies to the Work (as defined
 below) which is provided under the terms of this Licence. Any use of the Work,
 other than as authorised under this Licence is prohibited (to the extent such
 use is covered by a right of the copyright holder of the Work).
-Anyone is free to copy, modify, publish, use, compile, sell, or
+The Work is provided under the terms of this Licence when the Licensor (as
-distribute this software, either in source code form or as a compiled
+defined below) has placed the following notice immediately following the
-binary, for any purpose, commercial or non-commercial, and by any
+copyright notice for the Work:
 means.
-In jurisdictions that recognize copyright laws, the author or authors
+				Licensed under the EUPL
 of this software dedicate any and all copyright interest in the
 software to the public domain. We make this dedication for the benefit
 of the public at large and to the detriment of our heirs and
 successors. We intend this dedication to be an overt act of
 relinquishment in perpetuity of all present and future rights to this
 software under copyright law.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+or has expressed by any other means his willingness to license under the EUPL.
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 OTHER DEALINGS IN THE SOFTWARE.
-For more information, please refer to &lt;<http://unlicense.org/>&gt;
+1. Definitions
 In this Licence, the following terms have the following meaning:
 - ‘The Licence’: this Licence.
 - ‘The Original Work’: the work or software distributed or communicated by the
 	Licensor under this Licence, available as Source Code and also as Executable
 	Code as the case may be.
 - ‘Derivative Works’: the works or software that could be created by the
 	Licensee, based upon the Original Work or modifications thereof. This Licence
 	does not define the extent of modification or dependence on the Original Work
 	required in order to classify a work as a Derivative Work; this extent is
 	determined by copyright law applicable in the country mentioned in Article 15.
 - ‘The Work’: the Original Work or its Derivative Works.
 - ‘The Source Code’: the human-readable form of the Work which is the most
 	convenient for people to study and modify.
 - ‘The Executable Code’: any code which has generally been compiled and which is
 	meant to be interpreted by a computer as a program.
 - ‘The Licensor’: the natural or legal person that distributes or communicates
 	the Work under the Licence.
 - ‘Contributor(s)’: any natural or legal person who modifies the Work under the
 	Licence, or otherwise contributes to the creation of a Derivative Work.
 - ‘The Licensee’ or ‘You’: any natural or legal person who makes any usage of
 	the Work under the terms of the Licence.
 - ‘Distribution’ or ‘Communication’: any act of selling, giving, lending,
 	renting, distributing, communicating, transmitting, or otherwise making
 	available, online or offline, copies of the Work or providing access to its
 	essential functionalities at the disposal of any other natural or legal
 	person.
 2. Scope of the rights granted by the Licence
 The Licensor hereby grants You a worldwide, royalty-free, non-exclusive,
 sublicensable licence to do the following, for the duration of copyright vested
 in the Original Work:
 - use the Work in any circumstance and for all usage,
 - reproduce the Work,
 - modify the Work, and make Derivative Works based upon the Work,
 - communicate to the public, including the right to make available or display
 	the Work or copies thereof to the public and perform publicly, as the case may
 	be, the Work,
 - distribute the Work or copies thereof,
 - lend and rent the Work or copies thereof,
 - sublicense rights in the Work or copies thereof.
 Those rights can be exercised on any media, supports and formats, whether now
 known or later invented, as far as the applicable law permits so.
 In the countries where moral rights apply, the Licensor waives his right to
 exercise his moral right to the extent allowed by law in order to make effective
 the licence of the economic rights here above listed.
 The Licensor grants to the Licensee royalty-free, non-exclusive usage rights to
 any patents held by the Licensor, to the extent necessary to make use of the
 rights granted on the Work under this Licence.
 3. Communication of the Source Code
 The Licensor may provide the Work either in its Source Code form, or as
 Executable Code. If the Work is provided as Executable Code, the Licensor
 provides in addition a machine-readable copy of the Source Code of the Work
 along with each copy of the Work that the Licensor distributes or indicates, in
 a notice following the copyright notice attached to the Work, a repository where
 the Source Code is easily and freely accessible for as long as the Licensor
 continues to distribute or communicate the Work.
 4. Limitations on copyright
 Nothing in this Licence is intended to deprive the Licensee of the benefits from
 any exception or limitation to the exclusive rights of the rights owners in the
 Work, of the exhaustion of those rights or of other applicable limitations
 thereto.
 5. Obligations of the Licensee
 The grant of the rights mentioned above is subject to some restrictions and
 obligations imposed on the Licensee. Those obligations are the following:
 Attribution right: The Licensee shall keep intact all copyright, patent or
 trademarks notices and all notices that refer to the Licence and to the
 disclaimer of warranties. The Licensee must include a copy of such notices and a
 copy of the Licence with every copy of the Work he/she distributes or
 communicates. The Licensee must cause any Derivative Work to carry prominent
 notices stating that the Work has been modified and the date of modification.
 Copyleft clause: If the Licensee distributes or communicates copies of the
 Original Works or Derivative Works, this Distribution or Communication will be
 done under the terms of this Licence or of a later version of this Licence
 unless the Original Work is expressly distributed only under this version of the
 Licence — for example by communicating ‘EUPL v. 1.2 only’. The Licensee
 (becoming Licensor) cannot offer or impose any additional terms or conditions on
 the Work or Derivative Work that alter or restrict the terms of the Licence.
 Compatibility clause: If the Licensee Distributes or Communicates Derivative
 Works or copies thereof based upon both the Work and another work licensed under
 a Compatible Licence, this Distribution or Communication can be done under the
 terms of this Compatible Licence. For the sake of this clause, ‘Compatible
 Licence’ refers to the licences listed in the appendix attached to this Licence.
 Should the Licensee's obligations under the Compatible Licence conflict with
 his/her obligations under this Licence, the obligations of the Compatible
 Licence shall prevail.
 Provision of Source Code: When distributing or communicating copies of the Work,
 the Licensee will provide a machine-readable copy of the Source Code or indicate
 a repository where this Source will be easily and freely available for as long
 as the Licensee continues to distribute or communicate the Work.
 Legal Protection: This Licence does not grant permission to use the trade names,
 trademarks, service marks, or names of the Licensor, except as required for
 reasonable and customary use in describing the origin of the Work and
 reproducing the content of the copyright notice.
 6. Chain of Authorship
 The original Licensor warrants that the copyright in the Original Work granted
 hereunder is owned by him/her or licensed to him/her and that he/she has the
 power and authority to grant the Licence.
 Each Contributor warrants that the copyright in the modifications he/she brings
 to the Work are owned by him/her or licensed to him/her and that he/she has the
 power and authority to grant the Licence.
 Each time You accept the Licence, the original Licensor and subsequent
 Contributors grant You a licence to their contributions to the Work, under the
 terms of this Licence.
 7. Disclaimer of Warranty
 The Work is a work in progress, which is continuously improved by numerous
 Contributors. It is not a finished work and may therefore contain defects or
 ‘bugs’ inherent to this type of development.
 For the above reason, the Work is provided under the Licence on an ‘as is’ basis
 and without warranties of any kind concerning the Work, including without
 limitation merchantability, fitness for a particular purpose, absence of defects
 or errors, accuracy, non-infringement of intellectual property rights other than
 copyright as stated in Article 6 of this Licence.
 This disclaimer of warranty is an essential part of the Licence and a condition
 for the grant of any rights to the Work.
 8. Disclaimer of Liability
 Except in the cases of wilful misconduct or damages directly caused to natural
 persons, the Licensor will in no event be liable for any direct or indirect,
 material or moral, damages of any kind, arising out of the Licence or of the use
 of the Work, including without limitation, damages for loss of goodwill, work
 stoppage, computer failure or malfunction, loss of data or any commercial
 damage, even if the Licensor has been advised of the possibility of such damage.
 However, the Licensor will be liable under statutory product liability laws as
 far such laws apply to the Work.
 9. Additional agreements
 While distributing the Work, You may choose to conclude an additional agreement,
 defining obligations or services consistent with this Licence. However, if
 accepting obligations, You may act only on your own behalf and on your sole
 responsibility, not on behalf of the original Licensor or any other Contributor,
 and only if You agree to indemnify, defend, and hold each Contributor harmless
 for any liability incurred by, or claims asserted against such Contributor by
 the fact You have accepted any warranty or additional liability.
 10. Acceptance of the Licence
 The provisions of this Licence can be accepted by clicking on an icon ‘I agree’
 placed under the bottom of a window displaying the text of this Licence or by
 affirming consent in any other similar way, in accordance with the rules of
 applicable law. Clicking on that icon indicates your clear and irrevocable
 acceptance of this Licence and all of its terms and conditions.
 Similarly, you irrevocably accept this Licence and all of its terms and
 conditions by exercising any rights granted to You by Article 2 of this Licence,
 such as the use of the Work, the creation by You of a Derivative Work or the
 Distribution or Communication by You of the Work or copies thereof.
 11. Information to the public
 In case of any Distribution or Communication of the Work by means of electronic
 communication by You (for example, by offering to download the Work from a
 remote location) the distribution channel or media (for example, a website) must
 at least provide to the public the information requested by the applicable law
 regarding the Licensor, the Licence and the way it may be accessible, concluded,
 stored and reproduced by the Licensee.
 12. Termination of the Licence
 The Licence and the rights granted hereunder will terminate automatically upon
 any breach by the Licensee of the terms of the Licence.
 Such a termination will not terminate the licences of any person who has
 received the Work from the Licensee under the Licence, provided such persons
 remain in full compliance with the Licence.
 13. Miscellaneous
 Without prejudice of Article 9 above, the Licence represents the complete
 agreement between the Parties as to the Work.
 If any provision of the Licence is invalid or unenforceable under applicable
 law, this will not affect the validity or enforceability of the Licence as a
 whole. Such provision will be construed or reformed so as necessary to make it
 valid and enforceable.
 The European Commission may publish other linguistic versions or new versions of
 this Licence or updated versions of the Appendix, so far this is required and
 reasonable, without reducing the scope of the rights granted by the Licence. New
 versions of the Licence will be published with a unique version number.
 All linguistic versions of this Licence, approved by the European Commission,
 have identical value. Parties can take advantage of the linguistic version of
 their choice.
 14. Jurisdiction
 Without prejudice to specific agreement between parties,
 - any litigation resulting from the interpretation of this License, arising
 	between the European Union institutions, bodies, offices or agencies, as a
 	Licensor, and any Licensee, will be subject to the jurisdiction of the Court
 	of Justice of the European Union, as laid down in article 272 of the Treaty on
 	the Functioning of the European Union,
 - any litigation arising between other parties and resulting from the
 	interpretation of this License, will be subject to the exclusive jurisdiction
 	of the competent court where the Licensor resides or conducts its primary
 	business.
 15. Applicable Law
 Without prejudice to specific agreement between parties,
 - this Licence shall be governed by the law of the European Union Member State
 	where the Licensor has his seat, resides or has his registered office,
 - this licence shall be governed by Belgian law if the Licensor has no seat,
 	residence or registered office inside a European Union Member State.
 Appendix
 ‘Compatible Licences’ according to Article 5 EUPL are:
 - GNU General Public License (GPL) v. 2, v. 3
 - GNU Affero General Public License (AGPL) v. 3
 - Open Software License (OSL) v. 2.1, v. 3.0
 - Eclipse Public License (EPL) v. 1.0
 - CeCILL v. 2.0, v. 2.1
 - Mozilla Public Licence (MPL) v. 2
 - GNU Lesser General Public Licence (LGPL) v. 2.1, v. 3
 - Creative Commons Attribution-ShareAlike v. 3.0 Unported (CC BY-SA 3.0) for
 	works other than software
 - European Union Public Licence (EUPL) v. 1.1, v. 1.2
 - Québec Free and Open-Source Licence — Reciprocity (LiLiQ-R) or Strong
 	Reciprocity (LiLiQ-R+).
 The European Commission may update this Appendix to later versions of the above
 licences without producing a new version of the EUPL, as long as they provide
 the rights granted in Article 2 of this Licence and protect the covered Source
 Code from exclusive appropriation.
 All other changes or additions to this Appendix require the production of a new
 EUPL version.
--- a/Package.swift
+++ b/Package.swift
@@ -1,14 +1,14 @@
 // swift-tools-version:4.2
 import PackageDescription
-let pkg = Package(
+let package = Package(
-    name: "Path.swift",
+    name: "swiftpm-pathkit",
    products: [
-        .library(name: "Path", targets: ["Path"]),
+        .library(name: "PathKit", targets: ["PathKit"]),
    ],
    targets: [
-        .target(name: "Path", path: "Sources"),
+        .target(name: "PathKit", path: "Sources"),
-        .testTarget(name: "PathTests", dependencies: ["Path"]),
+        .testTarget(name: "PathTests", dependencies: ["PathKit"]),
    ],
-    swiftLanguageVersions: [.v4, .v4_2]
+    swiftLanguageVersions: [.v4, .v4_2, .version("5")]
 )
--- a/Package@swift-5.0.swift
+++ b/Package@swift-5.0.swift
@@ -1,14 +0,0 @@
 // swift-tools-version:5.0
 import PackageDescription
 let pkg = Package(
    name: "Path.swift",
    products: [
        .library(name: "Path", targets: ["Path"]),
    ],
    targets: [
        .target(name: "Path", path: "Sources"),
        .testTarget(name: "PathTests", dependencies: ["Path"]),
    ],
    swiftLanguageVersions: [.v4, .v4_2, .v5]
 )
--- a/README.md
+++ b/README.md
@@ -1,10 +1,18 @@
-# Path.swift ![badge-platforms][] ![badge-languages][] [![badge-ci][]][travis] [![badge-jazzy][]][docs] [![badge-codecov][]][codecov] [![badge-version][]][cocoapods]
+# Swift PathKit ![badge-platforms][] ![badge-languages][]
 A file-system pathing library focused on developer experience and robust end
 results.
 > [!NOTE]
 > This repository is a fork of [mxcl/Path.swift][] by [mxcl](), which due to inactivity does not receive new features.
 [mxcl/Path.swift]: https://github.com/mxcl/Path.swift
 [mxcl]: https://github.com/mxcl
 ## Examples
 ```swift
-import Path
+import PathKit
 // convenient static members
 let home = Path.home
@@ -31,38 +39,28 @@ 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 members (_use_sparingly_):
+// we support dynamic-member-syntax when joining named static members, eg:
-let prefs = Path.home.Library.Preferences  // => /Users/mxcl/Library/Preferences
+let prefs = Path.home.Library.Preferences  // => /Users/someuser/Library/Preferences
 // a practical example: installing a helper executable
 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
+This repository emphasizes safety and correctness, just like Swift, and also (again like
 Swift), we provide a thoughtful and comprehensive (yet concise) API.
 # Support mxcl
 Hi, I’m Max Howell and I have written a lot of open source software, and
 probably you already use some of it (Homebrew anyone?). I work full-time on
 open source and it’s hard; currently I earn *less* than minimum wage. Please
 help me continue my work, I appreciate it x
 <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.github.io/donate/)
 # Handbook
-Our [online API documentation][docs] covers 100% of our public API and is
+The [online API documentation][docs] covers 100% of the public API and is
 automatically updated for new releases.
 ## Codable
-We support `Codable` as you would expect:
+`Path` conforms to `Codable`:
 ```swift
 try JSONEncoder().encode([Path.home, Path.home/"foo"])
@@ -70,47 +68,70 @@ try JSONEncoder().encode([Path.home, Path.home/"foo"])
 ```json
 [
-    "/Users/mxcl",
+    "/Users/someuser",
-    "/Users/mxcl/foo",
+    "/Users/someuser/foo",
 ]
 ```
-However, often you want to encode relative paths:
+`Paths` can be encoded as *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`
+**Note** if you encode with this key set you *must* decode with the key
-(unless the paths are absolute obv.)
+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`:
+`Path` supports `@dynamicMemberLookup`:
 ```swift
 let ls = Path.root.usr.bin.ls  // => /usr/bin/ls
 ```
-This is less commonly useful than you would think, hence our documentation
+This is provided for “starting” functions only, eg. `Path.home` or `Bundle.path`.
-does not use it. Usually you are joining variables or other `String` arguments
+Allowing arbitrary property access only in special cases is a precaution.
-or trying to describe files (and files usually have extensions). However when
+
-you need it, it’s *lovely*.
+### 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
@@ -125,9 +146,31 @@ This is explicit, not hiding anything that code-review may miss and preventing
 common bugs like accidentally creating `Path` objects from strings you did not
 expect to be relative.
-Our initializer is nameless to be consistent with the equivalent operation for
+The 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:
@@ -145,28 +188,69 @@ try Bundle.main.resources.join("foo").copy(to: .home)
 ## Directory listings
-We provide `ls()`, called because it behaves like the Terminal `ls` function,
+`Path` provides `ls()` to list files. Like `ls` it is not recursive and doesn’t
-the name thus implies its behavior, ie. that it is not recursive.
+list hidden files.
 ```swift
-for entry in Path.home.ls() {
+for path in Path.home.ls() {
    print(entry.path)
    print(entry.kind)  // .directory or .file
 }
 for entry in Path.home.ls() where entry.kind == .file {
    //…
 }
-for entry in Path.home.ls() where entry.path.mtime > yesterday {
+for path in Path.home.ls() where path.isFile {
    //…
 }
 for path in Path.home.ls() where path.mtime > yesterday {
    //…
 }
 let dirs = Path.home.ls().directories
 // ^^ directories that *exist*
 let files = Path.home.ls().files
 // ^^ files that both *exist* and are *not* directories
-let swiftFiles = Path.home.ls().files(withExtension: "swift")
+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.
 `Path` provides `find()` for recursive listing:
 ```swift
 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) {
    //…
 }
 ```
 It can be controlled with a closure syntax:
 ```swift
 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 }
    //…
    return .continue
 }
 ```
 Or get everything at once as an array:
 ```swift
 let paths = Path.home.find().map(\.self)
 ```
 # `Path.swift` is robust
@@ -175,50 +259,53 @@ 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
+`isExecutableFile`. `Path.swift` has done the leg-work for you so you can just
-with your work without worries.
+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].
-[this test]: https://github.com/mxcl/Path.swift/blob/master/Tests/PathTests/PathTests.swift#L539-L554
+[this test]: https://github.com/astzweig/swiftpm-pathkit/blob/master/Tests/PathTests/PathTests.swift#L539-L554
-# `Path.swift` is properly cross-platform
+# `PathKit` is properly cross-platform
-`FileManager` on Linux is full of holes. We have found the holes and worked
+`FileManager` on Linux has a lot of pitfalls, which this library works around on.
 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
+Path.home/"b"      // => /Users/someuser/b
 // joining multiple strings works as you’d expect
-Path.home/"b"/"c"  // => /Users/mxcl/b/c
+Path.home/"b"/"c"  // => /Users/someuser/b/c
-// joining multiple parts at a time is fine
+// joining multiple parts simultaneously is fine
-Path.home/"b/c"    // => /Users/mxcl/b/c
+Path.home/"b/c"    // => /Users/someuser/b/c
 // joining with absolute paths omits prefixed slash
-Path.home/"/b"     // => /Users/mxcl/b
+Path.home/"/b"     // => /Users/someuser/b
 // joining with .. or . works as expected
-Path.home.foo.bar.join("..")  // => /Users/mxcl/foo
+Path.home.foo.bar.join("..")  // => /Users/someuser/foo
-Path.home.foo.bar.join(".")   // => /Users/mxcl/foo/bar
+Path.home.foo.bar.join(".")   // => /Users/someuser/foo/bar
 // though note that we provide `.parent`:
 Path.home.foo.bar.parent      // => /Users/someuser/foo
 // of course, feel free to join variables:
 let b = "b"
 let c = "c"
-Path.home/b/c      // => /Users/mxcl/b/c
+Path.home/b/c      // => /Users/someuser/b/c
 // tilde is not special here
 Path.root/"~b"     // => /~b
 Path.root/"~/b"    // => /~/b
 // but is here
-Path("~/foo")!     // => /Users/mxcl/foo
+Path("~/foo")!     // => /Users/someuser/foo
 // this works provided the user `Guest` exists
 Path("~Guest")     // => /Users/Guest
@@ -231,24 +318,24 @@ 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
+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,
+*PathKit* has the general policy that if the desired end result preexists,
 then it’s a noop:
-* If you try to delete a file, but the file doesn't exist, we do nothing.
+* If you try to delete a file, but the file doesn't exist, nothing happens.
-* If you try to make a directory and it already exists, we do nothing.
+* If you try to make a directory and it already exists, nothing happens.
 * 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
+and the file already exists at the destination and is identical, *PathKit* doesn't check
 for that as the check was deemed too expensive to be worthwhile.
 ## Symbolic links
@@ -258,17 +345,27 @@ 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`), but we do *not* for
+    functions that you would expect it (notably `realpath`), we *do* the same
-    `Path.init`, *nor* if you are joining a path that ends up being one of these
+    for `Path.init`, but *do not* if you are joining a path that ends up being
-    paths, (eg. `Path.root.join("var/private')`).
+    one of these paths, (eg. `Path.root.join("var/private')`).
-## We do not provide change directory functionality
+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
 meant to be an abstraction for filesystems. To instead verify that there is
 no filesystem entry there at all check if `type` is `nil`.
 ## There is no change directory functionality
 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?
@@ -277,8 +374,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
+Therefore, if you are not using this feature you are fine. If you have URLs the
-way to get a `Path` is:
+correct way to get a `Path` is:
 ```swift
 if let path = Path(url: url) {
@@ -291,32 +388,32 @@ 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: "0.13.0"))
+package.append(
    .package(url: "https://github.com/astzweig/swiftpm-pathkit.git", from: "1.0.0")
 )
 package.targets.append(
    .target(name: "Foo", dependencies: [
        .product(name: "Path", package: "swiftpm-pathkit")
    ])
 )
 ```
-CocoaPods:
+# Naming Conflicts with `SwiftUI.Path`, etc.
-```ruby
+We have a typealias of `PathStruct` you can use instead.
 pod 'Path.swift', '~> 0.13'
 ```
 Carthage:
 > Waiting on: [@Carthage#1945](https://github.com/Carthage/Carthage/pull/1945).
 ## Pre‐1.0 status
 We are pre 1.0, thus we can change the API as we like, and we will (to the
 pursuit of getting it *right*)! We will tag 1.0 as soon as possible.
 ### Get push notifications for new releases
 https://codebasesaga.com/canopy/
 # Alternatives
@@ -327,12 +424,5 @@ https://codebasesaga.com/canopy/
 [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-orange.svg
+[badge-languages]: https://img.shields.io/badge/swift-4.2%20%7C%205.x-orange.svg
-[docs]: https://mxcl.github.io/Path.swift/Structs/Path.html
+[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
 [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
--- a/Sources/Extensions.swift
+++ b/Sources/Extensions.swift
@@ -13,26 +13,31 @@ public extension Bundle {
     Returns the path for the shared-frameworks directory in this bundle.
     - Note: This is typically `ShareFrameworks`
    */
-    var sharedFrameworks: Path {
+    var sharedFrameworks: DynamicPath {
-        return sharedFrameworksPath.flatMap(Path.init) ?? defaultSharedFrameworksPath
+        return sharedFrameworksPath.flatMap(DynamicPath.init) ?? defaultSharedFrameworksPath
    }
    /**
     Returns the path for the private-frameworks directory in this bundle.
     - Note: This is typically `Frameworks`
    */
-    var privateFrameworks: Path {
+    var privateFrameworks: DynamicPath {
-        return privateFrameworksPath.flatMap(Path.init) ?? defaultSharedFrameworksPath
+        return privateFrameworksPath.flatMap(DynamicPath.init) ?? defaultSharedFrameworksPath
    }
    /// Returns the path for the resources directory in this bundle.
-    var resources: Path {
+    var resources: DynamicPath {
-        return resourcePath.flatMap(Path.init) ?? defaultResourcesPath
+        return resourcePath.flatMap(DynamicPath.init) ?? defaultResourcesPath
    }
    /// Returns the path for this bundle.
-    var path: Path {
+    var path: DynamicPath {
-        return Path(string: bundlePath)
+        return DynamicPath(string: bundlePath)
    }
    /// Returns the executable for this bundle, if there is one, not all bundles have one hence `Optional`.
    var executable: DynamicPath? {
        return executablePath.flatMap(DynamicPath.init)
    }
 }
@@ -40,14 +45,14 @@ public extension Bundle {
 public extension String {
    /// Initializes this `String` with the contents of the provided path.
    @inlinable
-    init(contentsOf path: Path) throws {
+    init<P: Pathish>(contentsOf path: P) throws {
        try self.init(contentsOfFile: path.string)
    }
    /// - Returns: `to` to allow chaining
    @inlinable
    @discardableResult
-    func write(to: Path, atomically: Bool = false, encoding: String.Encoding = .utf8) throws -> Path {
+    func write<P: Pathish>(to: P, atomically: Bool = false, encoding: String.Encoding = .utf8) throws -> P {
        try write(toFile: to.string, atomically: atomically, encoding: encoding)
        return to
    }
@@ -57,14 +62,14 @@ public extension String {
 public extension Data {
    /// Initializes this `Data` with the contents of the provided path.
    @inlinable
-    init(contentsOf path: Path) throws {
+    init<P: Pathish>(contentsOf path: P) throws {
        try self.init(contentsOf: path.url)
    }
    /// - Returns: `to` to allow chaining
    @inlinable
    @discardableResult
-    func write(to: Path, atomically: Bool = false) throws -> Path {
+    func write<P: Pathish>(to: P, atomically: Bool = false) throws -> P {
        let opts: NSData.WritingOptions
        if atomically {
        #if !os(Linux)
@@ -84,39 +89,39 @@ public extension Data {
 public extension FileHandle {
    /// Initializes this `FileHandle` for reading at the location of the provided path.
    @inlinable
-    convenience init(forReadingAt path: Path) throws {
+    convenience init<P: Pathish>(forReadingAt path: P) throws {
        try self.init(forReadingFrom: path.url)
    }
    /// Initializes this `FileHandle` for writing at the location of the provided path.
    @inlinable
-    convenience init(forWritingAt path: Path) throws {
+    convenience init<P: Pathish>(forWritingAt path: P) throws {
        try self.init(forWritingTo: path.url)
    }
    /// Initializes this `FileHandle` for reading and writing at the location of the provided path.
    @inlinable
-    convenience init(forUpdatingAt path: Path) throws {
+    convenience init<P: Pathish>(forUpdatingAt path: P) throws {
        try self.init(forUpdating: path.url)
    }
 }
 internal extension Bundle {
-    var defaultSharedFrameworksPath: Path {
+    var defaultSharedFrameworksPath: DynamicPath {
      #if os(macOS)
-        return path.join("Contents/Frameworks")
+        return path.Contents.Frameworks
      #elseif os(Linux)
-        return path.join("lib")
+        return path.lib
      #else
-        return path.join("Frameworks")
+        return path.Frameworks
      #endif
    }
-    var defaultResourcesPath: Path {
+    var defaultResourcesPath: DynamicPath {
      #if os(macOS)
-        return path.join("Contents/Resources")
+        return path.Contents.Resources
      #elseif os(Linux)
-        return path.join("share")
+        return path.share
      #else
        return path
      #endif
--- a/Sources/Path+Attributes.swift
+++ b/Sources/Path+Attributes.swift
@@ -1,6 +1,6 @@
 import Foundation
-public extension Path {
+public extension Pathish {
    //MARK: Filesystem Attributes
    /**
@@ -30,6 +30,29 @@ public extension Path {
        }
    }
    /// The type of the entry.
    /// - SeeAlso: `Path.EntryType`
    @available(*, deprecated, message: "- SeeAlso: Path.type")
    var kind: Path.EntryType? {
        return type
    }
    /// The type of the entry.
    /// - SeeAlso: `Path.EntryType`
    var type: Path.EntryType? {
        var buf = stat()
        guard lstat(string, &buf) == 0 else {
            return nil
        }
        if buf.st_mode & S_IFMT == S_IFLNK {
            return .symlink
        } else if buf.st_mode & S_IFMT == S_IFDIR {
            return .directory
        } else {
            return .file
        }
    }
    /**
     Sets the file’s attributes using UNIX octal notation.
@@ -38,9 +61,11 @@ public extension Path {
    @discardableResult
    func chmod(_ octal: Int) throws -> Path {
        try FileManager.default.setAttributes([.posixPermissions: octal], ofItemAtPath: string)
-        return self
+        return Path(self)
    }
    //MARK: Filesystem Locking
    /**
     Applies the macOS filesystem “lock” attribute.
     - Note: If file is already locked, does nothing.
@@ -57,7 +82,7 @@ public extension Path {
            try FileManager.default.setAttributes(attrs, ofItemAtPath: string)
        }
    #endif
-        return self
+        return Path(self)
    }
    /**
@@ -73,7 +98,7 @@ public extension Path {
        do {
            attrs = try FileManager.default.attributesOfItem(atPath: string)
        } catch CocoaError.fileReadNoSuchFile {
-            return self
+            return Path(self)
        }
        let b = attrs[.immutable] as? Bool ?? false
        if b {
@@ -81,6 +106,19 @@ public extension Path {
            try FileManager.default.setAttributes(attrs, ofItemAtPath: string)
        }
    #endif
-        return self
+        return Path(self)
    }
 }
 /// The `extension` that provides `Kind`.
 public extension Path {
    /// A filesystem entry’s kind, file, directory, symlink etc.
    enum EntryType: CaseIterable {
        /// The entry is a file.
        case file
        /// The entry is a symlink.
        case symlink
        /// The entry is a directory.
        case directory
    }
 }
--- a/Sources/Path+Codable.swift
+++ b/Sources/Path+Codable.swift
@@ -30,11 +30,12 @@ extension Path: Codable {
        let value = try decoder.singleValueContainer().decode(String.self)
        if value.hasPrefix("/") {
            string = value
-        } else {
+        } else if let root = decoder.userInfo[.relativePath] as? Path {
            guard let root = decoder.userInfo[.relativePath] as? Path else {
                throw DecodingError.dataCorrupted(.init(codingPath: [], debugDescription: "Path cannot decode a relative path if `userInfo[.relativePath]` not set to a Path object."))
            }
            string = (root/value).string
        } else if let root = decoder.userInfo[.relativePath] as? DynamicPath {
            string = (root/value).string
        } else {
            throw DecodingError.dataCorrupted(.init(codingPath: [], debugDescription: "Path cannot decode a relative path if `userInfo[.relativePath]` not set to a Path object."))
        }
    }
@@ -44,6 +45,8 @@ extension Path: Codable {
        var container = encoder.singleValueContainer()
        if let root = encoder.userInfo[.relativePath] as? Path {
            try container.encode(relative(to: root))
        } else if let root = encoder.userInfo[.relativePath] as? DynamicPath {
            try container.encode(relative(to: root))
        } else {
            try container.encode(string)
        }
--- a/Sources/Path+CommonDirectories.swift
+++ b/Sources/Path+CommonDirectories.swift
@@ -1,20 +1,33 @@
 import Foundation
-extension Path {
+/// The `extension` that provides static properties that are common directories.
 private enum Foo {
    //MARK: Common Directories
    /// Returns a `Path` containing `FileManager.default.currentDirectoryPath`.
-    public static var cwd: Path {
+    static var cwd: DynamicPath {
-        return Path(string: FileManager.default.currentDirectoryPath)
+        return .init(string: FileManager.default.currentDirectoryPath)
    }
    /// Returns a `Path` representing the root path.
-    public static var root: Path {
+    static var root: DynamicPath {
-        return Path(string: "/")
+        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: Path {
+    static var home: DynamicPath {
        let string: String
      #if os(macOS)
        if #available(OSX 10.12, *) {
@@ -25,30 +38,30 @@ extension Path {
      #else
        string = NSHomeDirectory()
      #endif
-        return Path(string: string)
+        return .init(string: string)
    }
    /// Helper to allow search path and domain mask to be passed in.
-    private static func path(for searchPath: FileManager.SearchPathDirectory) -> Path {
+    private static func path(for searchPath: FileManager.SearchPathDirectory) -> DynamicPath {
    #if os(Linux)
        // the urls(for:in:) function is not implemented on Linux
        //TODO strictly we should first try to use the provided binary tool
-        let foo = { ProcessInfo.processInfo.environment[$0].flatMap(Path.init) ?? $1 }
+        let foo = { ProcessInfo.processInfo.environment[$0].flatMap(Path.init).map(DynamicPath.init) ?? $1 }
        switch searchPath {
        case .documentDirectory:
-            return Path.home/"Documents"
+            return Path.home.Documents
        case .applicationSupportDirectory:
-            return foo("XDG_DATA_HOME", Path.home/".local/share")
+            return foo("XDG_DATA_HOME", Path.home[dynamicMember: ".local/share"])
        case .cachesDirectory:
-            return foo("XDG_CACHE_HOME", Path.home/".cache")
+            return foo("XDG_CACHE_HOME", Path.home[dynamicMember: ".cache"])
        default:
            fatalError()
        }
    #else    
        guard let pathString = FileManager.default.urls(for: searchPath, in: .userDomainMask).first?.path else { return defaultUrl(for: searchPath) }
-        return Path(string: pathString)
+        return DynamicPath(string: pathString)
    #endif
    }
@@ -57,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: Path {
+    static var documents: DynamicPath {
        return path(for: .documentDirectory)
    }
@@ -66,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: Path {
+    static var caches: DynamicPath {
        return path(for: .cachesDirectory)
    }
@@ -75,23 +88,55 @@ extension Path {
     - Note: On Linux is `XDG_DATA_HOME`.
     - Note: You should create a subdirectory before creating any files.
     */
-    public static var applicationSupport: Path {
+    static var applicationSupport: DynamicPath {
        return path(for: .applicationSupportDirectory)
    }
 }
 #if !os(Linux)
-func defaultUrl(for searchPath: FileManager.SearchPathDirectory) -> Path {
+func defaultUrl(for searchPath: FileManager.SearchPathDirectory) -> DynamicPath {
    switch searchPath {
    case .documentDirectory:
-        return Path.home/"Documents"
+        return Path.home.Documents
    case .applicationSupportDirectory:
-        return Path.home/"Library/Application Support"
+        return Path.home.Library[dynamicMember: "Application Support"]
    case .cachesDirectory:
-        return Path.home/"Library/Caches"
+        return Path.home.Library.Caches
    default:
        fatalError()
    }
 }
 #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
--- a/Sources/Path+FileManager.swift
+++ b/Sources/Path+FileManager.swift
@@ -3,7 +3,8 @@ import Foundation
 import Glibc
 #endif
-public extension Path {
+public extension Pathish {
    //MARK: File Management
    /**
@@ -24,17 +25,18 @@ public extension Path {
     - SeeAlso: `copy(into:overwrite:)`
     */
    @discardableResult
-    func copy(to: Path, overwrite: Bool = false) throws -> Path {
+    func copy<P: Pathish>(to: P, overwrite: Bool = false) throws -> Path {
-        if overwrite, to.isFile, isFile {
+        if overwrite, let tokind = to.type, tokind != .directory, type != .directory {
            try FileManager.default.removeItem(at: to.url)
        }
-    #if os(Linux) && !swift(>=5.1) // check if fixed
+    #if os(Linux)
-        if !overwrite, to.isFile {
+        //NOTE doing manually due to inconsistency in Linux Foundation behavior
        if !overwrite, to.type != nil {
            throw CocoaError.error(.fileWriteFileExists)
        }
    #endif
        try FileManager.default.copyItem(atPath: string, toPath: to.string)
-        return to
+        return Path(to)
    }
    /**
@@ -60,16 +62,17 @@ public extension Path {
     - SeeAlso: `copy(to:overwrite:)`
     */
    @discardableResult
-    func copy(into: Path, overwrite: Bool = false) throws -> Path {
+    func copy<P: Pathish>(into: P, overwrite: Bool = false) throws -> Path {
-        if !into.exists {
+        if into.type == nil {
            try into.mkdir(.p)
        }
        let rv = into/basename()
-        if overwrite, rv.isFile {
+        if overwrite, let kind = rv.type, kind != .directory {
-            try rv.delete()
+            try FileManager.default.removeItem(at: rv.url)
        }
-    #if os(Linux) && !swift(>=5.1) // check if fixed
+    #if os(Linux)
-        if !overwrite, rv.isFile {
+        //NOTE doing manually due to inconsistency in Linux Foundation behavior
        if !overwrite, rv.type != nil {
            throw CocoaError.error(.fileWriteFileExists)
        }
    #endif
@@ -94,12 +97,12 @@ public extension Path {
     - SeeAlso: `move(into:overwrite:)`
     */
    @discardableResult
-    func move(to: Path, overwrite: Bool = false) throws -> Path {
+    func move<P: Pathish>(to: P, overwrite: Bool = false) throws -> Path {
-        if overwrite, to.isFile {
+        if overwrite, let kind = to.type, kind != .directory {
            try FileManager.default.removeItem(at: to.url)
        }
        try FileManager.default.moveItem(at: url, to: to.url)
-        return to
+        return Path(to)
    }
    /**
@@ -118,18 +121,22 @@ public extension Path {
     - SeeAlso: `move(to:overwrite:)`
     */
    @discardableResult
-    func move(into: Path, overwrite: Bool = false) throws -> Path {
+    func move<P: Pathish>(into: P, overwrite: Bool = false) throws -> Path {
-        if !into.exists {
+        switch into.type {
        case nil:
            try into.mkdir(.p)
-        } else if !into.isDirectory {
+            fallthrough
-            throw CocoaError.error(.fileWriteFileExists)
+        case .directory?:
        }
            let rv = into/basename()
-        if overwrite, rv.isFile {
+            if overwrite, let rvkind = rv.type, rvkind != .directory {
                try FileManager.default.removeItem(at: rv.url)
            }
            try FileManager.default.moveItem(at: url, to: rv.url)
            return rv
        case .file?, .symlink?:
            throw CocoaError.error(.fileWriteFileExists)
        }
    }
    /**
@@ -138,23 +145,24 @@ public extension Path {
     ∵ *Path.swift* doesn’t error if desired end result preexists.
     - Note: On UNIX will this function will succeed if the parent directory is writable and the current user has permission.
     - Note: This function will fail if the file or directory is “locked”
     - Note: If entry is a symlink, deletes the symlink.
     - SeeAlso: `lock()`
    */
    @inlinable
    func delete() throws {
-        if exists {
+        if type != nil {
            try FileManager.default.removeItem(at: url)
        }
    }
    /**
     Creates an empty file at this path or if the file exists, updates its modification time.
-     - Returns: `self` to allow chaining.
+     - Returns: A copy of `self` to allow chaining.
     */
    @inlinable
    @discardableResult
    func touch() throws -> Path {
-        if !exists {
+        if type == nil {
            guard FileManager.default.createFile(atPath: string, contents: nil) else {
                throw CocoaError.error(.fileWriteUnknown)
            }
@@ -167,7 +175,7 @@ public extension Path {
            try FileManager.default.setAttributes([.modificationDate: Date()], ofItemAtPath: string)
        #endif
        }
-        return self
+        return Path(self)
    }
    /**
@@ -175,7 +183,7 @@ public extension Path {
     - Parameter options: Specify `mkdir(.p)` to create intermediary directories.
     - Note: We do not error if the directory already exists (even without `.p`)
       because *Path.swift* noops if the desired end result preexists.
-     - Returns: `self` to allow chaining.
+     - Returns: A copy of `self` to allow chaining.
     */
    @discardableResult
    func mkdir(_ options: MakeDirectoryOptions? = nil) throws -> Path {
@@ -194,11 +202,11 @@ public extension Path {
            throw error
        #endif
        }
-        return self
+        return Path(self)
    }
    /**
-     Renames the file at path.
+     Renames the file (basename only) at path.
         Path.root.foo.bar.rename(to: "baz")  // => /foo/baz
@@ -217,9 +225,9 @@ public extension Path {
     - Note: If `self` does not exist, is **not** an error.
     */
    @discardableResult
-    func symlink(as: Path) throws -> Path {
+    func symlink<P: Pathish>(as: P) throws -> Path {
        try FileManager.default.createSymbolicLink(atPath: `as`.string, withDestinationPath: string)
-        return `as`
+        return Path(`as`)
    }
    /**
@@ -227,15 +235,18 @@ public extension Path {
     - Note: If into does not exist, creates the directory with intermediate directories if necessary.
     */
    @discardableResult
-    func symlink(into dir: Path) throws -> Path {
+    func symlink<P: Pathish>(into dir: P) throws -> Path {
-        if !dir.exists {
+        switch dir.type {
        case nil, .symlink?:
            try dir.mkdir(.p)
-        } else if !dir.isDirectory {
+            fallthrough
-            throw CocoaError.error(.fileWriteFileExists)
+        case .directory?:
        }
            let dst = dir/basename()
            try FileManager.default.createSymbolicLink(atPath: dst.string, withDestinationPath: string)
            return dst
        case .file?:
            throw CocoaError.error(.fileWriteFileExists)
        }
    }
 }
--- a/Sources/Path+StringConvertibles.swift
+++ b/Sources/Path+StringConvertibles.swift
@@ -11,3 +11,17 @@ extension Path: CustomDebugStringConvertible {
        return "Path(\(string))"
    }
 }
 extension DynamicPath: CustomStringConvertible {
    /// Returns `Path.string`
    public var description: String {
        return string
    }
 }
 extension DynamicPath: CustomDebugStringConvertible {
    /// Returns eg. `Path(string: "/foo")`
    public var debugDescription: String {
        return "Path(\(string))"
    }
 }
--- a/Sources/Path+ls.swift
+++ b/Sources/Path+ls.swift
@@ -1,67 +1,219 @@
 import Foundation
 /**
 A file entry from a directory listing.
 - SeeAlso: `ls()`
 */
 public struct Entry {
    /// The kind of this directory entry.
    public enum Kind {
        /// The path is a file.
        case file
        /// The path is a directory.
        case directory
    }
    /// The kind of this entry.
    public let kind: Kind
    /// The path of this entry.
    public let path: Path
 }
 public extension Path {
-    //MARK: Directory Listings
+    /// The builder for `Path.find()`
    class Finder {
        fileprivate init(path: Path) {
            self.path = path
            self.enumerator = FileManager.default.enumerator(atPath: path.string)
        }
-    /**
+        /// The `path` find operations operate on.
-     Same as the `ls -a` command ∴ output is ”shallow” and unsorted.
+        public let path: Path
-     - Parameter includeHiddenFiles: If `true`, hidden files are included in the results. Defaults to `true`.
+
-     - Important: `includeHiddenFiles` does not work on Linux
+        private let enumerator: FileManager.DirectoryEnumerator!
-     */
+
-    func ls(includeHiddenFiles: Bool = true) throws -> [Entry] {
+        /// The range of directory depths for which the find operation will return entries.
-        var opts = FileManager.DirectoryEnumerationOptions()
+        private(set) public var depth: ClosedRange<Int> = 1...Int.max {
-    #if !os(Linux)
+            didSet {
-        if !includeHiddenFiles {
+                if depth.lowerBound < 0 {
-            opts.insert(.skipsHiddenFiles)
+                    depth = 0...depth.upperBound
                }
            }
        }
        /// The kinds of filesystem entries find operations will return.
        public var types: Set<EntryType> {
            return _types ?? Set(EntryType.allCases)
        }
        private var _types: Set<EntryType>?
        /// 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
    }
 }
 extension Path.Finder: Sequence, IteratorProtocol {
    public func next() -> Path? {
        guard let enumerator = enumerator else {
            return nil
        }
        while let relativePath = enumerator.nextObject() as? String {
            let path = self.path/relativePath
          #if !os(Linux) || swift(>=5.0)
            if enumerator.level > depth.upperBound {
                enumerator.skipDescendants()
                continue
            }
            if enumerator.level < depth.lowerBound {
                continue
            }
            if !hidden, path.basename().hasPrefix(".") {
                enumerator.skipDescendants()
                continue
            }
          #endif
-        let paths = try FileManager.default.contentsOfDirectory(at: url, includingPropertiesForKeys: nil, options: opts)
+            if let type = path.type, !types.contains(type) { continue }
-        func convert(url: URL) -> Entry? {
+            if let exts = extensions, !exts.contains(path.extension) { continue }
            return path
        }
        return nil
    }
    public typealias Element = Path
 }
 public extension Path.Finder {
    /// A max depth of `0` returns only the path we are searching, `1` is that directory’s listing.
    func depth(max maxDepth: Int) -> Path.Finder {
    #if os(Linux) && !swift(>=5.0)
        fputs("warning: depth not implemented for Swift < 5\n", stderr)
    #endif
        depth = Swift.min(maxDepth, depth.lowerBound)...maxDepth
        return self
    }
    /// A min depth of `0` also returns the path we are searching, `1` is that directory’s listing. Default is `1` thus not returning ourself.
    func depth(min minDepth: Int) -> Path.Finder {
      #if os(Linux) && !swift(>=5.0)
        fputs("warning: depth not implemented for Swift < 5\n", stderr)
      #endif
        depth = minDepth...Swift.max(depth.upperBound, minDepth)
        return self
    }
    /// A max depth of `0` returns only the path we are searching, `1` is that directory’s listing.
    /// A min depth of `0` also returns the path we are searching, `1` is that directory’s listing. Default is `1` thus not returning ourself.
    func depth(_ rng: Range<Int>) -> Path.Finder {
      #if os(Linux) && !swift(>=5.0)
        fputs("warning: depth not implemented for Swift < 5\n", stderr)
      #endif
        depth = rng.lowerBound...(rng.upperBound - 1)
        return self
    }
    /// A max depth of `0` returns only the path we are searching, `1` is that directory’s listing.
    /// A min depth of `0` also returns the path we are searching, `1` is that directory’s listing. Default is `1` thus not returning ourself.
    func depth(_ rng: ClosedRange<Int>) -> Path.Finder {
      #if os(Linux) && !swift(>=5.0)
        fputs("warning: depth not implemented for Swift < 5\n", stderr)
      #endif
        depth = rng
        return self
    }
    /// Multiple calls will configure the Finder with multiple kinds.
    func type(_ type: Path.EntryType) -> Path.Finder {
        _types = _types ?? []
        _types!.insert(type)
        return self
    }
    /// Multiple calls will configure the Finder with for multiple extensions
    func `extension`(_ ext: String) -> Path.Finder {
        extensions = extensions ?? []
        extensions!.insert(ext)
        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.
        case skip
        /// Stop enumerating all together.
        case abort
        /// Keep going.
        case `continue`
    }
    /// Enumerate, one file at a time.
    func execute(_ closure: (Path) throws -> ControlFlow) rethrows {
        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:
                continue
            }
        }
    }
 }
 public extension Pathish {
    //MARK: Directory Listing
    /**
     Same as the `ls` command ∴ output is ”shallow” and unsorted.
     - Note: as per `ls`, by default we do *not* return hidden files. Specify `.a` for hidden files.
     - Parameter options: Configure the listing.
     - Important: On Linux the listing is always `ls -a`
     */
    func ls(_ options: ListDirectoryOptions? = nil) -> [Path] {
        guard let urls = try? FileManager.default.contentsOfDirectory(at: url, includingPropertiesForKeys: nil) else {
            fputs("warning: could not list: \(self)\n", stderr)
            return []
        }
        return urls.compactMap { url in
            guard let path = Path(url.path) else { return nil }
-            return Entry(kind: path.isDirectory ? .directory : .file, path: path)
+            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()
    }
-        return paths.compactMap(convert)
+
    /// Recursively find files under this path. If the path is a file, no files will be found.
    func find() -> Path.Finder {
        return .init(path: Path(self))
    }
 }
-/// Convenience functions for the array return value of `Path.ls()`
+/// Convenience functions for the arrays of `Path`
-public extension Array where Element == Entry {
+public extension Array where Element == Path {
-    /// Filters the list of entries to be a list of Paths that are directories.
+    /// Filters the list of entries to be a list of Paths that are directories. Symlinks to directories are not returned.
    var directories: [Path] {
-        return compactMap {
+        return filter {
-            $0.kind == .directory ? $0.path : nil
+            $0.isDirectory
        }
    }
-    /// Filters the list of entries to be a list of Paths that are files.
+    /// Filters the list of entries to be a list of Paths that exist and are *not* directories. Thus expect symlinks, etc.
    /// - Note: symlinks that point to files that do not exist are *not* returned.
    var files: [Path] {
-        return compactMap {
+        return filter {
-            $0.kind == .file ? $0.path : nil
+            switch $0.type {
            case .none, .directory?:
                return false
            case .file?, .symlink?:
                return true
            }
        }
    }
 }
-    /// Filters the list of entries to be a list of Paths that are files with the specified extension.
+/// Options for `Path.ls(_:)`
-    func files(withExtension ext: String) -> [Path] {
+public enum ListDirectoryOptions {
-        return compactMap {
+    /// Lists hidden files also
-            $0.kind == .file && $0.path.extension == ext ? $0.path : nil
+    case a
        }
    }
 }
--- a/Sources/Path.swift
+++ b/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.
@@ -32,11 +34,16 @@ let _realpath = Glibc.realpath
     let p1 = Path.root.usr.bin.ls  // => /usr/bin/ls
- - Note: A `Path` does not necessarily represent an actual filesystem entry.
+ However we only provide this support off of the static members like `root` due
- */
+ to the anti-pattern where Path.swift suddenly feels like Javascript otherwise.
-@dynamicMemberLookup
+ - Note: A `Path` does not necessarily represent an actual filesystem entry.
-public struct Path: Equatable, Hashable, Comparable {
+ - SeeAlso: `Pathish` for most methods you will use on `Path` instances.
 */
 public struct Path: Pathish {
    /// The normalized string representation of the underlying filesystem path
    public let string: String
    init(string: String) {
        assert(string.first == "/")
@@ -53,14 +60,28 @@ public struct Path: Equatable, Hashable, Comparable {
     - Note: On macOS, removes an initial component of “/private/var/automount”, “/var/automount”, or “/private” from the path, if the result still indicates an existing file or directory (checked by consulting the file system).
     - Returns: The path or `nil` if fed a relative path or a `~foo` string where there is no user `foo`.
     */
-    public init?(_ description: String) {
+    public init?<S: StringProtocol>(_ description: S) {
        var pathComponents = description.split(separator: "/")
        switch description.first {
        case "/":
-            break
+        #if os(macOS)
            func ifExists(withPrefix prefix: String, removeFirst n: Int) {
                assert(prefix.split(separator: "/").count == n)
                if description.hasPrefix(prefix), FileManager.default.fileExists(atPath: String(description)) {
                    pathComponents.removeFirst(n)
                }
            }
            ifExists(withPrefix: "/private/var/automount", removeFirst: 3)
            ifExists(withPrefix: "/var/automount", removeFirst: 2)
            ifExists(withPrefix: "/private", removeFirst: 1)
        #endif
            string = join_(prefix: "/", pathComponents: pathComponents)
        case "~":
            if description == "~" {
-                self = Path.home
+                string = Path.home.string
                return
            }
            let tilded: String
@@ -82,26 +103,11 @@ public struct Path: Equatable, Hashable, Comparable {
            #endif
            }
            pathComponents.remove(at: 0)
-            pathComponents.insert(contentsOf: tilded.split(separator: "/"), at: 0)
+            string = join_(prefix: tilded, pathComponents: pathComponents)
        default:
            return nil
        }
    #if os(macOS)
        func ifExists(withPrefix prefix: String, removeFirst n: Int) {
            assert(prefix.split(separator: "/").count == n)
            if description.hasPrefix(prefix), FileManager.default.fileExists(atPath: description) {
                pathComponents.removeFirst(n)
            }
        }
        ifExists(withPrefix: "/private/var/automount", removeFirst: 3)
        ifExists(withPrefix: "/var/automount", removeFirst: 2)
        ifExists(withPrefix: "/private", removeFirst: 1)
    #endif
        self.string = join_(prefix: "/", pathComponents: pathComponents)
    }
    /**
@@ -125,20 +131,17 @@ public struct Path: Equatable, Hashable, Comparable {
        // ^^ works even if the url is a file-reference url
    }
-    /// :nodoc:
+    /// Converts anything that is `Pathish` to a `Path`
-    public subscript(dynamicMember addendum: String) -> Path {
+    public init<P: Pathish>(_ path: P) {
-        //NOTE it’s possible for the string to be anything if we are invoked via
+        string = path.string
-        // explicit subscript thus we use our fully sanitized `join` function
+    }
        return Path(string: join_(prefix: string, appending: addendum))
 }
-//MARK: Properties
+public extension Pathish {
-
+    //MARK: Filesystem Representation
    /// The underlying filesystem path
    public let string: String
    /// Returns a `URL` representing this file path.
-    public var url: URL {
+    var url: URL {
        return URL(fileURLWithPath: string)
    }
@@ -148,7 +151,7 @@ public struct Path: Equatable, Hashable, Comparable {
     - SeeAlso: https://developer.apple.com/documentation/foundation/nsurl/1408631-filereferenceurl
     - Important: On Linux returns an file scheme NSURL for this path string.
     */
-    public var fileReferenceURL: NSURL? {
+    var fileReferenceURL: NSURL? {
    #if !os(Linux)
        // https://bugs.swift.org/browse/SR-2728
        return (url as NSURL).perform(#selector(NSURL.fileReferenceURL))?.takeUnretainedValue() as? NSURL
@@ -165,8 +168,9 @@ public struct Path: Equatable, Hashable, Comparable {
     - Note: always returns a valid path, `Path.root.parent` *is* `Path.root`.
     */
-    public var parent: Path {
+    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))
    }
@@ -175,10 +179,10 @@ public struct Path: Equatable, Hashable, Comparable {
     Returns the filename extension of this path.
     - Remark: If there is no extension returns "".
     - Remark: If the filename ends with any number of ".", returns "".
-     - Note: We special case eg. `foo.tar.gz`.
+     - Note: We special case eg. `foo.tar.gz`—there are a limited number of these specializations, feel free to PR more.
     */
    @inlinable
-    public var `extension`: String {
+    var `extension`: String {
        //FIXME efficiency
        switch true {
        case string.hasSuffix(".tar.gz"):
@@ -200,7 +204,16 @@ public struct Path: Equatable, Hashable, Comparable {
        }
    }
-//MARK: Pathing
+    /**
     Splits the string representation on the directory separator.
     - Important: `NSString.pathComponents` will always return an initial `/` in its array for absolute paths to indicate that the path was absolute, we don’t do this because we are *always* absolute paths.
    */
    @inlinable
    var components: [String] {
        return string.split(separator: "/").map(String.init)
    }
    //MARK:- Pathing
    /**
     Joins a path and a string to produce a new path.
@@ -217,7 +230,7 @@ public struct Path: Equatable, Hashable, Comparable {
     - Returns: A new joined path.
     - SeeAlso: `Path./(_:_:)`
     */
-    public func join<S>(_ addendum: S) -> Path where S: StringProtocol {
+    func join<S>(_ addendum: S) -> Path where S: StringProtocol {
        return Path(string: join_(prefix: string, appending: addendum))
    }
@@ -238,7 +251,7 @@ public struct Path: Equatable, Hashable, Comparable {
     - SeeAlso: `join(_:)`
     */
    @inlinable
-    public static func /<S>(lhs: Path, rhs: S) -> Path where S: StringProtocol {
+    static func /<S>(lhs: Self, rhs: S) -> Path where S: StringProtocol {
        return lhs.join(rhs)
    }
@@ -249,7 +262,7 @@ public struct Path: Equatable, Hashable, Comparable {
     - Parameter base: The base to which we calculate the relative path.
     - ToDo: Another variant that returns `nil` if result would start with `..`
     */
-    public func relative(to base: Path) -> String {
+    func relative<P: Pathish>(to base: P) -> String {
        // Split the two paths into their components.
        // FIXME: The is needs to be optimized to avoid unncessary copying.
        let pathComps = (string as NSString).pathComponents
@@ -288,7 +301,7 @@ public struct Path: Equatable, Hashable, Comparable {
     - Returns: A string that is the filename’s basename.
     - Parameter dropExtension: If `true` returns the basename without its file extension.
     */
-    public func basename(dropExtension: Bool = false) -> String {
+    func basename(dropExtension: Bool = false) -> String {
        var lastPathComponent: Substring {
            let slash = string.lastIndex(of: "/")!
            let index = string.index(after: slash)
@@ -313,27 +326,25 @@ public struct Path: Equatable, Hashable, Comparable {
     If the path represents an actual entry that is a symlink, returns the symlink’s
     absolute destination.
-     - Important: This is not exhaustive, the resulting path may still contain
+     - Important: This is not exhaustive, the resulting path may still contain a symlink.
-     symlink.
+     - Important: The path will only be different if the last path component is a symlink, any symlinks in prior components are not resolved.
     - Important: The path will only be different if the last path component is a
     symlink, any symlinks in prior components are not resolved.
     - Note: If file exists but isn’t a symlink, returns `self`.
     - Note: If symlink destination does not exist, is **not** an error.
     */
-    public func readlink() throws -> Path {
+    func readlink() throws -> Path {
        do {
            let rv = try FileManager.default.destinationOfSymbolicLink(atPath: string)
            return Path(rv) ?? parent/rv
        } catch CocoaError.fileReadUnknown {
            // file is not symlink, return `self`
            assert(exists)
-            return self
+            return Path(string: string)
        } catch {
        #if os(Linux)
            // ugh: Swift on Linux
            let nsError = error as NSError
            if nsError.domain == NSCocoaErrorDomain, nsError.code == CocoaError.fileReadUnknown.rawValue, exists {
-                return self
+                return Path(self)
            }
        #endif
            throw error
@@ -341,7 +352,7 @@ public struct Path: Equatable, Hashable, Comparable {
    }
    /// Recursively resolves symlinks in this path.
-    public func realpath() throws -> Path {
+    func realpath() throws -> Path {
        guard let rv = _realpath(string, nil) else { throw CocoaError.error(.fileNoSuchFile) }
        defer { free(rv) }
        guard let rvv = String(validatingUTF8: rv) else { throw CocoaError.error(.fileReadUnknownStringEncoding) }
@@ -359,7 +370,7 @@ public struct Path: Equatable, Hashable, Comparable {
    /// Returns the locale-aware sort order for the two paths.
    /// :nodoc:
    @inlinable
-    public static func <(lhs: Path, rhs: Path) -> Bool {
+    static func <(lhs: Self, rhs: Self) -> Bool {
        return lhs.string.compare(rhs.string, locale: .current) == .orderedAscending
    }
 }
@@ -398,3 +409,27 @@ private func join_<S>(prefix: String, pathComponents: S) -> String where S: Sequ
    }
    return rv
 }
 /// A path that supports arbituary dot notation, eg. `Path.root.usr.bin`
@dynamicMemberLookup
 public struct DynamicPath: Pathish {
    /// The normalized string representation of the underlying filesystem path
    public let string: String
    init(string: String) {
        assert(string.hasPrefix("/"))
        self.string = string
    }
    /// Converts a `Path` to a `DynamicPath`
    public init<P: Pathish>(_ path: P) {
        string = path.string
    }
    /// :nodoc:
    public subscript(dynamicMember addendum: String) -> DynamicPath {
        //NOTE it’s possible for the string to be anything if we are invoked via
        // explicit subscript thus we use our fully sanitized `join` function
        return DynamicPath(string: join_(prefix: string, appending: addendum))
    }
 }
--- a/Sources/PathToBool.swift
+++ b/Sources/PathToBool.swift
@@ -5,10 +5,15 @@ import func Glibc.access
 import Darwin
 #endif
-public extension Path {
+public extension Pathish {
    //MARK: Filesystem Properties
-    /// Returns true if the path represents an actual filesystem entry.
+    /**
     - Returns: `true` if the path represents an actual filesystem entry.
     - Note: If `self` is a symlink the return value represents the destination, thus if the destination doesn’t exist this returns `false` even if the symlink exists.
     - Note: To determine if a symlink exists, use `.type`.
     */
    var exists: Bool {
        return FileManager.default.fileExists(atPath: string)
    }
--- a/Sources/Pathish.swift
+++ b/Sources/Pathish.swift
@@ -0,0 +1,6 @@
 /// A type that represents a filesystem path, if you conform your type
 /// to `Pathish` it is your responsibility to ensure the string is correctly normalized
 public protocol Pathish: Hashable, Comparable {
    /// The normalized string representation of the underlying filesystem path
    var string: String { get }
 }
--- a/Tests/PathTests/PathTests+ls().swift
+++ b/Tests/PathTests/PathTests+ls().swift
@@ -0,0 +1,251 @@
 import XCTest
 import PathKit
 extension PathTests {
    func testFindMaxDepth1() throws {
        try Path.mktemp { tmpdir in
            try tmpdir.a.touch()
            try tmpdir.b.touch()
            try tmpdir.c.mkdir().join("e").touch()
            do {
                let finder = tmpdir.find().depth(max: 1)
                XCTAssertEqual(finder.depth, 1...1)
              #if !os(Linux) || swift(>=5)
                XCTAssertEqual(Set(finder), Set([tmpdir.a, tmpdir.b, tmpdir.c].map(Path.init)))
              #endif
            }
            do {
                let finder = tmpdir.find().depth(max: 0)
                XCTAssertEqual(finder.depth, 0...0)
              #if !os(Linux) || swift(>=5)
                XCTAssertEqual(Set(finder), Set())
              #endif
            }
        }
    }
    func testFindMaxDepth2() 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()
            do {
                let finder = tmpdir.find().depth(max: 2)
                XCTAssertEqual(finder.depth, 1...2)
              #if !os(Linux) || swift(>=5)
                XCTAssertEqual(
                    Set(finder),
                    Set([tmpdir.a, tmpdir.b, tmpdir.b.d, tmpdir.b.c].map(Path.init)))
              #endif
            }
            do {
                let finder = tmpdir.find().depth(max: 3)
                XCTAssertEqual(finder.depth, 1...3)
              #if !os(Linux) || swift(>=5)
                XCTAssertEqual(
                    Set(finder),
                    Set([tmpdir.a, tmpdir.b, tmpdir.b.d, tmpdir.b.c, tmpdir.b.d.e].map(Path.init)))
              #endif
            }
        }
    }
    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()
            try tmpdir.join("bar.txt").touch()
            XCTAssertEqual(
                Set(tmpdir.find().extension("json")),
                [tmpdir.join("foo.json")])
            XCTAssertEqual(
                Set(tmpdir.find().extension("txt").extension("json")),
                [tmpdir.join("foo.json"), tmpdir.join("bar.txt")])
        }
    }
    //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()
            try tmpdir.bar.touch()
            XCTAssertEqual(
                Set(tmpdir.find().type(.file)),
                [tmpdir.join("bar")])
            XCTAssertEqual(
                Set(tmpdir.find().type(.directory)),
                [tmpdir.join("foo")])
            XCTAssertEqual(
                Set(tmpdir.find().type(.file).type(.directory)),
                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())
        }
    }
 }
--- a/Tests/PathTests/PathTests.swift
+++ b/Tests/PathTests/PathTests.swift
@@ -1,7 +1,22 @@
-@testable import Path
+@testable import PathKit
 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)
@@ -18,32 +33,31 @@ class PathTests: XCTestCase {
    func testEnumeration() throws {
        let tmpdir_ = try TemporaryDirectory()
        let tmpdir = tmpdir_.path
-        try tmpdir.a.mkdir().c.touch()
+        try tmpdir.join("a").mkdir().join("c").touch()
        try tmpdir.join("b.swift").touch()
-        try tmpdir.c.touch()
+        try tmpdir.join("c").touch()
-        try tmpdir.join(".d").mkdir().e.touch()
+        try tmpdir.join(".d").mkdir().join("e").touch()
        var paths = Set<String>()
-        let lsrv = try tmpdir.ls()
+        let lsrv = tmpdir.ls(.a)
        var dirs = 0
-        for entry in lsrv {
+        for path in lsrv {
-            if entry.kind == .directory {
+            if path.isDirectory {
                dirs += 1
            }
-            paths.insert(entry.path.basename())
+            paths.insert(path.basename())
        }
        XCTAssertEqual(dirs, 2)
        XCTAssertEqual(dirs, lsrv.directories.count)
        XCTAssertEqual(["a", ".d"], Set(lsrv.directories.map{ $0.relative(to: tmpdir) }))
        XCTAssertEqual(["b.swift", "c"], Set(lsrv.files.map{ $0.relative(to: tmpdir) }))
-        XCTAssertEqual(["b.swift"], Set(lsrv.files(withExtension: "swift").map{ $0.relative(to: tmpdir) }))
+        XCTAssertEqual(["b.swift"], Set(lsrv.files.filter{ $0.extension == "swift" }.map{ $0.relative(to: tmpdir) }))
-        XCTAssertEqual(["c"], Set(lsrv.files(withExtension: "").map{ $0.relative(to: tmpdir) }))
+        XCTAssertEqual(["c"], Set(lsrv.files.filter{ $0.extension == "" }.map{ $0.relative(to: tmpdir) }))
        XCTAssertEqual(paths, ["a", "b.swift", "c", ".d"])
    }
    func testEnumerationSkippingHiddenFiles() throws {
    #if !os(Linux)
        let tmpdir_ = try TemporaryDirectory()
        let tmpdir = tmpdir_.path
        try tmpdir.join("a").mkdir().join("c").touch()
@@ -53,25 +67,33 @@ class PathTests: XCTestCase {
        var paths = Set<String>()
        var dirs = 0
-        for entry in try tmpdir.ls(includeHiddenFiles: false) {
+        for path in tmpdir.ls() {
-            if entry.kind == .directory {
+            if path.isDirectory {
                dirs += 1
            }
-            paths.insert(entry.path.basename())
+            paths.insert(path.basename())
        }
        XCTAssertEqual(dirs, 1)
        XCTAssertEqual(paths, ["a", "b", "c"])
    #endif
    }
    func testRelativeTo() {
-        XCTAssertEqual((Path.root/"tmp/foo").relative(to: .root/"tmp"), "foo")
+        XCTAssertEqual((Path.root.tmp.foo).relative(to: Path.root/"tmp"), "foo")
-        XCTAssertEqual((Path.root/"tmp/foo/bar").relative(to: .root/"tmp/baz"), "../foo/bar")
+        XCTAssertEqual((Path.root.tmp.foo.bar).relative(to: Path.root/"tmp/baz"), "../foo/bar")
    }
-    func testExists() {
+    func testExists() throws {
        XCTAssert(Path.root.exists)
        XCTAssert((Path.root/"bin").exists)
        try Path.mktemp { tmpdir in
            XCTAssertTrue(tmpdir.exists)
            XCTAssertFalse(try tmpdir.bar.symlink(as: tmpdir.foo).exists)
            XCTAssertTrue(tmpdir.foo.type == .symlink)
            XCTAssertTrue(try tmpdir.bar.touch().symlink(as: tmpdir.baz).exists)
            XCTAssertTrue(tmpdir.bar.type == .file)
            XCTAssertTrue(tmpdir.type == .directory)
        }
    }
    func testIsDirectory() {
@@ -96,7 +118,7 @@ class PathTests: XCTestCase {
    }
    func testMktemp() throws {
-        var path: Path!
+        var path: DynamicPath!
        try Path.mktemp {
            path = $0
            XCTAssert(path.isDirectory)
@@ -124,7 +146,7 @@ class PathTests: XCTestCase {
    }
    func testCodable() throws {
-        let input = [Path.root.foo, Path.root.foo.bar, Path.root]
+        let input = [Path.root.foo, Path.root.foo.bar, Path.root].map(Path.init)
        XCTAssertEqual(try JSONDecoder().decode([Path].self, from: try JSONEncoder().encode(input)), input)
    }
@@ -134,18 +156,24 @@ class PathTests: XCTestCase {
            Path.root,
            root,
            root.bar
-        ]
+        ].map(Path.init)
        let encoder = JSONEncoder()
-        encoder.userInfo[.relativePath] = root
+
        func test<P: Pathish>(relativePath: P, line: UInt = #line) throws {
            encoder.userInfo[.relativePath] = relativePath
            let data = try encoder.encode(input)
-        XCTAssertEqual(try JSONSerialization.jsonObject(with: data) as? [String], ["..", "", "bar"])
+            XCTAssertEqual(try JSONSerialization.jsonObject(with: data) as? [String], ["..", "", "bar"], line: line)
            let decoder = JSONDecoder()
-        XCTAssertThrowsError(try decoder.decode([Path].self, from: data))
+            XCTAssertThrowsError(try decoder.decode([Path].self, from: data), line: line)
-        decoder.userInfo[.relativePath] = root
+            decoder.userInfo[.relativePath] = relativePath
-        XCTAssertEqual(try decoder.decode([Path].self, from: data), input)
+            XCTAssertEqual(try decoder.decode([Path].self, from: data), input, line: line)
        }
        try test(relativePath: root)       // DynamicPath
        try test(relativePath: Path(root)) // Path
    }
    func testJoin() {
@@ -177,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")
@@ -184,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 {
@@ -195,7 +231,9 @@ class PathTests: XCTestCase {
            XCTAssertThrowsError(try root.foo.copy(to: root.bar))
            try root.foo.copy(to: root.bar, overwrite: true)
        }
    }
    func testCopyToExistingDirectoryFails() throws {
        // test copy errors if directory exists at destination, even with overwrite
        try Path.mktemp { root in
            try root.foo.touch()
@@ -288,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)
@@ -302,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 {
@@ -354,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 foo = try tmpdir.foo.touch()
-            let now2 = Date().timeIntervalSince1970.rounded(.down)
+        #if !os(Linux)
-            XCTAssertNotEqual(now1, now2)
+            XCTAssertGreaterThan(foo.ctime?.timeIntervalSince1970.rounded(.down) ?? 0, now1)  //FIXME flakey
-            XCTAssertEqual(foo.mtime?.timeIntervalSince1970.rounded(.down), now2)  //FIXME flakey
+        #endif
            XCTAssertGreaterThan(foo.mtime?.timeIntervalSince1970.rounded(.down) ?? 0, now1)  //FIXME flakey
            XCTAssertNil(tmpdir.void.mtime)
            XCTAssertNil(tmpdir.void.ctime)
@@ -379,11 +422,29 @@ class PathTests: XCTestCase {
        #if !os(Linux)
            XCTAssertThrowsError(try tmpdir.bar3.touch().lock().delete())
        #endif
            // regression test: can delete a symlink that points to a non-existent file
            let bar5 = try tmpdir.bar4.symlink(as: tmpdir.bar5)
            XCTAssertEqual(bar5.type, .symlink)
            XCTAssertFalse(bar5.exists)
            XCTAssertNoThrow(try bar5.delete())
            XCTAssertEqual(bar5.type, nil)
            // test that deleting a symlink *only* deletes the symlink
            let bar7 = try tmpdir.bar6.touch().symlink(as: tmpdir.bar7)
            XCTAssertEqual(bar7.type, .symlink)
            XCTAssertTrue(bar7.exists)
            XCTAssertNoThrow(try bar7.delete())
            XCTAssertEqual(bar7.type, nil)
            XCTAssertEqual(tmpdir.bar6.type, .file)
            // for code-coverage
            XCTAssertEqual(tmpdir.bar6.kind, .file)
        }
    }
    func testRelativeCodable() throws {
-        let path = Path.home.foo
+        let path = Path(Path.home.foo)
        let encoder = JSONEncoder()
        encoder.userInfo[.relativePath] = Path.home
        let data = try encoder.encode([path])
@@ -391,23 +452,26 @@ class PathTests: XCTestCase {
        decoder.userInfo[.relativePath] = Path.home
        XCTAssertEqual(try decoder.decode([Path].self, from: data), [path])
        decoder.userInfo[.relativePath] = Path.documents
-        XCTAssertEqual(try decoder.decode([Path].self, from: data), [Path.documents.foo])
+        XCTAssertEqual(try decoder.decode([Path].self, from: data), [Path(Path.documents.foo)])
        XCTAssertThrowsError(try JSONDecoder().decode([Path].self, from: data))
    }
    func testBundleExtensions() throws {
-        try Path.mktemp { tmpdir in
+        try Path.mktemp { tmpdir -> Void in
-            let bndl = Bundle(path: tmpdir.string)!
+            guard let bndl = Bundle(path: tmpdir.string) else {
                return XCTFail("Couldn’t make Bundle for \(tmpdir)")
            }
            XCTAssertEqual(bndl.path, tmpdir)
            XCTAssertEqual(bndl.sharedFrameworks, tmpdir.SharedFrameworks)
            XCTAssertEqual(bndl.privateFrameworks, tmpdir.Frameworks)
            XCTAssertEqual(bndl.resources, tmpdir)
            XCTAssertNil(bndl.path(forResource: "foo", ofType: "bar"))
            XCTAssertNil(bndl.executable)
        #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
@@ -459,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)
        }
    }
@@ -488,7 +563,7 @@ class PathTests: XCTestCase {
            let foo = try tmpdir.foo.touch()
            let bar = try tmpdir.bar.mkdir()
            XCTAssertThrowsError(try foo.symlink(as: bar))
-            XCTAssert(try foo.symlink(as: bar.foo).isSymlink)
+            XCTAssert(try foo.symlink(as: bar/"foo").isSymlink)
        }
    }
@@ -543,8 +618,8 @@ class PathTests: XCTestCase {
        try Path.mktemp { tmpdir in
            let foo = try tmpdir.foo.mkdir()
-            try foo.bar.mkdir().fuz.touch()
+            try foo.join("bar").mkdir().join("fuz").touch()
-            let baz = try foo.symlink(as: tmpdir.baz)
+            let baz = DynamicPath(try foo.symlink(as: tmpdir.baz))
            XCTAssert(baz.isSymlink)
            XCTAssert(baz.bar.isDirectory)
            XCTAssertEqual(baz.bar.join("..").string, "\(tmpdir)/baz")
@@ -557,7 +632,7 @@ class PathTests: XCTestCase {
        try Path.mktemp { tmpdir in
            let b = try tmpdir.a.b.mkdir(.p)
            let c = try tmpdir.a.c.touch()
-            let e = try c.symlink(as: b.e)
+            let e = try c.symlink(as: b/"e")
            let f = try e.symlink(as: tmpdir.f)
            XCTAssertEqual(try f.readlink(), e)
            XCTAssertEqual(try f.realpath(), c)
@@ -588,4 +663,35 @@ class PathTests: XCTestCase {
        XCTAssertNil(Path("../foo"))
        XCTAssertNil(Path("./foo"))
    }
    func testPathComponents() throws {
        XCTAssertEqual(Path.root.foo.bar.components, ["foo", "bar"])
        XCTAssertEqual(Path.root.components, [])
    }
    func testFlatMap() throws {
        // testing compile works
        let foo: String? = "/a"
        _ = foo.flatMap(Path.init)
        let bar: Substring? = "/a"
        _ = bar.flatMap(Path.init)
        let baz: String.SubSequence? = "/a/b:1".split(separator: ":").first
        _ = baz.flatMap(Path.init)
    }
    func testKind() throws {
        try Path.mktemp { tmpdir in
            let foo = try tmpdir.foo.touch()
            let bar = try foo.symlink(as: tmpdir.bar)
            XCTAssertEqual(tmpdir.type, .directory)
            XCTAssertEqual(foo.type, .file)
            XCTAssertEqual(bar.type, .symlink)
        }
    }
    func testOptionalInitializer() throws {
        XCTAssertNil(Path(""))
        XCTAssertNil(Path("./foo"))
        XCTAssertEqual(Path("/foo"), Path.root.foo)
    }
 }
--- a/Tests/PathTests/TemporaryDirectory.swift
+++ b/Tests/PathTests/TemporaryDirectory.swift
@@ -1,9 +1,9 @@
-@testable import Path
+@testable import PathKit
 import Foundation
 class TemporaryDirectory {
    let url: URL
-    var path: Path { return Path(string: url.path) }
+    var path: DynamicPath { return DynamicPath(Path(string: url.path)) }
    /**
     Creates a new temporary directory.
@@ -51,7 +51,7 @@ class TemporaryDirectory {
 }
 extension Path {
-    static func mktemp<T>(body: (Path) throws -> T) throws -> T {
+    static func mktemp<T>(body: (DynamicPath) throws -> T) throws -> T {
        let tmp = try TemporaryDirectory()
        return try body(tmp.path)
    }
--- a/Tests/PathTests/XCTestManifests.swift
+++ b/Tests/PathTests/XCTestManifests.swift
@@ -1,7 +1,11 @@
 #if !canImport(ObjectiveC)
 import XCTest
 extension PathTests {
-    static let __allTests = [
+    // DO NOT MODIFY: This is autogenerated, use:
    //   `swift test --generate-linuxmain`
    // to regenerate.
    static let __allTests__PathTests = [
        ("testBasename", testBasename),
        ("testBundleExtensions", testBundleExtensions),
        ("testCodable", testCodable),
@@ -9,6 +13,7 @@ extension PathTests {
        ("testConcatenation", testConcatenation),
        ("testCopyInto", testCopyInto),
        ("testCopyTo", testCopyTo),
        ("testCopyToExistingDirectoryFails", testCopyToExistingDirectoryFails),
        ("testDataExtensions", testDataExtensions),
        ("testDelete", testDelete),
        ("testDynamicMember", testDynamicMember),
@@ -19,15 +24,33 @@ 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),
        ("testIsDirectory", testIsDirectory),
        ("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),
        ("testReadlinkOnRelativeSymlink", testReadlinkOnRelativeSymlink),
@@ -47,10 +70,9 @@ extension PathTests {
    ]
 }
 #if !os(macOS)
 public func __allTests() -> [XCTestCaseEntry] {
    return [
-        testCase(PathTests.__allTests),
+        testCase(PathTests.__allTests__PathTests),
    ]
 }
 #endif
--- a/Tests/PathTests/etc.swift
+++ b/Tests/PathTests/etc.swift
@@ -0,0 +1,43 @@
 import XCTest
 import PathKit
 #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
Author	SHA1	Message	Date
T. R. Bernstein	5d164c34f3	Adapt for new repository Some checks failed CI / verify-linuxmain (push) Has been cancelled Details CI / apple (macos-10.15, iOS) (push) Has been cancelled Details CI / apple (macos-10.15, macOS) (push) Has been cancelled Details CI / apple (macos-10.15, tvOS) (push) Has been cancelled Details CI / apple (macos-10.15, watchOS) (push) Has been cancelled Details CI / apple (macos-11, iOS) (push) Has been cancelled Details CI / apple (macos-11, macOS) (push) Has been cancelled Details CI / apple (macos-11, tvOS) (push) Has been cancelled Details CI / apple (macos-11, watchOS) (push) Has been cancelled Details CI / linux (swift:4.2) (push) Has been cancelled Details CI / linux (swift:5.0) (push) Has been cancelled Details CI / linux (swift:5.1) (push) Has been cancelled Details CI / linux (swift:5.2) (push) Has been cancelled Details CI / linux (swift:5.3) (push) Has been cancelled Details CI / linux (swift:5.4) (push) Has been cancelled Details CI / linux (swiftlang/swift:nightly-5.5) (push) Has been cancelled Details	2025-09-30 17:25:19 +02:00
Max Howell	dbdc3aeef6	participate in tea protocol	2024-02-22 05:59:31 -05:00
Dave Kolas	8e355c28e9	Rename Path->Bool.swift to PathToBool.swift Makes path Windows-friendly	2023-10-24 10:24:59 -04:00
Max Howell	46b0cd883b	Document `PathStruct`	2023-06-27 10:13:35 -04:00
Max Howell	9c6f807b0a	Merge pull request #77 from ConfusedVorlon/find_hidden_modifier Find hidden modifier	2021-07-30 12:28:04 -04:00
Rob Jonson	dad3d84040	don't implement hidden(false) for swift < 5 and provide a warning	2021-07-30 17:09:37 +01:00
Rob Jonson	5377bceb5f	Update linux test list	2021-07-28 22:29:02 +01:00
Rob Jonson	f593437cf5	make find() configurable to ignore hidden files & directories	2021-07-28 15:12:09 +01:00
Rob Jonson	6e8a42f01d	Fix assert error message	2021-07-28 15:06:20 +01:00
Max Howell	13d62c3068	Merge pull request #75 from mxcl/ci/macos-11 [ci] can has macos-11	2021-06-23 12:48:10 -04:00
Max Howell	99a0474b0f	[ci] can has macos-11	2021-06-23 12:32:23 -04:00
Max Howell	82640e629d	Merge pull request #74 from mxcl/ci/5.5 ci/5.5	2021-06-17 12:00:29 -04:00
Max Howell	f49e5c82c7	This seems more correct	2021-06-17 11:55:53 -04:00
Max Howell	287afe3783	Fix docs for `ls(.a)`	2021-06-17 11:55:52 -04:00
Max Howell	bb449ff412	Merge pull request #73 from mxcl/fixes/55 typealias PathStruct and add Swift 5.5 niceness	2021-06-16 11:11:18 -04:00
Max Howell	14f03abaad	typealias PathStruct and add Swift 5.5 niceness Fixes #55	2021-06-16 11:05:17 -04:00
Max Howell	ecbb3a60fe	Merge pull request #71 from mxcl/ci/warnings-as-errors [ci] warnings as errors	2021-06-07 10:45:37 -04:00
Max Howell	3af771f543	[ci] warnings as errors	2021-06-07 10:14:36 -04:00
Max Howell	0b68e5c011	Merge pull request #70 from mxcl/ci/mxcl/xcodebuild use mxcl/xcodebuild	2021-06-05 13:45:31 -04:00
Max Howell	fec4ed25de	use mxcl/xcodebuild	2021-06-05 10:55:16 -04:00
Max Howell	6e78d9317e	Merge pull request #69 from mxcl/continuous-resilience #continuous-resilience	2021-05-29 15:12:58 -04:00
Max Howell	3035c45808	#continuous-resilience	2021-05-29 15:10:17 -04:00
Max Howell	39f81ae258	Fix pods deploy	2021-05-28 16:23:47 -04:00
Max Howell	670dc1163f	Merge pull request #68 from mxcl/ci/more	2021-05-28 16:05:44 -04:00
Max Howell	eb33ff8906	[ci] more; some fixes I found	2021-05-28 16:01:57 -04:00
Max Howell	f9cee2c75f	Merge pull request #67 [ci] fix	2021-04-30 08:20:56 -04:00
Max Howell	7a974911d8	[ci] fix	2021-04-30 08:06:10 -04:00
Max Howell	891d70ec7c	Specify Swift 5.1 syntax for targets	2020-08-30 16:27:17 -04:00
Max Howell	142d4bc111	Merge pull request #64 from mxcl/Path.source() Add `Path.source()`	2020-08-19 13:41:50 -04:00
Max Howell	6461a550c6	Add `Path.source()`	2020-08-19 13:27:40 -04:00
Max Howell	8b90260517	Merge pull request #63 from mxcl/codecov-linux Code coverage for linux	2020-08-01 19:45:07 -04:00
Max Howell	7924d20c8c	Code coverage for linux	2020-08-01 15:59:54 -04:00
Max Howell	07007a5421	GHA CI Badge	2020-07-26 13:59:53 -04:00
Max Howell	8a217b3982	Merge pull request #62 from mxcl/sort-ls ls() is sorted; Fixes #58	2020-07-26 13:58:44 -04:00
Max Howell	2b50909946	ls() is sorted; Fixes #58	2020-07-26 13:48:15 -04:00
Max Howell	baa6416208	Use GHA instead of Travis where possible	2020-07-26 13:39:10 -04:00
Max Howell	6e99825d9f	Probably redundant tests, but why not	2020-02-09 14:52:49 -05:00
Max Howell	6e37bfde4d	Update README.md	2020-02-09 14:29:28 -05:00
Max Howell	6e1eeb158a	No fatal on linux Swift < 5	2020-01-25 14:00:59 -05:00
Max Howell	260196a27a	CodeCoverage++	2020-01-25 14:00:59 -05:00
Max Howell	0de9715b46	[ci skip] Update README.md	2020-01-25 12:05:58 -05:00
Max Howell	240d699986	Delete pushed version tag on failed deploy	2020-01-25 10:53:23 -05:00
Max Howell	b63b5746dc	Delete pushed version tag on failed deploy	2020-01-24 12:14:03 -05:00
Max Howell	f062ed9ce3	Fix CI deploy	2020-01-24 12:01:34 -05:00
Max Howell	f1f7ee33b1	[ci skip] List all support Swift	2020-01-24 11:17:42 -05:00
Max Howell	694d04f18b	Prepare 1.0.0 release	2020-01-24 11:03:07 -05:00
Max Howell	5636a7ac65	Update Swift Linux test versions	2020-01-18 12:10:32 -05:00
Max Howell	3e964833ff	Fix README documentation for `Finder`	2020-01-18 12:10:32 -05:00
Max Howell	30122659a5	Update linux-tests; fail if warnings on travis * Update linux-tests; fail if warnings on travis * Fix warnings on Linux * Typo * Can’t test these on Linux	2019-08-18 16:52:24 -04:00
Max Howell	0ef50dff2e	Finder is a iterable Sequence; .type -> .kind	2019-07-24 14:39:47 -04:00
Max Howell	dfad7367b7	Get out documentation %age up	2019-07-21 21:35:48 -04:00
Max Howell	af091cc1f0	Split this test so I can figure out CI failure	2019-07-21 18:58:50 -04:00
Max Howell	e5188bf93b	Still not fixed	2019-07-21 18:58:49 -04:00
Max Howell	462a62920f	Update Swifts in CI; Test Xcode 11	2019-07-21 18:58:49 -04:00
Max Howell	45b0b59a94	Better rx for tagged version detection on Travis	2019-07-21 17:37:10 -04:00
Max Howell	62073d584b	Remove `Entry` since it is barely worthwhile sugar	2019-07-21 17:37:10 -04:00
Max Howell	621d1b0160	Remove @dynamicMember generally	2019-07-21 17:37:10 -04:00
Max Howell	d2bb2a1fdc	Path.find()	2019-07-21 17:22:38 -04:00
Max Howell	38e98ee7fd	Jazzy requires Xcode 10.2 now (per their docs)	2019-07-21 09:07:03 -04:00
Dash2507	dac007e907	Change "pkg" to "package" (#50 )	2019-06-10 17:20:05 -04:00
Max Howell	b6b4a74a26	Move deploy script to @mxcl/ops	2019-04-14 12:40:07 -04:00
Max Howell	b76db41ca4	422 means the release already exists, so… succeed	2019-04-14 10:49:17 -04:00
Max Howell	8d5d67b81b	Merge pull request #48 from mxcl/travis-swift-5.0-GM [travis] Swift 5 GM	2019-03-25 22:02:33 -04:00
Max Howell	21ddc7dc3a	[travis] Swift 5 GM	2019-03-25 21:40:17 -04:00
Max Howell	f324b4a562	Merge pull request #47 from mxcl/fix-symlink-delete Adds `kind` fixes deleting broken symlinks	2019-03-18 19:56:39 -04:00
Max Howell	0e061f9cc8	Adds `kind` fixes deleting broken symlinks `delete()` and other functions would check `exists` to do certain behaviors, but `exists` will validate a symlink if the entry is a symlink, thus instead we check if the path is an actual entry now instead.	2019-03-18 19:47:49 -04:00
Max Howell	7e774b6cf5	Use 10.2 image for pretest Also some tidy	2019-03-06 15:55:51 -05:00
Max Howell	8b371fa5d2	Allow initialization from Substring etc.	2019-03-06 15:55:51 -05:00
Max Howell	02fd579f19	mxcl.github.io -> mxcl.dev [ci skip]	2019-02-28 18:40:19 -05:00
repo-ranger[bot]	e915bc0cfb	Merge pull request #43 from mxcl/Bundle.executable Add Bundle.executable	2019-02-17 15:14:17 +00:00
Max Howell	f4c2c75aa1	Add Bundle.executable	2019-02-17 10:05:30 -05:00
repo-ranger[bot]	dc7affa28c	Merge pull request #42 from mxcl/path-components Add Path.components	2019-02-15 18:49:13 +00:00
Max Howell	476cdc1461	Add Path.components	2019-02-15 13:38:36 -05:00
Max Howell	a644208c62	Test Swift 4.0.3 also	2019-02-13 21:34:35 -05:00
Max Howell	d7a9819350	Fix publishing the release in the deploy stage [ci skip]	2019-02-13 20:52:39 -05:00
repo-ranger[bot]	24a54c2ee0	Merge pull request #39 from mxcl/less-manifests-test You can specify future Swifts in a 4.2 manifest!	2019-02-14 01:00:02 +00:00
Max Howell	3735ed4476	You can specify future Swifts in a 4.2 manifest!	2019-02-13 19:40:07 -05:00