xccache 0.0.1a1 → 0.0.1a2

data/lib/xccache/installer/rollback.rb

@@ -0,0 +1,36 @@
+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)
+      end
+    end
+  end
+end

data/lib/xccache/installer/use.rb

@@ -0,0 +1,27 @@
+require "xccache/spm"
+
+module XCCache
+  class Installer
+    class Use < Installer
+      def install!
+        perform_install do
+          update_projects do |project|
+            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
+      end
+    end
+  end
+end

data/lib/xccache/installer.rb

@@ -0,0 +1,67 @@
+require "xccache/spm"
+Dir["#{__dir__}/#{File.basename(__FILE__, '.rb')}/*.rb"].sort.each { |f| require f }
+
+module XCCache
+  class Installer
+    include PkgMixin
+
+    def initialize(options = {})
+      @umbrella_pkg = options[:umbrella_pkg]
+      @skip_resolving_dependencies = options[:skip_resolving_dependencies]
+    end
+
+    def perform_install
+      verify_projects!
+      sync_lockfile if @umbrella_pkg.nil?
+      umbrella_pkg.prepare(skip_resolve: @skip_resolving_dependencies) if @umbrella_pkg.nil?
+      yield
+      umbrella_pkg.write_manifest
+      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.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
+  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/desc/base.rb

@@ -0,0 +1,61 @@
+require "xccache/core"
+
+module XCCache
+  module SPM
+    class Package
+      class BaseObject < JSONRepresentable
+        include Config::Mixin
+
+        attr_accessor :root, :retrieve_pkg_desc
+
+        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 pkg_name
+          @pkg_name ||= root.name
+        end
+
+        def pkg_slug
+          @pkg_slug ||= root.path.basename(".json").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 = 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,110 @@
+require "xccache/spm/desc/base"
+
+module XCCache
+  module SPM
+    class Package
+      class Description < BaseObject
+        include Cacheable
+        cacheable :resolve_recursive_dependencies
+
+        def self.in_dir(dir, save_to_dir: nil, checksum: true)
+          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}"))
+            this = Description.new(path, raw: raw)
+            this.calc_checksum if checksum
+            this
+          rescue StandardError => e
+            UI.error("Failed to dump package in #{dir}. Error: #{e}")
+          end
+        end
+
+        def root
+          self
+        end
+
+        def metadata
+          raw["_metadata"] ||= {}
+        end
+
+        def checksum
+          metadata["checksum"]
+        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)
+        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 calc_checksum
+          metadata["checksum"] = git.nil? ? src_dir.checksum : git.sha
+        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?
+            cur.direct_dependency_targets.each do |t|
+              to_visit << t
+              edges << [cur, t]
+              parents[t] ||= []
+              parents[t] << cur
+            end
+          end
+          [nodes, edges, parents]
+        end
+
+        private
+
+        def git
+          @git ||= Git.new(src_dir) if Dir.git?(src_dir)
+        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.rb

