xccache 0.0.1a1 → 0.0.1a3

data/lib/xccache/core/system.rb

@@ -0,0 +1,62 @@
+require "digest"
+require "mkmf"
+
+class String
+  def c99extidentifier
+    gsub(/[^a-zA-Z0-9.]/, "_")
+  end
+end
+
+class File
+  def self.which(bin)
+    find_executable0(bin)
+  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?
+    dst.parent.mkpath
+    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/installer/build.rb

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

data/lib/xccache/installer/rollback.rb

@@ -0,0 +1,37 @@
+module XCCache
+  class Installer
+    class Rollback < Installer
+      def install!
+        update_projects do |project|
+          UI.section("Rolling back cache for project #{project.display_name}".bold.green) do
+            rollback_for_project(project)
+          end
+        end
+      end
+
+      private
+
+      def rollback_for_project(project)
+        hash = lockfile.hash_for_project(project)
+        pkgs, deps_by_targets = hash["packages"], hash["dependencies"]
+
+        # Add packages back to the project
+        pkgs.reject { |h| project.has_pkg?(h) }.each do |h|
+          project.add_pkg(h)
+        end
+
+        # Add products back to `Link Binary with Libraries` of targets
+        deps_by_targets.each do |name, deps|
+          target = project.get_target(name)
+          deps.reject { |d| target.has_pkg_product_dependency?(d) }.each do |d|
+            target.add_pkg_product_dependency(d)
+          end
+        end
+
+        # Remove .binary product from the project
+        project.targets.each(&:remove_xccache_product_dependencies)
+        project.xccache_pkg&.remove_from_project
+      end
+    end
+  end
+end

data/lib/xccache/installer/use.rb

@@ -0,0 +1,28 @@
+require "xccache/spm"
+
+module XCCache
+  class Installer
+    class Use < Installer
+      def install!
+        update_projects do |project|
+          perform_install do
+            UI.section("Using cache for project #{project.display_name}".bold.green) do
+              replace_binaries_for_project(project)
+            end
+          end
+        end
+      end
+
+      private
+
+      def replace_binaries_for_project(project)
+        project.add_xccache_pkg unless project.has_xccache_pkg?
+        project.targets.each do |target|
+          target.add_xccache_product_dependency unless target.has_xccache_product_dependency?
+          target.remove_pkg_product_dependencies { |d| !d.pkg.xccache_pkg? }
+        end
+        project.remove_pkgs(&:non_xccache_pkg?) unless config.keep_pkgs_in_project?
+      end
+    end
+  end
+end

data/lib/xccache/installer.rb

@@ -0,0 +1,113 @@
+require "xccache/spm"
+Dir["#{__dir__}/#{File.basename(__FILE__, '.rb')}/*.rb"].sort.each { |f| require f }
+
+module XCCache
+  class Installer
+    include PkgMixin
+
+    def initialize(options = {})
+      ctx = options[:ctx]
+      raise GeneralError, "Missing context (Command) for #{self.class}" if ctx.nil?
+      @umbrella_pkg = options[:umbrella_pkg]
+      @install_options = ctx.install_options
+      @build_options = ctx.build_options
+    end
+
+    def perform_install
+      config.in_installation = true
+      verify_projects!
+      if @umbrella_pkg.nil?
+        sync_lockfile
+        umbrella_pkg.prepare(**@install_options)
+      end
+
+      yield
+      umbrella_pkg.write_manifest
+      umbrella_pkg.gen_xcconfigs
+      projects.each do |project|
+        add_xccache_refs_to_project(project)
+        inject_xcconfig_to_project(project)
+      end
+      umbrella_pkg.gen_cachemap_viz
+    end
+
+    def sync_lockfile
+      UI.info("Syncing lockfile")
+      update_projects do |project|
+        lockfile.deep_merge!(project.display_name => lockfile_hash_for_project(project))
+      end
+      lockfile.save
+    end
+
+    def lockfile
+      config.lockfile
+    end
+
+    def projects
+      config.projects
+    end
+
+    def save_projects
+      yield if block_given?
+      projects.each(&:save)
+    end
+
+    def update_projects
+      projects.each do |project|
+        yield project if block_given?
+        project.save
+      end
+    end
+
+    private
+
+    def lockfile_hash_for_project(project)
+      deps_by_targets = project.targets.to_h do |target|
+        deps = target.non_xccache_pkg_product_dependencies.select(&:pkg).map { |d| "#{d.pkg.slug}/#{d.product_name}" }
+        [target.name, deps]
+      end
+      {
+        "packages" => project.non_xccache_pkgs.map(&:to_h),
+        "dependencies" => deps_by_targets,
+      }
+    end
+
+    def verify_projects!
+      raise "No projects detected. Are you running on the correct project directory?" if projects.empty?
+    end
+
+    def add_xccache_refs_to_project(project)
+      group = project.xccache_config_group
+      add_file = proc { |p| group[p.basename.to_s] || group.new_file(p) }
+      add_file.call(config.spm_umbrella_sandbox / "Package.swift")
+      add_file.call(config.lockfile.path)
+      add_file.call(config.path) if config.path.exist?
+      group.ensure_synced_group(name: "local-packages", path: config.spm_local_pkgs_dir)
+    end
+
+    def inject_xcconfig_to_project(project)
+      group = project.xccache_config_group.ensure_synced_group(name: "xcconfigs", path: config.spm_xcconfig_dir)
+      project.targets.each do |target|
+        xcconfig_path = config.spm_xcconfig_dir / "#{target.name}.xcconfig"
+        target.build_configurations.each do |build_config|
+          if (existing = build_config.base_configuration_xcconfig)
+            next if existing.path == xcconfig_path
+
+            relative_path = xcconfig_path.relative_path_from(existing.path.parent)
+            next if existing.includes.include?(relative_path.to_s)
+
+            UI.info("Injecting base configuration for #{target} (#{build_config}) (at: #{existing.path})")
+            existing.path.write <<~DESC
+              #include "#{relative_path}" // Injected by xccache, for prebuilt macros support
+              #{existing.path.read.strip}
+            DESC
+          else
+            UI.info("Setting base configuration #{target} (#{build_config}) as #{xcconfig_path}")
+            build_config.base_configuration_reference_anchor = group
+            build_config.base_configuration_reference_relative_path = xcconfig_path.basename.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xccache/main.rb

