xccache 0.0.1a1 → 0.0.1a3

data/lib/xccache/command/pkg/build.rb

@@ -1,8 +1,38 @@
+require "xccache/spm"
+
 module XCCache
   class Command
     class Pkg < Command
       class Build < Pkg
         self.summary = "Build a Swift package into an xcframework"
+        def self.options
+          [
+            *Options.build_options,
+            ["--out=foo", "Output directory for the xcframework"],
+            ["--checksum/no-checksum", "Whether to include checksum to the binary name"],
+          ].concat(super)
+        end
+        self.arguments = [
+          CLAide::Argument.new("TARGET", false, true),
+        ]
+
+        def initialize(argv)
+          super
+          @targets = argv.arguments!
+          @out_dir = argv.option("out")
+          @include_checksum = argv.flag?("checksum")
+        end
+
+        def run
+          pkg = SPM::Package.new
+          pkg.build(
+            targets: @targets,
+            config: @config,
+            out_dir: @out_dir,
+            checksum: @include_checksum,
+            **@build_options,
+          )
+        end
       end
     end
   end

data/lib/xccache/command/pkg.rb

@@ -1,3 +1,4 @@
+require_relative "base"
 require "xccache/command/pkg/build"
 
 module XCCache

data/lib/xccache/command/remote/pull.rb

@@ -0,0 +1,15 @@
+require "xccache/spm"
+
+module XCCache
+  class Command
+    class Remote < Command
+      class Pull < Remote
+        self.summary = "Pulling cache to local"
+
+        def run
+          storage.pull
+        end
+      end
+    end
+  end
+end

data/lib/xccache/command/remote/push.rb

@@ -0,0 +1,15 @@
+require "xccache/spm"
+
+module XCCache
+  class Command
+    class Remote < Command
+      class Push < Remote
+        self.summary = "Pushing cache to remote"
+
+        def run
+          storage.push
+        end
+      end
+    end
+  end
+end

data/lib/xccache/command/remote.rb

@@ -0,0 +1,39 @@
+require_relative "base"
+require "xccache/storage"
+require "xccache/command/remote/pull"
+require "xccache/command/remote/push"
+
+module XCCache
+  class Command
+    class Remote < Command
+      self.abstract_command = true
+      self.summary = "Working with remote cache"
+      def self.options
+        [
+          ["--branch=foo", "Cache branch (if using git) (default: main)"],
+        ].concat(super)
+      end
+
+      def initialize(argv)
+        super
+        @branch = argv.option("branch", "main")
+      end
+
+      def storage
+        @storage ||= create_storage
+      end
+
+      private
+
+      def create_storage
+        remote_config = config.remote_config
+        if (remote = remote_config["git"])
+          return GitStorage.new(branch: @branch, remote: remote)
+        elsif (s3_config = remote_config["s3"])
+          return S3Storage.new(uri: s3_config["uri"], creds_path: s3_config["creds"])
+        end
+        Storage.new
+      end
+    end
+  end
+end

data/lib/xccache/command/rollback.rb

@@ -0,0 +1,14 @@
+require "xccache/installer"
+require_relative "base"
+
+module XCCache
+  class Command
+    class Rollback < Command
+      self.summary = "Roll back prebuilt cache for packages"
+
+      def run
+        Installer::Rollback.new(ctx: self).install!
+      end
+    end
+  end
+end

data/lib/xccache/command/use.rb

@@ -0,0 +1,19 @@
+require "xccache/installer"
+require_relative "base"
+
+module XCCache
+  class Command
+    class Use < Command
+      self.summary = "Use prebuilt cache for packages"
+      def self.options
+        [
+          *Options.install_options,
+        ].concat(super)
+      end
+
+      def run
+        Installer::Use.new(ctx: self).install!
+      end
+    end
+  end
+end

data/lib/xccache/command.rb

@@ -1,10 +1,36 @@
 require "claide"
+require "xccache/core/config"
+require "xccache/swift/sdk"
 
 module XCCache
   class Command < CLAide::Command
-    require "xccache/command/pkg"
+    include Config::Mixin
+    Dir["#{__dir__}/#{File.basename(__FILE__, '.rb')}/*.rb"].sort.each { |f| require f }
 
     self.abstract_command = true
+    self.default_subcommand = "use"
     self.summary = "xccache - a build caching tool"
