Implement NSURLDirectoryEnumerator for Windows

Author: gmittert

Foundation/FileManager.swift

@@ -2377,46 +2377,107 @@ extension FileManager {
             self.innerEnumerator = ie
         }
 
-        @available(Windows, deprecated, message: "Not Yet Implemented")
         override func nextObject() -> Any? {
             let o = innerEnumerator.nextObject()
             guard let url = o as? URL else {
                 return nil
             }
 
 #if os(Windows)
-            NSUnimplemented()
+            let path = url.path.replacingOccurrences(of: baseURL.path+"\\", with: "")
 #else
             let path = url.path.replacingOccurrences(of: baseURL.path+"/", with: "")
+#endif
             _currentItemPath = path
             return path
-#endif
         }
     }
 
-#if os(Windows)
     internal class NSURLDirectoryEnumerator : DirectoryEnumerator {
-        internal typealias ErrorHandler = /* @escaping */ (URL, Error) -> Bool
+#if os(Windows)
+        var _options : FileManager.DirectoryEnumerationOptions
+        var _errorHandler : ((URL, Error) -> Bool)?
+        var _stack: [URL]
+        var _current: URL?
+        var _root_depth : Int
+
 
-        init(url: URL, options: FileManager.DirectoryEnumerationOptions, errorHandler: ErrorHandler?) {
+        init(url: URL, options: FileManager.DirectoryEnumerationOptions, errorHandler: (/* @escaping */ (URL, Error) -> Bool)?) {
+            _options = options
+            _errorHandler = errorHandler
+            _stack = [url]
+            _root_depth = url.pathComponents.count
+        }
+
+
+        override func nextObject() -> Any? {
+            func contentsOfDir(directory: URL) -> [URL]? {
+                var ffd: WIN32_FIND_DATAW = WIN32_FIND_DATAW()
+                let dirPath = Array((directory.absoluteString + "\\*\0").utf16)
+                guard let h = dirPath.withContiguousStorageIfAvailable(
+                    {FindFirstFileW($0.baseAddress, &ffd)}),
+                    h != INVALID_HANDLE_VALUE else {
+                    return nil
+                }
+                defer {
+                    FindClose(h)
+                }
+
+                var files: [URL] = []
+                repeat {
+                    let fileArr = [WCHAR](UnsafeBufferPointer(start: &ffd.cFileName.0,
+                                                              count: MemoryLayout.size(ofValue: ffd.cFileName)))
+                    let file = String(decodingCString: fileArr, as: UTF16.self)
+                    if file != "."
+                        && file != ".."
+                        && (_options.contains(.skipsHiddenFiles)
+                            && (ffd.dwFileAttributes & DWORD(FILE_ATTRIBUTE_HIDDEN) == 0)) {
+                        files.append(URL(fileURLWithPath: "\(directory.absoluteString)\\\(file)"))
+                      }
+                } while(FindNextFileW(h, &ffd) != 0)
+                return files
+            }
+            while let url = _stack.popLast() {
+                if url.hasDirectoryPath && !_options.contains(.skipsSubdirectoryDescendants) {
+                    guard let dirContents = contentsOfDir(directory: url)?.reversed() else {
+                        if let handler = _errorHandler,
+                           handler(URL(fileURLWithPath: url.absoluteString),
+                                   _NSErrorWithWindowsError(GetLastError(), reading: true)) {
+                            return nil
+                        }
+                        continue
+                    }
+                    _stack.append(contentsOf: dirContents)
+                }
+                _current = url
+                return url
+            }
+            return nil
+        }
+
+        override var level: Int {
+            return _root_depth - (_current?.pathComponents.count ?? _root_depth)
+        }
+
+        override func skipDescendants() {
+            _options.insert(.skipsSubdirectoryDescendants)
         }
-    }
 #else
-    internal class NSURLDirectoryEnumerator : DirectoryEnumerator {
         var _url : URL
         var _options : FileManager.DirectoryEnumerationOptions
         var _errorHandler : ((URL, Error) -> Bool)?
         var _stream : UnsafeMutablePointer<FTS>? = nil
         var _current : UnsafeMutablePointer<FTSENT>? = nil
         var _rootError : Error? = nil
         var _gotRoot : Bool = false
-        
+
+
         // See @escaping comments above.
         init(url: URL, options: FileManager.DirectoryEnumerationOptions, errorHandler: (/* @escaping */ (URL, Error) -> Bool)?) {
             _url = url
             _options = options
             _errorHandler = errorHandler
-            
+
             if FileManager.default.fileExists(atPath: _url.path) {
                 let fsRep = FileManager.default.fileSystemRepresentation(withPath: _url.path)
                 let ps = UnsafeMutablePointer<UnsafeMutablePointer<Int8>?>.allocate(capacity: 2)
@@ -2430,15 +2491,15 @@ extension FileManager {
                 _rootError = _NSErrorWithErrno(ENOENT, reading: true, url: url)
             }
         }
-        
+
         deinit {
             if let stream = _stream {
                 fts_close(stream)
             }
         }
-        
-        override func nextObject() -> Any? {
 
+
+        override func nextObject() -> Any? {
             func match(filename: String, to options: DirectoryEnumerationOptions, isDir: Bool) -> (Bool, Bool) {
                 var showFile = true
                 var skipDescendants = false
@@ -2459,10 +2520,10 @@ extension FileManager {
 
 
             if let stream = _stream {
-                
+
                 if !_gotRoot  {
                     _gotRoot = true
-                    
+
                     // Skip the root.
                     _current = fts_read(stream)
                 }
@@ -2504,7 +2565,7 @@ extension FileManager {
                     _current = fts_read(stream)
                 }
                 // TODO: Error handling if fts_read fails.
-                
+
             } else if let error = _rootError {
                 // Was there an error opening the stream?
                 if let handler = _errorHandler {
@@ -2513,24 +2574,21 @@ extension FileManager {
             }
             return nil
         }
-        
-        override var directoryAttributes : [FileAttributeKey : Any]? {
-            return nil
-        }
-        
-        override var fileAttributes: [FileAttributeKey : Any]? {
-            return nil
-        }
-        
         override var level: Int {
             return Int(_current?.pointee.fts_level ?? 0)
         }
-        
+
         override func skipDescendants() {
             if let stream = _stream, let current = _current {
                 fts_set(stream, current, FTS_SKIP)
             }
         }
-    }
 #endif
+        override var directoryAttributes : [FileAttributeKey : Any]? {
+            return nil
+        }
+        override var fileAttributes: [FileAttributeKey : Any]? {
+            return nil
+        }
+    }
 }