xccache 0.0.1 → 1.0.0.rc15341775774

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xccache
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.0.rc15341775774
 platform: ruby
 authors:
 - Thuyen Trinh
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-05-13 00:00:00.000000000 Z
+date: 2025-05-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: claide
@@ -69,7 +69,6 @@ files:
 - lib/xccache/assets/templates/framework.modulemap.template
 - lib/xccache/assets/templates/resource_bundle_accessor.m.template
 - lib/xccache/assets/templates/resource_bundle_accessor.swift.template
-- lib/xccache/assets/templates/umbrella.Package.swift.template
 - lib/xccache/cache/cachemap.rb
 - lib/xccache/command.rb
 - lib/xccache/command/base.rb
@@ -77,6 +76,7 @@ files:
 - lib/xccache/command/cache.rb
 - lib/xccache/command/cache/clean.rb
 - lib/xccache/command/cache/list.rb
+- lib/xccache/command/off.rb
 - lib/xccache/command/pkg.rb
 - lib/xccache/command/pkg/build.rb
 - lib/xccache/command/remote.rb
@@ -102,6 +102,11 @@ files:
 - lib/xccache/core/system.rb
 - lib/xccache/installer.rb
 - lib/xccache/installer/build.rb
+- lib/xccache/installer/integration.rb
+- lib/xccache/installer/integration/build.rb
+- lib/xccache/installer/integration/descs.rb
+- lib/xccache/installer/integration/supporting_files.rb
+- lib/xccache/installer/integration/viz.rb
 - lib/xccache/installer/rollback.rb
 - lib/xccache/installer/use.rb
 - lib/xccache/main.rb
@@ -119,13 +124,8 @@ files:
 - lib/xccache/spm/mixin.rb
 - lib/xccache/spm/pkg.rb
 - lib/xccache/spm/pkg/base.rb
-- lib/xccache/spm/pkg/umbrella.rb
-- lib/xccache/spm/pkg/umbrella/build.rb
-- lib/xccache/spm/pkg/umbrella/cachemap.rb
-- lib/xccache/spm/pkg/umbrella/descs.rb
-- lib/xccache/spm/pkg/umbrella/manifest.rb
-- lib/xccache/spm/pkg/umbrella/viz.rb
-- lib/xccache/spm/pkg/umbrella/xcconfigs.rb
+- lib/xccache/spm/pkg/proxy.rb
+- lib/xccache/spm/pkg/proxy_executable.rb
 - lib/xccache/spm/xcframework.rb
 - lib/xccache/spm/xcframework/metadata.rb
 - lib/xccache/spm/xcframework/slice.rb
@@ -161,9 +161,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.2.33
 signing_key:

data/lib/xccache/assets/templates/umbrella.Package.swift.template

