Example:

$ cat Cartfile
github "kylef/PathKit"
$ carthage bootstrap
*** No Cartfile.resolved found, updating dependencies
*** Fetching PathKit
*** Checking out PathKit at "0.5.0"
*** xcodebuild output can be found in /var/folders/76/q9xfxg_s187bkp6gyxqqxw8r0000gn/T/carthage-xcodebuild.f9pQMQ.log
*** Building scheme "PathKit" in PathKit.xcworkspace

So carthage builds PathKit, which is great. However, the framework can't be used for whatever reason.

$ cat main.swift
import PathKit
print(Path.current)
$ ls Carthage/Build/Mac
PathKit.framework
$ swiftc main.swift -F Carthage/Build/Mac/
$ ./main
dyld: Library not loaded: @rpath/PathKit.framework/Versions/A/PathKit
  Referenced from: /Users/dan/Desktop/test/./main
  Reason: image not found
[1]    45284 trace trap  ./main

It works perfectly fine with other frameworks, for example Commander.

Thoughts?

When I build the package for release (using swift build -c release) I get the following errors:

/Users/ci/Downloads/PathKit-master/Sources/PathKit.swift:594:12: error: value of optional type 'UnsafeMutablePointer<CChar>?' (aka 'Optional<UnsafeMutablePointer<Int8>>') must be unwrapped to a value of type 'UnsafeMutablePointer<CChar>' (aka 'UnsafeMutablePointer<Int8>')
      free(cPattern)
           ^
/Users/ci/Downloads/PathKit-master/Sources/PathKit.swift:594:12: note: coalesce using '??' to provide a default when the optional value contains 'nil'
      free(cPattern)
           ^
                    ?? <#default value#>
/Users/ci/Downloads/PathKit-master/Sources/PathKit.swift:594:12: note: force-unwrap using '!' to abort execution if the optional value contains 'nil'
      free(cPattern)
           ^
                   !
/Users/ci/Downloads/PathKit-master/Sources/PathKit.swift:625:12: error: value of optional type 'UnsafeMutablePointer<CChar>?' (aka 'Optional<UnsafeMutablePointer<Int8>>') must be unwrapped to a value of type 'UnsafeMutablePointer<CChar>' (aka 'UnsafeMutablePointer<Int8>')
      free(cPattern)
           ^
/Users/ci/Downloads/PathKit-master/Sources/PathKit.swift:625:12: note: coalesce using '??' to provide a default when the optional value contains 'nil'
      free(cPattern)
           ^
                    ?? <#default value#>
/Users/ci/Downloads/PathKit-master/Sources/PathKit.swift:625:12: note: force-unwrap using '!' to abort execution if the optional value contains 'nil'
      free(cPattern)
           ^
                   !
/Users/ci/Downloads/PathKit-master/Sources/PathKit.swift:626:12: error: value of optional type 'UnsafeMutablePointer<CChar>?' (aka 'Optional<UnsafeMutablePointer<Int8>>') must be unwrapped to a value of type 'UnsafeMutablePointer<CChar>' (aka 'UnsafeMutablePointer<Int8>')
      free(cPath)
           ^
/Users/ci/Downloads/PathKit-master/Sources/PathKit.swift:626:12: note: coalesce using '??' to provide a default when the optional value contains 'nil'
      free(cPath)
           ^
                 ?? <#default value#>
/Users/ci/Downloads/PathKit-master/Sources/PathKit.swift:626:12: note: force-unwrap using '!' to abort execution if the optional value contains 'nil'
      free(cPath)
           ^
                !

Is this a straightforward patch that can be applied?

Hi,

I added support for swift 3.0 (DEVELOPMENT-SNAPSHOT-2016-03-24-a) using macros checking the swift version, so should work both with 2.2 and (current) 3.0 dev.

Changes are mostly about keeping up with the swift-3-api-guidelines induced changes.

This fixes the build of PathKit on Xcode 13 RC.

strdup returns an implicitly unwrapped optional, which seems to loose its "implicit" via the assignment. I couldn't find anything in the Xcode release notes, but I guess it's a fair change :-) Let's treat the returned pointers as true optionals and instead of crashing, return defaults.

Swift 3 introduced breaking changes:

 Compiling Swift Module 'PathKit061' (1 sources)