@@ -1 +1,3 @@
-require "xccache/command"
+require "pry" if ENV["XCCACHE_IMPORT_PRY"] == "true"
+require "pathname"
+Dir["#{__dir__}/*.rb"].sort.each { |f| require f unless f == __FILE__ }

data/lib/xccache/spm/build.rb

@@ -0,0 +1,53 @@
+module XCCache
+  module SPM
+    class Buildable
+      attr_reader :name, :module_name, :pkg_dir, :pkg_desc, :sdk, :sdks, :config, :path, :tmpdir, :library_evolution
+      alias library_evolution? library_evolution
+
+      def initialize(options = {})
+        @name = options[:name]
+        @module_name = @name.c99extidentifier
+        @pkg_dir = Pathname(options[:pkg_dir] || ".").expand_path
+        @pkg_desc = options[:pkg_desc]
+        @sdks = options[:sdks] || []
+        @sdk = options[:sdk] || @sdks&.first
+        @config = options[:config] || "debug"
+        @path = options[:path]
+        @tmpdir = options[:tmpdir]
+        @library_evolution = options[:library_evolution]
+      end
+
+      def build(options = {})
+        raise NotImplementedError
+      end
+
+      def swift_build(target: nil)
+        cmd = ["swift", "build"] + swift_build_args
+        cmd << "--package-path" << pkg_dir
+        cmd << "--target" << (target || name)
+        cmd << "--sdk" << sdk.sdk_path
+        sdk.swiftc_args.each { |arg| cmd << "-Xswiftc" << arg }
+        if library_evolution?
+          # 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"
+        end
+        Sh.run(cmd, suppress_err: /(dependency '.*' is not used by any target|unable to create symbolic link)/)
+      end
+
+      def swift_build_args
+        [
+          "--configuration", config,
+          "--triple", sdk.triple,
+        ]
+      end
+
+      def pkg_target
+        @pkg_target ||= pkg_desc.get_target(name)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+require "xccache/core"
+
+module XCCache
+  module SPM
+    class Package
+      class BaseObject < JSONRepresentable
+        include Config::Mixin
+
+        ATTRS = %i[root retrieve_pkg_desc].freeze
+        attr_accessor(*ATTRS)
+
+        def name
+          raw["name"]
+        end
+
+        def full_name
+          is_a?(Description) ? name : "#{pkg_slug}/#{name}"
+        end
+
+        def inspect
+          to_s
+        end
+
+        def display_name
+          name
+        end
+
+        def to_s
+          "<#{self.class} name=#{display_name}>"
+        end
+
+        def cast_to(cls)
+          o = cls.new(path, raw: raw)
+          ATTRS.each { |sym| o.send("#{sym}=", send(sym.to_s)) }
+          o
+        end
+
+        def pkg_name
+          @pkg_name ||= root.name
+        end
+
+        def pkg_slug
+          @pkg_slug ||= src_dir.basename.to_s
+        end
+
+        def fetch(key, dtype)
+          raw[key].map do |h|
+            o = dtype.new(nil, raw: h)
+            o.root = root
+            o.retrieve_pkg_desc = retrieve_pkg_desc
+            o
+          end
+        end
+
+        def pkg_desc_of(name)
+          retrieve_pkg_desc.call(name)
+        end
+
+        def src_dir
+          @src_dir ||= begin
+            path = root.raw.fetch("packageKind", {}).fetch("root", [])[0]
+            Pathname.new(path) unless path.nil?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+require "xccache/spm/desc/base"
+
+module XCCache
+  module SPM
+    class Package
+      class Dependency < BaseObject
+        def display_name
+          slug
+        end
+
+        def local?
+          raw.key?("fileSystem")
+        end
+
+        def hash
+          @hash ||= local? ? raw["fileSystem"].first : raw["sourceControl"].first
+        end
+
+        def slug
+          @slug ||=
+            if hash.key?("path")
+              File.basename(hash["path"])
+            elsif (location = hash["location"]) && location.key?("remote")
+              File.basename(location["remote"].flat_map(&:values)[0], ".*")
+            else
+              hash["identity"]
+            end
+        end
+
+        def path
+          @path ||= Pathname(hash["path"]).expand_path if local?
+        end
+
+        def pkg_desc
+          @pkg_desc ||= pkg_desc_of(slug)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,126 @@
+require "xccache/spm/desc/base"
+
+module XCCache
+  module SPM
+    class Package
+      class Description < BaseObject
+        include Cacheable
+        cacheable :resolve_recursive_dependencies
+
+        def self.descs_in_metadata_dir
+          descs = Config.instance.spm_metadata_dir.glob("*.json").map { |p| Description.new(p) }
+          [descs, combine_descs(descs)]
+        end
+
+        def self.in_dir(dir, save_to_dir: nil)
+          path = save_to_dir / "#{dir.basename}.json" unless save_to_dir.nil?
+          begin
+            raw = JSON.parse(Sh.capture_output("swift package dump-package --package-path #{dir}"))
+            Description.new(path, raw: raw)
+          rescue StandardError => e
+            UI.error("Failed to dump package in #{dir}. Error: #{e}")
+          end
+        end
+
+        def self.descs_in_dir(root_dir, save_to_dir: nil)
+          dirs = [root_dir] + root_dir.glob(".build/checkouts/*").reject { |p| p.glob("Package*.swift").empty? }
+          descs = dirs.parallel_map do |dir|
+            desc = Description.in_dir(dir, save_to_dir: save_to_dir)
+            unless save_to_dir.nil?
+              desc.save
+              desc.save(to: desc.path.parent / "#{desc.name}.json") if desc.name != dir.basename.to_s
+            end
+            desc
+          end
+          [descs, combine_descs(descs)]
+        end
+
+        def root
+          self
+        end
+
+        def metadata
+          raw["_metadata"] ||= {}
+        end
+
+        def dependencies
+          @dependencies ||= fetch("dependencies", Dependency)
+        end
+
+        def uniform_dependencies
+          dependencies.filter_map(&:pkg_desc)
+        end
+
+        def products
+          @products ||= fetch("products", Product)
+        end
+
+        def targets
+          @targets ||= fetch("targets", Target).map(&:downcast)
+        end
+
+        def binary_targets
+          @binary_targets ||= targets.select(&:binary?)
+        end
+
+        def has_target?(name)
+          targets.any? { |t| t.name == name }
+        end
+
+        def get_target(name)
+          targets.find { |t| t.name == name }
+        end
+
+        def targets_of_products(name)
+          matched_products = products.select { |p| p.name == name }
+          matched_products
+            .flat_map { |p| targets.select { |t| p.target_names.include?(t.name) } }
+        end
+
+        def resolve_recursive_dependencies(platform: nil)
+          products.to_h { |p| [p, p.recursive_targets(platform: platform)] }
+        end
+
+        def local?
+          # Workaround: If the pkg dir is under the build checkouts dir -> remote
+          !src_dir.to_s.start_with?((config.spm_build_dir / "checkouts").to_s)
+        end
+
+        def traverse
+          nodes, edges, parents = [], [], {}
+          to_visit = targets.dup
+          visited = Set.new
+          until to_visit.empty?
+            cur = to_visit.pop
+            next if visited.include?(cur)
+
+            visited << cur
+            nodes << cur
+            yield cur if block_given?
+
+            # For macro impl, we don't need their dependencies, just the tool binary
+            # So, no need to care about swift-syntax dependencies
+            next if cur.macro?
+            cur.direct_dependency_targets.each do |t|
+              to_visit << t
+              edges << [cur, t]
+              parents[t] ||= []
+              parents[t] << cur
+            end
+          end
+          [nodes, edges, parents]
+        end
+
+        def git
+          @git ||= Git.new(src_dir) if Dir.git?(src_dir)
+        end
+
+        def self.combine_descs(descs)
+          descs_by_name = descs.flat_map { |d| [[d.name, d], [d.pkg_slug, d]] }.to_h
+          descs.each { |d| d.retrieve_pkg_desc = proc { |name| descs_by_name[name] } }
+          descs_by_name
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require "xccache/spm/desc/base"
+
+module XCCache
+  module SPM
+    class Package
+      class Product < BaseObject
+        include Cacheable
+        cacheable :recursive_targets
+
+        def target_names
+          raw["targets"]
+        end
+
+        def flatten_as_targets
+          targets
+        end
+
+        def targets
+          @targets ||= root.targets.select { |t| target_names.include?(t.name) }
+        end
+
+        def library?
+          type == :library
+        end
+
+        def type
+          @type ||= raw["type"].keys.first.to_sym
+        end
+
+        def recursive_targets(platform: nil)
+          targets + targets.flat_map { |t| t.recursive_targets(platform: platform) }.uniq
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+module XCCache
+  module SPM
+    class Package
+      class BinaryTarget < Target
+      end
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+module XCCache
+  module SPM
+    class Package
+      class MacroTarget < Target
+      end
+    end
+  end
+end