+
+    attr_reader :install_options, :build_options
+
+    def initialize(argv)
+      super
+      config.verbose = verbose unless verbose.nil?
+      @install_options = {
+        :sdks => str_to_sdks(argv.option("sdk")),
+        :skip_resolving_dependencies => argv.flag?("skip-resolving-dependencies"),
+      }
+      @build_options = {
+        **@install_options,
+        :config => argv.option("config"),
+        :recursive => argv.flag?("recursive"),
+        :merge_slices => argv.flag?("merge-slices", true),
+        :library_evolution => argv.flag?("library-evolution"),
+      }
+    end
+
+    def str_to_sdks(str)
+      (str || config.default_sdk).split(",").map { |s| Swift::Sdk.new(s) }
+    end
   end
 end

data/lib/xccache/core/cacheable.rb

@@ -0,0 +1,28 @@
+module XCCache
+  module Cacheable
+    def cacheable(*method_names)
+      method_names.each do |method_name|
+        const_get(__cacheable_module_name).class_eval do
+          define_method(method_name) do |*args, **kwargs|
+            @_cache ||= {}
+            @_cache[method_name] ||= {}
+            @_cache[method_name][args.hash | kwargs.hash] ||=
+              method(method_name).super_method.call(*args, **kwargs)
+          end
+        end
+      end
+    end
+
+    def __cacheable_module_name
+      "#{name}_Cacheable".gsub(':', '_')
+    end
+
+    def self.included(base)
+      base.extend(self)
+
+      module_name = base.send(:__cacheable_module_name)
+      remove_const(module_name) if const_defined?(module_name)
+      base.prepend(const_set(module_name, Module.new))
+    end
+  end
+end

data/lib/xccache/core/config.rb

@@ -0,0 +1,110 @@
+require "xcodeproj"
+require "xccache/core/syntax/yml"
+
+module XCCache
+  class Config < YAMLRepresentable
+    module Mixin
+      def config
+        Config.instance
+      end
+    end
+
+    def self.instance
+      @instance ||= new(Pathname("xccache.yml").expand_path)
+    end
+
+    attr_accessor :verbose
+    alias verbose? verbose
+
+    # To distinguish if it's within an installation, or standalone like `xccache pkg build`
+    attr_accessor :in_installation
+    alias in_installation? in_installation
+
+    def sandbox
+      @sandbox = Dir.prepare("xccache").expand_path
+    end
+
+    def spm_sandbox
+      @spm_sandbox ||= Dir.prepare(sandbox / "packages").expand_path
+    end
+
+    def spm_local_pkgs_dir
+      @spm_local_pkgs_dir ||= Dir.prepare(spm_sandbox / "local")
+    end
+
+    def spm_xcconfig_dir
+      @spm_xcconfig_dir ||= Dir.prepare(spm_sandbox / "xcconfigs")
+    end
+
+    def spm_repo_dir
+      @spm_repo_dir ||= Dir.prepare(Pathname("~/.xccache/default").expand_path)
+    end
+
+    def spm_binaries_dir
+      @spm_binaries_dir ||= Dir.prepare(spm_umbrella_sandbox / "binaries")
+    end
+
+    def spm_build_dir
+      @spm_build_dir ||= spm_umbrella_sandbox / ".build"
+    end
+
+    def spm_artifacts_dir
+      @spm_artifacts_dir ||= spm_build_dir / "artifacts"
+    end
+
+    def spm_umbrella_sandbox
+      @spm_umbrella_sandbox ||= Dir.prepare(spm_sandbox / "umbrella")
+    end
+
+    def spm_metadata_dir
+      @spm_metadata_dir ||= Dir.prepare(spm_sandbox / "metadata")
+    end
+
+    def lockfile
+      @lockfile ||= Lockfile.new(Pathname("xccache.lock").expand_path)
+    end
+
+    def cachemap
+      @cachemap ||= Cache::Cachemap.new(sandbox / "cachemap.json")
+    end
+
+    def projects
+      @projects ||= Pathname(".").glob("*.xcodeproj").map do |p|
+        Xcodeproj::Project.open(p)
+      end
+    end
+
+    def project_targets
+      projects.flat_map(&:targets)
+    end
+
+    def remote_config
+      raw["remote"] || {}
+    end
+
+    def ignore_list
+      raw["ignore"] || []
+    end
+
+    def ignore?(item)
+      return true if ignore_local? && lockfile.local_pkg_slugs.include?(item.split("/").first)
+      ignore_list.any? { |p| File.fnmatch(p, item) }
+    end
+
+    def ignore_local?
+      raw["ignore_local"]
+    end
+
+    def ignore_build_errors?
+      raw["ignore_build_errors"]
+    end
+
+    def keep_pkgs_in_project?
+      raw["keep_pkgs_in_project"]
+    end
+
+    def default_sdk
+      raw["default_sdk"] || "iphonesimulator"
+    end
+  end
+end

