This hack did not work in fact

Tweaks

.github/codecov.yml

@@ -0,0 +1,2 @@
+ignore:
+  - Tests

.github/deploy

@@ -0,0 +1,174 @@
+#!/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()

.github/jazzy.yml

@@ -0,0 +1,13 @@
+module: Path
+custom_categories:
+  - name: Path
+    children:
+      - Path
+      - /(_:_:)
+xcodebuild_arguments:
+  - UseModernBuildSystem=NO
+output:
+  ../output
+  # output directory is relative to config file… ugh
+exclude:
+  - Sources/Path+StringConvertibles.swift

.github/ranger.yml

@@ -0,0 +1,2 @@
+merges:
+  - action: delete_branch

.gitignore

@@ -1,3 +1,5 @@
 .DS_Store
 /.build
 /*.xcodeproj
+/build
+/docs

.travis.yml

@@ -1,26 +1,36 @@
 # 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:
-    - script: swift test
+    - name: macOS / Swift 4.2.1
-      name: macOS
+      script: swift test --parallel
-      
+    - name: macOS / Swift 5.0
+      osx_image: xcode10.2
+      script: swift test --parallel
+
     - &xcodebuild
-      before_install: swift package generate-xcodeproj
+      before_install: swift package generate-xcodeproj --enable-code-coverage
       xcode_destination: platform=iOS Simulator,OS=latest,name=iPhone XS
-      name: iOS
+      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
+      name: tvOS / Swift 4.2.1
     - <<: *xcodebuild
-      name: watchOS
+      name: watchOS / Swift 4.2.1
       script: |
         set -o pipefail
         xcodebuild \
@@ -28,13 +38,46 @@ jobs:
           -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
+      env: SWIFT_VERSION=4.2.1
       os: linux
-      name: 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
+      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

Package.swift

@@ -1,7 +1,7 @@
 // swift-tools-version:4.2
 import PackageDescription
 
-let package = Package(
+let pkg = Package(
     name: "Path.swift",
     products: [
         .library(name: "Path", targets: ["Path"]),
@@ -9,5 +9,6 @@ let package = Package(
     targets: [
         .target(name: "Path", path: "Sources"),
         .testTarget(name: "PathTests", dependencies: ["Path"]),
-    ]
+    ],
+    swiftLanguageVersions: [.v4, .v4_2]
 )

Package@swift-5.0.swift

@@ -0,0 +1,14 @@
+// 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]
+)

README.md

@@ -1,7 +1,7 @@
-# Path.swift ![badge-platforms] ![badge-languages] [![Build Status](https://travis-ci.com/mxcl/Path.swift.svg)](https://travis-ci.com/mxcl/Path.swift)
+# Path.swift ![badge-platforms][] ![badge-languages][] [![badge-ci][]][travis] [![badge-jazzy][]][docs] [![badge-codecov][]][codecov] [![badge-version][]][cocoapods]
 
-A file-system pathing library focused on developer experience and robust
+A file-system pathing library focused on developer experience and robust end
-end‐results.
+results.
 
 ```swift
 import Path
@@ -15,31 +15,51 @@ let docs = Path.home/"Documents"
 // paths are *always* absolute thus avoiding common bugs
 let path = Path(userInput) ?? Path.cwd/userInput
 
-// chainable syntax so you have less boilerplate
+// elegant, chainable syntax
-try Path.home.join("foo").mkpath().join("bar").chmod(0o555)
+try Path.home.join("foo").mkdir().join("bar").touch().chmod(0o555)
+
+// sensible considerations
+try Path.home.join("bar").mkdir()
+try Path.home.join("bar").mkdir()  // doesn’t throw ∵ we already have the desired result
 
 // easy file-management
-try Path.root.join("foo").copy(to: Path.root.join("bar"))
+let bar = try Path.root.join("foo").copy(to: Path.root/"bar")
+print(bar)         // => /bar
+print(bar.isFile)  // => true
 
-// careful API to avoid common bugs
+// careful API considerations so as to avoid common bugs
-try Path.root.join("foo").copy(into: Path.root.mkdir("bar"))
+let foo = try Path.root.join("foo").copy(into: Path.root.join("bar").mkdir())
-// ^^ other libraries would make the `to:` form handle both these cases
+print(foo)         // => /bar/foo
-// but that can easily lead to bugs where you accidentally write files that
+print(foo.isFile)  // => true
-// were meant to be directory destinations
+
+// we support dynamic members (_use_sparingly_):
+let prefs = Path.home.Library.Preferences  // => /Users/mxcl/Library/Preferences
+
+// a practical example: installing a helper executable
+try Bundle.resources.helper.copy(into: Path.root.usr.local.bin).chmod(0o500)
 ```
 
-Paths are just string representations, there *might not* be a real file there.
+We emphasize 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?). Please help me so I
+probably you already use some of it (Homebrew anyone?). I work full-time on
-can continue to make tools and software you need and love. I appreciate it x.
+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
+automatically updated for new releases.
+
 ## Codable
 
 We support `Codable` as you would expect:
@@ -79,6 +99,19 @@ decoder.userInfo[.relativePath] = Path.home
 decoder.decode(from: data)
 ```
 
+## Dynamic members
+
+We support `@dynamicMemberLookup`:
+
+```swift
+let ls = Path.root.usr.bin.ls  // => /usr/bin/ls
+```
+
+This is less commonly useful than you would think, hence our documentation
+does not use it. Usually you are joining variables or other `String` arguments
+or trying to describe files (and files usually have extensions). However when
+you need it, it’s *lovely*.
+
 ## Initializing from user-input
 
 The `Path` initializer returns `nil` unless fed an absolute path; thus to
@@ -92,6 +125,9 @@ 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
+converting strings to `Int`, `Float` etc. in the standard library.
+
 ## Extensions
 
 We have some extensions to Apple APIs:
@@ -104,8 +140,7 @@ bashProfile += "\n\nfoo"
 
 try bashProfile.write(to: Path.home/".bash_profile")
 
-try Bundle.main.resources!.join("foo").copy(to: .home)
+try Bundle.main.resources.join("foo").copy(to: .home)
-// ^^ `-> Path?` because the underlying `Bundle` function is `-> String?`
 ```
 
 ## Directory listings
@@ -127,25 +162,177 @@ for entry in Path.home.ls() where entry.path.mtime > yesterday {
     //…
 }
 
-let dirs = Path.home.ls().directories().filter {
+let dirs = Path.home.ls().directories
-    //…
+
-}
+let files = Path.home.ls().files
 
 let swiftFiles = Path.home.ls().files(withExtension: "swift")
 ```
 
-# Installation
+# `Path.swift` is robust
 
-SwiftPM only:
+Some parts of `FileManager` are not exactly idiomatic. For example
+`isExecutableFile` returns `true` even if there is no file there, it is instead
+telling you that *if* you made a file there it *could* be executable. Thus we
+check the POSIX permissions of the file first, before returning the result of
+`isExecutableFile`. `Path.swift` has done the leg-work for you so you can get on
+with your work without worries.
+
+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
+
+# `Path.swift` is properly cross-platform
+
+`FileManager` on Linux is full of holes. We have found the holes and worked
+round them where necessary.
+
+# Rules & Caveats
+
+Paths are just string representations, there *might not* be a real file there.
 
 ```swift
-package.append(.package(url: "https://github.com/mxcl/Path.swift", from: "0.0.0"))
+Path.home/"b"      // => /Users/mxcl/b
+
+// joining multiple strings works as you’d expect
+Path.home/"b"/"c"  // => /Users/mxcl/b/c
+
+// joining multiple parts at a time is fine
+Path.home/"b/c"    // => /Users/mxcl/b/c
+
+// joining with absolute paths omits prefixed slash
+Path.home/"/b"     // => /Users/mxcl/b
+
+// joining with .. or . works as expected
+Path.home.foo.bar.join("..")  // => /Users/mxcl/foo
+Path.home.foo.bar.join(".")   // => /Users/mxcl/foo/bar
+
+// of course, feel free to join variables:
+let b = "b"
+let c = "c"
+Path.home/b/c      // => /Users/mxcl/b/c
+
+// tilde is not special here
+Path.root/"~b"     // => /~b
+Path.root/"~/b"    // => /~/b
+
+// but is here
+Path("~/foo")!     // => /Users/mxcl/foo
+
+// this works provided the user `Guest` exists
+Path("~Guest")     // => /Users/Guest
+
+// but if the user does not exist
+Path("~foo")       // => nil
+
+// paths with .. or . are resolved
+Path("/foo/bar/../baz")  // => /foo/baz
+
+// symlinks are not resolved
+Path.root.bar.symlink(as: "foo")
+Path("foo")        // => /foo
+Path.foo           // => /foo
+
+// unless you do it explicitly
+try Path.foo.readlink()  // => /bar
+                         // `readlink` only resolves the *final* path component,
+                         // thus use `realpath` if there are multiple symlinks
 ```
 
+*Path.swift* 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 make a directory and it already exists, we do nothing.
+* If you call `readlink` on a non-symlink, we return `self`
+
+However notably if you try to copy or move a file with specifying `overwrite`
+and the file already exists at the destination and is identical, we don’t check
+for that as the check was deemed too expensive to be worthwhile.
+
+## Symbolic links
+
+* Two paths may represent the same *resolved* path yet not be equal due to
+    symlinks in such cases you should use `realpath` on both first if an
+    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
+    `Path.init`, *nor* if you are joining a path that ends up being one of these
+    paths, (eg. `Path.root.join("var/private')`).
+
+## We do not provide 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`.
+
+If you must then use `FileManager.changeCurrentDirectory`.
+
+# I thought I should only use `URL`s?
+
+Apple recommend this because they provide a magic translation for
+[file-references embodied by URLs][file-refs], which gives you URLs like so:
+
+    file:///.file/id=6571367.15106761
+
+Therefore, if you are not using this feature you are fine. If you have URLs the correct
+way to get a `Path` is:
+
+```swift
+if let path = Path(url: url) {
+    /*…*/
+}
+```
+
+Our initializer calls `path` on the URL which resolves any reference to an
+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
+
+# Installation
+
+SwiftPM:
+
+```swift
+package.append(.package(url: "https://github.com/mxcl/Path.swift.git", from: "0.13.0"))
+```
+
+CocoaPods:
+
+```ruby
+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
+
+* [Pathos](https://github.com/dduan/Pathos) by Daniel Duan
+* [PathKit](https://github.com/kylef/PathKit) by Kyle Fuller
+* [Files](https://github.com/JohnSundell/Files) by John Sundell
+* [Utility](https://github.com/apple/swift-package-manager) by Apple
+
 
 [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-orange.svg
+[badge-languages]: https://img.shields.io/badge/swift-4.2%20%7C%205.0-orange.svg
+[docs]: https://mxcl.github.io/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

Sources/Extensions.swift

@@ -1,26 +1,44 @@
 import Foundation
 
+/// Extensions on Foundation’s `Bundle` so you get `Path` rather than `String` or `URL`.
 public extension Bundle {
+    /// Returns the path for requested resource in this bundle.
     func path(forResource: String, ofType: String?) -> Path? {
         let f: (String?, String?) -> String? = path(forResource:ofType:)
         let str = f(forResource, ofType)
         return str.flatMap(Path.init)
     }
 
-    public var sharedFrameworks: Path? {
+    /**
-        return sharedFrameworksPath.flatMap(Path.init)
+     Returns the path for the shared-frameworks directory in this bundle.
+     - Note: This is typically `ShareFrameworks`
+    */
+    var sharedFrameworks: Path {
+        return sharedFrameworksPath.flatMap(Path.init) ?? defaultSharedFrameworksPath
     }
 
-    public var resources: Path? {
+    /**
-        return resourcePath.flatMap(Path.init)
+     Returns the path for the private-frameworks directory in this bundle.
+     - Note: This is typically `Frameworks`
+    */
+    var privateFrameworks: Path {
+        return privateFrameworksPath.flatMap(Path.init) ?? defaultSharedFrameworksPath
     }
 
-    public var path: Path {
+    /// Returns the path for the resources directory in this bundle.
+    var resources: Path {
+        return resourcePath.flatMap(Path.init) ?? defaultResourcesPath
+    }
+
+    /// Returns the path for this bundle.
+    var path: Path {
         return Path(string: bundlePath)
     }
 }
 
+/// Extensions on `String` that work with `Path` rather than `String` or `URL`
 public extension String {
+    /// Initializes this `String` with the contents of the provided path.
     @inlinable
     init(contentsOf path: Path) throws {
         try self.init(contentsOfFile: path.string)
@@ -35,7 +53,9 @@ public extension String {
     }
 }
 
+/// Extensions on `Data` that work with `Path` rather than `String` or `URL`
 public extension Data {
+    /// Initializes this `Data` with the contents of the provided path.
     @inlinable
     init(contentsOf path: Path) throws {
         try self.init(contentsOf: path.url)
@@ -59,3 +79,46 @@ public extension Data {
         return to
     }
 }
+
+/// Extensions on `FileHandle` that work with `Path` rather than `String` or `URL`
+public extension FileHandle {
+    /// Initializes this `FileHandle` for reading at the location of the provided path.
+    @inlinable
+    convenience init(forReadingAt path: Path) 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 {
+        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 {
+        try self.init(forUpdating: path.url)
+    }
+}
+
+internal extension Bundle {
+    var defaultSharedFrameworksPath: Path {
+      #if os(macOS)
+        return path.join("Contents/Frameworks")
+      #elseif os(Linux)
+        return path.join("lib")
+      #else
+        return path.join("Frameworks")
+      #endif
+    }
+
+    var defaultResourcesPath: Path {
+      #if os(macOS)
+        return path.join("Contents/Resources")
+      #elseif os(Linux)
+        return path.join("share")
+      #else
+        return path
+      #endif
+    }
+}

Sources/Path+Attributes.swift

@@ -1,23 +1,74 @@
 import Foundation
 
 public extension Path {
-    /// - Note: If file is already locked, does nothing
+    //MARK: Filesystem Attributes
-    /// - Note: If file doesn’t exist, throws
+
+    /**
+     Returns the creation-time of the file.
+     - Note: Returns `nil` if there is no creation-time, this should only happen if the file doesn’t exist.
+     - Important: On Linux this is filesystem dependendent and may not exist.
+     */
+    var ctime: Date? {
+        do {
+            let attrs = try FileManager.default.attributesOfItem(atPath: string)
+            return attrs[.creationDate] as? Date
+        } catch {
+            return nil
+        }
+    }
+
+    /**
+     Returns the modification-time of the file.
+     - Note: If this returns `nil` and the file exists, something is very wrong.
+     */
+    var mtime: Date? {
+        do {
+            let attrs = try FileManager.default.attributesOfItem(atPath: string)
+            return attrs[.modificationDate] as? Date
+        } catch {
+            return nil
+        }
+    }
+
+    /**
+     Sets the file’s attributes using UNIX octal notation.
+
+         Path.home.join("foo").chmod(0o555)
+     */
     @discardableResult
-    public func lock() throws -> Path {
+    func chmod(_ octal: Int) throws -> Path {
+        try FileManager.default.setAttributes([.posixPermissions: octal], ofItemAtPath: string)
+        return self
+    }
+    
+    /**
+     Applies the macOS filesystem “lock” attribute.
+     - Note: If file is already locked, does nothing.
+     - Note: If file doesn’t exist, throws.
+     - Important: On Linux does nothing.
+     */
+    @discardableResult
+    func lock() throws -> Path {
+    #if !os(Linux)
         var attrs = try FileManager.default.attributesOfItem(atPath: string)
         let b = attrs[.immutable] as? Bool ?? false
         if !b {
             attrs[.immutable] = true
             try FileManager.default.setAttributes(attrs, ofItemAtPath: string)
         }
+    #endif
         return self
     }
 
-    /// - Note: If file isn‘t locked, does nothing
+    /**
-    /// - Note: If file doesn’t exist, does nothing
+     - Note: If file isn‘t locked, does nothing.
+     - Note: If file doesn’t exist, does nothing.
+     - Important: On Linux does nothing.
+     - SeeAlso: `lock()`
+     */
     @discardableResult
-    public func unlock() throws -> Path {
+    func unlock() throws -> Path {
+    #if !os(Linux)
         var attrs: [FileAttributeKey: Any]
         do {
             attrs = try FileManager.default.attributesOfItem(atPath: string)
@@ -29,28 +80,7 @@ public extension Path {
             attrs[.immutable] = false
             try FileManager.default.setAttributes(attrs, ofItemAtPath: string)
         }
+    #endif
         return self
     }
-
-    /**
-     Sets the file’s attributes using UNIX octal notation.
-
-         Path.home.join("foo").chmod(0o555)
-     */
-    @discardableResult
-    public func chmod(_ octal: Int) throws -> Path {
-        try FileManager.default.setAttributes([.posixPermissions: octal], ofItemAtPath: string)
-        return self
-    }
-
-    /// - Returns: modification-time or creation-time if none
-    public var mtime: Date {
-        do {
-            let attrs = try FileManager.default.attributesOfItem(atPath: string)
-            return attrs[.modificationDate] as? Date ?? attrs[.creationDate] as? Date ?? Date()
-        } catch {
-            //TODO print(error)
-            return Date()
-        }
-    }
 }

Sources/Path+Codable.swift

@@ -1,10 +1,31 @@
 import Foundation
 
+/**
+ Provided for relative-path coding. See the instructions in our
+ [README](https://github.com/mxcl/Path.swift/#codable).
+*/
 public extension CodingUserInfoKey {
+    /**
+     If set on an `Encoder`’s `userInfo` all paths are encoded relative to this path.
+
+     For example:
+
+         let encoder = JSONEncoder()
+         encoder.userInfo[.relativePath] = Path.home
+         encoder.encode([Path.home, Path.home/"foo"])
+
+     - Remark: See the [README](https://github.com/mxcl/Path.swift/#codable) for more information.
+    */
     static let relativePath = CodingUserInfoKey(rawValue: "dev.mxcl.Path.relative")!
 }
 
-extension Path: Codable {
+/**
+ Provided for relative-path coding. See the instructions in our
+ [README](https://github.com/mxcl/Path.swift/#codable).
+*/
+extension Path: Codable {    
+    /// - SeeAlso: `CodingUserInfoKey.relativePath`
+    /// :nodoc:
     public init(from decoder: Decoder) throws {
         let value = try decoder.singleValueContainer().decode(String.self)
         if value.hasPrefix("/") {
@@ -17,6 +38,8 @@ extension Path: Codable {
         }
     }
 
+    /// - SeeAlso: `CodingUserInfoKey.relativePath`
+    /// :nodoc:
     public func encode(to encoder: Encoder) throws {
         var container = encoder.singleValueContainer()
         if let root = encoder.userInfo[.relativePath] as? Path {

Sources/Path+CommonDirectories.swift

@@ -0,0 +1,97 @@
+import Foundation
+
+extension Path {
+    //MARK: Common Directories
+    
+    /// Returns a `Path` containing `FileManager.default.currentDirectoryPath`.
+    public static var cwd: Path {
+        return Path(string: FileManager.default.currentDirectoryPath)
+    }
+
+    /// Returns a `Path` representing the root path.
+    public static var root: Path {
+        return Path(string: "/")
+    }
+
+    /// Returns a `Path` representing the user’s home directory
+    public static var home: Path {
+        let string: String
+      #if os(macOS)
+        if #available(OSX 10.12, *) {
+            string = FileManager.default.homeDirectoryForCurrentUser.path
+        } else {
+            string = NSHomeDirectory()
+        }
+      #else
+        string = NSHomeDirectory()
+      #endif
+        return Path(string: string)
+    }
+
+    /// Helper to allow search path and domain mask to be passed in.
+    private static func path(for searchPath: FileManager.SearchPathDirectory) -> Path {
+    #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 }
+
+        switch searchPath {
+        case .documentDirectory:
+            return Path.home/"Documents"
+        case .applicationSupportDirectory:
+            return foo("XDG_DATA_HOME", Path.home/".local/share")
+        case .cachesDirectory:
+            return foo("XDG_CACHE_HOME", Path.home/".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)
+    #endif
+    }
+
+    /**
+     The root for user documents.
+     - 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 {
+        return path(for: .documentDirectory)
+    }
+
+    /**
+     The root for cache files.
+     - Note: On Linux this is `XDG_CACHE_HOME`.
+     - Note: You should create a subdirectory before creating any files.
+     */
+    public static var caches: Path {
+        return path(for: .cachesDirectory)
+    }
+
+    /**
+     For data that supports your running application.
+     - Note: On Linux is `XDG_DATA_HOME`.
+     - Note: You should create a subdirectory before creating any files.
+     */
+    public static var applicationSupport: Path {
+        return path(for: .applicationSupportDirectory)
+    }
+}
+
+#if !os(Linux)
+func defaultUrl(for searchPath: FileManager.SearchPathDirectory) -> Path {
+    switch searchPath {
+    case .documentDirectory:
+        return Path.home/"Documents"
+    case .applicationSupportDirectory:
+        return Path.home/"Library/Application Support"
+    case .cachesDirectory:
+        return Path.home/"Library/Caches"
+    default:
+        fatalError()
+    }
+}
+#endif
+

Sources/Path+FileManager.swift

@@ -1,19 +1,38 @@
 import Foundation
+#if os(Linux)
+import Glibc
+#endif
 
 public extension Path {
+    //MARK: File Management
+    
     /**
      Copies a file.
+
+         try Path.root.join("bar").copy(to: Path.home/"foo")
+         // => "/Users/mxcl/foo"
+
      - Note: `throws` if `to` is a directory.
      - Parameter to: Destination filename.
-     - Parameter overwrite: If true overwrites any file that already exists at `to`.
+     - Parameter overwrite: If `true` and both `self` and `to` are files, overwrites `to`.
+     - Note: If either `self` or `to are directories, `overwrite` is ignored.
+     - Note: Throws if `overwrite` is `false` yet `to` is *already* identical to
+      `self` because even though *Path.swift’s* policy is to noop if the desired
+       end result preexists, checking for this condition is too expensive a
+       trade-off.
      - Returns: `to` to allow chaining
-     - SeeAlso: copy(into:overwrite:)
+     - SeeAlso: `copy(into:overwrite:)`
      */
     @discardableResult
-    public func copy(to: Path, overwrite: Bool = false) throws -> Path {
+    func copy(to: Path, overwrite: Bool = false) throws -> Path {
-        if overwrite, to.exists {
+        if overwrite, to.isFile, isFile {
             try FileManager.default.removeItem(at: to.url)
         }
+    #if os(Linux) && !swift(>=5.1) // check if fixed
+        if !overwrite, to.isFile {
+            throw CocoaError.error(.fileWriteFileExists)
+        }
+    #endif
         try FileManager.default.copyItem(atPath: string, toPath: to.string)
         return to
     }
@@ -21,112 +40,207 @@ public extension Path {
     /**
      Copies a file into a directory
 
-     If the destination does not exist, this function creates the directory first.
+         try Path.root.join("bar").copy(into: .home)
+         // => "/Users/mxcl/bar"
+
+         // Create ~/.local/bin, copy `ls` there and make the new copy executable
+         try Path.root.join("bin/ls").copy(into: Path.home.join(".local/bin").mkdir(.p)).chmod(0o500)
+
+     If the destination does not exist, this function creates the directory
+     (including intermediary directories if necessary) first.
 
-     - Note: `throws` if `into` is a file.
      - Parameter into: Destination directory
      - Parameter overwrite: If true overwrites any file that already exists at `into`.
      - Returns: The `Path` of the newly copied file.
-     - SeeAlso: copy(into:overwrite:)
+     - Note: `throws` if `into` is a file.
+     - Note: Throws if `overwrite` is `false` yet `to` is *already* identical to
+      `self` because even though *Path.swift’s* policy is to noop if the desired
+       end result preexists, checking for this condition is too expensive a
+       trade-off.
+     - SeeAlso: `copy(to:overwrite:)`
      */
     @discardableResult
-    public func copy(into: Path, overwrite: Bool = false) throws -> Path {
+    func copy(into: Path, overwrite: Bool = false) throws -> Path {
         if !into.exists {
-            try FileManager.default.createDirectory(at: url, withIntermediateDirectories: true)
+            try into.mkdir(.p)
-        } else if overwrite, !into.isDirectory {
-            try into.delete()
         }
         let rv = into/basename()
+        if overwrite, rv.isFile {
+            try rv.delete()
+        }
+    #if os(Linux) && !swift(>=5.1) // check if fixed
+        if !overwrite, rv.isFile {
+            throw CocoaError.error(.fileWriteFileExists)
+        }
+    #endif
         try FileManager.default.copyItem(at: url, to: rv.url)
         return rv
     }
 
+    /**
+     Moves a file.
+
+         try Path.root.join("bar").move(to: Path.home/"foo")
+         // => "/Users/mxcl/foo"
+
+     - Parameter to: Destination filename.
+     - Parameter overwrite: If true overwrites any file that already exists at `to`.
+     - Returns: `to` to allow chaining
+     - Note: `throws` if `to` is a directory.
+     - Note: Throws if `overwrite` is `false` yet `to` is *already* identical to
+       `self` because even though *Path.swift’s* policy is to noop if the desired
+       end result preexists, checking for this condition is too expensive a
+       trade-off.
+     - SeeAlso: `move(into:overwrite:)`
+     */
     @discardableResult
-    public func move(to: Path, overwrite: Bool = false) throws -> Path {
+    func move(to: Path, overwrite: Bool = false) throws -> Path {
-        if overwrite, to.exists {
+        if overwrite, to.isFile {
             try FileManager.default.removeItem(at: to.url)
         }
         try FileManager.default.moveItem(at: url, to: to.url)
         return to
     }
 
+    /**
+     Moves a file into a directory
+
+         try Path.root.join("bar").move(into: .home)
+         // => "/Users/mxcl/bar"
+
+     If the destination does not exist, this function creates the directory
+     (including intermediary directories if necessary) first.
+
+     - Parameter into: Destination directory
+     - Parameter overwrite: If true *overwrites* any file that already exists at `into`.
+     - Note: `throws` if `into` is a file.
+     - Returns: The `Path` of destination filename.
+     - SeeAlso: `move(to:overwrite:)`
+     */
     @discardableResult
-    public func move(into: Path) throws -> Path {
+    func move(into: Path, overwrite: Bool = false) throws -> Path {
         if !into.exists {
-            try into.mkpath()
+            try into.mkdir(.p)
         } else if !into.isDirectory {
             throw CocoaError.error(.fileWriteFileExists)
         }
         let rv = into/basename()
+        if overwrite, rv.isFile {
+            try FileManager.default.removeItem(at: rv.url)
+        }
         try FileManager.default.moveItem(at: url, to: rv.url)
         return rv
     }
 
+    /**
+     Deletes the path, recursively if a directory.
+     - Note: noop: if the path doesn’t exist
+     ∵ *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”
+     - SeeAlso: `lock()`
+    */
     @inlinable
-    public func delete() throws {
+    func delete() throws {
-        try FileManager.default.removeItem(at: url)
+        if exists {
+            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.
+     */
     @inlinable
     @discardableResult
     func touch() throws -> Path {
-        return try "".write(to: self)
+        if !exists {
+            guard FileManager.default.createFile(atPath: string, contents: nil) else {
+                throw CocoaError.error(.fileWriteUnknown)
+            }
+        } else {
+        #if os(Linux)
+            let fd = open(string, O_WRONLY)
+            defer { close(fd) }
+            futimens(fd, nil)
+        #else
+            try FileManager.default.setAttributes([.modificationDate: Date()], ofItemAtPath: string)
+        #endif
+        }
+        return self
     }
 
-    private func _foo(go: () throws -> Void) throws {
+    /**
-    #if !os(Linux)
+     Creates the directory at this 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.
+     */
+    @discardableResult
+    func mkdir(_ options: MakeDirectoryOptions? = nil) throws -> Path {
         do {
-            try go()
+            let wid = options == .p
+            try FileManager.default.createDirectory(at: self.url, withIntermediateDirectories: wid, attributes: nil)
         } catch CocoaError.Code.fileWriteFileExists {
-            // noop
+            //noop (fails to trigger on Linux)
-        }
-    #else
-        do {
-            try go()
         } catch {
+        #if os(Linux)
             let error = error as NSError
             guard error.domain == NSCocoaErrorDomain, error.code == CocoaError.Code.fileWriteFileExists.rawValue else {
                 throw error
             }
-        }
+        #else
-    #endif
+            throw error
-    }
+        #endif
-
-    @discardableResult
-    public func mkdir() throws -> Path {
-        try _foo {
-            try FileManager.default.createDirectory(at: self.url, withIntermediateDirectories: false, attributes: nil)
         }
         return self
     }
 
+    /**
+     Renames the file at path.
+
+         Path.root.foo.bar.rename(to: "baz")  // => /foo/baz
+
+     - Parameter to: the new basename for the file
+     - Returns: The renamed path.
+     */
     @discardableResult
-    public func mkpath() throws -> Path {
+    func rename(to newname: String) throws -> Path {
-        try _foo {
+        let newpath = parent/newname
-            try FileManager.default.createDirectory(at: url, withIntermediateDirectories: true, attributes: nil)
+        try FileManager.default.moveItem(atPath: string, toPath: newpath.string)
-        }
+        return newpath
-        return self
     }
 
-    /// - Note: If file doesn’t exist, creates file
+    /**
-    /// - Note: If file is not writable, makes writable first, resetting permissions after the write
+     Creates a symlink of this file at `as`.
+     - Note: If `self` does not exist, is **not** an error.
+     */
     @discardableResult
-    public func replaceContents(with contents: String, atomically: Bool = false, encoding: String.Encoding = .utf8) throws -> Path {
+    func symlink(as: Path) throws -> Path {
-        let resetPerms: Int?
+        try FileManager.default.createSymbolicLink(atPath: `as`.string, withDestinationPath: string)
-        if exists, !isWritable {
+        return `as`
-            resetPerms = try FileManager.default.attributesOfItem(atPath: string)[.posixPermissions] as? Int
+    }
-            let perms = resetPerms ?? 0o777
+
-            try chmod(perms | 0o200)
+    /**
-        } else {
+     Creates a symlink of this file with the same filename in the `into` directory.
-            resetPerms = nil
+     - Note: If into does not exist, creates the directory with intermediate directories if necessary.
+     */
+    @discardableResult
+    func symlink(into dir: Path) throws -> Path {
+        if !dir.exists {
+            try dir.mkdir(.p)
+        } else if !dir.isDirectory {
+            throw CocoaError.error(.fileWriteFileExists)
         }
-
+        let dst = dir/basename()
-        defer {
+        try FileManager.default.createSymbolicLink(atPath: dst.string, withDestinationPath: string)
-            _ = try? resetPerms.map(self.chmod)
+        return dst
-        }
-
-        try contents.write(to: self)
-
-        return self
     }
 }
+
+/// Options for `Path.mkdir(_:)`
+public enum MakeDirectoryOptions {
+    /// Creates intermediary directories; works the same as `mkdir -p`.
+    case p
+}

Sources/Path+StringConvertibles.swift

@@ -1,21 +1,13 @@
-import class Foundation.NSString
+extension Path: CustomStringConvertible {    
-
+    /// Returns `Path.string`
-extension Path: LosslessStringConvertible {
-    /// Returns `nil` unless fed an absolute path
-    public init?(_ description: String) {
-        guard description.starts(with: "/") || description.starts(with: "~/") else { return nil }
-        self.init(string: (description as NSString).standardizingPath)
-    }
-}
-
-extension Path: CustomStringConvertible {
     public var description: String {
         return string
     }
 }
 
 extension Path: CustomDebugStringConvertible {
+    /// Returns eg. `Path(string: "/foo")`
     public var debugDescription: String {
-        return "Path(string: \(string))"
+        return "Path(\(string))"
     }
 }

Sources/Path+ls.swift

@@ -1,24 +1,64 @@
 import Foundation
 
-public extension Path {
+/**
-    /// same as the `ls` command ∴ is ”shallow”
+ A file entry from a directory listing.
-    func ls() throws -> [Entry] {
+ - SeeAlso: `ls()`
-        let relativePaths = try FileManager.default.contentsOfDirectory(atPath: string)
+*/
-        func convert(relativePath: String) -> Entry {
+public struct Entry {
-            let path = self/relativePath
+    /// 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
+
+    /**
+     Same as the `ls -a` command ∴ output is ”shallow” and unsorted.
+     - Parameter includeHiddenFiles: If `true`, hidden files are included in the results. Defaults to `true`.
+     - Important: `includeHiddenFiles` does not work on Linux
+     */
+    func ls(includeHiddenFiles: Bool = true) throws -> [Entry] {
+        var opts = FileManager.DirectoryEnumerationOptions()
+    #if !os(Linux)
+        if !includeHiddenFiles {
+            opts.insert(.skipsHiddenFiles)
+        }
+    #endif
+        let paths = try FileManager.default.contentsOfDirectory(at: url, includingPropertiesForKeys: nil, options: opts)
+        func convert(url: URL) -> Entry? {
+            guard let path = Path(url.path) else { return nil }
             return Entry(kind: path.isDirectory ? .directory : .file, path: path)
         }
-        return relativePaths.map(convert)
+        return paths.compactMap(convert)
     }
 }
 
-public extension Array where Element == Path.Entry {
+/// Convenience functions for the array return value of `Path.ls()`
+public extension Array where Element == Entry {
+    /// Filters the list of entries to be a list of Paths that are directories.
     var directories: [Path] {
         return compactMap {
             $0.kind == .directory ? $0.path : nil
         }
     }
 
+    /// Filters the list of entries to be a list of Paths that are files.
+    var files: [Path] {
+        return compactMap {
+            $0.kind == .file ? $0.path : nil
+        }
+    }
+
+    /// Filters the list of entries to be a list of Paths that are files with the specified extension.
     func files(withExtension ext: String) -> [Path] {
         return compactMap {
             $0.kind == .file && $0.path.extension == ext ? $0.path : nil

Sources/Path->Bool.swift

@@ -1,25 +1,65 @@
 import Foundation
+#if os(Linux)
+import func Glibc.access
+#else
+import Darwin
+#endif
 
 public extension Path {
-    var isWritable: Bool {
+    //MARK: Filesystem Properties
-        return FileManager.default.isWritableFile(atPath: string)
+
-    }
+    /// Returns true if the path represents an actual filesystem entry.
-
+    var exists: Bool {
-    var isDirectory: Bool {
+        return FileManager.default.fileExists(atPath: string)
-        var isDir: ObjCBool = false
-        return FileManager.default.fileExists(atPath: string, isDirectory: &isDir) && isDir.boolValue
     }
 
+    /// Returns true if the path represents an actual filesystem entry that is *not* a directory.
     var isFile: Bool {
         var isDir: ObjCBool = true
         return FileManager.default.fileExists(atPath: string, isDirectory: &isDir) && !isDir.boolValue
     }
 
-    var isExecutable: Bool {
+    /// Returns true if the path represents an actual directory.
-        return FileManager.default.isExecutableFile(atPath: string)
+    var isDirectory: Bool {
+        var isDir: ObjCBool = false
+        return FileManager.default.fileExists(atPath: string, isDirectory: &isDir) && isDir.boolValue
     }
 
-    var exists: Bool {
+    /// Returns true if the path represents an actual file that is also readable by the current user.
-        return FileManager.default.fileExists(atPath: string)
+    var isReadable: Bool {
+        return FileManager.default.isReadableFile(atPath: string)
+    }
+
+    /// Returns true if the path represents an actual file that is also writable by the current user.
+    var isWritable: Bool {
+        return FileManager.default.isWritableFile(atPath: string)
+    }
+        
+    /// Returns true if the path represents an actual file that is also deletable by the current user.
+    var isDeletable: Bool {
+    #if os(Linux) && !swift(>=5.1)
+        return exists && access(parent.string, W_OK) == 0
+    #else
+        // FileManager.isDeletableFile returns true if there is *not* a file there
+        return exists && FileManager.default.isDeletableFile(atPath: string)
+    #endif
+    }
+
+    /// Returns true if the path represents an actual file that is also executable by the current user.
+    var isExecutable: Bool {
+        if access(string, X_OK) == 0 {
+            // FileManager.isExxecutableFile returns true even if there is *not*
+            // a file there *but* if there was it could be *made* executable
+            return FileManager.default.isExecutableFile(atPath: string)
+        } else {
+            return false
+        }
+    }
+
+    /// Returns `true` if the file is a symbolic-link (symlink).
+    var isSymlink: Bool {
+        var sbuf = stat()
+        lstat(string, &sbuf)
+        return (sbuf.st_mode & S_IFMT) == S_IFLNK 
     }
 }

Sources/Path.swift

@@ -1,50 +1,254 @@
 import Foundation
+#if !os(Linux)
+import func Darwin.realpath
+let _realpath = Darwin.realpath
+#else
+import func Glibc.realpath
+let _realpath = Glibc.realpath
+#endif
 
+/**
+ A `Path` represents an absolute path on a filesystem.
+
+ All functions on `Path` are chainable and short to facilitate doing sequences
+ of file operations in a concise manner.
+
+ `Path` supports `Codable`, and can be configured to
+ [encode paths *relatively*](https://github.com/mxcl/Path.swift/#codable).
+
+ Sorting a `Sequence` of paths will return the locale-aware sort order, which
+ will give you the same order as Finder.
+
+ Converting from a `String` is a common first step, here are the recommended
+ ways to do that:
+
+     let p1 = Path.root/pathString
+     let p2 = Path.root/url.path
+     let p3 = Path.cwd/relativePathString
+     let p4 = Path(userInput) ?? Path.cwd/userInput
+
+ If you are constructing paths from static-strings we provide support for
+ dynamic members:
+
+     let p1 = Path.root.usr.bin.ls  // => /usr/bin/ls
+
+ - Note: A `Path` does not necessarily represent an actual filesystem entry.
+ */
+
+@dynamicMemberLookup
 public struct Path: Equatable, Hashable, Comparable {
+
+    init(string: String) {
+        assert(string.first == "/")
+        assert(string.last != "/" || string == "/")
+        assert(string.split(separator: "/").contains("..") == false)
+        self.string = string
+    }
+
+    /**
+     Creates a new absolute, standardized path.
+     - Note: Resolves any .. or . components.
+     - Note: Removes multiple subsequent and trailing occurences of `/`.
+     - Note: Does *not* resolve any symlinks.
+     - 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) {
+        var pathComponents = description.split(separator: "/")
+        switch description.first {
+        case "/":
+            break
+        case "~":
+            if description == "~" {
+                self = Path.home
+                return
+            }
+            let tilded: String
+            if description.hasPrefix("~/") {
+                tilded = Path.home.string
+            } else {
+                let username = String(pathComponents[0].dropFirst())
+            #if os(macOS) || os(Linux)
+                if #available(OSX 10.12, *) {
+                    guard let url = FileManager.default.homeDirectory(forUser: username) else { return nil }
+                    assert(url.scheme == "file")
+                    tilded = url.path
+                } else {
+                    guard let dir = NSHomeDirectoryForUser(username) else { return nil }
+                    tilded = dir
+                }
+            #else
+                return nil  // there are no usernames on iOS, etc.
+            #endif
+            }
+            pathComponents.remove(at: 0)
+            pathComponents.insert(contentsOf: tilded.split(separator: "/"), at: 0)
+        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)
+    }
+
+    /**
+     Creates a new absolute, standardized path from the provided file-scheme URL.
+     - Note: If the URL is not a file URL, returns `nil`.
+    */
+    public init?(url: URL) {
+        guard url.scheme == "file" else { return nil }
+        self.init(url.path)
+        //NOTE: URL cannot be a file-reference url, unlike NSURL, so this always works
+    }
+
+    /**
+     Creates a new absolute, standardized path from the provided file-scheme URL.
+     - Note: If the URL is not a file URL, returns `nil`.
+     - Note: If the URL is a file reference URL, converts it to a POSIX path first.
+    */
+    public init?(url: NSURL) {
+        guard url.scheme == "file", let path = url.path else { return nil }
+        self.init(string: path)
+        // ^^ works even if the url is a file-reference url
+    }
+
+    /// :nodoc:
+    public subscript(dynamicMember addendum: String) -> Path {
+        //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 Path(string: join_(prefix: string, appending: addendum))
+    }
+
+//MARK: Properties
+
+    /// The underlying filesystem path
     public let string: String
 
-    public static var cwd: Path {
+    /// Returns a `URL` representing this file path.
-        return Path(string: FileManager.default.currentDirectoryPath)
-    }
-
-    public static var root: Path {
-        return Path(string: "/")
-    }
-
-    public static var home: Path {
-        return Path(string: NSHomeDirectory())
-    }
-
-    @inlinable
-    public var `extension`: String {
-        return (string as NSString).pathExtension
-    }
-
-    /// - Note: always returns a valid path, `Path.root.parent` *is* `Path.root`
-    public var parent: Path {
-        return Path(string: (string as NSString).deletingLastPathComponent)
-    }
-
-    @inlinable
     public var url: URL {
         return URL(fileURLWithPath: string)
     }
 
-    public func basename(dropExtension: Bool = false) -> String {
+    /**
-        let str = string as NSString
+     Returns a file-reference URL.
-        if !dropExtension {
+     - Note: Only NSURL can be a file-reference-URL, hence we return NSURL.
-            return str.lastPathComponent
+     - SeeAlso: https://developer.apple.com/documentation/foundation/nsurl/1408631-filereferenceurl
-        } else {
+     - Important: On Linux returns an file scheme NSURL for this path string.
-            let ext = str.pathExtension
+     */
-            if !ext.isEmpty {
+    public var fileReferenceURL: NSURL? {
-                return String(str.lastPathComponent.dropLast(ext.count + 1))
+    #if !os(Linux)
+        // https://bugs.swift.org/browse/SR-2728
+        return (url as NSURL).perform(#selector(NSURL.fileReferenceURL))?.takeUnretainedValue() as? NSURL
+    #else
+        return NSURL(fileURLWithPath: string)
+    #endif
+    }
+
+    /**
+     Returns the parent directory for this path.
+
+     Path is not aware of the nature of the underlying file, but this is
+     irrlevant since the operation is the same irrespective of this fact.
+
+     - Note: always returns a valid path, `Path.root.parent` *is* `Path.root`.
+     */
+    public var parent: Path {
+        let index = string.lastIndex(of: "/")!
+        let substr = string[string.indices.startIndex..<index]
+        return Path(string: String(substr))
+    }
+
+    /**
+     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`.
+     */
+    @inlinable
+    public var `extension`: String {
+        //FIXME efficiency
+        switch true {
+        case string.hasSuffix(".tar.gz"):
+            return "tar.gz"
+        case string.hasSuffix(".tar.bz"):
+            return "tar.bz"
+        case string.hasSuffix(".tar.bz2"):
+            return "tar.bz2"
+        case string.hasSuffix(".tar.xz"):
+            return "tar.xz"
+        default:
+            let slash = string.lastIndex(of: "/")!
+            if let dot = string.lastIndex(of: "."), slash < dot {
+                let foo = string.index(after: dot)
+                return String(string[foo...])
             } else {
-                return str.lastPathComponent
+                return ""
             }
         }
     }
 
-    //TODO another variant that returns `nil` if result would start with `..`
+//MARK: Pathing
+
+    /**
+     Joins a path and a string to produce a new path.
+
+         Path.root.join("a")             // => /a
+         Path.root.join("a/b")           // => /a/b
+         Path.root.join("a").join("b")   // => /a/b
+         Path.root.join("a").join("/b")  // => /a/b
+
+     - Note: `..` and `.` components are interpreted.
+     - Note: pathComponent *may* be multiple components.
+     - Note: symlinks are *not* resolved.
+     - Parameter pathComponent: The string to join with this path.
+     - Returns: A new joined path.
+     - SeeAlso: `Path./(_:_:)`
+     */
+    public func join<S>(_ addendum: S) -> Path where S: StringProtocol {
+        return Path(string: join_(prefix: string, appending: addendum))
+    }
+
+    /**
+     Joins a path and a string to produce a new path.
+
+         Path.root/"a"       // => /a
+         Path.root/"a/b"     // => /a/b
+         Path.root/"a"/"b"   // => /a/b
+         Path.root/"a"/"/b"  // => /a/b
+
+     - Note: `..` and `.` components are interpreted.
+     - Note: pathComponent *may* be multiple components.
+     - Note: symlinks are *not* resolved.
+     - Parameter lhs: The base path to join with `rhs`.
+     - Parameter rhs: The string to join with this `lhs`.
+     - Returns: A new joined path.
+     - SeeAlso: `join(_:)`
+     */
+    @inlinable
+    public static func /<S>(lhs: Path, rhs: S) -> Path where S: StringProtocol {
+        return lhs.join(rhs)
+    }
+
+    /**
+     Returns a string representing the relative path to `base`.
+
+     - Note: If `base` is not a logical prefix for `self` your result will be prefixed some number of `../` components.
+     - 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 {
         // Split the two paths into their components.
         // FIXME: The is needs to be optimized to avoid unncessary copying.
@@ -75,28 +279,122 @@ public struct Path: Equatable, Hashable, Comparable {
         }
     }
 
-    public func join<S>(_ part: S) -> Path where S: StringProtocol {
+    /**
-        //TODO standardizingPath does more than we want really (eg tilde expansion)
+     The basename for the provided file, optionally dropping the file extension.
-        let str = (string as NSString).appendingPathComponent(String(part))
+
-        return Path(string: (str as NSString).standardizingPath)
+         Path.root.join("foo.swift").basename()  // => "foo.swift"
+         Path.root.join("foo.swift").basename(dropExtension: true)  // => "foo"
+
+     - 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 {
+        var lastPathComponent: Substring {
+            let slash = string.lastIndex(of: "/")!
+            let index = string.index(after: slash)
+            return string[index...]
+        }
+        var go: Substring {
+            if !dropExtension {
+                return lastPathComponent
+            } else {
+                let ext = self.extension
+                if !ext.isEmpty {
+                    return lastPathComponent.dropLast(ext.count + 1)
+                } else {
+                    return lastPathComponent
+                }
+            }
+        }
+        return String(go)
     }
 
+    /**
+     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
+     symlink.
+     - 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 {
+        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
+        } 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
+            }
+        #endif
+            throw error
+        }
+    }
+
+    /// Recursively resolves symlinks in this path.
+    public 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) }
+
+        // “Removing 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).”
+        // ^^ we do this to not conflict with the results that other Apple APIs give
+        // which is necessary if we are to have equality checks work reliably
+        let rvvv = (rvv as NSString).standardizingPath
+
+        return Path(string: rvvv)
+    }
+
+    /// Returns the locale-aware sort order for the two paths.
+    /// :nodoc:
     @inlinable
     public static func <(lhs: Path, rhs: Path) -> Bool {
         return lhs.string.compare(rhs.string, locale: .current) == .orderedAscending
     }
+}
 
-    public struct Entry {
+@inline(__always)
-        public enum Kind {
+private func join_<S>(prefix: String, appending: S) -> String where S: StringProtocol {
-            case file
+    return join_(prefix: prefix, pathComponents: appending.split(separator: "/"))
-            case directory
+}
+
+private func join_<S>(prefix: String, pathComponents: S) -> String where S: Sequence, S.Element: StringProtocol {
+    assert(prefix.first == "/")
+
+    var rv = prefix
+    for component in pathComponents {
+
+        assert(!component.contains("/"))
+
+        switch component {
+        case "..":
+            let start = rv.indices.startIndex
+            let index = rv.lastIndex(of: "/")!
+            if start == index {
+                rv = "/"
+            } else {
+                rv = String(rv[start..<index])
+            }
+        case ".":
+            break
+        default:
+            if rv == "/" {
+                rv = "/\(component)"
+            } else {
+                rv = "\(rv)/\(component)"
+            }
         }
-        public let kind: Kind
-        public let path: Path
     }
-}
+    return rv
-
-@inlinable
-public func /<S>(lhs: Path, rhs: S) -> Path where S: StringProtocol {
-    return lhs.join(rhs)
 }

Tests/PathTests/PathTests.swift

@@ -1,5 +1,5 @@
+@testable import Path
 import XCTest
-import Path
 
 class PathTests: XCTestCase {
     func testConcatenation() {
@@ -9,18 +9,51 @@ class PathTests: XCTestCase {
         XCTAssertEqual((Path.root/"///bar").string, "/bar")
         XCTAssertEqual((Path.root/"foo///bar////").string, "/foo/bar")
         XCTAssertEqual((Path.root/"foo"/"/bar").string, "/foo/bar")
+
+        XCTAssertEqual(Path.root.foo.bar.join(".."), Path.root.foo)
+        XCTAssertEqual(Path.root.foo.bar.join("."), Path.root.foo.bar)
+        XCTAssertEqual(Path.root.foo.bar.join("../baz"), Path.root.foo.baz)
     }
 
     func testEnumeration() throws {
+        let tmpdir_ = try TemporaryDirectory()
+        let tmpdir = tmpdir_.path
+        try tmpdir.a.mkdir().c.touch()
+        try tmpdir.join("b.swift").touch()
+        try tmpdir.c.touch()
+        try tmpdir.join(".d").mkdir().e.touch()
+
+        var paths = Set<String>()
+        let lsrv = try tmpdir.ls()
+        var dirs = 0
+        for entry in lsrv {
+            if entry.kind == .directory {
+                dirs += 1
+            }
+            paths.insert(entry.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(["c"], Set(lsrv.files(withExtension: "").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()
         try tmpdir.join("b").touch()
         try tmpdir.join("c").touch()
-
+        try tmpdir.join(".d").mkdir().join("e").touch()
+        
         var paths = Set<String>()
         var dirs = 0
-        for entry in try tmpdir.ls() {
+        for entry in try tmpdir.ls(includeHiddenFiles: false) {
             if entry.kind == .directory {
                 dirs += 1
             }
@@ -28,6 +61,7 @@ class PathTests: XCTestCase {
         }
         XCTAssertEqual(dirs, 1)
         XCTAssertEqual(paths, ["a", "b", "c"])
+    #endif
     }
 
     func testRelativeTo() {
@@ -45,6 +79,22 @@ class PathTests: XCTestCase {
         XCTAssert((Path.root/"bin").isDirectory)
     }
 
+    func testExtension() {
+        for prefix in [Path.root, Path.root.foo, Path.root.foo.bar] {
+            XCTAssertEqual(prefix.join("a.swift").extension, "swift")
+            XCTAssertEqual(prefix.join("a").extension, "")
+            XCTAssertEqual(prefix.join("a.").extension, "")
+            XCTAssertEqual(prefix.join("a..").extension, "")
+            XCTAssertEqual(prefix.join("a..swift").extension, "swift")
+            XCTAssertEqual(prefix.join("a..swift.").extension, "")
+            XCTAssertEqual(prefix.join("a.tar.gz").extension, "tar.gz")
+            XCTAssertEqual(prefix.join("a.tar.bz2").extension, "tar.bz2")
+            XCTAssertEqual(prefix.join("a.tar.xz").extension, "tar.xz")
+            XCTAssertEqual(prefix.join("a..tar.bz").extension, "tar.bz")
+            XCTAssertEqual(prefix.join("a..tar..xz").extension, "xz")
+        }
+    }
+
     func testMktemp() throws {
         var path: Path!
         try Path.mktemp {
@@ -59,38 +109,483 @@ class PathTests: XCTestCase {
         try Path.mktemp {
             for _ in 0...1 {
                 try $0.join("a").mkdir()
-                try $0.join("b/c").mkpath()
+                try $0.join("b/c").mkdir(.p)
             }
         }
     }
 
     func testBasename() {
-        XCTAssertEqual(Path.root.join("foo.bar").basename(dropExtension: true), "foo")
+        for prefix in [Path.root, Path.root.foo, Path.root.foo.bar] {
-        XCTAssertEqual(Path.root.join("foo").basename(dropExtension: true), "foo")
+            XCTAssertEqual(prefix.join("foo.bar").basename(dropExtension: true), "foo")
-        XCTAssertEqual(Path.root.join("foo.").basename(dropExtension: true), "foo.")
+            XCTAssertEqual(prefix.join("foo").basename(dropExtension: true), "foo")
-        XCTAssertEqual(Path.root.join("foo.bar.baz").basename(dropExtension: true), "foo.bar")
+            XCTAssertEqual(prefix.join("foo.").basename(dropExtension: true), "foo.")
+            XCTAssertEqual(prefix.join("foo.bar.baz").basename(dropExtension: true), "foo.bar")
+        }
     }
 
     func testCodable() throws {
-        let input = [Path.root/"bar"]
+        let input = [Path.root.foo, Path.root.foo.bar, Path.root]
         XCTAssertEqual(try JSONDecoder().decode([Path].self, from: try JSONEncoder().encode(input)), input)
     }
 
     func testRelativePathCodable() throws {
-        let root = Path.root/"bar"
+        let root = Path.root.foo
         let input = [
-            root/"foo"
+            Path.root,
+            root,
+            root.bar
         ]
 
         let encoder = JSONEncoder()
         encoder.userInfo[.relativePath] = root
         let data = try encoder.encode(input)
 
-        XCTAssertEqual(try JSONSerialization.jsonObject(with: data) as? [String], ["foo"])
+        XCTAssertEqual(try JSONSerialization.jsonObject(with: data) as? [String], ["..", "", "bar"])
 
         let decoder = JSONDecoder()
         XCTAssertThrowsError(try decoder.decode([Path].self, from: data))
         decoder.userInfo[.relativePath] = root
         XCTAssertEqual(try decoder.decode([Path].self, from: data), input)
     }
+
+    func testJoin() {
+        let prefix = Path.root/"Users/mxcl"
+
+        XCTAssertEqual(prefix/"b", Path("/Users/mxcl/b"))
+        XCTAssertEqual(prefix/"b"/"c", Path("/Users/mxcl/b/c"))
+        XCTAssertEqual(prefix/"b/c", Path("/Users/mxcl/b/c"))
+        XCTAssertEqual(prefix/"/b", Path("/Users/mxcl/b"))
+        let b = "b"
+        let c = "c"
+        XCTAssertEqual(prefix/b/c, Path("/Users/mxcl/b/c"))
+        XCTAssertEqual(Path.root/"~b", Path("/~b"))
+        XCTAssertEqual(Path.root/"~/b", Path("/~/b"))
+
+        XCTAssertEqual(Path("~/foo"), Path.home/"foo")
+        XCTAssertEqual(Path("~"), Path.home)
+        XCTAssertEqual(Path("~/"), Path.home)
+        XCTAssertEqual(Path("~///"), Path.home)
+        XCTAssertEqual(Path("/~///"), Path.root/"~")
+        XCTAssertNil(Path("~foo"))
+        XCTAssertNil(Path("~foo/bar"))
+
+        XCTAssertEqual(Path("~\(NSUserName())"), Path.home)
+
+        XCTAssertEqual(Path.root/"a/foo"/"../bar", Path.root/"a/bar")
+        XCTAssertEqual(Path.root/"a/foo"/"/../bar", Path.root/"a/bar")
+        XCTAssertEqual(Path.root/"a/foo"/"../../bar", Path.root/"bar")
+        XCTAssertEqual(Path.root/"a/foo"/"../../../bar", Path.root/"bar")
+    }
+
+    func testDynamicMember() {
+        XCTAssertEqual(Path.root.Documents, Path.root/"Documents")
+
+        let a = Path.home.foo
+        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")
+    }
+
+    func testCopyTo() throws {
+        try Path.mktemp { root in
+            try root.foo.touch().copy(to: root.bar)
+            XCTAssert(root.foo.isFile)
+            XCTAssert(root.bar.isFile)
+            XCTAssertThrowsError(try root.foo.copy(to: root.bar))
+            try root.foo.copy(to: root.bar, overwrite: true)
+        }
+
+        // test copy errors if directory exists at destination, even with overwrite
+        try Path.mktemp { root in
+            try root.foo.touch()
+            XCTAssert(root.foo.isFile)
+            XCTAssertThrowsError(try root.foo.copy(to: root.bar.mkdir()))
+            XCTAssertThrowsError(try root.foo.copy(to: root.bar, overwrite: true))
+        }
+    }
+
+    func testCopyInto() throws {
+        try Path.mktemp { root1 in
+            let bar1 = try root1.join("bar").touch()
+            try Path.mktemp { root2 in
+                let bar2 = try root2.join("bar").touch()
+                XCTAssertThrowsError(try bar1.copy(into: root2))
+                try bar1.copy(into: root2, overwrite: true)
+                XCTAssertTrue(bar1.exists)
+                XCTAssertTrue(bar2.exists)
+            }
+
+            // test creates intermediary directories
+            try bar1.copy(into: root1.create.directories)
+
+            // test doesn’t replace file if “copy into” a file
+            let d = try root1.fuz.touch()
+            XCTAssertThrowsError(try root1.baz.touch().copy(into: d))
+            XCTAssert(d.isFile)
+            XCTAssert(root1.baz.isFile)
+        }
+    }
+
+    func testMoveTo() throws {
+        try Path.mktemp { tmpdir in
+            try tmpdir.foo.touch().move(to: tmpdir.bar)
+            XCTAssertFalse(tmpdir.foo.exists)
+            XCTAssert(tmpdir.bar.isFile)
+            XCTAssertThrowsError(try tmpdir.foo.touch().move(to: tmpdir.bar))
+            try tmpdir.foo.move(to: tmpdir.bar, overwrite: true)
+        }
+
+        // test move errors if directory exists at destination, even with overwrite
+        try Path.mktemp { root in
+            try root.foo.touch()
+            XCTAssert(root.foo.isFile)
+            XCTAssertThrowsError(try root.foo.move(to: root.bar.mkdir()))
+            XCTAssertThrowsError(try root.foo.move(to: root.bar, overwrite: true))
+        }
+    }
+
+    func testMoveInto() throws {
+        try Path.mktemp { root1 in
+            let bar1 = try root1.join("bar").touch()
+            try Path.mktemp { root2 in
+                let bar2 = try root2.join("bar").touch()
+                XCTAssertThrowsError(try bar1.move(into: root2))
+                try bar1.move(into: root2, overwrite: true)
+                XCTAssertFalse(bar1.exists)
+                XCTAssertTrue(bar2.exists)
+            }
+
+            // test creates intermediary directories
+            try root1.baz.touch().move(into: root1.create.directories)
+            XCTAssertFalse(root1.baz.exists)
+            XCTAssert(root1.create.directories.baz.isFile)
+
+            // test doesn’t replace file if “move into” a file
+            let d = try root1.fuz.touch()
+            XCTAssertThrowsError(try root1.baz.touch().move(into: d))
+            XCTAssert(d.isFile)
+            XCTAssert(root1.baz.isFile)
+        }
+    }
+
+    func testRename() throws {
+        try Path.mktemp { root in
+            do {
+                let file = try root.bar.touch()
+                let foo = try file.rename(to: "foo")
+                XCTAssertFalse(file.exists)
+                XCTAssertTrue(foo.isFile)
+            }
+            do {
+                let file = try root.bar.touch()
+                XCTAssertThrowsError(try file.rename(to: "foo"))
+            }
+        }
+    }
+
+    func testCommonDirectories() {
+        XCTAssertEqual(Path.root.string, "/")
+        XCTAssertEqual(Path.home.string, NSHomeDirectory())
+        XCTAssertEqual(Path.documents.string, NSHomeDirectory() + "/Documents")
+    #if !os(Linux)
+        XCTAssertEqual(Path.caches.string, NSHomeDirectory() + "/Library/Caches")
+        XCTAssertEqual(Path.cwd.string, FileManager.default.currentDirectoryPath)
+        XCTAssertEqual(Path.applicationSupport.string, NSHomeDirectory() + "/Library/Application Support")
+
+        _ = defaultUrl(for: .documentDirectory)
+        _ = defaultUrl(for: .cachesDirectory)
+        _ = defaultUrl(for: .applicationSupportDirectory)
+    #endif
+    }
+
+    func testStringConvertibles() {
+        XCTAssertEqual(Path.root.description, "/")
+        XCTAssertEqual(Path.root.debugDescription, "Path(/)")
+    }
+
+    func testFilesystemAttributes() throws {
+        XCTAssert(Path(#file)!.isFile)
+        XCTAssert(Path(#file)!.isReadable)
+        XCTAssert(Path(#file)!.isWritable)
+        XCTAssert(Path(#file)!.isDeletable)
+        XCTAssert(Path(#file)!.parent.isDirectory)
+
+        try Path.mktemp { tmpdir in
+            XCTAssertTrue(tmpdir.isDirectory)
+            XCTAssertFalse(tmpdir.isFile)
+
+            let bar = try tmpdir.bar.touch().chmod(0o000)
+            XCTAssertFalse(bar.isReadable)
+            XCTAssertFalse(bar.isWritable)
+            XCTAssertFalse(bar.isDirectory)
+            XCTAssertFalse(bar.isExecutable)
+            XCTAssertTrue(bar.isFile)
+            XCTAssertTrue(bar.isDeletable)  // can delete even if no read permissions
+
+            try bar.chmod(0o777)
+            XCTAssertTrue(bar.isReadable)
+            XCTAssertTrue(bar.isWritable)
+            XCTAssertTrue(bar.isDeletable)
+            XCTAssertTrue(bar.isExecutable)
+
+            try bar.delete()
+            XCTAssertFalse(bar.exists)
+            XCTAssertFalse(bar.isReadable)
+            XCTAssertFalse(bar.isWritable)
+            XCTAssertFalse(bar.isExecutable)
+            XCTAssertFalse(bar.isDeletable)
+
+            let nonExistantFile = tmpdir.baz
+            XCTAssertFalse(nonExistantFile.exists)
+            XCTAssertFalse(nonExistantFile.isExecutable)
+            XCTAssertFalse(nonExistantFile.isReadable)
+            XCTAssertFalse(nonExistantFile.isWritable)
+            XCTAssertFalse(nonExistantFile.isDeletable)
+            XCTAssertFalse(nonExistantFile.isDirectory)
+            XCTAssertFalse(nonExistantFile.isFile)
+
+            let baz = try tmpdir.baz.touch()
+            XCTAssertTrue(baz.isDeletable)
+            try tmpdir.chmod(0o500)  // remove write permission on directory
+            XCTAssertFalse(baz.isDeletable)  // this is how deletion is prevented on UNIX
+        }
+    }
+
+    func testTimes() throws {
+        try Path.mktemp { tmpdir in
+            let foo = try tmpdir.foo.touch()
+            let now1 = Date().timeIntervalSince1970.rounded(.down)
+        #if !os(Linux)
+            XCTAssertEqual(foo.ctime?.timeIntervalSince1970.rounded(.down), now1)  //FIXME flakey
+        #endif
+            XCTAssertEqual(foo.mtime?.timeIntervalSince1970.rounded(.down), now1)  //FIXME flakey
+            sleep(1)
+            try foo.touch()
+            let now2 = Date().timeIntervalSince1970.rounded(.down)
+            XCTAssertNotEqual(now1, now2)
+            XCTAssertEqual(foo.mtime?.timeIntervalSince1970.rounded(.down), now2)  //FIXME flakey
+
+            XCTAssertNil(tmpdir.void.mtime)
+            XCTAssertNil(tmpdir.void.ctime)
+        }
+    }
+
+    func testDelete() throws {
+        try Path.mktemp { tmpdir in
+            try tmpdir.bar1.delete()
+            try tmpdir.bar2.touch().delete()
+            try tmpdir.bar3.touch().chmod(0o000).delete()
+        #if !os(Linux)
+            XCTAssertThrowsError(try tmpdir.bar3.touch().lock().delete())
+        #endif
+        }
+    }
+
+    func testRelativeCodable() throws {
+        let path = Path.home.foo
+        let encoder = JSONEncoder()
+        encoder.userInfo[.relativePath] = Path.home
+        let data = try encoder.encode([path])
+        let decoder = JSONDecoder()
+        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])
+        XCTAssertThrowsError(try JSONDecoder().decode([Path].self, from: data))
+    }
+
+    func testBundleExtensions() throws {
+        try Path.mktemp { tmpdir in
+            let bndl = Bundle(path: tmpdir.string)!
+            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"))
+
+        #if os(macOS)
+            XCTAssertEqual(bndl.defaultSharedFrameworksPath, tmpdir.Contents.Frameworks)
+            XCTAssertEqual(bndl.defaultResourcesPath, tmpdir.Contents.Resources)
+        #elseif os(tvOS) || os(iOS)
+            XCTAssertEqual(bndl.defaultSharedFrameworksPath, tmpdir.Frameworks)
+            XCTAssertEqual(bndl.defaultResourcesPath, tmpdir)
+        #else
+            XCTAssertEqual(bndl.defaultSharedFrameworksPath, tmpdir.lib)
+            XCTAssertEqual(bndl.defaultResourcesPath, tmpdir.share)
+        #endif
+        }
+    }
+
+    func testDataExtensions() throws {
+        let data = try Data(contentsOf: Path(#file)!)
+        try Path.mktemp { tmpdir in
+            _ = try data.write(to: tmpdir.foo)
+            _ = try data.write(to: tmpdir.foo, atomically: true)
+        }
+    }
+
+    func testStringExtensions() throws {
+        let string = try String(contentsOf: Path(#file)!)
+        try Path.mktemp { tmpdir in
+            _ = try string.write(to: tmpdir.foo)
+        }
+    }
+
+    func testFileHandleExtensions() throws {
+        _ = try FileHandle(forReadingAt: Path(#file)!)
+        _ = try FileHandle(forWritingAt: Path(#file)!)
+        _ = try FileHandle(forUpdatingAt: Path(#file)!)
+    }
+
+    func testSort() {
+        XCTAssertEqual([Path.root.a, Path.root.c, Path.root.b].sorted(), [Path.root.a, Path.root.b, Path.root.c])
+    }
+
+    func testLock() throws {
+    #if !os(Linux)
+        try Path.mktemp { tmpdir in
+            let bar = try tmpdir.bar.touch()
+            try bar.lock()
+            XCTAssertThrowsError(try bar.touch())
+            try bar.unlock()
+            try bar.touch()
+
+            // a non existant file is already “unlocked”
+            try tmpdir.nonExit.unlock()
+        }
+    #endif
+    }
+
+    func testTouchThrowsIfCannotWrite() throws {
+        try Path.mktemp { tmpdir in
+            try tmpdir.chmod(0o000)
+            XCTAssertThrowsError(try tmpdir.bar.touch())
+        }
+    }
+
+    func testSymlinkFunctions() throws {
+        try Path.mktemp { tmpdir in
+            let foo = try tmpdir.foo.touch()
+            let bar = try foo.symlink(as: tmpdir.bar)
+            XCTAssert(bar.isSymlink)
+            XCTAssertEqual(try bar.readlink(), foo)
+        }
+
+        try Path.mktemp { tmpdir in
+            let foo1 = try tmpdir.foo.touch()
+            let foo2 = try foo1.symlink(into: tmpdir.bar)
+            XCTAssert(foo2.isSymlink)
+            XCTAssert(tmpdir.bar.isDirectory)
+            XCTAssertEqual(try foo2.readlink(), foo1)
+
+            // cannot symlink into when `into` is an existing entry that is not a directory
+            let baz = try tmpdir.baz.touch()
+            XCTAssertThrowsError(try foo1.symlink(into: baz))
+        }
+
+        try Path.mktemp { tmpdir in
+            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)
+        }
+    }
+
+    func testReadlinkOnRelativeSymlink() throws {
+        //TODO how to test on iOS etc.?
+    #if os(macOS) || os(Linux)
+        try Path.mktemp { tmpdir in
+            let foo = try tmpdir.foo.mkdir()
+            let bar = try tmpdir.bar.touch()
+
+            let task = Process()
+            task.currentDirectoryPath = foo.string
+            task.launchPath = "/bin/ln"
+            task.arguments = ["-s", "../bar", "baz"]
+            task.launch()
+            task.waitUntilExit()
+            XCTAssertEqual(task.terminationStatus, 0)
+
+            XCTAssert(tmpdir.foo.baz.isSymlink)
+
+            XCTAssertEqual(try FileManager.default.destinationOfSymbolicLink(atPath: tmpdir.foo.baz.string), "../bar")
+
+            XCTAssertEqual(try tmpdir.foo.baz.readlink(), bar)
+        }
+    #endif
+    }
+
+    func testReadlinkOnFileReturnsSelf() throws {
+        try Path.mktemp { tmpdir in
+            XCTAssertEqual(try tmpdir.foo.touch(), tmpdir.foo)
+            XCTAssertEqual(try tmpdir.foo.readlink(), tmpdir.foo)
+        }
+    }
+
+    func testReadlinkOnNonExistantFileThrows() throws {
+        try Path.mktemp { tmpdir in
+            XCTAssertThrowsError(try tmpdir.bar.readlink())
+        }
+    }
+
+    func testReadlinkWhereLinkDestinationDoesNotExist() throws {
+        try Path.mktemp { tmpdir in
+            let bar = try tmpdir.foo.symlink(as: tmpdir.bar)
+            XCTAssertEqual(try bar.readlink(), tmpdir.foo)
+        }
+    }
+
+    func testNoUndesiredSymlinkResolution() throws {
+
+        // this test because NSString.standardizingPath will resolve symlinks
+        // if the path you give it contains .. and the result is an actual entry
+
+        try Path.mktemp { tmpdir in
+            let foo = try tmpdir.foo.mkdir()
+            try foo.bar.mkdir().fuz.touch()
+            let baz = try foo.symlink(as: tmpdir.baz)
+            XCTAssert(baz.isSymlink)
+            XCTAssert(baz.bar.isDirectory)
+            XCTAssertEqual(baz.bar.join("..").string, "\(tmpdir)/baz")
+
+            XCTAssertEqual(Path("\(tmpdir)/baz/bar/..")?.string, "\(tmpdir)/baz")
+        }
+    }
+
+    func testRealpath() throws {
+        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 f = try e.symlink(as: tmpdir.f)
+            XCTAssertEqual(try f.readlink(), e)
+            XCTAssertEqual(try f.realpath(), c)
+        }
+
+        try Path.mktemp { tmpdir in
+            XCTAssertThrowsError(try tmpdir.foo.realpath())
+        }
+    }
+
+    func testFileReference() throws {
+        let ref = Path.home.fileReferenceURL
+    #if !os(Linux)
+        XCTAssertTrue(ref?.isFileReferenceURL() ?? false)
+    #endif
+        XCTAssertEqual(ref?.path, Path.home.string)
+    }
+
+    func testURLInitializer() throws {
+        XCTAssertEqual(Path(url: Path.home.url), Path.home)
+        XCTAssertEqual(Path.home.fileReferenceURL.flatMap(Path.init), Path.home)
+        XCTAssertNil(Path(url: URL(string: "https://foo.com")!))
+        XCTAssertNil(Path(url: NSURL(string: "https://foo.com")!))
+    }
+
+    func testInitializerForRelativePath() throws {
+        XCTAssertNil(Path("foo"))
+        XCTAssertNil(Path("../foo"))
+        XCTAssertNil(Path("./foo"))
+    }
 }

Tests/PathTests/TemporaryDirectory.swift

@@ -1,8 +1,9 @@
+@testable import Path
 import Foundation
 
-public class TemporaryDirectory {
+class TemporaryDirectory {
-    public let url: URL
+    let url: URL
-    public var path: Path { return Path(string: url.path) }
+    var path: Path { return Path(string: url.path) }
 
     /**
      Creates a new temporary directory.
@@ -19,7 +20,7 @@ public class TemporaryDirectory {
      - Parameter appropriateFor: The temporary directory will be located on this
      volume.
     */
-    public init(appropriateFor: URL? = nil) throws {
+    init(appropriateFor: URL? = nil) throws {
       #if !os(Linux)
         let appropriate: URL
         if let appropriateFor = appropriateFor {
@@ -41,13 +42,34 @@ public class TemporaryDirectory {
     }
 
     deinit {
-        _ = try? FileManager.default.removeItem(at: url)
+        do {
+            try path.chmod(0o777).delete()
+        } catch {
+            //TODO log
+        }
     }
 }
 
-public extension Path {
+extension Path {
     static func mktemp<T>(body: (Path) throws -> T) throws -> T {
         let tmp = try TemporaryDirectory()
         return try body(tmp.path)
     }
 }
+
+
+#if !os(macOS) && !os(Linux)
+import XCTest
+
+// SwiftPM generates code that is improperly escaped thus we require this to
+// compile on iOS & tvOS.
+public typealias XCTestCaseEntry = (testCaseClass: XCTestCase.Type, allTests: [(String, (XCTestCase) throws -> Void)])
+
+public func testCase<T: XCTestCase>(_ allTests: [(String, (T) -> () throws -> Void)]) -> XCTestCaseEntry {
+    fatalError()
+}
+
+public func testCase<T: XCTestCase>(_ allTests: [(String, (T) -> () -> Void)]) -> XCTestCaseEntry {
+    fatalError()
+}
+#endif

Tests/PathTests/XCTestManifests.swift

@@ -3,19 +3,51 @@ import XCTest
 extension PathTests {
     static let __allTests = [
         ("testBasename", testBasename),
+        ("testBundleExtensions", testBundleExtensions),
         ("testCodable", testCodable),
+        ("testCommonDirectories", testCommonDirectories),
         ("testConcatenation", testConcatenation),
+        ("testCopyInto", testCopyInto),
+        ("testCopyTo", testCopyTo),
+        ("testDataExtensions", testDataExtensions),
+        ("testDelete", testDelete),
+        ("testDynamicMember", testDynamicMember),
         ("testEnumeration", testEnumeration),
+        ("testEnumerationSkippingHiddenFiles", testEnumerationSkippingHiddenFiles),
         ("testExists", testExists),
+        ("testExtension", testExtension),
+        ("testFileHandleExtensions", testFileHandleExtensions),
+        ("testFileReference", testFileReference),
+        ("testFilesystemAttributes", testFilesystemAttributes),
+        ("testInitializerForRelativePath", testInitializerForRelativePath),
         ("testIsDirectory", testIsDirectory),
+        ("testJoin", testJoin),
+        ("testLock", testLock),
         ("testMkpathIfExists", testMkpathIfExists),
         ("testMktemp", testMktemp),
+        ("testMoveInto", testMoveInto),
+        ("testMoveTo", testMoveTo),
+        ("testNoUndesiredSymlinkResolution", testNoUndesiredSymlinkResolution),
+        ("testReadlinkOnFileReturnsSelf", testReadlinkOnFileReturnsSelf),
+        ("testReadlinkOnNonExistantFileThrows", testReadlinkOnNonExistantFileThrows),
+        ("testReadlinkOnRelativeSymlink", testReadlinkOnRelativeSymlink),
+        ("testReadlinkWhereLinkDestinationDoesNotExist", testReadlinkWhereLinkDestinationDoesNotExist),
+        ("testRealpath", testRealpath),
+        ("testRelativeCodable", testRelativeCodable),
         ("testRelativePathCodable", testRelativePathCodable),
         ("testRelativeTo", testRelativeTo),
+        ("testRename", testRename),
+        ("testSort", testSort),
+        ("testStringConvertibles", testStringConvertibles),
+        ("testStringExtensions", testStringExtensions),
+        ("testSymlinkFunctions", testSymlinkFunctions),
+        ("testTimes", testTimes),
+        ("testTouchThrowsIfCannotWrite", testTouchThrowsIfCannotWrite),
+        ("testURLInitializer", testURLInitializer),
     ]
 }
 
-#if os(Linux)
+#if !os(macOS)
 public func __allTests() -> [XCTestCaseEntry] {
     return [
         testCase(PathTests.__allTests),