xccache 0.0.1a1 → 0.0.1a2

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,82 @@
+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
+
+    def sandbox
+      @sandbox = Dir.prepare("xccache").expand_path
+    end
+
+    def spm_sandbox
+      @spm_sandbox ||= Dir.prepare(sandbox / "packages").expand_path
+    end
+
+    def spm_binaries_frameworks_dir
+      @spm_binaries_frameworks_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 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
+  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,19 @@
+module XCCache
+  class Git
+    attr_reader :root
+
+    def initialize(root)
+      @root = Pathname(root)
+    end
+
+    def sha
+      run("rev-parse --short HEAD", capture: true, log_cmd: false)[0].strip
+    end
+
+    private
+
+    def run(cmd, options = {})
+      Sh.run("git -C #{root} #{cmd}", options)
+    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,41 @@
+require "xccache/core/config"
+require "colored2"
+
+module XCCache
+  module UI
+    @indent = 0
+
+    class << self
+      include Config::Mixin
+      attr_accessor :indent
+
+      def section(title)
+        UI.puts(title)
+        self.indent += 2
+        res = yield if block_given?
+        self.indent -= 2
+        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/sh.rb

@@ -0,0 +1,50 @@
+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(cmd, options = {})
+        cmd = cmd.join(" ") if cmd.is_a?(Array)
+        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
+
+        Open3.popen3(cmd) 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/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 }

data/lib/xccache/core/system.rb

@@ -0,0 +1,54 @@
+require "digest"
+
+class String
+  def c99extidentifier
+    gsub(/[^a-zA-Z0-9.]/, "_")
+  end
+end
+
+class Dir
+  def self.prepare(dir)
+    dir = Pathname(dir)
+    dir.mkpath
+    dir
+  end
+
+  def self.create_tmpdir
+    dir = Pathname(Dir.mktmpdir("xccache"))
+    res = block_given? ? (yield dir) : dir
+    dir.rmtree if block_given?
+    res
+  end
+
+  def self.git?(dir)
+    XCCache::Sh.capture_output("git -C #{dir} rev-parse --git-dir") == ".git"
+  end
+end
+
+class Pathname
+  def symlink_to(dst)
+    dst = Pathname(dst)
+    dst.rmtree if dst.symlink?
+    dst.parent.mkpath
+    File.symlink(expand_path, dst)
+  end
+
+  def copy(to: nil, to_dir: nil)
+    dst = to || (Pathname(to_dir) / basename)
+    dst.rmtree if dst.exist? || dst.symlink?
+    FileUtils.copy_entry(self, dst)
+    dst
+  end
+
+  def checksum
+    hasher = Digest::SHA256.new
+    glob("**/*").reject { |p| p.directory? || p.symlink? }.sort.each do |p|
+      p.open("rb") do |f|
+        while (chunk = f.read(65_536)) # Read 64KB chunks
+          hasher.update(chunk)
+        end
+      end
+    end
+    hasher.hexdigest[...8]
+  end
+end

data/lib/xccache/core.rb

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

data/lib/xccache/framework/slice.rb

