Path(_ url:) -> Path(url:)

Fill in this TODO in README
[skip ci]
2019-02-11 20:40:27 -05:00 · 2019-02-11 15:13:14 -05:00 · 2019-02-11 15:11:22 -05:00 · 2019-02-11 15:06:56 -05:00 · 2019-02-11 14:19:27 -05:00 · 2019-02-11 14:04:06 -05:00
19 changed files with 1895 additions and 231 deletions
--- a/.github/codecov.yml
+++ b/.github/codecov.yml
@@ -0,0 +1,2 @@
+ignore:
+  - Tests
--- a/.github/ranger.yml
+++ b/.github/ranger.yml
@@ -0,0 +1,2 @@
+merges:
+  - action: delete_branch
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,5 @@
 .DS_Store
 /.build
 /*.xcodeproj
+/build
+/docs
--- a/.travis.yml
+++ b/.travis.yml
@@ -0,0 +1,132 @@
+# 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 --parallel
+      name: macOS / Swift 4.2.1
+
+    - &xcodebuild
+      before_install: swift package generate-xcodeproj --enable-code-coverage
+      xcode_destination: platform=iOS Simulator,OS=latest,name=iPhone XS
+      name: iOS / Swift 4.2.1
+      after_success: bash <(curl -s https://codecov.io/bash)
+    - <<: *xcodebuild
+      xcode_destination: platform=tvOS Simulator,OS=latest,name=Apple TV
+      name: tvOS / Swift 4.2.1
+    - <<: *xcodebuild
+      name: watchOS / Swift 4.2.1
+      script: |
+        set -o pipefail
+        xcodebuild \
+          -project Path.swift.xcodeproj \
+          -scheme Path.swift-Package \
+          -destination 'platform=watchOS Simulator,OS=latest,name=Apple Watch Series 4 - 40mm' \
+          build | xcpretty
+      after_success: false
+
+    - &linux
+      env: SWIFT_VERSION=4.2.1
+      os: linux
+      name: Linux / Swift 4.2.1
+      language: generic
+      dist: trusty
+      sudo: false
+      install: eval "$(curl -sL https://swiftenv.fuller.li/install.sh)"
+      script: swift test --parallel
+      
+    - <<: *linux
+      env: SWIFT_VERSION='5.0-DEVELOPMENT-SNAPSHOT-2019-01-22-a'
+      name: Linux / Swift 5.0.0-dev (2019-01-22)
+      
+    - stage: pretest
+      name: Check Linux tests are sync’d
+      install: swift test --generate-linuxmain
+      script: git diff --exit-code
+
+    - stage: deploy
+      name: Jazzy
+      before_install: |
+        cat <<\ \ EOF> .jazzy.yaml
+        module: Path
+        module_version: TRAVIS_TAG
+        custom_categories:
+          - name: Path
+            children:
+              - Path
+              - /(_:_:)
+        xcodebuild_arguments:
+          - UseModernBuildSystem=NO
+        output: output
+        github_url: https://github.com/mxcl/Path.swift
+        exclude:
+          - Sources/Path+StringConvertibles.swift
+        EOF
+        sed -i '' "s/TRAVIS_TAG/$TRAVIS_TAG/" .jazzy.yaml
+      # ^^ this weirdness because Travis multiline YAML is broken and inserts
+      # two spaces in front of the output which means we need a prefixed
+      # delimiter which also weirdly stops bash from doing variable substitution
+      install: gem install jazzy
+      before_script: swift package generate-xcodeproj
+      script: jazzy
+      deploy:
+        provider: pages
+        skip-cleanup: true
+        github-token: $GITHUB_TOKEN
+        local-dir: output
+        on:
+          tags: true
+
+    - name: CocoaPods
+      before_install: export TRAVIS_REPO_NAME=${TRAVIS_REPO_SLUG#*/}
+      install: gem install cocoapods
+      before_script: |
+        export DESCRIPTION=$(swift - <<\ \ EOF
+          import Foundation
+          struct Response: Decodable { let description: String }
+          let token = ProcessInfo.processInfo.environment["GITHUB_TOKEN"]!
+          let slug = ProcessInfo.processInfo.environment["TRAVIS_REPO_SLUG"]!
+          let url = URL(string: "https://api.github.com/repos/\(slug)")!
+          var rq = URLRequest(url: url)
+          rq.setValue("token \(token)", forHTTPHeaderField: "Authorization")
+          let semaphore = DispatchSemaphore(value: 0)
+          var data: Data!
+          URLSession.shared.dataTask(with: rq) { d, _, _ in
+              data = d
+              semaphore.signal()
+          }.resume()
+          semaphore.wait()
+          let rsp = try JSONDecoder().decode(Response.self, from: data)
+          print(rsp.description, terminator: "")
+        EOF)
+        cat <<\ \ EOF> $TRAVIS_REPO_NAME.podspec
+        Pod::Spec.new do |s|
+          s.name = ENV['TRAVIS_REPO_NAME']
+          s.version = ENV['TRAVIS_TAG']
+          s.summary = ENV['DESCRIPTION']
+          s.homepage = "https://github.com/#{ENV['TRAVIS_REPO_SLUG']}"
+          s.license = { type: 'Unlicense', file: 'LICENSE.md' }
+          s.author = { mxcl: 'mxcl@me.com' }
+          s.source = { git: "https://github.com/#{ENV['TRAVIS_REPO_SLUG']}.git", tag: s.version }
+          s.social_media_url = 'https://twitter.com/mxcl'
+          s.osx.deployment_target = '10.10'
+          s.ios.deployment_target = '8.0'
+          s.tvos.deployment_target = '10.0'
+          s.watchos.deployment_target = '3.0'
+          s.source_files = 'Sources/*'
+          s.swift_version = '4.2'
+        end
+        EOF
+      script: pod trunk push
--- a/Package@swift-5.0.swift
+++ b/Package@swift-5.0.swift
@@ -0,0 +1,20 @@
+// 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"]),
+    ]
+)
+
+pkg.platforms = [
+   .macOS(.v10_10), .iOS(.v8), .tvOS(.v10), .watchOS(.v3)
+]
+pkg.swiftLanguageVersions = [
+    .v4_2, .v5
+]
--- a/README.md
+++ b/README.md
@@ -1,9 +1,11 @@
-# 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
-end‐results.
+A file-system pathing library focused on developer experience and robust end
+results.

 ```swift
+import Path
+
 // convenient static members
 let home = Path.home

@@ -13,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
-try Path.home.join("foo").mkpath().join("bar").chmod(0o555)
+// elegant, chainable syntax
+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
-try Path.root.join("foo").copy(into: Path.root.mkdir("bar"))
-// ^^ other libraries would make the `to:` form handle both these cases
-// but that can easily lead to bugs where you accidentally write files that
-// were meant to be directory destinations
+// careful API considerations so as to avoid common bugs
+let foo = try Path.root.join("foo").copy(into: Path.root.join("bar").mkdir())
+print(foo)         // => /bar/foo
+print(foo.isFile)  // => true
+
+// 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 *may 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
-can continue to make tools and software you need and love. I appreciate it x.
+probably you already use some of it (Homebrew anyone?). I work full-time on
+open source and it’s hard; currently I earn *less* than minimum wage. Please
+help me continue my work, I appreciate it x

 <a href="https://www.patreon.com/mxcl">
 	<img src="https://c5.patreon.com/external/logo/become_a_patron_button@2x.png" width="160">
 </a>

+[Other donation/tipping options](http://mxcl.github.io/donate/)
+
+# Handbook
+
+Our [online API documentation][docs] covers 100% of our public API and is
+automatically updated for new releases.
+
 ## Codable

 We support `Codable` as you would expect:
@@ -77,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
@@ -90,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:
@@ -102,8 +140,7 @@ bashProfile += "\n\nfoo"

 try bashProfile.write(to: Path.home/".bash_profile")

-try Bundle.main.resources!.join("foo").copy(to: .home)
-// ^^ `-> Path?` because the underlying `Bundle` function is `-> String?`
+try Bundle.main.resources.join("foo").copy(to: .home)
 ```

 ## Directory listings
