xccache 1.0.2 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2357c61b242803e69f54fe2b9a4db8eef00deabb636dbd98e84a808bd6c3d56a
-  data.tar.gz: b4d9615136cb599bff14e73ef51472c6b6d3838acd5518d6e17ce9446275de4a
+  metadata.gz: e985d50b212e526c36c94d40d93210a81850267fb205a3c2b10aee659357a039
+  data.tar.gz: 8e720a6bda28fc18cefd3bcc18b37aab2ecbf29acee27f688db5508ab9c38af2
 SHA512:
-  metadata.gz: b353117fdc74f92fe4c091d94936b55548b7f4b8450441dd51ebe6728b4513960af76f0278095b7f777aec0189c5c371c8a268a10092d1d522494b7da26e4f74
-  data.tar.gz: ab9c2d5bb982bb0d7c86703ca4d1ca84ab1a3b8598eb671400a0eee47ac1caf26ff54cf9d2567c47d35702eca071d909b648243d2fa194f0b982b3d879ec7cbb
+  metadata.gz: 7f84d4d129ae5e4b5e07aa96dd47d9618d9f117f2a28679f49de286075173eac12c51e8c4c47b52d85da20d5fb024cd395b1e76c3203598a5199a05c278d6027
+  data.tar.gz: e0d610301f133cc22ede54d34db62e57bf1f98701b3f57b408217c6a92ccb21ba6a65a0296e102c98bd337963544d4333918aa9c4aa6556c1eea118343c7ef69

data/lib/xccache/cache/cachemap.rb

@@ -57,15 +57,18 @@ module XCCache
       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/command/base.rb

@@ -5,6 +5,7 @@ module XCCache
     class Options
       SDK = ["--sdk=foo,bar", "SDKs (iphonesimulator, iphoneos, macos, etc.)"].freeze
       CONFIG = ["--config=foo", "Configuration (debug, release) (default: debug)"].freeze