@@ -0,0 +1,183 @@
+require "xccache/utils/template"
+
+module XCCache
+  class Framework
+    class Slice
+      attr_reader :name, :module_name, :pkg_dir, :pkg_desc, :sdk, :config, :path, :tmpdir
+
+      def initialize(options = {})
+        @name = options[:name]
+        @module_name = @name.c99extidentifier
+        @pkg_dir = Pathname(options[:pkg_dir] || ".").expand_path
+        @pkg_desc = options[:pkg_desc]
+        @sdk = options[:sdk]
+        @config = options[:config] || "debug"
+        @path = options[:path]
+        @tmpdir = options[:tmpdir]
+      end
+
+      def build
+        UI.section("Building slice: #{name} (#{config}, #{sdk})".bold) do
+          cmd = ["swift", "build"] + swift_build_args
+          cmd << "--package-path" << pkg_dir
+          cmd << "--target" << name
+          cmd << "--sdk" << sdk.sdk_path
+          # Workaround for swiftinterface emission
+          # https://github.com/swiftlang/swift/issues/64669#issuecomment-1535335601
+          cmd << "-Xswiftc" << "-enable-library-evolution"
+          cmd << "-Xswiftc" << "-alias-module-names-in-module-interface"
+          cmd << "-Xswiftc" << "-emit-module-interface"
+          cmd << "-Xswiftc" << "-no-verify-emitted-module-interface"
+          Sh.run(cmd, suppress_err: /(dependency '.*' is not used by any target|unable to create symbolic link)/)
+          create_framework
+        end
+      end
+
+      private
+
+      def override_resource_bundle_accessor
+        # By default, Swift generates resource_bundle_accessor.swift for targets having resources
+        # (Check .build/<Target>.build/DerivedSources/resource_bundle_accessor.swift)
+        # This enables accessing the resource bundle via `Bundle.module`.
+        # However, `Bundle.module` expects the resource bundle to be under the app bundle,
+        # which is not the case for binary targets. Instead the bundle is under `Frameworks/<Target>.framework`
+        # 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")
+        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"
+        Template.new(template_name).render(
+          { :pkg => pkg_target.pkg_name, :target => name, :module_name => module_name },
+          save_to: source_path
+        )
+
+        if use_clang?
+          cmd = ["xcrun", "clang"]
+          cmd << "-x" << "objective-c"
+          cmd << "-target" << sdk.triple << "-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 << "-o" << obj_path.to_s
+          cmd << source_path
+        end
+        Sh.run(cmd)
+      end
+
+      def create_framework
+        override_resource_bundle_accessor if resource_bundle_product_path.exist?
+        create_info_plist
+        create_framework_binary
+        create_headers
+        create_modules
+        copy_resource_bundles if resource_bundle_product_path.exist?
+      end
+
+      def create_framework_binary
+        # Write .o file list into a file
+        obj_paths = products_dir.glob("#{module_name}.build/**/*.o")
+        raise GeneralError, "Detected no object files for #{name}" if obj_paths.empty?
+
+        objlist_path = tmpdir / "objects.txt"
+        objlist_path.write(obj_paths.map(&:to_s).join("\n"))
+
+        cmd = ["libtool", "-static"]
+        cmd << "-o" << "#{path}/#{module_name}"
+        cmd << "-filelist" << objlist_path.to_s
+        Sh.run(cmd)
+        FileUtils.chmod("+x", path / module_name)
+      end
+
+      def create_info_plist
+        Template.new("framework.info.plist").render(
+          { :module_name => module_name },
+          save_to: path / "Info.plist",
+        )
+      end
+
+      def create_headers
+        Dir.prepare(path / "Headers")
+        copy_headers if use_clang?
+      end
+
+      def create_modules
+        Dir.prepare(path / "Modules")
+        return copy_swiftmodules unless use_clang?
+
+        UI.message("Creating framework modulemap")
+        Template.new("framework.modulemap").render(
+          { :module_name => module_name },
+          save_to: path / "Modules" / "module.modulemap"
+        )
+      end
+
+      def copy_headers
+        UI.message("Copying headers")
+        framework_headers_path = path / "Headers"
+        umbrella_header_content =
+          pkg_target
+          .header_paths
+          .map { |p| p.copy(to_dir: framework_headers_path) }
+          .map { |p| "#include \"#{p.basename}\"" }
+          .join("\n")
+        (framework_headers_path / "#{module_name}-umbrella.h").write(umbrella_header_content)
+      end
+
+      def copy_swiftmodules
+        UI.message("Copying swiftmodules")
+        swiftmodule_dir = Dir.prepare("#{path}/Modules/#{module_name}.swiftmodule")
+        swiftinterfaces = products_dir.glob("#{module_name}.build/#{module_name}.swiftinterface")
+        to_copy = products_dir.glob("Modules/#{module_name}.*") + swiftinterfaces
+        to_copy.each do |p|
+          p.copy(to: swiftmodule_dir / p.basename.sub(module_name, sdk.triple))
+        end
+      end
+
+      def copy_resource_bundles
+        resolve_resource_symlinks
+        UI.message("Copy resource bundle to framework: #{resource_bundle_product_path.basename}")
+        resource_bundle_product_path.copy(to_dir: path)
+      end
+
+      def resolve_resource_symlinks
+        # Well, Xcode seems to well handle symlinks in resources. In xcodebuild log, you would see something like:
+        #   CpResource: builtin-copy ... -resolve-src-symlinks
+        # But this is not the case if we build with `swift build`. Here, we have to manually handle it
+        resource_bundle_product_path.glob("**/*").select(&:symlink?).reject(&:exist?).each do |p|
+          UI.message("Resolve resource symlink: #{p}")
+          original = pkg_target.resource_paths.find { |rp| rp.symlink? && rp.readlink == p.readlink }
+          original&.realpath&.copy(to: p)
+        end
+      end
+
+      def products_dir
+        @products_dir ||= pkg_dir / ".build" / sdk.triple / config
+      end
+
+      def swift_build_args
+        [
+          "--configuration", config,
+          "--triple", sdk.triple,
+        ]
+      end
+
+      def use_clang?
+        pkg_target.use_clang?
+      end
+
+      def pkg_target
+        @pkg_target ||= pkg_desc.get_target(name)
+      end
+
+      def resource_bundle_product_path
+        @resource_bundle_product_path ||= products_dir / pkg_target.bundle_name
+      end
+    end
+  end
+end

