xccache 1.0.1 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 31a523d3926f239135aaaebcc8c6cabe18da2a43e251e83edb486b13c22630e9
-  data.tar.gz: 2997cc54f7b5a4c2395181d29f1042433b4d24d38aef98d8053555d52e4c518c
+  metadata.gz: ec431281d554462ef40e31a982b9198f5e0b3e8201fe26d97b29dc776595c9e6
+  data.tar.gz: 265f10b7ab38e2d2351e6b5b0e5f337bacbe64499263f4ce736131691646dc83
 SHA512:
-  metadata.gz: 3d4d9014951e0e99cbfa57594831872404289522cf4943af250cba55e4b70f00567caa6d882b65d84b8825840aa279e0e6248dabfdc2a3e72ea8febd772ef532
-  data.tar.gz: d0e4eda645edc09208c1a097eae6959145171975b48bcb778b02f3d0df22d99332fd1a1b326fafbfe425cdec0d9e45d3b07cfe8954482fddfaaf09f9be2d6f7a
+  metadata.gz: 50a9eaba6ffeb480fd36688171fb9c97852a500f466b6b95d700dda1a134129b784bc916799a970ec9262f64e74930f497c72adfe95c1ec78f31b5ca9bbf9e9c
+  data.tar.gz: 45b141c6b9136dfeacce7129956c2147f8e5a20e2427206509c144ed1ca543b79c7b36c81cd1f6369a97ee639d7ad024030382fc285d261b5fe0a691fdbe5203

data/lib/xccache/cache/cachemap.rb

@@ -28,28 +28,47 @@ module XCCache
       end
 
       def print_stats
