xccache 0.0.2 → 1.0.0

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

@@ -2,11 +2,15 @@ require "json"
 require "xccache/spm/xcframework/slice"
 require "xccache/spm/xcframework/xcframework"
 require "xccache/spm/xcframework/metadata"
+require "xccache/spm/pkg/proxy"
 require "xccache/swift/sdk"
 
 module XCCache
   module SPM
     class Package
+      include Config::Mixin
+      include Proxy::Mixin
+
       include Cacheable
       cacheable :pkg_desc_of_target
 
@@ -14,7 +18,6 @@ module XCCache
 
       def initialize(options = {})
         @root_dir = Pathname(options[:root_dir] || ".").expand_path
-        @warn_if_not_direct_target = options.fetch(:warn_if_not_direct_target, true)
       end
 
       def build(options = {})
@@ -33,7 +36,10 @@ module XCCache
       end
 
       def build_target(target: nil, sdks: nil, config: nil, out_dir: nil, **options)
-        target_pkg_desc = pkg_desc_of_target(target, skip_resolving_dependencies: options[:skip_resolving_dependencies])
+        target_pkg_desc = pkg_desc_of_target(
+          target,
+          ensure_exist: true,
+        )
         if target_pkg_desc.binary_targets.any? { |t| t.name == target }
           return UI.warn("Target #{target} is a binary target -> no need to build")
         end
@@ -42,33 +48,44 @@ module XCCache
 
         out_dir = Pathname(out_dir || ".")
         out_dir /= target.name if options[:checksum]
+        ext = target.macro? ? ".macro" : ".xcframework"
         basename = options[:checksum] ? "#{target.name}-#{target.checksum}" : target.name
-        basename += target.macro? ? ".macro" : ".xcframework"
+        binary_path = out_dir / "#{basename}#{ext}"
 
-        Dir.create_tmpdir do |_tmpdir|
+        Dir.create_tmpdir do |tmpdir|
           cls = target.macro? ? Macro : XCFramework
           cls.new(
             name: target.name,
             pkg_dir: root_dir,
             config: config,
             sdks: sdks,
-            path: out_dir / basename,
-            tmpdir: Dir.create_tmpdir,
+            path: binary_path,
+            tmpdir: tmpdir,
             pkg_desc: target_pkg_desc,
             library_evolution: options[:library_evolution],
           ).build(**options)
         end
+        return if (symlinks_dir = options[:symlinks_dir]).nil?
+        binary_path.symlink_to(symlinks_dir / target.name / "#{target.name}#{ext}")
       end
 
-      def resolve(force: false)
-        return if @resolved && !force
-
-        UI.section("Resolving package dependencies (package: #{root_dir.basename})", timing: true) do
-          Sh.run("swift package resolve --package-path #{root_dir} 2>&1")
-        end
+      def resolve
+        return if @resolved
+        xccache_proxy.run("resolve --pkg #{root_dir} --metadata #{metadata_dir}")
         @resolved = true
       end
 
+      def pkg_desc_of_target(name, **options)
+        resolve
+        desc = descs.find { |d| d.has_target?(name) }
+        raise GeneralError, "Cannot find package with the given target #{name}" if options[:ensure_exist] && desc.nil?
+        desc
+      end
+
+      def get_target(name)
+        pkg_desc_of_target(name)&.get_target(name)
+      end
+
       private
 
       def validate!
@@ -76,31 +93,20 @@ module XCCache
         raise GeneralError, "No Package.swift in #{root_dir}. Are you sure you're running on a package dir?"
       end
 
-      def pkg_desc_of_target(name, skip_resolving_dependencies: false)
-        # The current package contains the given target
-        return pkg_desc if pkg_desc.has_target?(name)
+      def metadata_dir
+        config.in_installation? ? config.spm_metadata_dir : root_dir / ".build/metadata"
+      end
 
-        if @warn_if_not_direct_target
-          UI.message(
-            "#{name.yellow.dark} is not a direct target of package #{root_dir.basename.to_s.dark} " \
-            "-> trigger from dependencies"
-          )
-        end
-        # Otherwise, it's inside one of the dependencies. Need to resolve then find it
-        resolve unless skip_resolving_dependencies
-
-        @descs ||= if Config.instance.in_installation?
-                   then Description.descs_in_metadata_dir[0]
-                   else
-                     Description.descs_in_dir(Pathname(".").expand_path)[0]
-                   end
-        desc = @descs.find { |d| d.has_target?(name) }
-        return desc unless desc.nil?
-        raise GeneralError, "Cannot find package with the given target #{name}"
+      def descs
+        @descs ||= load_descs[0]
+      end
+
+      def descs_by_name
+        @descs_by_name ||= load_descs[1]
       end
 