data/lib/xccache/framework/xcframework.rb

@@ -0,0 +1,51 @@
+module XCCache
+  class Framework
+    class XCFramework
+      attr_reader :name, :module_name, :pkg_dir, :pkg_desc, :config, :sdks, :path
+
+      def initialize(options = {})
+        @name = options[:name]
+        @module_name = @name.c99extidentifier
+        @pkg_dir = options[:pkg_dir]
+        @pkg_desc = options[:pkg_desc]
+        @config = options[:config]
+        @sdks = options[:sdks]
+        @path = options[:path]
+      end
+
+      def create
+        slices.each(&:build)
+        UI.section("Creating #{name}.xcframework from slices") do
+          path.rmtree if path.exist?
+
+          cmd = ["xcodebuild", "-create-xcframework"]
+          cmd << "-output" << path
+          slices.each { |slice| cmd << "-framework" << slice.path }
+          Sh.run(cmd)
+        end
+        tmpdir.rmtree
+
+        # TODO: Should we dispose tmpdir here as well?
+      end
+
+      def tmpdir
+        @tmpdir ||= Dir.create_tmpdir
+      end
+
+      def slices
+        @slices ||= sdks.map do |s|
+          sdk = Swift::Sdk.new(s)
+          Framework::Slice.new(
+            name: name,
+            pkg_dir: pkg_dir,
+            pkg_desc: pkg_desc,
+            sdk: sdk,
+            config: config,
+            path: Dir.prepare(tmpdir / sdk.triple / "#{module_name}.framework"),
+            tmpdir: tmpdir,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/xccache/installer/build.rb

@@ -0,0 +1,27 @@
+require "xccache/spm"
+
+module XCCache
+  class Installer
+    class Build < Installer
+      def initialize(options = {})
+        super
+        @targets = options[:targets]
+        @sdk = options[:sdk]
+        @recursive = options[:recursive]
+      end
+
+      def install!
+        perform_install do
+          umbrella_pkg.build(
+            targets: @targets,
+            sdk: @sdk,
+            out_dir: config.spm_binaries_frameworks_dir,
+            checksum: true,
+            recursive: @recursive,
+            skip_resolve: @skip_resolving_dependencies,
+          )
+        end
+      end
+    end
+  end
+end