-        hit, missed, ignored = %i[hit missed ignored].map { |type| get_cache_data(type) }
-        total_count = cache_data.count
-        UI.message <<~DESC
-          -------------------------------------------------------------------
-          Cache stats
-          • Hit (#{hit.count}/#{total_count}): #{hit.to_s.green.dark}
-          • Missed (#{missed.count}/#{total_count}): #{missed.to_s.yellow.dark}
-          • Ignored (#{ignored.count}/#{total_count}): #{ignored.to_s.dark}
-          -------------------------------------------------------------------
-        DESC
+        verbose = Config.instance.verbose?
+        colors = { :hit => "green", :missed => "yellow" }
+        descs = %i[hit missed ignored].to_h do |type|
+          colorize = proc { |s| colors.key?(type) ? s.send(colors[type]).dark : s.dark }
+          items = get_cache_data(type)
+          percent = cache_data.count.positive? ? items.count.to_f / cache_data.count * 100 : 0
+          desc = "#{type} #{percent.round}% (#{items.count}/#{cache_data.count})"
+          desc = desc.capitalize if verbose
+          desc = "#{desc} #{colorize.call(items.to_s)}" if verbose && !items.empty?
+          [type, desc]
+        end
+        if verbose
+          UI.info <<~DESC
+            -------------------------------------------------------------------
+            Cache stats
+            #{descs.values.map { |s| "• #{s}" }.join("\n")}
+            -------------------------------------------------------------------
+          DESC
+        else
+          UI.info <<~DESC
+            -------------------------------------------------------------------
+            Cache stats: #{descs.values.join(', ')}
+            To see the full stats, use --verbose in the xccache command
+            -------------------------------------------------------------------
+          DESC
+        end
       end
 
       def get_cache_data(type)
-        cache_data.select { |k, v| v == type && !k.end_with?(".xccache") }.keys
+        cache_data.select { |_, v| v == type }.keys
       end
 
       def update_from_graph(graph)
-        cache_data = graph["cache"].to_h do |k, v|
-          next [k, :hit] if v
-          next [k, :ignored] if Config.instance.ignore?(k)
-          [k, :missed]
-        end
+        cache_data =
+          graph["cache"]
+          .reject { |k, _| k.end_with?(".xccache") }
+          .to_h do |k, v|
+            next [k, :hit] if v
+            next [k, :ignored] if Config.instance.ignore?(k)
+            [k, :missed]
+          end
 
         deps = graph["deps"]
         edges = deps.flat_map { |k, xs| xs.map { |v| { :source => k, :target => v } } }

data/lib/xccache/core/config.rb

@@ -40,11 +40,11 @@ module XCCache
     end
 
     def spm_local_pkgs_dir
-      @spm_local_pkgs_dir ||= Dir.prepare(spm_sandbox / "local", clean: true)
+      @spm_local_pkgs_dir ||= Dir.prepare(spm_sandbox / "local")
     end
 
-    def spm_xcconfig_dir
-      @spm_xcconfig_dir ||= Dir.prepare(spm_sandbox / "xcconfigs", clean: true)
+    def spm_xcconfigs_dir
+      @spm_xcconfigs_dir ||= Dir.prepare(spm_sandbox / "xcconfigs")
     end
 
     def spm_cache_dir
@@ -52,7 +52,7 @@ module XCCache
     end
 
     def spm_binaries_dir
-      @spm_binaries_dir ||= Dir.prepare(spm_sandbox / "binaries", clean: true)
+      @spm_binaries_dir ||= Dir.prepare(spm_sandbox / "binaries")
     end
 
     def spm_build_dir

data/lib/xccache/installer/integration/build.rb

@@ -10,7 +10,7 @@ module XCCache
       end
 
       def targets_to_build(options)
-        items = options[:targets] || []
+        items = (options[:targets] || []).map { |x| File.basename(x) }
         items = config.cachemap.missed.map { |x| File.basename(x) } if items.empty?
         targets = items.map { |x| umbrella_pkg.get_target(x) }
 

data/lib/xccache/installer/integration/supporting_files.rb

@@ -11,7 +11,7 @@ module XCCache
 
       def gen_xcconfigs
         macros_config_by_targets.each do |target, hash|
-          xcconfig_path = config.spm_xcconfig_dir / "#{target}.xcconfig"
+          xcconfig_path = config.spm_xcconfigs_dir / "#{target}.xcconfig"
           UI.message("XCConfig of target #{target} at: #{xcconfig_path}")
           Xcodeproj::Config.new(hash).save_as(xcconfig_path)
         end

data/lib/xccache/installer.rb

@@ -17,6 +17,7 @@ module XCCache
 
     def perform_install
       verify_projects!
+      recreate_config_dirs
       projects.each { |project| migrate_umbrella_to_proxy(project) }
       UI.message("Using cache dir: #{config.spm_cache_dir}")
       config.ensure_file!
@@ -87,7 +88,8 @@ module XCCache
 
     def platforms_for_project(project)
       project
-        .targets.map { |t| [t.platform_name.to_s, t.deployment_target] }
+        .targets.select(&:platform_name)
+        .map { |t| [t.platform_name.to_s, t.deployment_target] }
         .sort.reverse.to_h # sort descendingly -> min value is picked for the hash
     end
 
@@ -105,9 +107,9 @@ module XCCache
     end
 
     def inject_xcconfig_to_project(project)
-      group = project.xccache_config_group.ensure_synced_group(name: "xcconfigs", path: config.spm_xcconfig_dir)
+      group = project.xccache_config_group.ensure_synced_group(name: "xcconfigs", path: config.spm_xcconfigs_dir)
       project.targets.each do |target|
-        xcconfig_path = config.spm_xcconfig_dir / "#{target.name}.xcconfig"
+        xcconfig_path = config.spm_xcconfigs_dir / "#{target.name}.xcconfig"
         target.build_configurations.each do |build_config|
           if (existing = build_config.base_configuration_xcconfig)
             next if existing.path == xcconfig_path
@@ -144,5 +146,14 @@ module XCCache
         ref.path = "xccache/packages/proxy/Package.swift"
       end
     end
+
+    def recreate_config_dirs
+      [
+        config.spm_binaries_dir,
+        config.spm_local_pkgs_dir,
+        config.spm_xcconfigs_dir,
+        config.spm_metadata_dir,
+      ].each { |p| Dir.prepare(p, clean: true) }
+    end
   end
 end

data/lib/xccache/spm/build.rb

@@ -9,12 +9,14 @@ module XCCache
         @module_name = @name.c99extidentifier
         @pkg_dir = Pathname(options[:pkg_dir] || ".").expand_path
         @pkg_desc = options[:pkg_desc]
+        @ctx_desc = options[:ctx_desc] # Context desc, could be an umbrella or a standalone pkg
         @sdks = options[:sdks] || []
         @sdk = options[:sdk] || @sdks&.first
         @config = options[:config] || "debug"
         @path = options[:path]
         @tmpdir = options[:tmpdir]
         @library_evolution = options[:library_evolution]
+        @sdks.each { |sdk| sdk.version = @ctx_desc.platforms[sdk.platform] } if @ctx_desc
       end
 
       def build(options = {})
@@ -41,7 +43,7 @@ module XCCache
       def swift_build_args
         [
           "--configuration", config,
-          "--triple", sdk.triple,
+          "--triple", sdk.triple(with_version: true),
         ]
       end
 

data/lib/xccache/spm/desc/desc.rb

@@ -19,6 +19,10 @@ module XCCache
           raw["_metadata"] ||= {}
         end
 
+        def platforms
+          @platforms ||= raw.fetch("platforms", []).to_h { |h| [h["platformName"].to_sym, h["version"]] }
+        end
+
         def dependencies
           @dependencies ||= fetch("dependencies", Dependency)
         end

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

@@ -62,6 +62,7 @@ module XCCache
             path: binary_path,
             tmpdir: tmpdir,
             pkg_desc: target_pkg_desc,
+            ctx_desc: pkg_desc || target_pkg_desc,
             library_evolution: options[:library_evolution],
           ).build(**options)
         end
@@ -75,6 +76,10 @@ module XCCache
         @resolved = true
       end
 
+      def pkg_desc
+        descs_by_name[root_dir.basename.to_s]
+      end
+
       def pkg_desc_of_target(name, **options)
         resolve
         desc = descs.find { |d| d.has_target?(name) }

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

@@ -30,7 +30,7 @@ module XCCache
         end
 
         def invalidate_cache(sdks: [])
-          UI.message("Invalidating cache (sdks: #{sdks.map(&:name)})")
+          UI.message("Invalidating cache (sdks: #{sdks.map(&:to_s).join(', ')})")
 
           config.spm_cache_dir.glob("*/*.{xcframework,macro}").each do |p|
             cmps = p.basename(".*").to_s.split("-")
@@ -45,7 +45,7 @@ module XCCache
 
             # 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) }
+            expected_triples = sdks.map { |sdk| sdk.triple(with_vendor: false) }
             missing_triples = expected_triples - metadata.triples
             missing_triples.empty? ? accept_cache.call : reject_cache.call
           end

data/lib/xccache/spm/xcframework/slice.rb

@@ -33,14 +33,14 @@ module XCCache
         if use_clang?
           cmd = ["xcrun", "clang"]
           cmd << "-x" << "objective-c"
-          cmd << "-target" << sdk.triple << "-isysroot" << sdk.sdk_path
+          cmd << "-target" << sdk.triple(with_version: true) << "-isysroot" << sdk.sdk_path
           cmd << "-o" << obj_path.to_s
           cmd << "-c" << source_path
         else
           cmd = ["xcrun", "swiftc"]
           cmd << "-emit-library" << "-emit-object"
           cmd << "-module-name" << module_name
-          cmd << "-target" << sdk.triple << "-sdk" << sdk.sdk_path
+          cmd << "-target" << sdk.triple(with_version: true) << "-sdk" << sdk.sdk_path
           cmd << "-o" << obj_path.to_s
           cmd << source_path
         end

data/lib/xccache/swift/sdk.rb

@@ -3,38 +3,45 @@ require "xccache/core/sh"
 module XCCache
   module Swift
     class Sdk
-      attr_reader :name
-
-      NAME_TO_TRIPLE = {
-        :iphonesimulator => "arm64-apple-ios-simulator",
-        :iphoneos => "arm64-apple-ios",
-        :macos => "arm64-apple-macos",
-        :watchos => "arm64-apple-watchos",
-        :watchsimulator => "arm64-apple-watchos-simulator",
-        :appletvos => "arm64-apple-tvos",
-        :appletvsimulator => "arm64-apple-tvos-simulator",
-        :xros => "arm64-apple-xros",
-        :xrsimulator => "arm64-apple-xros-simulator",
+      attr_reader :name, :arch, :vendor, :platform
+      attr_accessor :version
+
+      NAME_TO_PLATFORM = {
+        :iphonesimulator => :ios,
+        :iphoneos => :ios,
+        :macos => :macos,
+        :watchos => :watchos,
+        :watchsimulator => :watchos,
+        :appletvos => :tvos,
+        :appletvsimulator => :tvos,
+        :xros => :xros,
+        :xrsimulator => :xros,
       }.freeze
 
-      def initialize(name)
-        @name = name
-        return if NAME_TO_TRIPLE.key?(name.to_sym)
-        raise GeneralError, "Unknown sdk: #{name}. Must be one of #{NAME_TO_TRIPLE.keys}"
+      def initialize(name, version: nil)
+        @name = name.to_sym
+        @vendor = "apple"
+        @arch = "arm64"
+        @platform = NAME_TO_PLATFORM.fetch(@name, @name)
+        @version = version
+        return if NAME_TO_PLATFORM.key?(@name)
+        raise GeneralError, "Unknown sdk: #{@name}. Must be one of #{NAME_TO_PLATFORM.keys}"
       end
 
       def to_s
-        name
+        name.to_s
       end
 
-      def triple(without_vendor: false)
-        res = NAME_TO_TRIPLE[name.to_sym]
-        res = res.sub("-apple", "") if without_vendor
-        res
+      def triple(with_vendor: true, with_version: false)
+        cmps = [arch]
+        cmps << vendor if with_vendor
+        cmps << (with_version && version ? "#{platform}#{version}" : platform.to_s)
+        cmps << "simulator" if simulator?
+        cmps.join("-")
       end
 
       def sdk_name
-        name == "macos" ? "macosx" : name
+        name == :macos ? :macosx : name
       end
 
       def sdk_path
@@ -56,6 +63,10 @@ module XCCache
           "-I#{developer_usr_lib_path}",
         ]
       end
+
+      def simulator?
+        name.to_s.end_with?("simulator")
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xccache
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.3
 platform: ruby
 authors:
 - Thuyen Trinh
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-06-03 00:00:00.000000000 Z
+date: 2025-06-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: claide