Merge pull request #27 from mxcl/codecov

More coverage

.github/codecov.yml

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

.github/ranger.yml

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

.travis.yml

@@ -19,9 +19,10 @@ jobs:
       name: macOS / Swift 4.2.1
 
     - &xcodebuild
-      before_install: swift package generate-xcodeproj
+      before_install: swift package generate-xcodeproj --enable-code-coverage
       xcode_destination: platform=iOS Simulator,OS=latest,name=iPhone XS
       name: iOS / 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
@@ -34,6 +35,7 @@ jobs:
           -scheme Path.swift-Package \
           -destination 'platform=watchOS Simulator,OS=latest,name=Apple Watch Series 4 - 40mm' \
           build | xcpretty
+      after_success: false
 
     - &linux
       env: SWIFT_VERSION=4.2.1
@@ -89,11 +91,28 @@ jobs:
 
     - name: CocoaPods
       before_install: |
+        export DESCRIPTION=$(swift - <<\ \ EOF
+          import Foundation
+          struct Response: Decodable { let description: String }
+          let token = ProcessInfo.processInfo.environment["GITHUB_TOKEN"]!
+          let url = URL(string: "https://api.github.com/repos/mxcl/Path.swift")!
+          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> Path.swift.podspec
         Pod::Spec.new do |s|
           s.name = 'Path.swift'
-          s.version = 'TRAVIS_TAG'
+          s.version = ENV['TRAVIS_TAG']
-          s.summary = 'Delightful, robust file-pathing functions'
+          s.summary = ENV['DESCRIPTION']
           s.homepage = 'https://github.com/mxcl/Path.swift'
           s.license = { :type => 'Unlicense', :file => 'LICENSE.md' }
           s.author = { 'mxcl' => 'mxcl@me.com' }
@@ -107,7 +126,5 @@ jobs:
           s.swift_version = '4.2'
         end
         EOF
-        sed -i '' "s/TRAVIS_TAG/$TRAVIS_TAG/" Path.swift.podspec
-      # ^^ see the Jazzy deployment for explanation
       install: gem install cocoapods --pre
       script: pod trunk push

README.md

@@ -1,7 +1,7 @@
-# Path.swift ![badge-platforms] ![badge-languages] [![Build Status](https://travis-ci.com/mxcl/Path.swift.svg)](https://travis-ci.com/mxcl/Path.swift)
+# Path.swift ![badge-platforms][] ![badge-languages][] [![badge-ci][]][travis] [![badge-jazzy][]][docs] [![badge-codecov][]][codecov] ![badge-version][]
 
-A file-system pathing library focused on developer experience and robust
+A file-system pathing library focused on developer experience and robust end
-end‐results.
+results.
 
 ```swift
 import Path
@@ -28,11 +28,14 @@ print(bar)         // => /bar
 print(bar.isFile)  // => true
 
 // careful API considerations so as to avoid common bugs
-let foo = try Path.root.join("foo").copy(into: Path.root.mkdir("bar"))
+let foo = try Path.root.join("foo").copy(into: Path.root.join("bar").mkdir())
 print(foo)         // => /bar/foo
 print(foo.isFile)  // => true
 
-// A practical example: installing a helper executable
+// 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.join("helper").copy(into: Path.home.join(".local/bin").mkdir(.p)).chmod(0o500)
 ```
 
@@ -42,8 +45,9 @@ Swift), we provide a thoughtful and comprehensive (yet concise) API.
 # Support mxcl
 
 Hi, I’m Max Howell and I have written a lot of open source software, and
-probably you already use some of it (Homebrew anyone?). Please help me so I
+probably you already use some of it (Homebrew anyone?). I work full-time on
-can continue to make tools and software you need and love. I appreciate it x.
+open source and it’s hard; currently I earn *less* than minimum wage. Please
+help me continue my work, I appreciate it x
 
 <a href="https://www.patreon.com/mxcl">
 	<img src="https://c5.patreon.com/external/logo/become_a_patron_button@2x.png" width="160">
@@ -53,7 +57,7 @@ can continue to make tools and software you need and love. I appreciate it x.
 
 # Handbook
 
-Our [online API documentation] is automatically updated for new releases.
+Our [online API documentation][docs] is automatically updated for new releases.
 
 ## Codable
 
@@ -94,6 +98,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
@@ -122,8 +139,7 @@ bashProfile += "\n\nfoo"
 
 try bashProfile.write(to: Path.home/".bash_profile")
 