data/lib/xccache/core/error.rb

@@ -0,0 +1,7 @@
+module XCCache
+  class BaseError < StandardError
+  end
+
+  class GeneralError < BaseError
+  end
+end

data/lib/xccache/core/git.rb

@@ -0,0 +1,27 @@
+module XCCache
+  class Git
+    attr_reader :root
+
+    def initialize(root)
+      @root = Pathname(root)
+    end
+
+    def run(*args, **kwargs)
+      Sh.run("git -C #{root}", *args, **kwargs)
+    end
+
+    def sha
+      run("rev-parse --short HEAD", capture: true, log_cmd: false)[0].strip
+    end
+
+    def clean?
+      status("--porcelain", capture: true, log_cmd: false)[0].empty?
+    end
+
+    %i[checkout fetch pull push clean add commit branch remote switch status].each do |name|
+      define_method(name) do |*args, **kwargs|
+        run(name, *args, **kwargs)
+      end
+    end
+  end
+end

data/lib/xccache/core/hash.rb

@@ -0,0 +1,21 @@
+class Hash
+  def deep_merge(other, uniq_block: nil, &block)
+    dup.deep_merge!(other, uniq_block: uniq_block, &block)
+  end
+
+  def deep_merge!(other, uniq_block: nil, &block)
+    merge!(other) do |key, this_val, other_val|
+      result = if this_val.is_a?(Hash) && other_val.is_a?(Hash)
+                 this_val.deep_merge(other_val, uniq_block: uniq_block, &block)
+               elsif this_val.is_a?(Array) && other_val.is_a?(Array)
+                 this_val + other_val
+               elsif block_given?
+                 block.call(key, this_val, other_val)
+               else
+                 other_val
+               end
+      next result if uniq_block.nil? || !result.is_a?(Array)
+      result.reverse.uniq(&uniq_block).reverse # prefer updates
+    end
+  end
+end

data/lib/xccache/core/lockfile.rb

@@ -0,0 +1,40 @@
+require "xccache/core/syntax/json"
+
+module XCCache
+  class Lockfile < JSONRepresentable
+    def hash_for_project(project)
+      raw[project.display_name] ||= {}
+    end
+
+    def product_dependencies_by_targets
+      @product_dependencies_by_targets ||= raw.values.map { |h| h["dependencies"] }.reduce { |acc, h| acc.merge(h) }
+    end
+
+    def deep_merge!(hash)
+      keys = ["repositoryURL", "path_from_root", "relative_path"]
+      raw.deep_merge!(hash, uniq_block: proc do |h|
+        h.is_a?(Hash) && (k = keys.find { |k| h.key?(k) }) ? h[k] : h
+      end)
+    end
+
+    def pkgs
+      @pkgs ||= raw.values.flat_map { |h| h["packages"] || [] }
+    end
+
+    def local_pkgs
+      @local_pkgs ||= pkgs.select { |h| h.key?("relative_path") || h.key?("path") }
+    end
+
+    def local_pkg_slugs
+      @local_pkg_slugs ||= local_pkgs.map { |h| File.basename(h["relative_path"] || h["path"]) }.uniq
+    end
+
+    def product_dependencies
+      @product_dependencies ||= product_dependencies_by_targets.values.flatten.uniq
+    end
+
+    def targets_data
+      @targets_data ||= product_dependencies_by_targets.transform_keys { |k| "#{k}.xccache" }
+    end
+  end
+end

data/lib/xccache/core/log.rb

@@ -0,0 +1,51 @@
+require "xccache/core/config"
+require "colored2"
+
+module XCCache
+  module UI
+    @indent = 0
+
+    class << self
+      include Config::Mixin
+      attr_accessor :indent
+
+      def section(title, timing: false)
+        start = Time.new if timing
+        UI.puts(title)
+        self.indent += 2
+        res = yield if block_given?
+        self.indent -= 2
+        if timing
+          duration = (Time.new - start).to_i
+          duration = if duration < 60 then "#{duration}s"
+                     elsif duration < 60 * 60 then "#{duration / 60}m"
+                     else
+                       "#{duration / 3600}h"
+                     end
+          UI.puts("-> Finished: #{title.dark} (#{duration})")
+        end
+        res
+      end
+
+      def message(message)
+        UI.puts(message) if config.verbose?
+      end
+
+      def info(message)
+        UI.puts(message)
+      end
+
+      def warn(message)
+        UI.puts(message.yellow)
+      end
+
+      def error(message)
+        UI.puts("[ERROR] #{message}".red)
+      end
+
+      def puts(message)
+        $stdout.puts("#{' ' * self.indent}#{message}")
+      end
+    end
+  end
+end