@@ -1,182 +0,0 @@
-// swift-tools-version: 6.0
-import Foundation
-import PackageDescription
-
-/*
- MARK: INSTRUCTIONS
- ----------------------------------------------------------------------------------------------------------------------
- This Package manifest is auto-generated from xccache (last updated: <%= timestamp %>).
- ----------------------------------------------------------------------------------------------------------------------
- During local development, you can switch between *BINARY mode* and *SOURCE mode* by adding or removing the `.binary`
- suffix in the JSON below.
- As a user, you just need to care about the JSON. The rest is just the tool's internal logic.
-
- NOTE that a product (ex. `pkg/foo.binary`) can only be used as binary if:
- - Binary exists for `pkg/foo` (in `xccache/packages/binaries/foo/foo.xcframework`)
- - Binary exists for all of its dependencies
- The tool auto-fallbacks to the *SOURCE mode* if the conditions are not met.
- ----------------------------------------------------------------------------------------------------------------------
-*/
-let JSON = """
-<%= json %>
-"""
-let DEPENDENCIES: [Package.Dependency] = [
-<%= dependencies %>
-]
-let PLATFORMS: [SupportedPlatform] = [
-<%= platforms %>
-]
-let PRODUCTS_TO_TARGETS: [String: [String]] = try parseJSON("""
-<%= products_to_targets %>
-""")
-// ------------------------------------------------------------------------------------
-
-// MARK: Main
-_ = try XCCache.Package(parseJSON(JSON)).spm
-
-// MARK: XCCache
-enum XCCache {
-  // MARK: Config
-  @MainActor
-  struct Config {
-    static let pkgDir = URL(filePath: #filePath).deletingLastPathComponent()
-    // NOTE: Do NOT change `binariesDir` to `static let`
-    // Somehow, incremental resolution doesnt work causing the `binaryExist` wrongly cached
-    static var binariesDir: URL { pkgDir.appending(path: "binaries") }
-  }
-
-  // MARK: Package
-  @MainActor
-  final class Package {
-    let targets: [XCCache.Target]
-    init(_ dict: [String: [String]]) {
-      targets = dict.map { XCCache.Target($0, $1) }
-    }
-
-    var spm: PackageDescription.Package {
-      let regularTargets = targets.map(\.spm)
-      let binaryTargets = targets.flatMap(\.flattenRegularDeps).unique(by: \.name).compactMap(\.spmBinaryTarget)
-      return .init(
-        name: "xccache",
-        platforms: PLATFORMS,
-        products: targets.map(\.spmProduct),
-        dependencies: DEPENDENCIES,
-        targets: regularTargets + binaryTargets
-      )
-    }
-  }
-
-  // MARK: Target
-  @MainActor
-  final class Target {
-    let name: String
-    let deps: [UmbrellaDependency]
-    init(_ name: String, _ deps: [String]) {
-      self.name = name
-      self.deps = deps.map { UmbrellaDependency($0) }
-    }
-
-    var spmProduct: PackageDescription.Product {
-      .library(name: name, targets: [name])
-    }
-    var spm: PackageDescription.Target {
-      .target(
-        name: name,
-        dependencies: flattenRegularDeps.map(\.spm),
-        path: ".Sources/\(name)",
-        swiftSettings: [
-          .unsafeFlags(macroFlags),
-        ]
-      )
-    }
-    var flattenDeps: [Dependency] { deps.flatMap(\.toBinariesIfOk).unique(by: \.name) }
-    var flattenRegularDeps: [Dependency] { flattenDeps.filter(\.regular) }
-    var macroFlags: [String] { flattenDeps.filter(\.macroBinary).flatMap(\.macroFlags) }
-  }
-
-  // MARK: Dependency
-  @MainActor
-  class Dependency {
-    let name: String
-    let bareName: String
-    let binaryURL: URL
-    let binary: Bool
-    let macro: Bool
-    var regular: Bool { !macro }
-    var regularBinary: Bool { binary && regular }
-    var macroBinary: Bool { binary && macro }
-
-    init(_ name: String) {
-      self.name = name
-      self.bareName = String(name.basename.split(separator: ".")[0])
-      self.macro = name.contains(".macro")
-      self.binaryURL = if macro {
-        Config.binariesDir.appending(path: "\(bareName)/\(bareName).macro").readlink()
-      } else {
-        Config.binariesDir.appending(path: "\(bareName)/\(bareName).xcframework").readlink()
-      }
-      self.binary = name.hasSuffix(".binary") && binaryURL.exist
-    }
-
-    var macroFlags: [String] {
-      ["-load-plugin-executable", "\(binaryURL.path())#\(bareName)"]
-    }
-
-    var spm: PackageDescription.Target.Dependency {
-      if binary { return .byName(name: name) }
-      return .product(name: bareName, package: name.slug)
-    }
-    var spmBinaryTarget: PackageDescription.Target? {
-      regularBinary ? .binaryTarget(name: name, path: "binaries/\(bareName)/\(bareName).xcframework") : nil
-    }
-  }
-
-  @MainActor
-  class UmbrellaDependency: Dependency {
-    let binaries: [Dependency]
-    override init(_ name: String) {
-      binaries = (PRODUCTS_TO_TARGETS[name.withoutBinary] ?? []).map { Dependency("\($0).binary") }
-      super.init(name)
-    }
-    var toBinariesIfOk: [Dependency] {
-      if name.hasSuffix(".binary"), !binaries.isEmpty && binaries.allSatisfy(\.binary) { return binaries }
-      return [Dependency(name.withoutBinary)]
-    }
-  }
-}
-
-// MARK: Helpers
-func parseJSON<T>(_ content: String) throws -> T {
-  if let data = content.data(using: .utf8), let result = try JSONSerialization.jsonObject(with: data) as? T {
-    return result
-  }
-  throw NSError(domain: "Invalid JSON:\n\(content)", code: 111)
-}
-
-extension URL {
-  var basename: String { lastPathComponent }
-  var exist: Bool { FileManager.default.fileExists(atPath: readlink().path()) }
-  /// Resolve symlinks recursively, equivalent to `readlink -f` in bash
-  func readlink() -> URL {
-    var prev = self, cur = resolvingSymlinksInPath()
-    while prev != cur {
-      prev = cur
-      cur = cur.resolvingSymlinksInPath()
-    }
-    return cur
-  }
-}
-
-extension String {
-  var slug: String { (self as NSString).deletingLastPathComponent.basename }
-  var basename: String { (self as NSString).lastPathComponent }
-  var withoutExtenstion: String { (self as NSString).deletingPathExtension }
-  var withoutBinary: String { replacing(#/\.binary$/#, with: "") }
-}
-
-extension Sequence {
-  func unique<T: Hashable>(by: (Element) -> T) -> [Element] {
-    var seen: Set<T> = []
-    return filter { seen.insert(by($0)).inserted }
-  }
-}

data/lib/xccache/spm/pkg/umbrella/build.rb

@@ -1,30 +0,0 @@
-module XCCache
-  module SPM
-    class Package
-      module UmbrellaBuildMixin
-        def build(options = {})
-          to_build = targets_to_build(options)
-          return UI.warn("Detected no targets to build among cache-missed targets") if to_build.empty?
-
-          UI.info("-> Targets to build: #{to_build.to_s.bold}")
-          super(options.merge(:targets => to_build))
-          sync_cachemap(sdks: options[:sdks])
-        end
-
-        def targets_to_build(options)
-          items = options[:targets] || []
-          items = config.cachemap.missed.map { |x| File.basename(x) } if items.empty?
-          targets = @descs.flat_map(&:targets).select { |t| items.include?(t.name) }
-          if options[:recursive]
-            UI.message("Will include cache-missed recursive targets")
-            targets += targets.flat_map do |t|
-              t.recursive_targets.select { |x| config.cachemap.missed?(x.full_name) }
-            end
-          end
-          # TODO: Sort by number of dependents
-          targets.map(&:full_name).uniq
-        end
-      end
-    end
-  end
-end

data/lib/xccache/spm/pkg/umbrella/cachemap.rb

@@ -1,110 +0,0 @@
-module XCCache
-  module SPM
-    class Package
-      module UmbrellaCachemapMixin
-        def sync_cachemap(sdks: [])
-          UI.section("Syncing cachemap (sdks: #{sdks.map(&:name)})")
-          nodes, edges, parents = xccache_desc.traverse
-          cache_data = gen_cache_data(nodes, parents, sdks)
-          targets_data, macros_data, deps_data = {}, {}, {}
-          xccache_desc.targets.each do |agg_target|
-            targets, macros = [], []
-            agg_target.direct_dependencies.each do |d|
-              all_hit = d.recursive_targets.all? { |t| cache_data[t] == :hit }
-              # If any associated targets is missed -> use original product form
-              # Otherwise, replace with recursive targets' binaries
-              deps_data[d.full_name] = d.recursive_targets.map(&:xccache_id)
-              targets << (all_hit ? "#{d.full_name}.binary" : d.full_name)
-              macros += d.recursive_targets.select(&:macro?).map(&:full_name) if all_hit
-            end
-            targets_data[agg_target.name] = targets.uniq.sort_by(&:downcase)
-            macros_data[agg_target.name] = macros.uniq
-          end
-
-          config.cachemap.raw = {
-            "manifest" => {
-              "targets" => targets_data,
-              "macros" => macros_data,
-              "deps" => deps_data,
-            },
-            "cache" => cache_data.transform_keys(&:full_name),
-            "depgraph" => {
-              "nodes" => nodes.map { |x| target_to_cytoscape_node(x, cache_data) },
-              "edges" => edges.map { |x, y| { :source => x.full_name, :target => y.full_name } },
-            },
-          }
-          config.cachemap.save
-          config.cachemap.print_stats
-        end
-
-        private
-
-        def gen_cache_data(nodes, parents, sdks)
-          result = nodes.to_h do |node|
-            res = if config.ignore?(node.full_name) then :ignored
-                  else
-                    verify_binary?(node, sdks) ? :hit : :missed
-                  end
-            [node, res]
-          end
-
-          # Propagate cache miss
-          to_visit = result.select { |_, v| %i[missed ignore].include?(v) }.keys
-          visited = Set.new
-          until to_visit.empty?
-            node = to_visit.pop
-            next if visited.include?(node)
-            visited << node
-            result[node] = :missed if result[node] == :hit
-            to_visit += parents[node] if parents.key?(node)
-          end
-          result.reject { |k, _| k.name.end_with?(".xccache") }
-        end
-
-        def verify_binary?(target, sdks)
-          return true if target.binary?
-
-          bpath = binary_path(target.xccache_id)
-          bpath_with_checksum = binary_path(target.xccache_id, checksum: target.checksum, in_repo: true)
-
-          check = proc do
-            # For macro, we just need the tool binary to exist
-            # For regular targets, the xcframework must satisfy the sdk constraints (ie. containing all the slices)
-            next bpath_with_checksum.exist? if target.macro?
-
-            metadata = XCFramework::Metadata.new(bpath_with_checksum / "Info.plist")
-            expected_triples = sdks.map { |sdk| sdk.triple(without_vendor: true) }
-            missing_triples = expected_triples - metadata.triples
-            missing_triples.empty?
-          end
-
-          # If requirements are meet, create symlink `A-abc123.xcframework` -> `A.framework`
-          # Otherwise, remove symlink `A.xcframework`
-          if check.call
-            bpath_with_checksum.symlink_to(bpath)
-          elsif bpath.exist?
-            bpath.rmtree
-          end
-          bpath.exist?
-        end
-
-        def binary_path(name, checksum: nil, in_repo: false)
-          suffix = checksum.nil? ? "" : "-#{checksum}"
-          ext = File.extname(name) == ".macro" ? ".macro" : ".xcframework"
-          binaries_dir = in_repo ? config.spm_cache_dir : config.spm_binaries_dir
-          p = binaries_dir / File.basename(name, ".*")
-          p / "#{p.basename}#{suffix}#{ext}"
-        end
-
-        def target_to_cytoscape_node(x, cache_data)
-          h = { :id => x.full_name, :cache => cache_data[x] }
-          h[:type] = if x.name.end_with?(".xccache") then "agg"
-                     elsif x.macro? then "macro" end
-          h[:checksum] = x.checksum
-          h[:binary] = binary_path(x.xccache_id) if cache_data[x] == :hit
-          h
-        end
-      end
-    end
-  end
-end

data/lib/xccache/spm/pkg/umbrella/descs.rb

@@ -1,35 +0,0 @@
-module XCCache
-  module SPM
-    class Package
-      module UmbrellaDescsMixin
-        def gen_metadata
-          UI.section("Generating metadata of packages", timing: true) do
-            @descs, @descs_by_name = Description.descs_in_dir(root_dir, save_to_dir: config.spm_metadata_dir)
-          end
-        end
-
-        def xccache_desc
-          @xccache_desc ||= desc_of("xccache")
-        end
-
-        def targets_of_products(products)
-          products = [products] if products.is_a?(String)
-          products.flat_map { |x| desc_of(x).targets_of_products(File.basename(x)) }
-        end
-
-        def dependency_targets_of_products(products)
-          products = [products] if products.is_a?(String)
-          products.flat_map { |p| @dependency_targets_by_products[p] || [p] }.uniq
-        end
-
-        def desc_of(d)
-          @descs_by_name[d.split("/").first]
-        end
-
-        def binary_targets
-          @descs_by_name.values.flatten.uniq.flat_map(&:binary_targets)
-        end
-      end
-    end
-  end
-end

data/lib/xccache/spm/pkg/umbrella/manifest.rb

@@ -1,83 +0,0 @@
-module XCCache
-  module SPM
-    class Package
-      module UmbrellaManifestMixin
-        def write_manifest(no_cache: false)
-          UI.info("Writing Package.swift (package: #{root_dir.basename})")
-          Template.new("umbrella.Package.swift").render(
-            {
-              :timestamp => Time.new.strftime("%F %T"),
-              :json => manifest_targets_json(no_cache: no_cache),
-              :products_to_targets => manifest_products_to_targets_json(no_cache: no_cache),
-              :platforms => manifest_platforms,
-              :dependencies => manifest_pkg_dependencies,
-              :swift_version => Swift::Swiftc.version_without_patch,
-            },
-            save_to: root_dir / "Package.swift",
-          )
-        end
-
-        def manifest_targets_json(no_cache: false)
-          data = no_cache ? config.lockfile.targets_data : config.cachemap.manifest_data["targets"]
-          JSON.pretty_generate(data)
-        end
-
-        def manifest_products_to_targets_json(no_cache: false)
-          data = no_cache ? {} : config.cachemap.manifest_data["deps"]
-          JSON.pretty_generate(data)
-        end
-
-        def manifest_pkg_dependencies
-          decl = proc do |hash|
-            if (path_from_root = hash["path_from_root"])
-              absolute_path = (Pathname(".") / path_from_root).expand_path
-              next ".package(path: \"#{absolute_path}\")"
-            end
-
-            requirement = hash["requirement"]
-            case requirement["kind"]
-            when "upToNextMajorVersion"
-              opt = ".upToNextMajor(from: \"#{requirement['minimumVersion']}\")"
-            when "upToNextMinorVersion"
-              opt = ".upToNextMinor(from: \"#{requirement['minimumVersion']}\")"
-            when "exactVersion"
-              opt = "exact: \"#{requirement['version']}\""
-            when "branch"
-              opt = "branch: \"#{requirement['branch']}\""
-            when "revision"
-              opt = "revision: \"#{requirement['revision']}\""
-            when "versionRange"
-              opt = "\"#{requirement['minimumVersion']}\"..<\"#{requirement['maximumVersion']}\""
-            end
-            ".package(url: \"#{hash['repositoryURL']}\", #{opt})"
-          end
-
-          config.lockfile.pkgs.map { |h| "  #{decl.call(h)}," }.join("\n")
-        end
-
-        def manifest_platforms
-          @manifest_platforms ||= begin
-            to_spm_platform = {
-              :ios => "iOS",
-              :macos => "macOS",
-              :osx => "macOS",
-              :tvos => "tvOS",
-              :watchos => "watchOS",
-              :visionos => "visionOS",
-            }
-            hash = {}
-            config.project_targets.each do |t|
-              platform = to_spm_platform[t.platform_name]
-              hash[platform] ||= []
-              hash[platform] << t.deployment_target.split(".")[0]
-            end
-            hash
-              .transform_values(&:min)
-              .map { |platform, version| "  .#{platform}(.v#{version})," }
-              .join("\n")
-          end
-        end
-      end
-    end
-  end
-end

data/lib/xccache/spm/pkg/umbrella/viz.rb

@@ -1,40 +0,0 @@
-module XCCache
-  module SPM
-    class Package
-      module UmbrellaVizMixin
-        def gen_cachemap_viz
-          stats = config.cachemap.stats
-          html_path = config.sandbox / "cachemap.html"
-          js_path = Dir.prepare(config.sandbox / "assets") / "cachemap.js"
-          css_path = config.sandbox / "assets" / "style.css"
-
-          root_dir = Pathname(".").expand_path
-          to_relative = proc do |p|
-            p.to_s.start_with?(root_dir.to_s) ? p.relative_path_from(root_dir).to_s : p.to_s
-          end
-
-          UI.info("Cachemap visualization: #{html_path}")
-          Template.new("cachemap.html").render(
-            {
-              :root_dir => root_dir.to_s,
-              :root_dir_short => root_dir.basename.to_s,
-              :lockfile_path => config.lockfile.path.to_s,
-              :lockfile_path_short => to_relative.call(config.lockfile.path),
-              :binaries_dir => config.spm_binaries_dir.to_s,
-              :binaries_dir_short => to_relative.call(config.spm_binaries_dir),
-              :desc_hit => stats[:hit],
-              :desc_missed => stats[:missed],
-              :desc_ignored => stats[:ignored],
-            },
-            save_to: html_path
-          )
-          Template.new("cachemap.js").render(
-            { :json => JSON.pretty_generate(config.cachemap.depgraph_data) },
-            save_to: js_path
-          )
-          Template.new("cachemap.style.css").render(save_to: css_path)
-        end
-      end
-    end
-  end
-end

data/lib/xccache/spm/pkg/umbrella/xcconfigs.rb

@@ -1,31 +0,0 @@
-module XCCache
-  module SPM
-    class Package
-      module UmbrellaXCConfigsMixin
-        def gen_xcconfigs
-          UI.section("Generating xcconfigs") do
-            macros_config_by_targets.each do |target, hash|
-              xcconfig_path = config.spm_xcconfig_dir / "#{target}.xcconfig"
-              UI.message("XCConfig of target #{target} at: #{xcconfig_path}")
-              Xcodeproj::Config.new(hash).save_as(xcconfig_path)
-            end
-          end
-        end
-
-        private
-
-        def macros_config_by_targets
-          config.cachemap.manifest_data["macros"].to_h do |target, macros|
-            swift_flags = macros.map do |m|
-              basename = File.basename(m, ".*")
-              binary_path = config.spm_binaries_dir / basename / "#{basename}.macro"
-              "-load-plugin-executable #{binary_path}##{basename}"
-            end
-            hash = { "OTHER_SWIFT_FLAGS" => "$(inherited) #{swift_flags.join(' ')}" }
-            [File.basename(target, ".*"), hash]
-          end
-        end
-      end
-    end
-  end
-end

data/lib/xccache/spm/pkg/umbrella.rb

@@ -1,91 +0,0 @@
-require "xccache/swift/swiftc"
-require "xccache/utils/template"
-require "xccache/cache/cachemap"
-require "xccache/spm/pkg/base"
-
-Dir["#{__dir__}/#{File.basename(__FILE__, '.rb')}/*.rb"].sort.each { |f| require f }
-
-module XCCache
-  module SPM
-    class Package
-      class Umbrella < Package
-        include Config::Mixin
-        include UmbrellaCachemapMixin
-        include UmbrellaDescsMixin
-        include UmbrellaBuildMixin
-        include UmbrellaManifestMixin
-        include UmbrellaVizMixin
-        include UmbrellaXCConfigsMixin
-
-        def initialize(options = {})
-          super
-          @descs = []
-          @descs_by_name = {}
-          @dependency_targets_by_products = {}
-        end
-
-        def prepare(options = {})
-          create
-          resolve unless options[:skip_resolving_dependencies]
-          create_symlinks_for_convenience
-          create_symlinks_to_local_pkgs
-          gen_metadata
-          resolve_recursive_dependencies
-          create_symlinks_to_artifacts
-          sync_cachemap(sdks: options[:sdks])
-        end
-
-        def resolve_recursive_dependencies
-          UI.section("Resolving recursive dependencies")
-          @descs.each do |desc|
-            @dependency_targets_by_products.merge!(desc.resolve_recursive_dependencies.transform_keys(&:full_name))
-          end
-        end
-
-        def create
-          UI.info("Creating umbrella package")
-          # Initially, write json with the original data in lockfile (without cache)
-          write_manifest(no_cache: true)
-          # Create dummy sources dirs prefixed with `.` so that they do not show up in Xcode
-          config.project_targets.each do |target|
-            dir = Dir.prepare(root_dir / ".Sources" / "#{target.name}.xccache")
-            (dir / "dummy.swift").write("")
-          end
-        end
-
-        def create_symlinks_for_convenience
-          # Symlinks for convenience
-          (root_dir / "binaries").symlink_to(root_dir.parent / "binaries")
-          (root_dir / ".build").symlink_to(root_dir.parent / ".build")
-          (root_dir / ".build/checkouts").symlink_to(root_dir.parent / "checkouts")
-        end
-
-        def create_symlinks_to_local_pkgs
-          pkg_desc.dependencies.select(&:local?).each do |dep|
-            # For metadata generation
-            dep.path.symlink_to(root_dir / ".build/checkouts/#{dep.slug}")
-            # For convenience, synced group under `xccache.config` group in xcodeproj
-            dep.path.symlink_to(Config.instance.spm_local_pkgs_dir / dep.slug)
-          end
-        end
-
-        def create_symlinks_to_artifacts
-          # Clean up symlinks beforehand
-          config.spm_binaries_dir.glob("*/*.{xcframework,macro}").each do |p|
-            p.rmtree if p.symlink?
-          end
-
-          binary_targets.each do |target|
-            dst_path = config.spm_binaries_dir / target.name / "#{target.name}.xcframework"
-            # For local xcframework, just symlink to the path
-            # Zip frameworks (either of local or remote pkgs) are unzipped in the build artifacts
-            target.local_binary_path.symlink_to(dst_path) if target.local_binary_path&.extname == ".xcframework"
-            config.spm_artifacts_dir.glob("#{target.full_name}/*.xcframework").each do |p|
-              p.symlink_to(dst_path)
-            end
-          end
-        end
-      end
-    end
-  end
-end