Fix for FileManager repo suddenly being deleted

.swiftpm/xcode/xcshareddata/xcschemes/spmgraph-Package.xcscheme

@@ -172,6 +172,16 @@
                ReferencedContainer = "container:">
             </BuildableReference>
          </TestableReference>
+         <TestableReference
+            skipped = "NO">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "SPMGraphConfigSetupTests"
+               BuildableName = "SPMGraphConfigSetupTests"
+               BlueprintName = "SPMGraphConfigSetupTests"
+               ReferencedContainer = "container:">
+            </BuildableReference>
+         </TestableReference>
       </Testables>
    </TestAction>
    <LaunchAction

Package.swift

@@ -44,10 +44,6 @@ let package = Package(
       url: "https://github.com/apple/swift-package-manager",
       revision: "swift-6.2-RELEASE"
     ),
-    .package(
-      url: "https://github.com/aus-der-Technik/FileMonitor",
-      revision: "1.2.0"
-    ),
   ],
   targets: [
     // MARK: - Functionality
@@ -93,10 +89,6 @@ let package = Package(
       name: "SPMGraphConfigSetup",
       dependencies: [
         .target(name: "Core"),
-        .product(
-          name: "FileMonitor",
-          package: "FileMonitor"
-        ),
       ],
       resources: [
         .copy("Resources")
@@ -168,6 +160,15 @@ let package = Package(
         .enableExperimentalFeature("StrictConcurrency")
       ]
     ),
+    .testTarget(
+      name: "SPMGraphConfigSetupTests",
+      dependencies: [
+        .target(name: "SPMGraphConfigSetup"),
+      ],
+      swiftSettings: [
+        .enableExperimentalFeature("StrictConcurrency")
+      ]
+    ),
     .testTarget(
       name: "SPMGraphDescriptionInterfaceTests",
       dependencies: [

Sources/FixtureSupport/Package+Fixture.swift

@@ -21,8 +21,6 @@ import Basics
 import Foundation
 import PackageModel
 import Testing
-import Workspace
-
 public extension AbsolutePath {
   static var fixturePackagePath: AbsolutePath {
     do {
@@ -38,11 +36,162 @@ public extension AbsolutePath {
 }
 
 public func loadFixturePackage() async throws -> Package {
-  let observability = ObservabilitySystem { print("\($0): \($1)") }
-  let workspace = try Workspace(forRootPackage: .fixturePackagePath)
+  let packagePath = AbsolutePath.fixturePackagePath
+  let manifestPath = packagePath.appending(component: Manifest.filename)
+  let manifest = Manifest(
+    displayName: "LintFixturePackage",
+    packageIdentity: .plain("LintFixturePackage"),
+    path: manifestPath,
+    packageKind: .root(packagePath),
+    packageLocation: packagePath.pathString,
+    defaultLocalization: nil,
+    platforms: [],
+    version: nil,
+    revision: nil,
+    toolsVersion: .v6_0,
+    pkgConfig: nil,
+    providers: nil,
+    cLanguageStandard: nil,
+    cxxLanguageStandard: nil,
+    swiftLanguageVersions: nil,
+    dependencies: [],
+    products: [],
+    targets: [],
+    traits: []
+  )
+
+  let modules = try makeFixtureModules(at: packagePath)
+
+  return Package(
+    identity: manifest.packageIdentity,
+    manifest: manifest,
+    path: packagePath,
+    targets: modules,
+    products: [],
+    targetSearchPath: packagePath.appending(component: "Sources"),
+    testTargetSearchPath: packagePath.appending(component: "Tests")
+  )
+}
+
+private func makeFixtureModules(at packagePath: AbsolutePath) throws -> [Module] {
+  let baseModule = try makeSwiftModule(
+    name: "BaseModule",
+    path: packagePath.appending(components: "Sources", "BaseModule"),
+    type: .library,
+    dependencies: []
+  )
+
+  let interfaceModule = try makeSwiftModule(
+    name: "InterfaceModule",
+    path: packagePath.appending(components: "Sources", "InterfaceModule"),
+    type: .library,
+    dependencies: [
+      .module(baseModule, conditions: [])
+    ]
+  )
+
+  let networkingLiveModule = try makeSwiftModule(
+    name: "NetworkingLive",
+    path: packagePath.appending(components: "Sources", "NetworkingLive"),
+    type: .library,
+    dependencies: [
+      .module(interfaceModule, conditions: [])
+    ]
+  )
+
+  let featureModule = try makeSwiftModule(
+    name: "FeatureModule",
+    path: packagePath.appending(components: "Sources", "FeatureModule"),
+    type: .library,
+    dependencies: [
+      .module(interfaceModule, conditions: []),
+      .module(networkingLiveModule, conditions: [])
+    ]
+  )
+
+  let storageLiveModule = try makeSwiftModule(
+    name: "StorageLive",
+    path: packagePath.appending(components: "Sources", "StorageLive"),
+    type: .library,
+    dependencies: [
+      .module(networkingLiveModule, conditions: [])
+    ]
+  )
 
-  return try await workspace.loadRootPackage(
-    at: .fixturePackagePath,
-    observabilityScope: observability.topScope
+  let moduleWithUnusedDep = try makeSwiftModule(
+    name: "ModuleWithUnusedDep",
+    path: packagePath.appending(components: "Sources", "ModuleWithUnusedDep"),
+    type: .library,
+    dependencies: [
+      .module(baseModule, conditions: []),
+      .module(interfaceModule, conditions: [])
+    ]
   )
+
+  let baseModuleTests = try makeSwiftModule(
+    name: "BaseModuleTests",
+    path: packagePath.appending(components: "Tests", "BaseModuleTests"),
+    type: .test,
+    dependencies: [
+      .module(baseModule, conditions: [])
+    ]
+  )
+
+  let moduleWithUnusedDepTests = try makeSwiftModule(
+    name: "ModuleWithUnusedDepTests",
+    path: packagePath.appending(components: "Tests", "ModuleWithUnusedDepTests"),
+    type: .test,
+    dependencies: [
+      .module(moduleWithUnusedDep, conditions: [])
+    ]
+  )
+
+  return [
+    baseModule,
+    interfaceModule,
+    featureModule,
+    networkingLiveModule,
+    storageLiveModule,
+    moduleWithUnusedDep,
+    baseModuleTests,
+    moduleWithUnusedDepTests
+  ]
+}
+
+private func makeSwiftModule(
+  name: String,
+  path: AbsolutePath,
+  type: Module.Kind,
+  dependencies: [Module.Dependency]
+) throws -> SwiftModule {
+  let sources = Sources(
+    paths: swiftSourceFiles(in: path),
+    root: path
+  )
+  return SwiftModule(
+    name: name,
+    type: type,
+    path: path,
+    sources: sources,
+    dependencies: dependencies,
+    packageAccess: false,
+    usesUnsafeFlags: false,
+    implicit: false
+  )
+}
+
+private func swiftSourceFiles(in path: AbsolutePath) -> [AbsolutePath] {
+  guard let enumerator = FileManager.default.enumerator(at: path.asURL, includingPropertiesForKeys: nil) else {
+    return []
+  }
+
+  var files: [AbsolutePath] = []
+  while let url = enumerator.nextObject() as? URL {
+    guard url.pathExtension == "swift" else { continue }
+    if let filePath = try? AbsolutePath(validating: url.path) {
+      files.append(filePath)
+    }
+  }
+
+  return files
 }

Sources/SPMGraphConfigSetup/FileMonitor.swift

@@ -0,0 +1,132 @@
+import Foundation
+
+enum FileChange: Sendable {
+  case changed(URL)
+  case added(URL)
+  case deleted(URL)
+}
+
+enum FileMonitorError: Error {
+  case invalidDirectory(URL)
+}
+
+final class FileMonitor {
+  private struct FileState: Equatable {
+    let modificationDate: Date?
+    let fileSize: Int?
+  }
+
+  private let directory: URL
+  private let pollInterval: DispatchTimeInterval
+  private var snapshot: [String: FileState]
+  private var continuation: AsyncStream<FileChange>.Continuation?
+  private let queue: DispatchQueue
+  private var timer: DispatchSourceTimer?
+
+  let stream: AsyncStream<FileChange>
+
+  init(directory: URL, pollInterval: DispatchTimeInterval = .milliseconds(250)) throws {
+    guard directory.isFileURL else {
+      throw FileMonitorError.invalidDirectory(directory)
+    }
+
+    var isDirectory: ObjCBool = false
+    guard
+      FileManager.default.fileExists(atPath: directory.path, isDirectory: &isDirectory),
+      isDirectory.boolValue
+    else {
+      throw FileMonitorError.invalidDirectory(directory)
+    }
+
+    self.directory = directory
+    self.pollInterval = pollInterval
+    self.snapshot = try Self.snapshot(directory: directory)
+    self.queue = DispatchQueue(label: "spmgraph.filemonitor")
+
+    var continuation: AsyncStream<FileChange>.Continuation?
+    self.stream = AsyncStream { continuation = $0 }
+    self.continuation = continuation
+  }
+
+  func start() throws {
+    guard timer == nil else {
+      return
+    }
+
+    let timer = DispatchSource.makeTimerSource(queue: queue)
+    timer.schedule(deadline: .now() + pollInterval, repeating: pollInterval)
+    timer.setEventHandler { [weak self] in
+      guard let self else {
+        return
+      }
+
+      do {
+        let currentSnapshot = try Self.snapshot(directory: self.directory)
+        Self.emitChanges(from: self.snapshot, to: currentSnapshot, continuation: self.continuation)
+        self.snapshot = currentSnapshot
+      } catch {
+        self.continuation?.finish()
+        timer.cancel()
+      }
+    }
+
+    self.timer = timer
+    timer.resume()
+  }
+
+  deinit {
+    timer?.cancel()
+    continuation?.finish()
+  }
+}
+
+private extension FileMonitor {
+  private static func snapshot(directory: URL) throws -> [String: FileState] {
+    let contents = try FileManager.default.contentsOfDirectory(
+      at: directory,
+      includingPropertiesForKeys: [
+        .contentModificationDateKey,
+        .fileSizeKey,
+        .isRegularFileKey
+      ],
+      options: [.skipsSubdirectoryDescendants]
+    )
+
+    var snapshot: [String: FileState] = [:]
+    snapshot.reserveCapacity(contents.count)
+
+    for url in contents {
+      let values = try url.resourceValues(forKeys: [.contentModificationDateKey, .fileSizeKey, .isRegularFileKey])
+      guard values.isRegularFile == true else {
+        continue
+      }
+
+      snapshot[url.path] = FileState(
+        modificationDate: values.contentModificationDate,
+        fileSize: values.fileSize
+      )
+    }
+
+    return snapshot
+  }
+
+  private static func emitChanges(
+    from previousSnapshot: [String: FileState],
+    to currentSnapshot: [String: FileState],
+    continuation: AsyncStream<FileChange>.Continuation?
+  ) {
+    for (path, state) in currentSnapshot {
+      if let previousState = previousSnapshot[path] {
+        if previousState != state {
+          continuation?.yield(.changed(URL(fileURLWithPath: path)))
+        }
+      } else {
+        continuation?.yield(.added(URL(fileURLWithPath: path)))
+      }
+    }
+
+    for path in previousSnapshot.keys where currentSnapshot[path] == nil {
+      continuation?.yield(.deleted(URL(fileURLWithPath: path)))
+    }
+  }
+}