+      LOG_DIR = ["--log-dir=foo", "Build log directory"].freeze
       MERGE_SLICES = [
         "--merge-slices/--no-merge-slices",
         "Whether to merge with existing slices/sdks in the xcframework (default: true)",
@@ -19,7 +20,7 @@ module XCCache
       end
 
       def self.build_options
-        install_options + [MERGE_SLICES, LIBRARY_EVOLUTION]
+        install_options + [LOG_DIR, MERGE_SLICES, LIBRARY_EVOLUTION]
       end
     end
   end

data/lib/xccache/command.rb

@@ -24,6 +24,7 @@ module XCCache
       }
       @build_options = {
         **@install_options,
+        :log_dir => argv.option("log-dir"),
         :recursive => argv.flag?("recursive"),
         :merge_slices => argv.flag?("merge-slices", true),
         :library_evolution => argv.flag?("library-evolution"),

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/core/live_log.rb

@@ -0,0 +1,82 @@
+require "monitor"
+require "tty-cursor"
+require "tty-screen"
+
+module XCCache
+  class LiveLog
+    include UI::Mixin
+    CURSOR_LOCK = Monitor.new
+
+    attr_reader :output, :max_lines, :lines, :cursor, :tee
+
+    def initialize(**options)
+      @output = options[:output] || $stdout
+      @max_lines = options[:max_lines] || 5
+      @n_sticky = 0
+      @lines = []
+      @cursor = TTY::Cursor
+      @screen = TTY::Screen
+      @tee = options[:tee]
+    end
+
+    def clear
+      commit do
+        output.print(cursor.clear_lines(lines.count + @n_sticky))
+        @lines = []
+        @n_sticky = 0
+      end
+    end
+
+    def puts(line, sticky: false)
+      commit do
+        output.print(cursor.clear_lines(lines.count + 1))
+        if sticky
+          @n_sticky += 1
+          output.puts(truncated(line))
+        else
+          lines.shift if lines.count >= max_lines
+          lines << truncated(line)
+        end
+        output.puts(lines) # print non-sticky content
+      end
+      File.open(tee, "a") { |f| f << "#{line}\n" } if tee
+    end
+
+    def capture(header)
+      header_start = header.magenta.bold
+      header_success = "#{header} ✔".green.bold
+      header_error = "#{header} ✖".red.bold
+      puts(header_start, sticky: true)
+      yield if block_given?
+      clear
+      update_header(header_success)
+    rescue StandardError => e
+      update_header(header_error)
+      raise e
+    end
+
+    private
+
+    def update_header(header)
+      commit do
+        n = lines.count + @n_sticky
+        output.print(cursor.up(n) + header + cursor.column(0) + cursor.down(n))
+      end
+    end
+
+    def commit
+      CURSOR_LOCK.synchronize do
+        yield
+        output.flush
+      end
+    end
+
+    def truncated(msg)
+      msg.length > @screen.width ? "#{msg[...@screen.width - 3]}..." : msg
+    end
+
+    def ui_cls
+      self
+    end
+  end
+end

data/lib/xccache/core/log.rb

@@ -5,13 +5,13 @@ module XCCache
   module UI
     @indent = 0
 
-    class << self
+    module Mixin
       include Config::Mixin
       attr_accessor :indent
 
       def section(title, timing: false)
         start = Time.new if timing
-        UI.puts(title)
+        ui_cls.puts(title)
         self.indent += 2
         res = yield if block_given?
         self.indent -= 2
@@ -22,25 +22,25 @@ module XCCache
                      else
                        "#{duration / 3600}h"
                      end
-          UI.puts("-> Finished: #{title.dark} (#{duration})")
+          ui_cls.puts("-> Finished: #{title.dark} (#{duration})")
         end
         res
       end
 
       def message(message)
-        UI.puts(message) if config.verbose?
+        ui_cls.puts(message) if config.verbose?
       end
 
       def info(message)
-        UI.puts(message)
+        ui_cls.puts(message)
       end
 
       def warn(message)
-        UI.puts(message.yellow)
+        ui_cls.puts(message.yellow)
       end
 
       def error(message)
-        UI.puts("[ERROR] #{message}".red)
+        ui_cls.puts("[ERROR] #{message}".red)
       end
 
       def error!(message)
@@ -51,6 +51,16 @@ module XCCache
       def puts(message)
         $stdout.puts("#{' ' * self.indent}#{message}")
       end
+
+      private
+
+      def ui_cls
+        UI
+      end
+    end
+
+    class << self
+      include Mixin
     end
   end
 end

data/lib/xccache/core/sh.rb

@@ -17,14 +17,25 @@ module XCCache
 
       def run(*args, env: nil, **options)
         cmd = args.join(" ")
-        UI.message("$ #{cmd}".cyan.dark) if config.verbose? && options[:log_cmd] != false
-        return system(cmd) || (raise GeneralError, "Command '#{cmd}' failed") unless options[:capture]
 
         out, err = [], []
+        handle_out = options[:handle_out] || proc { |l| out << l }
+        handle_err = options[:handle_err] || proc { |l| err << l }
+        if (live_log = options[:live_log])
+          handle_out = proc { |l| live_log.puts(l) }
+          handle_err = proc { |l| live_log.puts(l) }
+          live_log.puts("$ #{cmd}") if options[:log_cmd] != false
+        elsif options[:log_cmd] != false
+          UI.message("$ #{cmd}".cyan.dark)
+        end
+
+        use_popen = options[:capture] || options[:handle_out] || options[:handle_err] || options[:live_log]
+        return system(cmd) || (raise GeneralError, "Command '#{cmd}' failed") unless use_popen
+
         popen3_args = env ? [env, cmd] : [cmd]
         Open3.popen3(*popen3_args) do |_stdin, stdout, stderr, wait_thr|
-          stdout_thread = Thread.new { stdout.each { |l| out << l } }
-          stderr_thread = Thread.new { stderr.each { |l| err << l } }
+          stdout_thread = Thread.new { stdout.each { |l| handle_out.call(l.strip) } }
+          stderr_thread = Thread.new { stderr.each { |l| handle_err.call(l.strip) } }
           [stdout_thread, stderr_thread].each(&:join)
           result = wait_thr.value
           result.exitstatus
@@ -32,6 +43,13 @@ module XCCache
         end
         [out.join("\n"), err.join("\n")]
       end
+
+      private
+
+      def log_cmd(cmd, live_log: nil)
+        return live_log.puts("$ #{cmd}") if live_log
+        UI.message("$ #{cmd}".cyan.dark)
+      end
     end
   end
 end

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!
@@ -106,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
@@ -145,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

@@ -1,7 +1,8 @@
 module XCCache
   module SPM
     class Buildable
-      attr_reader :name, :module_name, :pkg_dir, :pkg_desc, :sdk, :sdks, :config, :path, :tmpdir, :library_evolution
+      attr_reader :name, :module_name, :pkg_dir, :pkg_desc, :sdk, :sdks, :config, :path, :tmpdir, :library_evolution,
+                  :live_log
       alias library_evolution? library_evolution
 
       def initialize(options = {})
@@ -9,12 +10,15 @@ 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
+        @live_log = options[:live_log]
       end
 
       def build(options = {})
@@ -35,13 +39,17 @@ module XCCache
           cmd << "-Xswiftc" << "-emit-module-interface"
           cmd << "-Xswiftc" << "-no-verify-emitted-module-interface"
         end
-        Sh.run(cmd)
+        sh(cmd)
+      end
+
+      def sh(cmd)
+        Sh.run(cmd, live_log: live_log)
       end
 
       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/macro.rb

@@ -21,7 +21,7 @@ module XCCache
         # -> WORKAROUND: Find the associated regular target and build it, then collect the tool binary
         # ---------------------------------------------------------------------------------
         associated_target = pkg_desc.targets.find { |t| t.direct_dependency_targets.include?(pkg_target) }
-        UI.message(
+        live_log.info(
           "#{name.yellow.dark} is a macro target. " \
           "Will build the associated target #{associated_target.name.dark} to get the tool binary."
         )
@@ -30,7 +30,7 @@ module XCCache
         raise GeneralError, "Tool binary not exist at: #{binary_path}" unless binary_path.exist?
         binary_path.copy(to: path)
         FileUtils.chmod("+x", path)
-        UI.info("-> Macro binary: #{path.to_s.dark}")
+        live_log.info("-> Macro binary: #{path}")
       end
 
       def products_dir

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

@@ -22,14 +22,19 @@ module XCCache
 
       def build(options = {})
         validate!
-        targets = options.delete(:targets) || []
+        targets = (options.delete(:targets) || []).map { |t| t.split("/")[-1] }
         raise GeneralError, "No targets were specified" if targets.empty?
 
-        targets.map { |t| t.split("/")[-1] }.each_with_index do |t, i|
-          UI.section("\n▶ Building target: #{t} (#{i + 1}/#{targets.count})".bold.magenta) do
-            build_target(**options, target: t)
+        Dir.create_tmpdir do |tmpdir|
+          targets.each_with_index do |t, i|
+            target_tmpdir = Dir.prepare(tmpdir / t)
+            log_dir = Dir.prepare(options[:log_dir] || target_tmpdir)
+            live_log = LiveLog.new(tee: log_dir / "build_#{t}.log")
+            live_log.capture("[#{i + 1}/#{targets.count}] Building target: #{t}") do
+              build_target(**options, target: t, live_log: live_log, tmpdir: target_tmpdir)
+            end
           rescue StandardError => e
-            UI.error("Failed to build target: #{t}. Error: #{e}")
+            UI.error("Error: #{e}\n" + "For details, check out: #{live_log.tee}".yellow.bold)
             raise e unless Config.instance.ignore_build_errors?
           end
         end
@@ -52,19 +57,19 @@ module XCCache
         basename = options[:checksum] ? "#{target.name}-#{target.checksum}" : target.name
         binary_path = out_dir / "#{basename}#{ext}"
 
-        Dir.create_tmpdir do |tmpdir|
-          cls = target.macro? ? Macro : XCFramework
-          cls.new(
-            name: target.name,
-            pkg_dir: root_dir,
-            config: config,
-            sdks: sdks,
-            path: binary_path,
-            tmpdir: tmpdir,
-            pkg_desc: target_pkg_desc,
-            library_evolution: options[:library_evolution],
-          ).build(**options)
-        end
+        cls = target.macro? ? Macro : XCFramework
+        cls.new(
+          name: target.name,
+          pkg_dir: root_dir,
+          config: config,
+          sdks: sdks,
+          path: binary_path,
+          tmpdir: options[:tmpdir],
+          pkg_desc: target_pkg_desc,
+          ctx_desc: pkg_desc || target_pkg_desc,
+          library_evolution: options[:library_evolution],
+          live_log: options[:live_log],
+        ).build(**options)
         return if (symlinks_dir = options[:symlinks_dir]).nil?
         binary_path.symlink_to(symlinks_dir / target.name / "#{target.name}#{ext}")
       end
@@ -75,6 +80,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/pkg/proxy_executable.rb

@@ -4,11 +4,12 @@ module XCCache
       class Proxy < Package
         class Executable
           REPO_URL = "https://github.com/trinhngocthuyen/xccache-proxy".freeze
-          VERSION_OR_SHA = "1.0.0rc1".freeze
+          VERSION_OR_SHA = "1.0.0".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]
+            cmd << "--verbose" if Config.instance.verbose?
             Sh.run(cmd, env: env)
           end
 

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

@@ -4,10 +4,9 @@ module XCCache
   module SPM
     class FrameworkSlice < Buildable
       def build(_options = {})
-        UI.section("Building slice: #{name} (#{config}, #{sdk})".bold) do
-          swift_build
-          create_framework
-        end
+        live_log.puts("Building #{name}.framework (#{config}, #{sdk})".cyan, sticky: true)
+        swift_build
+        create_framework
       end
 
       private
@@ -21,7 +20,7 @@ module XCCache
         # WORKAROUND:
         # - Overriding resource_bundle_accessor.swift to add `Frameworks/<Target>.framework` to the search list
         # - Compiling this file into an `.o` file before using `libtool` to create the framework binary
-        UI.message("Override resource_bundle_accessor")
+        live_log.info("Override resource_bundle_accessor")
         template_name = use_clang? ? "resource_bundle_accessor.m" : "resource_bundle_accessor.swift"
         source_path = tmpdir / File.basename(template_name)
         obj_path = products_dir / "#{module_name}.build" / "#{source_path.basename}.o"
@@ -33,18 +32,18 @@ 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
-        Sh.run(cmd)
+        sh(cmd)
       end
 
       def create_framework
@@ -67,7 +66,7 @@ module XCCache
         cmd = ["libtool", "-static"]
         cmd << "-o" << "#{path}/#{module_name}"
         cmd << "-filelist" << objlist_path.to_s
-        Sh.run(cmd)
+        sh(cmd)
         FileUtils.chmod("+x", path / module_name)
       end
 
@@ -85,7 +84,7 @@ module XCCache
       def create_modules
         copy_swiftmodules unless use_clang?
 
-        UI.message("Creating framework modulemap")
+        live_log.info("Creating framework modulemap")
         Template.new("framework.modulemap").render(
           { :module_name => module_name, :target => name },
           save_to: modules_dir / "module.modulemap"
@@ -93,7 +92,7 @@ module XCCache
       end
 
       def copy_headers
-        UI.message("Copying headers")
+        live_log.info("Copying headers")
         swift_header_paths = products_dir.glob("#{module_name}.build/*-Swift.h")
         paths = swift_header_paths + pkg_target.header_paths
         paths.each { |p| process_header(p) }
@@ -130,7 +129,7 @@ module XCCache
       end
 
       def copy_swiftmodules
-        UI.message("Copying swiftmodules")
+        live_log.info("Copying swiftmodules")
         swiftmodule_dir = Dir.prepare("#{modules_dir}/#{module_name}.swiftmodule")
         swiftinterfaces = products_dir.glob("#{module_name}.build/#{module_name}.swiftinterface")
         to_copy = products_dir.glob("Modules/#{module_name}.*") + swiftinterfaces
@@ -141,7 +140,7 @@ module XCCache
 
       def copy_resource_bundles
         resolve_resource_symlinks
-        UI.message("Copy resource bundle to framework: #{resource_bundle_product_path.basename}")
+        live_log.info("Copying resource bundle to framework: #{resource_bundle_product_path.basename}")
         resource_bundle_product_path.copy(to_dir: path)
       end
 

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

@@ -21,35 +21,32 @@ module XCCache
         tmp_existing_path = tmpdir / "existing.framework"
 
         slices.each(&:build)
-        UI.section("Creating #{name}.xcframework from slices") do
-          create_xcframework(from: slices.map(&:path), to: tmp_new_path)
-        end
+        create_xcframework(from: slices.map(&:path), to: tmp_new_path)
 
         path.copy(to: tmp_existing_path) if path.exist? && merge_slices
         path.rmtree if path.exist?
 
         if merge_slices && tmp_existing_path.exist?
-          UI.section("Merging #{name}.xcframework with existing slices") do
-            framework_paths =
-              [tmp_new_path, tmp_existing_path]
-              .flat_map { |p| p.glob("*/*.framework") }
-              .uniq { |p| p.parent.basename.to_s } # uniq by id (ex. ios-arm64), preferred new ones
-            create_xcframework(from: framework_paths, to: path)
-          end
+          framework_paths =
+            [tmp_new_path, tmp_existing_path]
+            .flat_map { |p| p.glob("*/*.framework") }
+            .uniq { |p| p.parent.basename.to_s } # uniq by id (ex. ios-arm64), preferred new ones
+          create_xcframework(from: framework_paths, to: path)
         else
           path.parent.mkpath
           tmp_new_path.copy(to: path)
         end
-        UI.info("-> XCFramework: #{path.to_s.dark}")
+        live_log.info("-> XCFramework: #{path}")
       end
 
       def create_xcframework(options = {})
+        live_log.info("Creating xcframework from slices")
         cmd = ["xcodebuild", "-create-xcframework"]
         cmd << "-allow-internal-distribution" unless library_evolution?
         cmd << "-output" << options[:to]
         options[:from].each { |p| cmd << "-framework" << p }
         cmd << "> /dev/null" # Only care about errors
-        Sh.run(cmd)
+        sh(cmd)
       end
     end
   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.2
+  version: 1.0.4
 platform: ruby
 authors:
 - Thuyen Trinh
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-06-08 00:00:00.000000000 Z
+date: 2025-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: claide
@@ -38,6 +38,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: tty-cursor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tty-screen
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: xcodeproj
   requirement: !ruby/object:Gem::Requirement
@@ -91,6 +119,7 @@ files:
 - lib/xccache/core/error.rb
 - lib/xccache/core/git.rb
 - lib/xccache/core/hash.rb
+- lib/xccache/core/live_log.rb
 - lib/xccache/core/lockfile.rb
 - lib/xccache/core/log.rb
 - lib/xccache/core/parallel.rb