From 9352098728c66b54ccc2efd17b1486ad540b6d1a Mon Sep 17 00:00:00 2001
From: jgvanwyk <123784102+jgvanwyk@users.noreply.github.com>
Date: Sat, 22 Jul 2023 23:41:52 -0400
Subject: [PATCH] Switched to using Core Foundation types

Also switched to using URL(fileURLWithPath:) all the time rather (this
wouldn't compile on some macOS versions).
---
 .../FileSystemEventStream.swift               | 64 ++++++++-----------
 .../StringConvertible.swift                   | 12 +---
 .../SwiftFileSystemEventsTests.swift          | 10 +++
 3 files changed, 38 insertions(+), 48 deletions(-)

diff --git a/Sources/SwiftFileSystemEvents/FileSystemEventStream.swift b/Sources/SwiftFileSystemEvents/FileSystemEventStream.swift
index ed10056..9ee8561 100644
--- a/Sources/SwiftFileSystemEvents/FileSystemEventStream.swift
+++ b/Sources/SwiftFileSystemEvents/FileSystemEventStream.swift
@@ -42,33 +42,34 @@ public final class FileSystemEventStream {
                 latency: TimeInterval = 0,
                 flags: Flags = [],
                 handler: @escaping (FileSystemEvent) -> Void) {
+        var flags = flags
+        flags.insert(.useCFTypes)
         self.handler = handler
-        let pathsToWatch: CFArray
-        if #available(macOS 13.0, *) {
-            pathsToWatch = directoriesToWatch.map { $0.path(percentEncoded: false) } as CFArray
-        } else {
-            pathsToWatch = directoriesToWatch.map { $0.path } as CFArray
-        }
+        let pathsToWatch = directoriesToWatch.map { $0.path } as CFArray
         // We pass an unmanaged pointer to `self` as context info to the stream.
         // `FileSystemEventStream.callback` uses this to call `handler` with each event.
         // As the memory for `self` is managed by Swift, we pass `nil` for both `retain`
         // and `release`.
-        var context = FSEventStreamContext(version: 0,
-                                           info: Unmanaged.passUnretained(self).toOpaque(),
-                                           retain: nil,
-                                           release: nil,
-                                           copyDescription: nil)
+        var context = FSEventStreamContext(
+            version: 0,
+            info: Unmanaged.passUnretained(self).toOpaque(),
+            retain: nil,
+            release: nil,
+            copyDescription: nil
+        )
         // While the return value of `FSEventStreamCreate` is imported in Swift as
         // `FSEventStreamRef?`, the documentation for `FSEventStreamCreate` asserts that
         // its return value will always be a valid `FSEventStreamRef`, so we unwrap the
         // return value here.
-        self.streamRef = FSEventStreamCreate(kCFAllocatorDefault,
-                                             Self.callback,
-                                             &context,
-                                             pathsToWatch,
-                                             sinceWhen.rawValue,
-                                             latency,
-                                             flags.rawValue)!
+        self.streamRef = FSEventStreamCreate(
+            kCFAllocatorDefault,
+            Self.callback,
+            &context,
+            pathsToWatch,
+            sinceWhen.rawValue,
+            latency,
+            flags.rawValue
+        )!
     }
     
     deinit {
@@ -77,12 +78,10 @@ public final class FileSystemEventStream {
     
     private static let callback: FSEventStreamCallback = { _, info, numEvents, eventPaths, eventFlags, eventIDs in
         guard let info = info else { return }
-        let eventPaths = eventPaths.assumingMemoryBound(to: UnsafeMutablePointer<CChar>.self)
+        let eventPaths = Unmanaged<CFArray>.fromOpaque(eventPaths).takeUnretainedValue() as! [CFString]
         let stream = Unmanaged<FileSystemEventStream>.fromOpaque(info).takeUnretainedValue()
         for index in 0..<numEvents {
-            let url = URL(fileURLWithFileSystemRepresentation: eventPaths[index],
-                          isDirectory: true,
-                          relativeTo: nil).standardizedFileURL
+            let url = CFURLCreateWithString(nil, eventPaths[index], nil) as URL
             let flags = FileSystemEvent.Flags(rawValue: eventFlags[index])
             let id = FileSystemEvent.ID(rawValue: eventIDs[index])
             let event = FileSystemEvent(url: url, id: id, flags: flags)
@@ -106,15 +105,9 @@ public final class FileSystemEventStream {
     /// This calls `FSEventStreamCopyPathsBeingWatched`.
     @available(macOS 10.5, *)
     public var directoriesBeingWatched: [URL] {
-        // `FSEventStreamCopyPathsBeingWatched` returns a `CFArray` of `CFStringRef`, which
-        // can always be converted to `[String]`.
-        let paths = FSEventStreamCopyPathsBeingWatched(streamRef) as! [String]
-        let urls: [URL]
-        if #available(macOS 13.0, *) {
-            urls = paths.map { URL(filePath: $0, directoryHint: .isDirectory) }
-        } else {
-            urls = paths.map { URL(fileURLWithPath: $0, isDirectory: true) }
-        }
+        // `FSEventStreamCopyPathsBeingWatched` returns a `CFArray` of `CFString`.
+        let paths = FSEventStreamCopyPathsBeingWatched(streamRef) as! [CFString]
+        let urls = paths.map { CFURLCreateWithString(nil, $0, nil) as URL }
         return urls
     }
         
@@ -238,12 +231,7 @@ public final class FileSystemEventStream {
     /// This calls `FSEventStreamSetExclusionPaths(_:,_:)`.
     @available(macOS 10.9, *)
     public func setExclusionDirectories(_ directoryURLs: [URL]) throws {
-        let paths: CFArray
-        if #available(macOS 13.0, *) {
-            paths = directoryURLs.map { $0.path(percentEncoded: false) } as CFArray
-        } else {
-            paths = directoryURLs.map { $0.path } as CFArray
-        }
+        let paths = directoryURLs.map { $0.path } as CFArray
         guard FSEventStreamSetExclusionPaths(streamRef, paths) else { throw Error.couldNotExcludeDirectories }
     }
     
@@ -270,7 +258,7 @@ public final class FileSystemEventStream {
         /// This wraps `kFSEventStreamCreateFlagNone`.
         public static let none = Self.init(rawValue: FSEventStreamCreateFlags(kFSEventStreamCreateFlagNone))
         
-        // public static let useCFTypes = Self.init(rawValue: FSEventStreamCreateFlags(kFSEventStreamCreateFlagUseCFTypes))
+        fileprivate static let useCFTypes = Self.init(rawValue: FSEventStreamCreateFlags(kFSEventStreamCreateFlagUseCFTypes))
                 
         /// Change the meaning of the latency parameter.
         ///
diff --git a/Sources/SwiftFileSystemEvents/StringConvertible.swift b/Sources/SwiftFileSystemEvents/StringConvertible.swift
index c771949..b9811b1 100644
--- a/Sources/SwiftFileSystemEvents/StringConvertible.swift
+++ b/Sources/SwiftFileSystemEvents/StringConvertible.swift
@@ -49,19 +49,11 @@ extension FileSystemEventStream.Flags: CustomStringConvertible, CustomDebugStrin
 extension FileSystemEvent: CustomStringConvertible, CustomDebugStringConvertible {
     
     public var description: String {
-        if #available(macOS 13.0, *) {
-            return "FileSystemEvent(path: \(url.path(percentEncoded: false)), flags: \(flags.description), id: \(id.description))"
-        } else {
-            return "FileSystemEvent(path: \(url.path), flags: \(flags.description), id: \(id.description))"
-        }
+        return "FileSystemEvent(path: \(url.path), flags: \(flags.description), id: \(id.description))"
     }
     
     public var debugDescription: String {
-        if #available(macOS 13.0, *) {
-            return "FileSystemEvent(path: \(url.path(percentEncoded: false)), flags: Flags(rawValue: \(flags.rawValue)), id: ID(rawValue: \(id.rawValue)))"
-        } else {
-            return "FileSystemEvent(path: \(url.path), flags: Flags(rawValue: \(flags.rawValue)), id: ID(rawValue: \(id.rawValue)))"
-        }
+        return "FileSystemEvent(path: \(url.path), flags: Flags(rawValue: \(flags.rawValue)), id: ID(rawValue: \(id.rawValue)))"
     }
     
 }
diff --git a/Tests/SwiftFileSystemEventsTests/SwiftFileSystemEventsTests.swift b/Tests/SwiftFileSystemEventsTests/SwiftFileSystemEventsTests.swift
index bc80e3f..e6e408a 100644
--- a/Tests/SwiftFileSystemEventsTests/SwiftFileSystemEventsTests.swift
+++ b/Tests/SwiftFileSystemEventsTests/SwiftFileSystemEventsTests.swift
@@ -13,6 +13,16 @@ import XCTest
 
 
 final class SwiftFileSystemEventsTests: XCTestCase {
+    
+    @available(macOS 13.0, *)
+    func test() {
+        let stream = FileSystemEventStream(directoriesToWatch: [.downloadsDirectory], handler: { print($0) })
+        stream.setDispatchQueue(.global(qos: .background))
+        try! stream.start()
+        Thread.sleep(forTimeInterval: 30)
+        stream.stop()
+        stream.invalidate()
+    }
 
     func testFileSystemEventStreamFlagsDescription() {
         let flags0: FileSystemEventStream.Flags = []