Implement _removeItem in terms of DirectoryEnumerator

Author: gmittert

Foundation/FileManager.swift

@@ -1441,73 +1441,63 @@ open class FileManager : NSObject {
         }
     }
 
-    @available(Windows, deprecated, message: "Not Yet Implemented")
     private func _removeItem(atPath path: String, isURL: Bool, alreadyConfirmed: Bool = false) throws {
         guard alreadyConfirmed || shouldRemoveItemAtPath(path, isURL: isURL) else {
             return
         }
 
-#if os(Windows)
-        NSUnimplemented()
-#else
-        if rmdir(path) == 0 {
-            return
-        } else if errno == ENOTEMPTY {
-
-            let stream = URL(fileURLWithPath: path).withUnsafeFileSystemRepresentation { (fsRep) -> UnsafeMutablePointer<FTS>? in
-                let ps = UnsafeMutablePointer<UnsafeMutablePointer<Int8>?>.allocate(capacity: 2)
-                ps.initialize(to: UnsafeMutablePointer(mutating: fsRep))
-                ps.advanced(by: 1).initialize(to: nil)
-                defer {
-                    ps.deinitialize(count: 2)
-                    ps.deallocate()
+        let urlItem = URL(fileURLWithPath: path)
+        if urlItem.hasDirectoryPath {
+
+            let stream =  NSURLDirectoryEnumerator(
+              url: urlItem,
+              options: [],
+              errorHandler: {(url, err) in
+                self.shouldProceedAfterError(err,
+                                             removingItemAtPath: url.absoluteString,
+                                             isURL: true)
+              })
+            while let itemPath = stream.nextObject() as? String {
+              do {
+                guard alreadyConfirmed || shouldRemoveItemAtPath(itemPath, isURL: true) else {
+                  continue
                 }
-                return fts_open(ps, FTS_PHYSICAL | FTS_XDEV | FTS_NOCHDIR, nil)
-            }
-            
-            if stream != nil {
-                defer {
-                    fts_close(stream)
+                if (URL(fileURLWithPath: itemPath).hasDirectoryPath) {
+                  #if os(Windows)
+                  let result = _NS_rmdir(itemPath)
+                  #else
+                  let result = rmdir(itemPath)
+                  #endif
+                  if result == -1 {
+                    throw _NSErrorWithErrno(errno, reading: false, path: itemPath)
+                  }
+                } else {
+                  #if os(Windows)
+                  let result = _NS_unlink(itemPath)
+                  #else
+                  let result = unlink(itemPath)
+                  #endif
+                  if result == -1 {
+                    throw _NSErrorWithErrno(errno, reading: false, path: itemPath)
+                  }
                 }
-
-                while let current = fts_read(stream)?.pointee {
-                    let itemPath = string(withFileSystemRepresentation: current.fts_path, length: Int(current.fts_pathlen))
-                    guard alreadyConfirmed || shouldRemoveItemAtPath(itemPath, isURL: isURL) else {
-                        continue
-                    }
-                    
-                    do {
-                        switch Int32(current.fts_info) {
-                        case FTS_DEFAULT, FTS_F, FTS_NSOK, FTS_SL, FTS_SLNONE:
-                            if unlink(current.fts_path) == -1 {
-                                throw _NSErrorWithErrno(errno, reading: false, path: itemPath)
-                            }
-                        case FTS_DP:
-                            if rmdir(current.fts_path) == -1 {
-                                throw _NSErrorWithErrno(errno, reading: false, path: itemPath)
-                            }
-                        case FTS_DNR, FTS_ERR, FTS_NS:
-                            throw _NSErrorWithErrno(current.fts_errno, reading: false, path: itemPath)
-                        default:
-                            break
-                        }
-                    } catch {
-                        if !shouldProceedAfterError(error, removingItemAtPath: itemPath, isURL: isURL) {
-                            throw error
-                        }
-                    }
+              } catch {
+                if !shouldProceedAfterError(error, removingItemAtPath: itemPath, isURL: true) {
+                  throw error
                 }
-            } else {
-                let _ = _NSErrorWithErrno(ENOTEMPTY, reading: false, path: path)
+              }
             }
-        } else if errno != ENOTDIR {
-            throw _NSErrorWithErrno(errno, reading: false, path: path)
-        } else if _fileSystemRepresentation(withPath: path, { unlink($0) != 0 }) {
-            throw _NSErrorWithErrno(errno, reading: false, path: path)
+        } else if _fileSystemRepresentation(withPath: path, {path in
+                                            #if os(Windows)
+                                            return _NS_unlink(path) != 0
+                                            #else
+                                            return unlink(path) != 0
+                                            #endif
+                                            }) {
+          throw _NSErrorWithErrno(errno, reading: false, path: path)
         }
-#endif
     }
-    
+
     open func copyItem(atPath srcPath: String, toPath dstPath: String) throws {
         try _copyItem(atPath: srcPath, toPath: dstPath, isURL: false)
     }