@@ -112,34 +149,190 @@ We provide `ls()`, called because it behaves like the Terminal `ls` function,
 the name thus implies its behavior, ie. that it is not recursive.

 ```swift
-for path in Path.home.ls() {
-    print(path.path)
-    print(path.kind)  // .directory or .file
+for entry in Path.home.ls() {
+    print(entry.path)
+    print(entry.kind)  // .directory or .file
 }

-for path in Path.home.ls() where path.kind == .file {
+for entry in Path.home.ls() where entry.kind == .file {
    //…
 }

-for path in Path.home.ls() where path.mtime > yesterday {
+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%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
--- a/Sources/Extensions.swift
+++ b/Sources/Extensions.swift
@@ -1,22 +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
+    }
+
+    /// 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)
@@ -31,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)
@@ -43,7 +67,11 @@ public extension Data {
    func write(to: Path, atomically: Bool = false) throws -> Path {
        let opts: NSData.WritingOptions
        if atomically {
+        #if !os(Linux)
            opts = .atomicWrite
+        #else
+            opts = .atomic
+        #endif
        } else {
            opts = []
        }
@@ -51,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
+    }
+}
--- a/Sources/Path+Attributes.swift
+++ b/Sources/Path+Attributes.swift
@@ -1,23 +1,74 @@
 import Foundation

 public extension Path {
-    /// - Note: If file is already locked, does nothing
-    /// - Note: If file doesn’t exist, throws
+    //MARK: Filesystem Attributes
+
+    /**
+     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()
-        }
-    }
 }
--- a/Sources/Path+Codable.swift
+++ b/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")!
 }

+/**
+ 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 {
--- a/Sources/Path+CommonDirectories.swift
+++ b/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
+
--- a/Sources/Path+FileManager.swift
+++ b/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 {
-        if overwrite, to.exists {
+    func copy(to: Path, overwrite: Bool = false) throws -> Path {
+        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,89 +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)
-        } else if overwrite, !into.isDirectory {
-            try into.delete()
+            try into.mkdir(.p)
        }
        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(into: Path) throws -> Path {
+    func move(to: Path, overwrite: Bool = false) throws -> Path {
+        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
+    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)
        }
-        try FileManager.default.moveItem(at: url, to: into.join(basename()).url)
-        return self
+        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 {
-        try FileManager.default.removeItem(at: url)
+    func delete() throws {
+        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)
-    }
-
-    @inlinable
-    @discardableResult
-    public func mkdir() throws -> Path {
-        do {
-            try FileManager.default.createDirectory(at: url, withIntermediateDirectories: false, attributes: nil)
-        } catch CocoaError.Code.fileWriteFileExists {
-            // noop
-        }
-        return self
-    }
-
-    @inlinable
-    @discardableResult
-    public func mkpath() throws -> Path {
-        do {
-            try FileManager.default.createDirectory(at: url, withIntermediateDirectories: true, attributes: nil)
-        } catch CocoaError.Code.fileWriteFileExists {
-            // noop
-        }
-        return self
-    }
-
-    /// - Note: If file doesn’t exist, creates file
-    /// - Note: If file is not writable, makes writable first, resetting permissions after the write
-    @discardableResult
-    public func replaceContents(with contents: String, atomically: Bool = false, encoding: String.Encoding = .utf8) throws -> Path {
-        let resetPerms: Int?
-        if exists, !isWritable {
-            resetPerms = try FileManager.default.attributesOfItem(atPath: string)[.posixPermissions] as? Int
-            let perms = resetPerms ?? 0o777
-            try chmod(perms | 0o200)
+        if !exists {
+            guard FileManager.default.createFile(atPath: string, contents: nil) else {
+                throw CocoaError.error(.fileWriteUnknown)
+            }
        } else {
-            resetPerms = nil
+        #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
        }
-
-        defer {
-            _ = try? resetPerms.map(self.chmod)
-        }
-
-        try contents.write(to: self)
-
        return self
    }
+
+    /**
+     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 {
+            let wid = options == .p
+            try FileManager.default.createDirectory(at: self.url, withIntermediateDirectories: wid, attributes: nil)
+        } catch CocoaError.Code.fileWriteFileExists {
+            //noop (fails to trigger on Linux)
+        } catch {
+        #if os(Linux)
+            let error = error as NSError
+            guard error.domain == NSCocoaErrorDomain, error.code == CocoaError.Code.fileWriteFileExists.rawValue else {
+                throw error
+            }
+        #else
+            throw error
+        #endif
+        }
+        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
+    func rename(to newname: String) throws -> Path {
+        let newpath = parent/newname
+        try FileManager.default.moveItem(atPath: string, toPath: newpath.string)
+        return newpath
+    }
+
+    /**
+     Creates a symlink of this file at `as`.
+     - Note: If `self` does not exist, is **not** an error.
+     */
+    @discardableResult
+    func symlink(as: Path) throws -> Path {
+        try FileManager.default.createSymbolicLink(atPath: `as`.string, withDestinationPath: string)
+        return `as`
+    }
+
+    /**
+     Creates a symlink of this file with the same filename in the `into` directory.
+     - 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()
+        try FileManager.default.createSymbolicLink(atPath: dst.string, withDestinationPath: string)
+        return dst
+    }
+}
+
+/// Options for `Path.mkdir(_:)`
+public enum MakeDirectoryOptions {
+    /// Creates intermediary directories; works the same as `mkdir -p`.
+    case p
 }
--- a/Sources/Path+StringConvertibles.swift
+++ b/Sources/Path+StringConvertibles.swift
@@ -1,21 +1,13 @@
-import class Foundation.NSString
-
-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 {    
+    /// Returns `Path.string`
    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))"
    }
 }
--- a/Sources/Path+ls.swift
+++ b/Sources/Path+ls.swift
@@ -1,24 +1,64 @@
 import Foundation

+/**
+ A file entry from a directory listing.
+ - SeeAlso: `ls()`
+*/
+public struct Entry {
+    /// The kind of this directory entry.
+    public enum Kind {
+        /// The path is a file.
+        case file
+        /// The path is a directory.
+        case directory
+    }
+    /// The kind of this entry.
+    public let kind: Kind
+    /// The path of this entry.
+    public let path: Path
+}
+
 public extension Path {    
-    /// same as the `ls` command ∴ is ”shallow”
-    func ls() throws -> [Entry] {
-        let relativePaths = try FileManager.default.contentsOfDirectory(atPath: string)
-        func convert(relativePath: String) -> Entry {
-            let path = self/relativePath
+    //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
--- a/Sources/Path->Bool.swift
+++ b/Sources/Path->Bool.swift
@@ -1,21 +1,65 @@
 import Foundation
+#if os(Linux)
+import func Glibc.access
+#else
+import Darwin
+#endif

 public extension Path {
-    var isWritable: Bool {
-        return FileManager.default.isWritableFile(atPath: string)
-    }
-
-    var isDirectory: Bool {
-        var isDir: ObjCBool = false
-        return FileManager.default.fileExists(atPath: string, isDirectory: &isDir) && isDir.boolValue
+    //MARK: Filesystem Properties
+
+    /// Returns true if the path represents an actual filesystem entry.
+    var exists: Bool {
+        return FileManager.default.fileExists(atPath: string)
    }

+    /// 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 exists: Bool {
-        return FileManager.default.fileExists(atPath: string)
+    /// Returns true if the path represents an actual directory.
+    var isDirectory: Bool {
+        var isDir: ObjCBool = false
+        return FileManager.default.fileExists(atPath: string, isDirectory: &isDir) && isDir.boolValue
+    }
+
+    /// Returns true if the path represents an actual file that is also readable by the current user.
+    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 
    }
 }
--- a/Sources/Path.swift
+++ b/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 {
-        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
+    /// Returns a `URL` representing this file path.
    public var url: URL {
        return URL(fileURLWithPath: string)
    }

-    public func basename(dropExtension: Bool = false) -> String {
-        let str = string as NSString
-        if !dropExtension {
-            return str.lastPathComponent
-        } else {
-            let ext = str.pathExtension
-            if !ext.isEmpty {
-                return String(str.lastPathComponent.dropLast(ext.count + 1))
+    /**
+     Returns a file-reference URL.
+     - Note: Only NSURL can be a file-reference-URL, hence we return NSURL.
+     - SeeAlso: https://developer.apple.com/documentation/foundation/nsurl/1408631-filereferenceurl
+     - Important: On Linux returns an file scheme NSURL for this path string.
+     */
+    public var fileReferenceURL: NSURL? {
+    #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)
-        let str = (string as NSString).appendingPathComponent(String(part))
-        return Path(string: (str as NSString).standardizingPath)
+    /**
+     The basename for the provided file, optionally dropping the file extension.
+
+         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 {
-        public enum Kind {
-            case file
-            case directory
+@inline(__always)
+private func join_<S>(prefix: String, appending: S) -> String where S: StringProtocol {
+    return join_(prefix: prefix, pathComponents: appending.split(separator: "/"))
+}
+
+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
    }
-}
-
-@inlinable
-public func /<S>(lhs: Path, rhs: S) -> Path where S: StringProtocol {
-    return lhs.join(rhs)
+    return rv
 }
--- a/Sources/TemporaryDirectory.swift
+++ b/Sources/TemporaryDirectory.swift
@@ -1,21 +0,0 @@
-import Foundation
-
-public class TemporaryDirectory {
-    public let url: URL
-    public var path: Path { return Path(string: url.path) }
-
-    public init() throws {
-        url = try FileManager.default.url(for: .itemReplacementDirectory, in: .userDomainMask, appropriateFor: URL(fileURLWithPath: "/"), create: true)
-    }
-
-    deinit {
-        _ = try? FileManager.default.removeItem(at: url)
-    }
-}
-
-public extension Path {
-    static func mktemp<T>(body: (Path) throws -> T) throws -> T {
-        let tmp = try TemporaryDirectory()
-        return try body(tmp.path)
-    }
-}
--- a/Tests/PathTests/PathTests.swift
+++ b/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() {
@@ -37,12 +71,28 @@ class PathTests: XCTestCase {

    func testExists() {
        XCTAssert(Path.root.exists)
-        XCTAssert((Path.root/"Users").exists)
+        XCTAssert((Path.root/"bin").exists)
    }

    func testIsDirectory() {
        XCTAssert(Path.root.isDirectory)
-        XCTAssert((Path.root/"Users").isDirectory)
+        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 {
@@ -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")
-        XCTAssertEqual(Path.root.join("foo").basename(dropExtension: true), "foo")
-        XCTAssertEqual(Path.root.join("foo.").basename(dropExtension: true), "foo.")
-        XCTAssertEqual(Path.root.join("foo.bar.baz").basename(dropExtension: true), "foo.bar")
+        for prefix in [Path.root, Path.root.foo, Path.root.foo.bar] {
+            XCTAssertEqual(prefix.join("foo.bar").basename(dropExtension: true), "foo")
+            XCTAssertEqual(prefix.join("foo").basename(dropExtension: true), "foo")
+            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"))
+    }
 }
--- a/Tests/PathTests/TemporaryDirectory.swift
+++ b/Tests/PathTests/TemporaryDirectory.swift
@@ -0,0 +1,75 @@
+@testable import Path
+import Foundation
+
+class TemporaryDirectory {
+    let url: URL
+    var path: Path { return Path(string: url.path) }
+
+    /**
+     Creates a new temporary directory.
+
+     The directory is recursively deleted when this object deallocates.
+
+     If you need a temporary directory on a specific volume use the `appropriateFor`
+     parameter.
+
+     - Important: If you are moving a file, ensure to use the `appropriateFor`
+     parameter, since it is volume aware and moving the file across volumes will take
+     exponentially longer!
+     - Important: The `appropriateFor` parameter does not work on Linux.
+     - Parameter appropriateFor: The temporary directory will be located on this
+     volume.
+    */
+    init(appropriateFor: URL? = nil) throws {
+      #if !os(Linux)
+        let appropriate: URL
+        if let appropriateFor = appropriateFor {
+            appropriate = appropriateFor
+        } else if #available(OSX 10.12, iOS 10, tvOS 10, watchOS 3, *) {
+            appropriate = FileManager.default.temporaryDirectory
+        } else {
+            appropriate = URL(fileURLWithPath: NSTemporaryDirectory())
+        }
+        url = try FileManager.default.url(for: .itemReplacementDirectory, in: .userDomainMask, appropriateFor: appropriate, create: true)
+      #else
+        let envs = ProcessInfo.processInfo.environment
+        let env = envs["TMPDIR"] ?? envs["TEMP"] ?? envs["TMP"] ?? "/tmp"
+        let dir = Path.root/env/"swift-sh.XXXXXX"
+        var template = [UInt8](dir.string.utf8).map({ Int8($0) }) + [Int8(0)]
+        guard mkdtemp(&template) != nil else { throw CocoaError.error(.featureUnsupported) }
+        url = URL(fileURLWithPath: String(cString: template))
+      #endif
+    }
+
+    deinit {
+        do {
+            try path.chmod(0o777).delete()
+        } catch {
+            //TODO log
+        }
+    }
+}
+
+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
--- a/Tests/PathTests/XCTestManifests.swift
+++ b/Tests/PathTests/XCTestManifests.swift
@@ -3,15 +3,47 @@ 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),
    ]
 }
Author	SHA1	Message	Date
Max Howell	c9d300a7b6	Path(_ url:) -> Path(url:)	2019-02-11 20:40:27 -05:00
Max Howell	ed4b773870	Fill in this TODO in README [skip ci]	2019-02-11 15:13:14 -05:00
Max Howell	097e020735	There are no usernames on iOS etc.	2019-02-11 15:11:22 -05:00
Max Howell	be49fb9e49	Merge pull request #34 from mxcl/symlinks Symlink funcs & support `NSURL` file-refs	2019-02-11 15:06:56 -05:00
Max Howell	164cd2b413	Fix iOS, etc.	2019-02-11 14:19:27 -05:00
Max Howell	709c3fb99d	Symlink funcs & support `NSURL` file-refs * Also removes most `NSString` usage * Also does more thorough testing in some places * Also adds * Fixes `Path?(_:)` resolving symlinks in some cases	2019-02-11 14:04:06 -05:00
repo-ranger[bot]	6c84754ad8	Merge pull request #33 from mxcl/bundle-private-frameworks Bundle.privateFrameworks	2019-02-09 18:32:02 +00:00
Max Howell	8469565b06	Bundle.privateFrameworks	2019-02-09 13:24:57 -05:00
Max Howell	ed45d10179	Docs updates; CocoaPods 16.0 release; [ci skip]	2019-02-08 09:14:23 -05:00
Max Howell	8033ae49b4	Add [pathos] [pathos]: https://github.com/dduan/Pathos [skip ci]	2019-02-04 12:05:14 -05:00
Max Howell	b290173486	Update travis scripts	2019-02-04 12:04:48 -05:00
Max Howell	8248354a80	Some documentation improvements	2019-02-01 15:18:15 -05:00
Max Howell	14963e48f5	Merge pull request #30 from mxcl/codecov More coverage	2019-02-01 10:26:59 -05:00
Max Howell	7f5340bc19	More coverage Though I can hardly test these functions, at least we can verify they run without crashing etc.	2019-02-01 10:17:37 -05:00
Max Howell	74074c634f	Merge pull request #29 from mxcl/codecov More coverage	2019-01-31 21:33:50 -05:00
Max Howell	74656bbfcd	More coverage	2019-01-31 21:17:37 -05:00
Max Howell	cced2af2cd	Merge pull request #28 from mxcl/codecov More coverage	2019-01-31 19:17:43 -05:00
Max Howell	b9abd07318	More coverage	2019-01-31 19:09:36 -05:00
Max Howell	6b52932e7b	Merge pull request #27 from mxcl/codecov More coverage	2019-01-31 16:29:08 -05:00
Max Howell	c456081e65	More coverage	2019-01-31 14:26:09 -05:00
Max Howell	ec6c0113f9	Remaining code coverage Can’t do coverage for Linux unfortunately.	2019-01-31 13:11:50 -05:00
Max Howell	7970c4d8a7	Document robustness & XP [ci skip]	2019-01-31 12:38:41 -05:00
Max Howell	e342da8644	Remove auto-tagging since I can do this manually	2019-01-31 12:28:16 -05:00
Max Howell	9aa91c649e	Merge pull request #26 from mxcl/codecov Increase code coverage	2019-01-31 12:25:41 -05:00
Max Howell	62ea0d47b3	Fixes & increased code coverage	2019-01-31 12:15:31 -05:00
repo-ranger[bot]	ab9a70e947	Merge pull request #25 from mxcl/rename Refactor rename -> rename(to:)	2019-01-31 15:32:59 +00:00
Max Howell	49ef073e34	Refactor rename -> rename(to:)	2019-01-31 10:15:39 -05:00
Max Howell	889d825b3a	Merge pull request #24 from mxcl/rename Rename	2019-01-31 10:08:02 -05:00
Max Howell	f1cd06fdff	Add CI post success hook yamls	2019-01-31 09:58:46 -05:00
Max Howell	c6e840b9b6	Add `rename`	2019-01-31 08:39:54 -05:00
Max Howell	eb34ac4af8	Add overwrite parameter to move(into:)	2019-01-31 08:37:32 -05:00
Max Howell	66ae86c986	Enable codecov.io	2019-01-31 08:37:14 -05:00
Max Howell	c432f710eb	Merge pull request #22 from mxcl/files() Entry.files defaults to all files	2019-01-28 12:17:08 -05:00
Max Howell	19c0c19bb6	Entry.files defaults to all files	2019-01-28 12:04:47 -05:00
Max Howell	ee1f46954c	Fixes #20 [skip ci]	2019-01-28 11:05:51 -05:00
Max Howell	2394cc1c85	Merge pull request #19 from JaapWijnen/filehandle-extensions added extension to initialize filehandle from path	2019-01-27 16:59:44 -05:00
Jaap Wijnen	50bb319619	added extension to initialize filehandle from path	2019-01-27 22:57:19 +01:00
Max Howell	9f40068833	Badge for Swift 5 support	2019-01-26 16:15:45 -05:00
Max Howell	67f4e5f41a	Merge pull request #16 from mxcl/bundle-non-optional Bundle extensions don’t return optional Paths	2019-01-26 15:46:03 -05:00
Max Howell	83c83dcaba	Bundle extensions don’t return optional Paths Rationale: Paths are not guaranteed to exist, the Bundle functions return optional if the path doesn't exist. So we'll provide a sensible default instead and you need to check the result exists at some point instead. This makes more elegant chains, the chain will fail when you operate on it, but you don’t have to do a check for optional first. Or risk a bang.	2019-01-26 15:20:32 -05:00
Max Howell	93e2701950	Docs tweaks [ci skip]	2019-01-26 15:10:52 -05:00
Max Howell	bbf1f24ef6	Fix Cocoapods deploy	2019-01-26 14:42:00 -05:00
Max Howell	c08ccdfb30	Merge pull request #15 from mxcl/dynamic-members Dynamic members	2019-01-26 13:34:17 -05:00
Max Howell	859164e59f	Dynamic Members	2019-01-26 13:23:25 -05:00
Max Howell	44be1c45a9	Add `Path.ctime`	2019-01-26 13:17:39 -05:00
Max Howell	99b948f9c1	Minor documentation fixes [ci skip]	2019-01-26 13:17:39 -05:00
Max Howell	3beba13677	Merge pull request #14 from mxcl/delete-noop Delete noop	2019-01-26 11:12:17 -05:00
Max Howell	bafb05ff54	Document noop behavior	2019-01-26 11:05:49 -05:00
Max Howell	356a1b3ac2	Delete is a noop if file doesn’t exist Closes #11.	2019-01-26 11:05:31 -05:00
Max Howell	6d8712f4d6	Remove mkpath, add mkdir(.p)	2019-01-26 11:05:10 -05:00
Max Howell	8744b68709	Make nodoc work for Codable	2019-01-26 10:59:20 -05:00
Max Howell	9ea32048f7	Merge pull request #13 from mxcl/more-docs Improved documentation; Fixes #12	2019-01-25 21:20:24 -05:00
Max Howell	4b16dac3bf	Improved documentation; Fixes #12	2019-01-25 20:46:37 -05:00
Max Howell	b613449232	Making this static will fix documentation location [ci skip]	2019-01-25 12:23:54 -05:00
Max Howell	db135e32c8	Tag 0.5.0	2019-01-25 11:08:57 -05:00
Max Howell	bfcc48db20	Merge pull request #10 from mxcl/fixes Swift 5 / Xcode 10.2 / Fixes	2019-01-25 11:04:35 -05:00
Max Howell	b0bf0d0074	This is not yet fixed in Linux Swift 5.0	2019-01-25 10:55:02 -05:00
Max Howell	5f364fe21b	Test against Swift 5 snapshot	2019-01-25 10:40:10 -05:00
Max Howell	fdff3bcc05	Swift 5 --warnings	2019-01-24 15:02:06 -05:00
Max Howell	2388c384a1	Swift 5 Manifest (untested until Travis catches up)	2019-01-24 15:01:53 -05:00
Max Howell	80960f5876	Don’t overwrite a file with a directory	2019-01-24 14:44:01 -05:00
Max Howell	9eca479f7b	Fix mtime return so it is as per doc contract	2019-01-24 14:43:45 -05:00
Max Howell	ca9f1e0a74	Parallelize tests	2019-01-23 11:25:51 -05:00
Max Howell	de4fb3ae47	Remove replaceContents, user can use String.write	2019-01-22 17:57:28 -05:00
Max Howell	58d026c8a9	Fix copy(into:) overwrite mode Seems like Linux Foundation has a bug I checked, seems fixed in Swift 5. But added a swift version check se we can verify and if not report the bug.	2019-01-22 15:26:04 -05:00
Max Howell	43d3e0a745	Improve docs	2019-01-21 14:30:12 -05:00
Max Howell	21fb03b9d9	Test `..` paths work with `join`	2019-01-21 14:26:56 -05:00
Max Howell	3333c731d3	Fix Travis	2019-01-21 12:57:13 -05:00
Max Howell	e15173cfbc	Merge pull request #9 from LucianoPAlmeida/is-path-conveniece-add Adding convenience extensions on Path->Bool	2019-01-20 19:28:05 -05:00
Luciano Almeida	7be264a38e	Adding convenience extensions on Path->Bool	2019-01-20 22:13:13 -02:00
Max Howell	aac81b85a4	Merge pull request #8 from mxcl/better-deploy Better deploy	2019-01-20 18:53:11 -05:00
Max Howell	3644124a36	Fix testing on tvOS/iOS	2019-01-20 18:44:24 -05:00
Max Howell	ca4ac3ec8f	Fix stage types in .travis.yml	2019-01-20 17:33:56 -05:00
Max Howell	920f007660	Fix Linux testEnumerationSkippingHiddenFiles()	2019-01-20 17:32:39 -05:00
Max Howell	751b855a26	Pretest that fails if Linux tests aren't current	2019-01-20 17:25:46 -05:00
Max Howell	c0e5023632	Better deployment of Jazzy and Pods	2019-01-20 17:13:03 -05:00
Max Howell	e0c62108e8	Update Linux tests	2019-01-20 16:30:02 -05:00
Max Howell	5cc2fcbf30	Tag 0.4.1	2019-01-20 16:26:22 -05:00
Max Howell	7595c601e8	Attempt custom Jazzy index/contents	2019-01-20 16:24:06 -05:00
Luciano Almeida	d8ea357459	Adding `ls -a` like functionality to Path.ls()	2019-01-20 16:23:40 -05:00
Max Howell	86798755be	Deploy to CocoaPods	2019-01-20 13:37:34 -05:00
Max Howell	152ad8a8ae	Implementations of CommonDirs for Linux	2019-01-20 13:03:38 -05:00
Max Howell	a98ba37e59	Merge pull request #1 from itsallmememe/master Common Directories	2019-01-20 12:30:29 -05:00
Max Howell	1c2cffada5	Support CocoaPods	2019-01-19 22:12:06 -05:00
Max Howell	6c24de4875	Fix actually deploying	2019-01-19 15:08:11 -05:00
Max Howell	6df12b3bb9	Refer to alternative packages	2019-01-19 15:07:47 -05:00
Max Howell	d52cdf96c4	Merge pull request #4 from mxcl/more-docs More docs	2019-01-19 14:46:46 -05:00
Max Howell	3eda9a9741	100% documentation please	2019-01-19 14:36:27 -05:00
Max Howell	29149da72b	Use FileManager.homeDirectory where possible	2019-01-19 14:35:42 -05:00
Max Howell	cd30e89808	Remove TemporaryDirectory This violates the responsibility of this framework.	2019-01-19 14:20:12 -05:00
Max Howell	9f76eeb507	Link to Jazzy docs	2019-01-19 12:55:18 -05:00
Max Howell	b5bdaa6ceb	Fix Jazzy root-url	2019-01-19 12:52:47 -05:00
Max Howell	17dd706115	Merge pull request #3 from mxcl/jazzy Generate Jazzy docs in Travis	2019-01-19 12:40:21 -05:00
Max Howell	903038ae80	Generate Jazzy docs in Travis	2019-01-19 12:34:35 -05:00
Max Howell	f56811d64f	Document various rules and caveats	2019-01-18 17:47:04 -05:00
Max Howell	f99e7b5ae7	Test iOS, tvOS & watchOS	2019-01-18 13:37:28 -05:00
Max Howell	9553968d66	Add Travis badge	2019-01-18 12:27:05 -05:00
Niall McCormack	12c7b348d6	added hooks for common directories - Documents, Caches and Application Support	2019-01-19 00:24:20 +08:00
Max Howell	3541c6ec8d	Tidy	2019-01-18 09:25:24 -05:00
Max Howell	b4c92f86dc	Fix tests on Linux	2019-01-17 18:23:22 -05:00
Max Howell	cac06d89fb	Linux	2019-01-17 17:31:29 -05:00
Max Howell	4af0ee3983	Missing functions	2019-01-17 17:31:14 -05:00