@@ -0,0 +1,138 @@
+require "xccache/spm/desc/base"
+
+module XCCache
+  module SPM
+    class Package
+      class Target < BaseObject
+        include Cacheable
+        cacheable :recursive_targets, :direct_dependency_targets, :direct_dependencies
+
+        def xccache?
+          name.end_with?(".xccache")
+        end
+
+        def type
+          @type ||= raw["type"].to_sym
+        end
+
+        def bundle_name
+          "#{pkg_name}_#{name}.bundle"
+        end
+
+        def flatten_as_targets
+          [self]
+        end
+
+        def sources_path
+          @sources_path ||= begin
+            path = raw["path"] || "Sources/#{name}"
+            root.src_dir / path
+          end
+        end
+
+        def use_clang?
+          !header_paths.empty?
+        end
+
+        def header_paths(options = {})
+          paths = []
+          paths += public_header_paths if options.fetch(:public, true)
+          paths += header_search_paths if options.fetch(:search, false)
+          paths
+            .flat_map { |p| p.glob("**/*.h*") }
+            .map(&:realpath)
+            .uniq
+        end
+
+        def settings
+          raw["settings"]
+        end
+
+        def header_search_paths
+          @header_search_paths ||=
+            settings
+            .filter_map { |h| h.fetch("kind", {})["headerSearchPath"] }
+            .flat_map(&:values)
+            .map { |p| sources_path / p }
+        end
+
+        def public_header_paths
+          @public_header_paths ||= begin
+            res = []
+            implicit_path = sources_path / "include"
+            res << implicit_path unless implicit_path.glob("**/*.h*").empty?
+            res << (sources_path / raw["publicHeadersPath"]) if raw.key?("publicHeadersPath")
+            res
+          end
+        end
+
+        def resource_paths
+          @resource_paths ||= begin
+            res = raw.fetch("resources", []).map { |h| sources_path / h["path"] }
+            # Refer to the following link for the implicit resources
+            # https://developer.apple.com/documentation/xcode/bundling-resources-with-a-swift-package#Add-resource-files
+            implicit = sources_path.glob("*.{xcassets,xib,storyboard,xcdatamodeld,lproj}")
+            res + implicit
+          end
+        end
+
+        def recursive_targets(platform: nil)
+          children = direct_dependency_targets(platform: platform)
+          children += children.flat_map { |t| t.recursive_targets(platform: platform) }
+          children.uniq
+        end
+
+        def direct_dependencies(platform: nil)
+          raw["dependencies"].flat_map do |hash|
+            dep_types = ["byName", "target", "product"]
+            if (dep_type = dep_types.intersection(hash.keys).first).nil?
+              raise GeneralError, "Unexpected dependency type. Must be one of #{dep_types}. Hash: #{hash}"
+            end
+            next [] unless match_platform?(hash[dep_type][-1], platform)
+            pkg_name = hash[dep_type][1] if dep_type == "product"
+            find_deps(hash[dep_type][0], pkg_name, dep_type)
+          end
+        end
+
+        def direct_dependency_targets(platform: nil)
+          direct_dependencies(platform: platform).flat_map(&:flatten_as_targets).uniq
+        end
+
+        def match_platform?(_condition, _platform)
+          true # FIXME: Handle this
+        end
+
+        def binary?
+          type == :binary
+        end
+
+        def binary_path
+          sources_path if binary?
+        end
+
+        def local_binary_path
+          binary_path if binary? && root.local?
+        end
+
+        private
+
+        def find_deps(name, pkg_name, dep_type)
+          # If `dep_type` is `target` -> constrained within current pkg only
+          # If `dep_type` is `product` -> `pkg_name` must be present
+          # If `dep_type` is `byName` -> it's either from this pkg, or its children/dependencies
+          res = []
+          descs = pkg_name.nil? ? [root] + root.uniform_dependencies : [pkg_desc_of(pkg_name)]
+          descs.each do |desc|
+            by_target = -> { desc.targets.select { |t| t.name == name } }
+            by_product = -> { desc.products.select { |t| t.name == name } }
+            return by_target.call if dep_type == "target"
+            return by_product.call if dep_type == "product"
+            return res unless (res = by_target.call).empty?
+            return res unless (res = by_product.call).empty?
+          end
+          []
+        end
+      end
+    end
+  end
+end

data/lib/xccache/spm/desc.rb

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

data/lib/xccache/spm/mixin.rb