data/lib/xccache/core/parallel.rb

@@ -0,0 +1,10 @@
+require "parallel"
+
+class Array
+  def parallel_map(options = {})
+    # By default, use in_threads (IO-bound tasks)
+    default = {}
+    default[:in_threads] = Parallel.processor_count unless options.key?(:in_processes)
+    Parallel.map(self, { **default, **options }) { |x| yield x if block_given? }
+  end
+end

data/lib/xccache/core/sh.rb

@@ -0,0 +1,51 @@
+require "open3"
+require "xccache/core/config"
+require "xccache/core/log"
+require "xccache/core/error"
+
+module XCCache
+  class Sh
+    class ExecError < BaseError
+    end
+
+    class << self
+      include Config::Mixin
+
+      def capture_output(cmd)
+        run(cmd, capture: true, log_cmd: false)[0].strip
+      end
+
+      def run(*args, env: nil, **options)
+        cmd = args.join(" ")
+        UI.message("$ #{cmd}".cyan.dark) if config.verbose? && options[:log_cmd] != false
+
+        out, err = [], []
+        handle_out = proc do |line|
+          if options[:capture]
+            out << line
+          else
+            UI.puts line
+          end
+        end
+        handle_err = proc do |line|
+          if options[:capture]
+            err << line
+          else
+            UI.puts line.strip.yellow unless options[:suppress_err]&.match(line)
+          end
+        end
+
+        popen3_args = env ? [env, cmd] : [cmd]
+        Open3.popen3(*popen3_args) do |_stdin, stdout, stderr, wait_thr|
+          stdout_thread = Thread.new { stdout.each { |l| handle_out.call(l) } }
+          stderr_thread = Thread.new { stderr.each { |l| handle_err.call(l) } }
+          [stdout_thread, stderr_thread].each(&:join)
+          result = wait_thr.value
+          result.exitstatus
+          raise ExecError, "Command '#{cmd}' failed with status: #{result.exitstatus}" unless result.success?
+        end
+        [out.join("\n"), err.join("\n")]
+      end
+    end
+  end
+end

data/lib/xccache/core/syntax/hash.rb

@@ -0,0 +1,31 @@
+module XCCache
+  class HashRepresentable
+    attr_reader :path
+    attr_accessor :raw
+
+    def initialize(path, raw: nil)
+      @path = path
+      @raw = raw || load || {}
+    end
+
+    def load
+      raise NotImplementedError
+    end
+
+    def merge!(other)
+      raw.merge!(other)
+    end
+
+    def save(to: nil)
+      raise NotImplementedError
+    end
+
+    def [](key)
+      raw[key]
+    end
+
+    def []=(key, value)
+      raw[key] = value
+    end
+  end
+end

data/lib/xccache/core/syntax/json.rb

@@ -0,0 +1,16 @@
+require "json"
+require_relative "hash"
+
+module XCCache
+  class JSONRepresentable < HashRepresentable
+    def load
+      JSON.parse(path.read) if path.exist?
+    rescue StandardError
+      {}
+    end
+
+    def save(to: nil)
+      (to || path).write(JSON.pretty_generate(raw))
+    end
+  end
+end

data/lib/xccache/core/syntax/plist.rb

@@ -0,0 +1,17 @@
+require "cfpropertylist"
+require_relative "hash"
+
+module XCCache
+  class PlistRepresentable < HashRepresentable
+    def load
+      plist = CFPropertyList::List.new(file: path)
+      CFPropertyList.native_types(plist.value)
+    rescue StandardError
+      {}
+    end
+
+    def save(to: nil)
+      raise NotImplementedError
+    end
+  end
+end

data/lib/xccache/core/syntax/yml.rb

@@ -0,0 +1,16 @@
+require "yaml"
+require_relative "hash"
+
+module XCCache
+  class YAMLRepresentable < HashRepresentable
+    def load
+      YAML.safe_load(path.read) if path.exist?
+    rescue StandardError
+      {}
+    end
+
+    def save(to: nil)
+      (to || path).write(raw.to_yaml)
+    end
+  end
+end

data/lib/xccache/core/syntax.rb

@@ -0,0 +1 @@
+Dir["#{__dir__}/#{File.basename(__FILE__, '.rb')}/*.rb"].sort.each { |f| require f }