xccache 1.0.3 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ec431281d554462ef40e31a982b9198f5e0b3e8201fe26d97b29dc776595c9e6
-  data.tar.gz: 265f10b7ab38e2d2351e6b5b0e5f337bacbe64499263f4ce736131691646dc83
+  metadata.gz: e985d50b212e526c36c94d40d93210a81850267fb205a3c2b10aee659357a039
+  data.tar.gz: 8e720a6bda28fc18cefd3bcc18b37aab2ecbf29acee27f688db5508ab9c38af2
 SHA512:
-  metadata.gz: 50a9eaba6ffeb480fd36688171fb9c97852a500f466b6b95d700dda1a134129b784bc916799a970ec9262f64e74930f497c72adfe95c1ec78f31b5ca9bbf9e9c
-  data.tar.gz: 45b141c6b9136dfeacce7129956c2147f8e5a20e2427206509c144ed1ca543b79c7b36c81cd1f6369a97ee639d7ad024030382fc285d261b5fe0a691fdbe5203
+  metadata.gz: 7f84d4d129ae5e4b5e07aa96dd47d9618d9f117f2a28679f49de286075173eac12c51e8c4c47b52d85da20d5fb024cd395b1e76c3203598a5199a05c278d6027
+  data.tar.gz: e0d610301f133cc22ede54d34db62e57bf1f98701b3f57b408217c6a92ccb21ba6a65a0296e102c98bd337963544d4333918aa9c4aa6556c1eea118343c7ef69

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/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/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 = {})
@@ -17,6 +18,7 @@ module XCCache
         @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 = {})
@@ -37,7 +39,11 @@ 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

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,20 +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,
-            ctx_desc: 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

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"
@@ -44,7 +43,7 @@ module XCCache
           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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xccache
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.4
 platform: ruby
 authors:
 - Thuyen Trinh
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-06-10 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