-try Bundle.main.resources!.join("foo").copy(to: .home)
+try Bundle.main.resources.join("foo").copy(to: .home)
-// ^^ `-> Path?` because the underlying `Bundle` function is `-> String?`
 ```
 
 ## Directory listings
@@ -145,13 +161,27 @@ 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")
 ```
 
+# `Path.swift` is robust
+
+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.
+
+# `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.
@@ -184,7 +214,7 @@ Path("~/foo")!     // => /Users/mxcl/foo
 Path("~foo")       // => nil
 ```
 
-*Path.swift* has the general policty that if the desired end result preexists,
+*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.
@@ -205,7 +235,7 @@ package.append(.package(url: "https://github.com/mxcl/Path.swift", from: "0.5.0"
 CocoaPods:
 
 ```ruby
-pod 'Path.swift' ~> '0.5.0'
+pod 'Path.swift', '~> 0.5'
 ```
 
 Carthage:
@@ -229,5 +259,11 @@ https://codebasesaga.com/canopy/
 
 
 [badge-platforms]: https://img.shields.io/badge/platforms-macOS%20%7C%20Linux%20%7C%20iOS%20%7C%20tvOS%20%7C%20watchOS-lightgrey.svg
-[badge-languages]: https://img.shields.io/badge/swift-4.2-orange.svg
+[badge-languages]: https://img.shields.io/badge/swift-4.2%20%7C%205.0-orange.svg
-[online API documentation]: https://mxcl.github.io/Path.swift/Structs/Path.html
+[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

Sources/Extensions.swift

@@ -10,13 +10,31 @@ public extension Bundle {
     }
 
     /// Returns the path for the shared-frameworks directory in this bundle.
-    var sharedFrameworks: Path? {
+    var sharedFrameworks: Path {
-        return sharedFrameworksPath.flatMap(Path.init)
+        var `default`: Path {
+          #if os(macOS)
+            return path.join("Contents/Frameworks")
+          #elseif os(Linux)
+            return path.join("lib")
+          #else
+            return path.join("Frameworks")
+          #endif
+        }
+        return sharedFrameworksPath.flatMap(Path.init) ?? `default`
     }
 
     /// Returns the path for the resources directory in this bundle.
-    var resources: Path? {
+    var resources: Path {
-        return resourcePath.flatMap(Path.init)
+        var `default`: Path {
+          #if os(macOS)
+            return path.join("Contents/Resources")
+          #elseif os(Linux)
+            return path.join("share")
+          #else
+            return path
+          #endif
+        }
+        return resourcePath.flatMap(Path.init) ?? `default`
     }
 
     /// Returns the path for this bundle.
@@ -68,3 +86,24 @@ 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)
+    }
+}

Sources/Path+Attributes.swift

@@ -1,20 +1,35 @@
 import Foundation
+//#if os(Linux)
+//import func Glibc.chmod
+//#endif
 
 public extension Path {
     //MARK: Filesystem Attributes
 
     /**
-     Returns the modification-time.
+     Returns the creation-time of the file.
-     - Note: Returns the creation time if there is no modification time.
+     - Note: Returns `nil` if there is no creation-time, this should only happen if the file doesn’t exist.
-     - Note: Returns UNIX-time-zero if neither are available, though this *should* be impossible.
+     - Important: On Linux this is filesystem dependendent and may not exist.
      */
-    var mtime: Date {
+    var ctime: Date? {
         do {
             let attrs = try FileManager.default.attributesOfItem(atPath: string)
-            return attrs[.modificationDate] as? Date ?? attrs[.creationDate] as? Date ?? Date(timeIntervalSince1970: 0)
+            return attrs[.creationDate] as? Date
         } catch {
-            //TODO log error
+            return nil
-            return Date(timeIntervalSince1970: 0)
+        }
+    }
+
+    /**
+     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
         }
     }
 
@@ -25,27 +40,40 @@ public extension Path {
      */
     @discardableResult
     func chmod(_ octal: Int) throws -> Path {
+//    #if os(Linux)
+//        Glibc.chmod(string, __mode_t(octal))
+//    #else
         try FileManager.default.setAttributes([.posixPermissions: octal], ofItemAtPath: string)
+//    #endif
         return self
     }
     
-    /// - Note: If file is already locked, does nothing
+    /**
-    /// - Note: If file doesn’t exist, throws
+     - 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.
+     */
     @discardableResult
     func unlock() throws -> Path {
+    #if !os(Linux)
         var attrs: [FileAttributeKey: Any]
         do {
             attrs = try FileManager.default.attributesOfItem(atPath: string)
@@ -57,6 +85,7 @@ public extension Path {
             attrs[.immutable] = false
             try FileManager.default.setAttributes(attrs, ofItemAtPath: string)
         }
+    #endif
         return self
     }
 }

Sources/Path+CommonDirectories.swift

@@ -3,7 +3,7 @@ import Foundation
 extension Path {
     //MARK: Common Directories
     
-    /// Returns a `Path` containing ``FileManager.default.currentDirectoryPath`.
+    /// Returns a `Path` containing `FileManager.default.currentDirectoryPath`.
     public static var cwd: Path {
         return Path(string: FileManager.default.currentDirectoryPath)
     }