-      def pkg_desc
-        @pkg_desc ||= Description.in_dir(root_dir)
+      def load_descs
+        @descs, @descs_by_name = Description.descs_in_metadata_dir(metadata_dir)
       end
     end
   end

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

@@ -0,0 +1,60 @@
+Dir["#{__dir__}/#{File.basename(__FILE__, '.rb')}/*.rb"].sort.each { |f| require f }
+require_relative "proxy_executable"
+
+module XCCache
+  module SPM
+    class Package
+      class Proxy < Package
+        module Mixin
+          def xccache_proxy
+            @xccache_proxy ||= Executable.new
+          end
+        end
+
+        include Mixin
+
+        def umbrella
+          @umbrella ||= Package.new(root_dir: config.spm_umbrella_sandbox)
+        end
+
+        def prepare(options = {})
+          xccache_proxy.run("gen-umbrella")
+          umbrella.resolve
+          invalidate_cache(sdks: options[:sdks])
+          gen_proxy
+        end
+
+        def gen_proxy
+          xccache_proxy.run("gen-proxy")
+          config.cachemap.update_from_graph(graph.reload)
+        end
+
+        def invalidate_cache(sdks: [])
+          UI.message("Invalidating cache (sdks: #{sdks.map(&:name)})")
+
+          config.spm_cache_dir.glob("*/*.{xcframework,macro}").each do |p|
+            cmps = p.basename(".*").to_s.split("-")
+            name, checksum = cmps[...-1].join("-"), cmps[-1]
+            p_without_checksum = config.spm_binaries_dir / name / "#{name}#{p.extname}"
+            accept_cache = proc { p.symlink_to(p_without_checksum) }
+            reject_cache = proc { p_without_checksum.rmtree if p_without_checksum.exist? }
+            next reject_cache.call if (target = umbrella.get_target(name)).nil?
+            next reject_cache.call if target.checksum != checksum
+            # For macro, we just need the tool binary to exist
+            next accept_cache.call if target.macro?
+
+            # For regular targets, the xcframework must satisfy the sdk constraints (ie. containing all the slices)
+            metadata = XCFramework::Metadata.new(p / "Info.plist")
+            expected_triples = sdks.map { |sdk| sdk.triple(without_vendor: true) }
+            missing_triples = expected_triples - metadata.triples
+            missing_triples.empty? ? accept_cache.call : reject_cache.call
+          end
+        end
+
+        def graph
+          @graph ||= JSONRepresentable.new(root_dir / "graph.json")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+module XCCache
+  module SPM
+    class Package
+      class Proxy < Package
+        class Executable
+          REPO_URL = "https://github.com/trinhngocthuyen/xccache-proxy".freeze
+          VERSION_OR_SHA = "0.0.1".freeze
+
+          def run(cmd)
+            env = { "FORCE_OUTPUT" => "console", "FORCE_COLOR" => "1" } if Config.instance.ansi?
+            cmd = cmd.is_a?(Array) ? [bin_path.to_s] + cmd : [bin_path.to_s, cmd]
+            Sh.run(cmd, env: env)
+          end
+
+          def bin_path
+            @bin_path ||= lookup
+          end
+
+          private
+
+          def lookup
+            [
+              local_bin_path,
+              default_bin_path,
+            ].find(&:exist?) || download_or_build_from_source
+          end
+
+          def default_use_downloaded?
+            VERSION_OR_SHA.include?(".")
+          end
+
+          def download_or_build_from_source
+            default_use_downloaded? ? download : build_from_source
+          end
+
+          def build_from_source
+            UI.section("Building xccache-proxy binary from source...".magenta) do
+              dir = Dir.prepare("~/.xccache/xccache-proxy", expand: true)
+              git = Git.new(dir)
+              git.init unless git.init?
+              git.remote("add", "origin", REPO_URL) unless git.remote(capture: true)[0].strip == "origin"
+              git.fetch("origin", VERSION_OR_SHA)
+              git.checkout("-f", "FETCH_HEAD", capture: true)
+
+              Dir.chdir(dir) { Sh.run("make build CONFIGURATION=release") }
+              (dir / ".build" / "release" / "xccache-proxy").copy(to: default_bin_path)
+            end
+          end
+
+          def download
+            UI.section("Downloading xccache-proxy binary from remote...".magenta) do
+              Dir.create_tmpdir do |dir|
+                url = "#{REPO_URL}/releases/download/#{VERSION_OR_SHA}/xccache-proxy.zip"
+                default_bin_path.parent.mkpath
+                tmp_path = dir / File.basename(url)
+                Sh.run("curl -fSL -o #{tmp_path} #{url} && unzip -d #{default_bin_path.parent} #{tmp_path}")
+                FileUtils.chmod("+x", default_bin_path)
+              end
+            end
+            default_bin_path
+          end
+
+          def default_bin_path
+            @default_bin_path ||= begin
+              dir = LIBEXEC / (default_use_downloaded? ? ".download" : ".build")
+              dir / "xccache-proxy-#{VERSION_OR_SHA}" / "xccache-proxy"
+            end
+          end
+
+          def local_bin_path
+            @local_bin_path ||= LIBEXEC / ".local" / "xccache-proxy"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xccache/utils/template.rb