@@ -0,0 +1,9 @@
+module XCCache
+  module PkgMixin
+    include Config::Mixin
+
+    def umbrella_pkg
+      @umbrella_pkg ||= SPM::Package::Umbrella.new(root_dir: config.spm_umbrella_sandbox)
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+require "json"
+require "xccache/framework/slice"
+require "xccache/framework/xcframework"
+require "xccache/swift/sdk"
+
+module XCCache
+  module SPM
+    class Package
+      attr_reader :root_dir
+
+      def initialize(options = {})
+        @root_dir = Pathname(options[:root_dir] || ".").expand_path
+      end
+
+      def build(options = {})
+        validate!
+        targets = options.delete(:targets) || []
+        raise GeneralError, "No targets were specified" if targets.empty?
+
+        targets.map { |t| t.split("/")[-1] }.each do |t|
+          UI.section("\n▶ Building target: #{t}".bold.magenta) do
+            build_target(**options, target: t)
+          rescue StandardError => e
+            UI.error("Failed to build target: #{t}. Error: #{e}")
+            raise e unless config.ignore_build_errors?
+          end
+        end
+      end
+
+      def build_target(target: nil, sdk: nil, config: nil, out_dir: nil, **options)
+        target_pkg_desc = pkg_desc_of_target(target, skip_resolve: options[:skip_resolve])
+        if target_pkg_desc.binary_targets.any? { |t| t.name == target }
+          return UI.warn("Target #{target} is a binary target -> no need to build")
+        end
+
+        sdks = (sdk || "iphonesimulator").split(",")
+
+        out_dir = Pathname(out_dir || ".")
+        out_dir /= target if options[:checksum]
+        basename = options[:checksum] ? "#{target}-#{target_pkg_desc.checksum}.xcframework" : "#{target}.xcframework"
+
+        Framework::XCFramework.new(
+          name: target,
+          pkg_dir: root_dir,
+          config: config,
+          sdks: sdks,
+          path: out_dir / basename,
+          pkg_desc: target_pkg_desc,
+        ).create
+      end
+
+      def resolve(force: false)
+        return if @resolved && !force
+
+        UI.info("Resolving package dependencies (package: #{root_dir.basename.to_s.dark})")
+        Sh.run("swift package resolve --package-path #{root_dir} 2>&1")
+        create_symlinks_to_local_pkgs
+        @resolved = true
+      end
+
+      private
+
+      def validate!
+        return unless root_dir.glob("Package*.swift").empty?
+        raise GeneralError, "No Package.swift in #{root_dir}. Are you sure you're running on a package dir?"
+      end
+
+      def pkg_desc_of_target(name, skip_resolve: false)
+        # TODO: Refactor this resolution logic
+        find_pkg_desc = proc do
+          # The current package contains the given target
+          return pkg_desc if pkg_desc.has_target?(name)
+
+          UI.message(
+            "#{name.yellow.dark} is not a direct target of package #{root_dir.basename.to_s.dark} " \
+            "-> trigger from dependencies"
+          )
+          # Otherwise, it's inside one of the dependencies. Need to resolve then find it
+          resolve unless skip_resolve
+          root_dir.glob(".build/checkouts/*").each do |dir|
+            desc = Description.in_dir(dir)
+            return desc if desc.has_target?(name)
+          end
+          raise GeneralError, "Cannot find package with the given target #{name}"
+        end
+
+        @cache_pkg_desc_by_name ||= {}
+        @cache_pkg_desc_by_name[name] = find_pkg_desc.call unless @cache_pkg_desc_by_name.key?(name)
+        @cache_pkg_desc_by_name[name]
+      end
+
+      def pkg_desc
+        @pkg_desc ||= Description.in_dir(root_dir)
+      end
+
+      def create_symlinks_to_local_pkgs
+        pkg_desc.dependencies.select(&:local?).each do |dep|
+          dep.path.symlink_to(root_dir / ".build/checkouts/#{dep.slug}")
+        end
+      end
+    end
+  end
+end

data/lib/xccache/spm/pkg/umbrella/build.rb

@@ -0,0 +1,30 @@
+module XCCache
+  module SPM
+    class Package
+      module UmbrellaBuilldMixin
+        def build(options = {})
+          to_build = targets_to_build(options)
+          return UI.warn("Detected no targets to build among cache-missed targets") if to_build.empty?
+
+          UI.info("-> Targets to build: #{to_build.to_s.bold}")
+          super(options.merge(:targets => to_build))
+          sync_cachemap
+        end
+
+        def targets_to_build(options)
+          items = options[:targets] || []
+          items = config.cachemap.missed.map { |x| File.basename(x) } if items.empty?
+          targets = @descs.flat_map(&:targets).select { |t| items.include?(t.name) }
+          if options[:recursive]
+            UI.message("Will include cache-missed recursive targets")
+            targets += targets.flat_map do |t|
+              t.recursive_targets.select { |x| config.cachemap.missed?(x.full_name) }
+            end
+          end
+          # TODO: Sort by number of dependents
+          targets.map(&:full_name).uniq
+        end
+      end
+    end
+  end
+end