@@ -74,7 +74,7 @@ extension Path {
 
     /**
      The root for cache files.
-     - Note: On Linux this is 'XDG_CACHE_HOME'.
+     - Note: On Linux this is `XDG_CACHE_HOME`.
      - Note: You should create a subdirectory before creating any files.
      */
     public static var caches: Path {

Sources/Path+FileManager.swift

@@ -1,4 +1,7 @@
 import Foundation
+#if os(Linux)
+import Glibc
+#endif
 
 public extension Path {
     //MARK: File Management
@@ -25,6 +28,11 @@ public extension 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
     }
@@ -53,20 +61,16 @@ public extension Path {
     @discardableResult
     func copy(into: Path, overwrite: Bool = false) throws -> Path {
         if !into.exists {
-            try FileManager.default.createDirectory(at: url, withIntermediateDirectories: true)
+            try FileManager.default.createDirectory(at: into.url, withIntermediateDirectories: true)
         }
         let rv = into/basename()
         if overwrite, rv.isFile {
             try rv.delete()
         }
-    #if os(Linux)
+    #if os(Linux) && !swift(>=5.1) // check if fixed
-    #if swift(>=5.1)
-        // check if fixed
-    #else
         if !overwrite, rv.isFile {
             throw CocoaError.error(.fileWriteFileExists)
         }
-    #endif
     #endif
         try FileManager.default.copyItem(at: url, to: rv.url)
         return rv
@@ -90,7 +94,7 @@ public extension Path {
      */
     @discardableResult
     func move(to: Path, overwrite: Bool = false) throws -> Path {
-        if overwrite, to.exists {
+        if overwrite, to.isFile {
             try FileManager.default.removeItem(at: to.url)
         }
         try FileManager.default.moveItem(at: url, to: to.url)
@@ -112,13 +116,16 @@ public extension Path {
      - SeeAlso: move(into:overwrite:)
      */
     @discardableResult
-    func move(into: Path) throws -> Path {
+    func move(into: Path, overwrite: Bool = false) throws -> Path {
         if !into.exists {
             try into.mkdir(.p)
         } else if !into.isDirectory {
             throw CocoaError.error(.fileWriteFileExists)
         }
         let rv = into/basename()
+        if overwrite, rv.isFile {
+            try FileManager.default.removeItem(at: rv.url)
+        }
         try FileManager.default.moveItem(at: url, to: rv.url)
         return rv
     }
@@ -127,6 +134,9 @@ public extension Path {
      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
     func delete() throws {
@@ -136,18 +146,30 @@ public extension Path {
     }
 
     /**
-     Creates an empty file at this path.
+     Creates an empty file at this path or if the file exists, updates its modification time.
      - Returns: `self` to allow chaining.
      */
     @inlinable
     @discardableResult
     func touch() throws -> Path {
-        return try "".write(to: self)
+        if !exists {
+            guard FileManager.default.createFile(atPath: string, contents: nil) else {
+                throw CocoaError.error(.fileWriteUnknown)
+            }
+        } else {
+        #if os(Linux)
+            let fd = open(string, O_WRONLY)
+            defer { close(fd) }
+            futimens(fd, nil)
+        #else
+            try FileManager.default.setAttributes([.modificationDate: Date()], ofItemAtPath: string)
+        #endif
+        }
+        return self
     }
 
     /**
      Creates the directory at this path.
-     - Note: Does not create any intermediary directories.
      - 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.
@@ -172,10 +194,25 @@ public extension Path {
         }
         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
+    }
 }
 
-/// Options for `Path.mkdir`
+/// Options for `Path.mkdir(_:)`
 public enum MakeDirectoryOptions {
-    /// Creates intermediary directories. Works the same as mkdir -p.
+    /// Creates intermediary directories; works the same as `mkdir -p`.
     case p
 }

Sources/Path+StringConvertibles.swift

@@ -10,6 +10,6 @@ extension Path: CustomStringConvertible {
 extension Path: CustomDebugStringConvertible {
     /// Returns eg. `Path(string: "/foo")`
     public var debugDescription: String {
-        return "Path(string: \(string))"
+        return "Path(\(string))"
     }
 }

Sources/Path+ls.swift

@@ -1,5 +1,23 @@
 import Foundation
 
+/**
+ A file entry from a directory listing.
+ - SeeAlso: `ls()`
+*/
+public struct Entry {
+    /// The kind of this directory entry.
+    public enum Kind {
+        /// The path is a file.
+        case file
+        /// The path is a directory.
+        case directory
+    }
+    /// The kind of this entry.
+    public let kind: Kind
+    /// The path of this entry.
+    public let path: Path
+}
+
 public extension Path {    
     //MARK: Directory Listings
 
@@ -25,7 +43,7 @@ public extension Path {
 }
 
 /// Convenience functions for the array return value of `Path.ls()`
-public extension Array where Element == Path.Entry {
+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 {
@@ -33,7 +51,14 @@ public extension Array where Element == Path.Entry {
         }
     }
 
-    /// Filters the list of entries to be a list of Paths that are files with the specified extension
+    /// Filters the list of entries to be a list of Paths that are files.
+    var files: [Path] {
+        return compactMap {
+            $0.kind == .file ? $0.path : nil
+        }
+    }
+
+    /// Filters the list of entries to be a list of Paths that are files with the specified extension.
     func files(withExtension ext: String) -> [Path] {
         return compactMap {
             $0.kind == .file && $0.path.extension == ext ? $0.path : nil

Sources/Path->Bool.swift

@@ -1,4 +1,9 @@
 import Foundation
+#if os(Linux)
+import func Glibc.access
+#else
+import func Darwin.access
+#endif
 
 public extension Path {
     //MARK: Filesystem Properties
@@ -32,11 +37,22 @@ public extension Path {
         
     /// Returns true if the path represents an actual file that is also deletable by the current user.
     var isDeletable: Bool {
-        return FileManager.default.isDeletableFile(atPath: string)
+    #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
+        }
     }
 }

Sources/Path.swift

@@ -1,14 +1,16 @@
 import Foundation
 
 /**
- Represents a platform filesystem absolute path.
+ 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 `Path`s will return the locale-aware sort order, which
+ Sorting a `Sequence` of paths will return the locale-aware sort order, which
- will give you the same order as Finder, (though folders will not be sorted
+ will give you the same order as Finder.
- first).
 
  Converting from a `String` is a common first step, here are the recommended
  ways to do that:
@@ -18,21 +20,33 @@ import Foundation
      let p3 = Path.cwd/relativePathString
      let p4 = Path(userInput) ?? Path.cwd/userInput
 
- - Note: There may not be an actual filesystem entry at the path. The underlying
+ If you are constructing paths from static-strings we provide support for
-   representation for `Path` is `String`.
+ 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) {
         self.string = string
     }
 
-    /// Returns `nil` unless fed an absolute path
+    /// 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)
     }
 
+    /// :nodoc:
+    public subscript(dynamicMember pathComponent: String) -> Path {
+        let str = (string as NSString).appendingPathComponent(pathComponent)
+        return Path(string: str)
+    }
+
 //MARK: Properties
 
     /// The underlying filesystem path
@@ -58,11 +72,16 @@ public struct Path: Equatable, Hashable, Comparable {
     /**
      Returns the filename extension of this path.
      - Remark: Implemented via `NSString.pathExtension`.
+     - Note: We special case eg. `foo.tar.gz`.
      */
     @inlinable
     public var `extension`: String {
+        if string.hasSuffix(".tar.gz") {
+            return "tar.gz"
+        } else {
             return (string as NSString).pathExtension
         }
+    }
 
 //MARK: Pathing
 
@@ -76,7 +95,7 @@ public struct Path: Equatable, Hashable, Comparable {
 
      - Parameter pathComponent: The string to join with this path.
      - Returns: A new joined path.
-     - SeeAlso: `Path./(_:, _:)`
+     - SeeAlso: `Path./(_:_:)`
      */
     public func join<S>(_ pathComponent: S) -> Path where S: StringProtocol {
         //TODO standardizingPath does more than we want really (eg tilde expansion)
@@ -168,24 +187,4 @@ public struct Path: Equatable, Hashable, Comparable {
     public static func <(lhs: Path, rhs: Path) -> Bool {
         return lhs.string.compare(rhs.string, locale: .current) == .orderedAscending
     }
-
-//MARK: Entry
-
-    /**
-     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
-    }
 }

Tests/PathTests/PathTests.swift

@@ -14,21 +14,27 @@ class PathTests: XCTestCase {
     func testEnumeration() throws {
         let tmpdir_ = try TemporaryDirectory()
         let tmpdir = tmpdir_.path
-        try tmpdir.join("a").mkdir().join("c").touch()
+        try tmpdir.a.mkdir().c.touch()
-        try tmpdir.join("b").touch()
+        try tmpdir.join("b.swift").touch()
-        try tmpdir.join("c").touch()
+        try tmpdir.c.touch()
-        try tmpdir.join(".d").mkdir().join("e").touch()
+        try tmpdir.join(".d").mkdir().e.touch()
 
         var paths = Set<String>()
+        let lsrv = try tmpdir.ls()
         var dirs = 0
-        for entry in try tmpdir.ls() {
+        for entry in lsrv {
             if entry.kind == .directory {
                 dirs += 1
             }
             paths.insert(entry.path.basename())
         }
         XCTAssertEqual(dirs, 2)
-        XCTAssertEqual(paths, ["a", "b", "c", ".d"])
+        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"])
         
     }
 
@@ -69,6 +75,18 @@ class PathTests: XCTestCase {
         XCTAssert((Path.root/"bin").isDirectory)
     }
 
+    func testExtension() {
+        XCTAssertEqual(Path.root.join("a.swift").extension, "swift")
+        XCTAssertEqual(Path.root.join("a").extension, "")
+        XCTAssertEqual(Path.root.join("a.").extension, "")
+        XCTAssertEqual(Path.root.join("a..").extension, "")
+        XCTAssertEqual(Path.root.join("a..swift").extension, "swift")
+        XCTAssertEqual(Path.root.join("a..swift.").extension, "")
+        XCTAssertEqual(Path.root.join("a.tar.gz").extension, "tar.gz")
+        XCTAssertEqual(Path.root.join("a..tar.gz").extension, "tar.gz")
+        XCTAssertEqual(Path.root.join("a..tar..gz").extension, "gz")
+    }
+
     func testMktemp() throws {
         var path: Path!
         try Path.mktemp {
@@ -139,14 +157,244 @@ class PathTests: XCTestCase {
         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")
+    }
+
+    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)
+        }
+    }
+
     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)
+        }
+    }
+
+    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
-            let bar = try root.join("bar").touch()
+            do {
-            try Path.mktemp { root in
+                let file = try root.bar.touch()
-                try root.join("bar").touch()
+                let foo = try file.rename(to: "foo")
-                XCTAssertThrowsError(try bar.copy(into: root))
+                XCTAssertFalse(file.exists)
-                try bar.copy(into: root, overwrite: true)
+                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")
+    #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() {
+        XCTAssertTrue(Bundle.main.path.isDirectory)
+        XCTAssertTrue(Bundle.main.resources.isDirectory)
+
+        // don’t exist in tests
+        _ = Bundle.main.path(forResource: "foo", ofType: "bar")
+        _ = Bundle.main.sharedFrameworks
+    }
+
+    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()
+        }
+    #endif
+    }
 }

Tests/PathTests/TemporaryDirectory.swift

@@ -42,7 +42,11 @@ class TemporaryDirectory {
     }
 
     deinit {
-        _ = try? FileManager.default.removeItem(at: url)
+        do {
+            try path.chmod(0o777).delete()
+        } catch {
+            //TODO log
+        }
     }
 }
 

Tests/PathTests/XCTestManifests.swift

@@ -3,18 +3,36 @@ 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),
+        ("testFilesystemAttributes", testFilesystemAttributes),
         ("testIsDirectory", testIsDirectory),
         ("testJoin", testJoin),
+        ("testLock", testLock),
         ("testMkpathIfExists", testMkpathIfExists),
         ("testMktemp", testMktemp),
+        ("testMoveInto", testMoveInto),
+        ("testMoveTo", testMoveTo),
+        ("testRelativeCodable", testRelativeCodable),
         ("testRelativePathCodable", testRelativePathCodable),
         ("testRelativeTo", testRelativeTo),
+        ("testRename", testRename),
+        ("testSort", testSort),
+        ("testStringConvertibles", testStringConvertibles),
+        ("testStringExtensions", testStringExtensions),
+        ("testTimes", testTimes),
     ]
 }