@@ -7,7 +7,7 @@ module XCCache
 
     def initialize(name)
       @name = name
-      @path = Gem.find_files("xccache/assets/templates/#{name}.template").first
+      @path = ROOT / "lib/xccache/assets/templates/#{name}.template"
     end
 
     def render(hash = {}, save_to: nil)

data/lib/xccache/xcodeproj/pkg.rb

@@ -17,7 +17,7 @@ module Xcodeproj
         end
 
         def xccache_pkg?
-          local? && id == "xccache/packages/umbrella"
+          local? && ["xccache/packages/umbrella", "xccache/packages/proxy"].include?(id)
         end
 
         def non_xccache_pkg?

data/lib/xccache/xcodeproj/pkg_product_dependency.rb

@@ -12,12 +12,12 @@ module Xcodeproj
           return package if package
           return if @warned_missing_pkg
           @warned_missing_pkg = true
-          XCCache::UI.warn("Missing pkg of product dependency #{uuid}: #{to_hash}")
+          Log.warn("Missing pkg of product dependency #{uuid}: #{to_hash}")
         end
 
         def remove_alongside_related
           target = referrers.find { |x| x.is_a?(PBXNativeTarget) }
-          XCCache::UI.info(
+          Log.info(
             "(-) Remove #{product_name.red} from product dependencies of target #{target.display_name.bold}"
           )
           target.dependencies.each { |x| x.remove_from_project if x.product_ref == self }

data/lib/xccache/xcodeproj/project.rb

@@ -41,7 +41,7 @@ module Xcodeproj
       pkg_hash = XCCache::Lockfile::Pkg.from_h(hash)
       pkg_hash["relative_path"] = pkg_hash.relative_path_from_dir(dir).to_s if pkg_hash.key == "path_from_root"
 
-      Log.message("Add package #{pkg_hash.id.bold} to project #{display_name.bold}")
+      Log.info("Add package #{pkg_hash.id.bold} to project #{display_name.bold}")
       cls = pkg_hash.local? ? XCLocalSwiftPackageReference : XCRemoteSwiftPackageReference
       ref = new(cls)
       custom_keys = ["path_from_root"]
@@ -51,13 +51,13 @@ module Xcodeproj
     end
 
     def add_xccache_pkg
-      sandbox_path = XCCache::Config.instance.spm_umbrella_sandbox
+      sandbox_path = XCCache::Config.instance.spm_proxy_sandbox
       add_pkg("relative_path" => sandbox_path.relative_path_from(path.parent).to_s)
     end
 
     def remove_pkgs(&block)
       pkgs.select(&block).each do |pkg|
-        XCCache::UI.info("(-) Remove #{pkg.display_name.red} from package refs of project #{display_name.bold}")
+        Log.info("(-) Remove #{pkg.display_name.red} from package refs of project #{display_name.bold}")
         pkg.remove_from_project
       end
     end

data/lib/xccache/xcodeproj/target.rb

@@ -19,14 +19,14 @@ module Xcodeproj
         end
 
         def add_pkg_product_dependency(name)
-          Log.message("(+) Add dependency #{name.blue} to target #{display_name.bold}")
+          Log.info("(+) Add dependency #{name.blue} to target #{display_name.bold}")
           pkg_name, product_name = name.split("/")
           pkg = project.get_pkg(pkg_name)
           pkg_product_dependencies << pkg.create_target_dependency_ref(product_name).product_ref
         end
 
         def add_xccache_product_dependency
-          add_pkg_product_dependency("umbrella/#{name}.xccache")
+          add_pkg_product_dependency("proxy/#{name}.xccache")
         end
 
         def remove_xccache_product_dependencies

data/lib/xccache.rb

@@ -1 +1,6 @@
 require "xccache/main"
+
+module XCCache
+  ROOT = Pathname(__dir__).parent
+  LIBEXEC = ROOT / "libexec"
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xccache
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Thuyen Trinh
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-05-18 00:00:00.000000000 Z
+date: 2025-05-31 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

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