/home/saulius/workspace/Swifton/Packages/PathKit-0.6.1/Sources/PathKit.swift:38:19: error: 'CollectionType' has been renamed to 'Collection'
  public init<S : CollectionType where S.Generator.Element == String>(components: S) {
                  ^~~~~~~~~~~~~~
                  Collection
/home/saulius/workspace/Swifton/Packages/PathKit-0.6.1/Sources/PathKit.swift:38:42: error: 'Generator' is not a member type of 'S'
  public init<S : CollectionType where S.Generator.Element == String>(components: S) {
                                       ~ ^
/home/saulius/workspace/Swifton/Packages/PathKit-0.6.1/Sources/PathKit.swift:577:18: error: 'SequenceType' has been renamed to 'Sequence'
extension Path : SequenceType {
                 ^~~~~~~~~~~~
                 Sequence
/home/saulius/workspace/Swifton/Packages/PathKit-0.6.1/Sources/PathKit.swift:580:39: error: 'GeneratorType' has been renamed to 'IteratorProtocol'
  public struct DirectoryEnumerator : GeneratorType {
                                      ^~~~~~~~~~~~~
                                      IteratorProtocol
/home/saulius/workspace/Swifton/Packages/PathKit-0.6.1/Sources/PathKit.swift:39:8: error: value of type 'S' has no member 'isEmpty'
    if components.isEmpty {
       ^~~~~~~~~~ ~~~~~~~
/home/saulius/workspace/Swifton/Packages/PathKit-0.6.1/Sources/PathKit.swift:41:15: error: value of type 'S' has no member 'first'
    } else if components.first == Path.separator && components.count > 1 {
              ^~~~~~~~~~ ~~~~~
/home/saulius/workspace/Swifton/Packages/PathKit-0.6.1/Sources/PathKit.swift:42:15: error: value of type 'S' has no member 'joinWithSeparator'
      let p = components.joinWithSeparator(Path.separator)
              ^~~~~~~~~~ ~~~~~~~~~~~~~~~~~
/home/saulius/workspace/Swifton/Packages/PathKit-0.6.1/Sources/PathKit.swift:51:14: error: value of type 'S' has no member 'joinWithSeparator'
      path = components.joinWithSeparator(Path.separator)
             ^~~~~~~~~~ ~~~~~~~~~~~~~~~~~
/home/saulius/workspace/Swifton/Packages/PathKit-0.6.1/Sources/PathKit.swift:557:30: error: 'fromCString' is unavailable: Please use String.init?(validatingUTF8:) instead. Note that it no longer accepts NULL as a valid input. Also consider using String(cString:), that will attempt to repair ill-formed code units.
        if let path = String.fromCString(gt.gl_pathv[index]) {
                             ^~~~~~~~~~~
Swift.String:4:24: note: 'fromCString' has been explicitly marked unavailable here
    public static func fromCString(cs: UnsafePointer<CChar>) -> String?
                       ^
/home/saulius/workspace/Swifton/Packages/PathKit-0.6.1/Sources/PathKit.swift:557:30: error: 'fromCString' is unavailable: Please use String.init?(validatingUTF8:) instead. Note that it no longer accepts NULL as a valid input. Also consider using String(cString:), that will attempt to repair ill-formed code units.
        if let path = String.fromCString(gt.gl_pathv[index]) {
                             ^~~~~~~~~~~
Swift.String:4:24: note: 'fromCString' has been explicitly marked unavailable here
    public static func fromCString(cs: UnsafePointer<CChar>) -> String?
                       ^
<unknown>:0: error: build had 1 command failures
error: exit(1): /home/saulius/.swiftenv/versions/DEVELOPMENT-SNAPSHOT-2016-03-24-a/usr/bin/swift-build-tool -f /home/saulius/workspace/Swifton/Packages/PathKit-0.6.1/.build/debug.yaml default

I tried to build your Package with the newest version of the Swift Package Manager. I failed with: NoSources(".../Packages/PathKit-0.6.1/Tests/Fixtures").

Has support for Carthage been dropped? I'm trying to build PathKit 0.7.0 using Carthage but no schemes are built. I checked the repo and I see that the .xcworkspace and .xcodeproj directories have gone. Would it be possible to bring these back? Carthage needs a scheme to be able to build the framework.

Demo:

import PathKit
import Foundation

struct Container: Codable {
  let path: Path
}

let decoder = JSONDecoder()

let string = """
  {
    "path": "/usr/bin/swift"
  }
"""

let container = try decoder.decode(Container.self, from: string.data(using: .utf8)!)
print(container.path.description)

let encoder = JSONEncoder()
let result = try encoder.encode(container)

print(String(data: result, encoding: .utf8)!)

I've love to add tests, but the test target keeps giving this error:

Not sure why, as the Spectre dependency is downloaded by Xcode just fine.

This updates Spectre to the recent 0.10.0 release. Without this packages that use both PathKit and Spectre can't update Spectre, and therefore are broken in Xcode 12.5

Here are some bottlenecks that I measured to have a significant perf impact. They're a little rough right now, but if they look good overall I can clean them up

Changes to allow PathKit to build on Swift 3.1, 4.0 and 4.1:

• Support Swift 3.1 through 4.1 by reintroducing the Swift 3 format Package.swift from 0.8.0, and renaming the Swift 4 format to [email protected]
• Remove deprecation warnings for String API changes in Swift 4 - similar to #42 / #45, but guarded to maintain compatibility with Swift 3
• Address compilation error on Linux + Swift 4.1 due to https://github.com/apple/swift-corelibs-foundation/pull/1223
• Update lastComponentWithoutExtension test for Linux + Swift 4.1
• Add travis matrix for testing with both Swift 3.1.1 and 4.0 snapshots (I didn't add a 4.1 dev snapshot, but this would be straightforward)

macOS Version: 12.5.1

Xcode: 14.0

Example (execute in macOS App):

        let p = Path("/Users/your-name/Desktops")
        let p2 = Path("~/Desktops")
        print(p ~= p2) // false

Reason:

• When in macOS App, Apple use symbol link in sandbox to show Desktops / Documents / Downloads. When I print p2, I found it was /Users/your-name/xxx/your-App/Data/Desktops which is symbol link to real Desktops. And the ~= result is false.
• When is Swift Package CLI, the result is true.

This is more of a question than an issue. In your README documentation, whenever a PathKit method is called such as path.exists() it uses the () at the end as seems normal. But when I do it in the Xcode IDE, it doesn't like the () at the end. I have a check in my code: if path.exists { .... } And that runs fine but with the parens: if path.exists() { ... }

it gives me a build error. Any idea why this is the case? It's not a big deal as I've figured how to make it work. Just curious as to whether I'm doing something wrong implementing PathKit.

Related: https://docs.travis-ci.com/user/reference/osx/

I came looking for an updated version of PathKit that worked with Xcode 12.5 (1.0.0 is limited because of kylef/Spectre#46) but noticed that it had already been patched in #74. I was going to raise an issue asking for a 1.0.1 release, but I also spotted that .travis.yml could do with a little refresh so here we are 🙂

After considering this change, it would be great if you could do a release so that I have a tag to point to 🙏

Thanks for the hard work!

Thanks for useful library 😄

While investigating performance problem, I found this library converts Swift.String into NSString and it's very high cost operation.

Why this library uses NSString instead of implementing its own logic?

I added a method which computes the relative path which goes between two paths. I added this downstream to yonaskolb/XcodeGen#524, but since it seems generally useful I figured I'd try to add it back to PathKit. This is similar to Pathname#relative_path_from in the ruby stdlib and PurePath.relative_to in python. Let me know if this is something you'd be interested in adding, and if there's anything I can do to help!

Declaration

  /// Returns the relative path necessary to go from `base` to `self`.
  ///
  /// Both paths must be absolute or relative paths.
  /// - throws: Throws an error when the path types do not match, or when `base` has so many parent path components
  ///           that it refers to an unknown parent directory.
  public func relativePath(from base: Path) throws -> Path

Examples

Path("a/b").relativePath(from: Path("a/c"))       == Path("../b")
Path("/a/b/c/d").relativePath(from: Path("/a/b")) == Path("c/d")
Path("/a/../../b").relativePath(from: Path("/b")) == Path(".")

Changes to normalize()

One would expect that a path like "a/../../b" could normalize to "b". Foundation's standardizingPath method only removes redundant parent directory references if the path is absolute, so "/a/../../b" normalizes to "/b" but the former case doesn't normalize at all. I realized that PathKit already has logic to remove redundant ".."s in its + operator, so I added a case to normalize() that adds up all the path components if the path is relative.

It'd be awesome if you could support a recursive glob, e.g /some/path/**/*.swift which would match arbitrary nesting.

Thanks for PathKit, love it 🤘🏼