xccache 0.0.1a1 → 0.0.1a2

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

@@ -0,0 +1,93 @@
+module XCCache
+  module SPM
+    class Package
+      module UmbrellaCachemapMixin
+        def sync_cachemap
+          UI.section("Syncing cachemap")
+          nodes, edges, parents = xccache_desc.traverse
+          cache_data = gen_cache_data(nodes, parents)
+          targets_data, deps_data = {}, {}
+          xccache_desc.targets.each do |agg_target|
+            targets_data[agg_target.name] = agg_target.direct_dependencies.flat_map do |d|
+              # If any associated targets is missed -> use original product form
+              # Otherwise, replace with recursive targets' binaries
+              deps_data[d.full_name] = d.recursive_targets.map(&:full_name)
+              if d.recursive_targets.all? { |t| cache_data[t] == :hit }
+                "#{d.full_name}.binary"
+              else
+                d.full_name
+              end
+            end.uniq.sort_by(&:downcase)
+          end
+
+          config.cachemap.raw = {
+            "manifest" => {
+              "targets" => targets_data,
+              "deps" => deps_data,
+            },
+            "cache" => cache_data.transform_keys(&:full_name),
+            "depgraph" => {
+              "nodes" => nodes.map { |x| target_to_cytoscape_node(x, cache_data) },
+              "edges" => edges.map { |x, y| { :source => x.full_name, :target => y.full_name } },
+            },
+          }
+          config.cachemap.save
+          config.cachemap.print_stats
+        end
+
+        private
+
+        def gen_cache_data(nodes, parents)
+          result = nodes.to_h do |node|
+            res = if config.ignore?(node.full_name) then :ignored
+                  else
+                    verify_binary?(node) ? :hit : :missed
+                  end
+            [node, res]
+          end
+
+          # Propagate cache miss
+          to_visit = result.select { |_, v| %i[missed ignore].include?(v) }.keys
+          visited = Set.new
+          until to_visit.empty?
+            node = to_visit.pop
+            next if visited.include?(node)
+            visited << node
+            result[node] = :missed if result[node] == :hit
+            to_visit += parents[node] if parents.key?(node)
+          end
+          result
+        end
+
+        def verify_binary?(target)
+          return true if target.binary?
+
+          bpath = binary_path(target.name)
+          bpath_with_checksum = binary_path(target.name, checksum: target.root.checksum)
+          # If checksum matches, create symlink from `A-abc123.xcframework` -> `A.framework`
+          # Otherwise, remove symlink `A.xcframework`
+          if bpath_with_checksum.exist?
+            bpath_with_checksum.symlink_to(bpath)
+          elsif bpath.exist?
+            bpath.rmtree
+          end
+          bpath_with_checksum.exist?
+        end
+
+        def binary_path(name, checksum: nil)
+          suffix = checksum.nil? ? "" : "-#{checksum}"
+          p = config.spm_binaries_frameworks_dir / File.basename(name, ".binary")
+          p / "#{p.basename}#{suffix}.xcframework"
+        end
+
+        def target_to_cytoscape_node(x, cache_data)
+          h = { :id => x.full_name, :cache => cache_data[x] }
+          h[:type] = "agg" if x.name.end_with?(".xccache")
+          h[:checksum] = x.root.checksum
+          h[:binary] = binary_path(x.name) if cache_data[x] == :hit
+          h
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module XCCache
+  module SPM
+    class Package
+      module UmbrellaDescsMixin
+        def gen_metadata
+          UI.section("Generating metadata of packages") do
+            dirs = [root_dir] + root_dir.glob(".build/checkouts/*").reject { |p| p.glob("Package*.swift").empty? }
+            dirs.each do |dir|
+              desc = Description.in_dir(dir, save_to_dir: config.spm_metadata_dir)
+              next if desc.nil?
+
+              desc.retrieve_pkg_desc = proc { |name| @descs_by_name[name] }
+              desc.save
+              desc.save(to: desc.path.parent / "#{desc.name}.json") if desc.name != dir.basename.to_s
+              @descs << desc
+              @descs_by_name[desc.name] = desc
+              @descs_by_name[dir.basename.to_s] = desc
+            end
+          end
+        end
+
+        def xccache_desc
+          @xccache_desc ||= desc_of("xccache")
+        end
+
+        def targets_of_products(products)
+          products = [products] if products.is_a?(String)
+          products.flat_map { |x| desc_of(x).targets_of_products(File.basename(x)) }
+        end
+
+        def dependency_targets_of_products(products)
+          products = [products] if products.is_a?(String)
+          products.flat_map { |p| @dependency_targets_by_products[p] || [p] }.uniq
+        end
+
+        def desc_of(d)
+          @descs_by_name[d.split("/").first]
+        end
+
+        def binary_targets
+          @descs_by_name.values.flatten.uniq.flat_map(&:binary_targets)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+module XCCache
+  module SPM
+    class Package
+      module UmbrellaManifestMixin
+        def write_manifest(no_cache: false)
+          UI.info("Writing Package.swift (package: #{root_dir.basename.to_s.dark})")
+          Template.new("umbrella.Package.swift").render(
+            {
+              :timestamp => Time.new.strftime("%F %T"),
+              :json => manifest_targets_json(no_cache: no_cache),
+              :products_to_targets => manifest_products_to_targets_json(no_cache: no_cache),
+              :platforms => manifest_platforms,
+              :dependencies => manifest_pkg_dependencies,
+              :swift_version => Swift::Swiftc.version_without_patch,
+            },
+            save_to: root_dir / "Package.swift",
+          )
+        end
+
+        def manifest_targets_json(no_cache: false)
+          data = no_cache ? config.lockfile.targets_data : config.cachemap.manifest_data["targets"]
+          JSON.pretty_generate(data)
+        end
+
+        def manifest_products_to_targets_json(no_cache: false)
+          data = no_cache ? {} : config.cachemap.manifest_data["deps"]
+          JSON.pretty_generate(data)
+        end
+
+        def manifest_pkg_dependencies
+          decl = proc do |hash|
+            if (path_from_root = hash["path_from_root"])
+              absolute_path = (Pathname(".") / path_from_root).expand_path
+              next ".package(path: \"#{absolute_path}\")"
+            end
+
+            requirement = hash["requirement"]
+            case requirement["kind"]
+            when "upToNextMajorVersion"
+              opt = ".upToNextMajor(from: \"#{requirement['minimumVersion']}\")"
+            when "upToNextMinorVersion"
+              opt = ".upToNextMinor(from: \"#{requirement['minimumVersion']}\")"
+            when "exactVersion"
+              opt = "exact: \"#{requirement['version']}\""
+            when "branch"
+              opt = "branch: \"#{requirement['branch']}\""
+            when "revision"
+              opt = "revision: \"#{requirement['revision']}\""
+            when "versionRange"
+              opt = "\"#{requirement['minimumVersion']}\"..<\"#{requirement['maximumVersion']}\""
+            end
+            ".package(url: \"#{hash['repositoryURL']}\", #{opt})"
+          end
+
+          config.lockfile.pkgs.map { |h| "  #{decl.call(h)}," }.join("\n")
+        end
+
+        def manifest_platforms
+          @manifest_platforms ||= begin
+            to_spm_platform = {
+              :ios => "iOS",
+              :macos => "macOS",
+              :osx => "macOS",
+              :tvos => "tvOS",
+              :watchos => "watchOS",
+              :visionos => "visionOS",
+            }
+            hash = {}
+            config.project_targets.each do |t|
+              platform = to_spm_platform[t.platform_name]
+              hash[platform] ||= []
+              hash[platform] << t.deployment_target.split(".")[0]
+            end
+            hash
+              .transform_values(&:min)
+              .map { |platform, version| "  .#{platform}(.v#{version})," }
+              .join("\n")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module XCCache
+  module SPM
+    class Package
+      module UmbrellaVizMixin
+        def gen_cachemap_viz
+          stats = config.cachemap.stats
+          html_path = config.sandbox / "cachemap.html"
+          js_path = Dir.prepare(config.sandbox / "assets") / "cachemap.js"
+          css_path = config.sandbox / "assets" / "style.css"
+
+          root_dir = Pathname(".").expand_path
+          to_relative = proc do |p|
+            p.to_s.start_with?(root_dir.to_s) ? p.relative_path_from(root_dir).to_s : p.to_s
+          end
+
+          UI.message("Cachemap visualization: #{html_path}")
+          Template.new("cachemap.html").render(
+            {
+              :root_dir => root_dir.to_s,
+              :root_dir_short => root_dir.basename.to_s,
+              :lockfile_path => config.lockfile.path.to_s,
+              :lockfile_path_short => to_relative.call(config.lockfile.path),
+              :binaries_dir => config.spm_binaries_frameworks_dir.to_s,
+              :binaries_dir_short => to_relative.call(config.spm_binaries_frameworks_dir),
+              :desc_hit => stats[:hit],
+              :desc_missed => stats[:missed],
+              :desc_ignored => stats[:ignored],
+            },
+            save_to: html_path
+          )
+          Template.new("cachemap.js").render(
+            { :json => JSON.pretty_generate(config.cachemap.depgraph_data) },
+            save_to: js_path
+          )
+          Template.new("cachemap.style.css").render(save_to: css_path)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+require "xccache/swift/swiftc"
+require "xccache/utils/template"
+require "xccache/cache/cachemap"
+require "xccache/spm/pkg/base"
+
+Dir["#{__dir__}/#{File.basename(__FILE__, '.rb')}/*.rb"].sort.each { |f| require f }
+
+module XCCache
+  module SPM
+    class Package
+      class Umbrella < Package
+        include Config::Mixin
+        include UmbrellaCachemapMixin
+        include UmbrellaDescsMixin
+        include UmbrellaBuilldMixin
+        include UmbrellaManifestMixin
+        include UmbrellaVizMixin
+
+        def initialize(options = {})
+          super
+          @descs = []
+          @descs_by_name = {}
+          @dependency_targets_by_products = {}
+        end
+
+        def prepare(options = {})
+          create
+          resolve unless options[:skip_resolve]
+          create_symlinks
+          gen_metadata
+          resolve_recursive_dependencies
+          create_symlinks_to_artifacts
+          sync_cachemap
+        end
+
+        def resolve_recursive_dependencies
+          UI.section("Resolving recursive dependencies")
+          @descs.each do |desc|
+            @dependency_targets_by_products.merge!(desc.resolve_recursive_dependencies.transform_keys(&:full_name))
+          end
+        end
+
+        def create
+          UI.info("Creating umbrella package")
+          # Initially, write json with the original data in lockfile (without cache)
+          write_manifest(no_cache: true)
+          # Create dummy sources dirs prefixed with `.` so that they do not show up in Xcode
+          config.project_targets.each do |target|
+            dir = Dir.prepare(root_dir / ".Sources" / "#{target.name}.xccache")
+            (dir / "dummy.swift").write("")
+          end
+        end
+
+        def create_symlinks
+          # Symlinks for convenience
+          (root_dir / "binaries").symlink_to(root_dir.parent / "binaries")
+          (root_dir / ".build").symlink_to(root_dir.parent / ".build")
+          (root_dir / ".build/checkouts").symlink_to(root_dir.parent / "checkouts")
+        end
+
+        def create_symlinks_to_artifacts
+          # Clean up broken symlinks
+          config.spm_binaries_frameworks_dir.glob("*/*.xcframework").each do |p|
+            p.rmtree if p.symlink? && !p.readlink.exist?
+          end
+
+          UI.message("Creating symlinks to binary artifacts of targets: #{binary_targets.map(&:full_name).to_s.dark}")
+          binary_targets.each do |target|
+            dst_path = config.spm_binaries_frameworks_dir / target.name / "#{target.name}.xcframework"
+            # For local xcframework, just symlink to the path
+            # Zip frameworks (either of local or remote pkgs) are unzipped in the build artifacts
+            target.local_binary_path.symlink_to(dst_path) if target.local_binary_path&.extname == ".xcframework"
+            config.spm_artifacts_dir.glob("#{target.full_name}/*.xcframework").each do |p|
+              p.symlink_to(dst_path)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xccache/spm/pkg.rb

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

data/lib/xccache/spm.rb

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

data/lib/xccache/swift/sdk.rb

@@ -0,0 +1,30 @@
+require "xccache/core/sh"
+
+module XCCache
+  module Swift
+    class Sdk
+      attr_reader :name
+
+      NAME_TO_TRIPLE = {
+        :iphonesimulator => "arm64-apple-ios-simulator",
+        :iphoneos => "arm64-apple-ios",
+      }.freeze
+
+      def initialize(name)
+        @name = name
+      end
+
+      def to_s
+        name
+      end
+
+      def triple
+        NAME_TO_TRIPLE[name.to_sym]
+      end
+
+      def sdk_path
+        @sdk_path ||= Pathname(Sh.capture_output("xcrun --sdk #{name} --show-sdk-path")).realpath
+      end
+    end
+  end
+end

data/lib/xccache/swift/swiftc.rb

@@ -0,0 +1,16 @@
+module XCCache
+  module Swift
+    module Swiftc
+      def self.version
+        @version ||= begin
+          m = /Apple Swift version ([\d\.]+)/.match(Sh.capture_output("xcrun swift -version"))
+          m.nil? ? "6.0" : m[1]
+        end
+      end
+
+      def self.version_without_patch
+        version.split(".")[...2].join(".")
+      end
+    end
+  end
+end

data/lib/xccache/utils/template.rb

@@ -0,0 +1,21 @@
+require "erb"
+require "xccache/core/error"
+
+module XCCache
+  class Template
+    attr_reader :name, :path
+
+    def initialize(name)
+      @name = name
+      @path = Gem.find_files("xccache/assets/templates/#{name}.template").first
+    end
+
+    def render(hash = {}, save_to: nil)
+      raise GeneralError, "Template not found: #{name}" if path.nil?
+
+      rendered = ERB.new(File.read(@path)).result_with_hash(hash)
+      Pathname(save_to).write(rendered) unless save_to.nil?
+      rendered
+    end
+  end
+end

data/lib/xccache/xcodeproj/pkg.rb

@@ -0,0 +1,69 @@
+require "xcodeproj"
+
+module Xcodeproj
+  class Project
+    module Object
+      module PkgRefMixin
+        def id
+          local? ? (relative_path || path) : repositoryURL
+        end
+
+        def slug
+          File.basename(id, File.extname(id))
+        end
+
+        def local?
+          is_a?(XCLocalSwiftPackageReference)
+        end
+
+        def xccache_pkg?
+          local? && id == "xccache/packages/umbrella"
+        end
+
+        def create_pkg_product_dependency_ref(product)
+          ref = project.new(XCSwiftPackageProductDependency)
+          ref.package = self
+          ref.product_name = product
+          ref
+        end
+
+        def create_target_dependency_ref(product)
+          ref = project.new(PBXTargetDependency)
+          ref.name = product
+          ref.product_ref = create_pkg_product_dependency_ref(product)
+          ref
+        end
+      end
+
+      class XCLocalSwiftPackageReference
+        include PkgRefMixin
+
+        def ascii_plist_annotation
+          # Workaround: Xcode is using display_name while Xcodeproj is using File.basename(display_name)
+          # Here, the plugin forces to use display_name so that updates either by Xcode or Xcodeproj are consistent
+          " #{isa} \"#{display_name}\" "
+        end
+
+        def to_h
+          {
+            "relative_path" => relative_path,
+            "path" => path,
+            "path_from_root" => absolute_path.relative_path_from(Pathname(".").expand_path).to_s,
+          }
+        end
+
+        def absolute_path
+          path.nil? ? project.path.parent / relative_path : path
+        end
+      end
+
+      class XCRemoteSwiftPackageReference
+        include PkgRefMixin
+
+        def to_h
+          { "repositoryURL" => repositoryURL, "requirement" => requirement }
+        end
+      end
+    end
+  end
+end

data/lib/xccache/xcodeproj/pkg_product_dependency.rb

@@ -0,0 +1,19 @@
+require "xcodeproj"
+
+module Xcodeproj
+  class Project
+    module Object
+      class XCSwiftPackageProductDependency
+        def full_name
+          "#{pkg.slug}/#{product_name}"
+        end
+
+        def pkg
+          return package unless package.nil?
+
+          Log.warn("Missing pkg for #{inspect}")
+        end
+      end
+    end
+  end
+end

data/lib/xccache/xcodeproj/project.rb

@@ -0,0 +1,63 @@
+require "xcodeproj"
+
+module Xcodeproj
+  class Project
+    Log = XCCache::UI
+
+    def display_name
+      relative_path.to_s
+    end
+
+    def relative_path
+      @relative_path ||= path.relative_path_from(Pathname(".").expand_path)
+    end
+
+    def pkgs
+      root_object.package_references
+    end
+
+    def non_xccache_pkgs
+      pkgs.reject(&:xccache_pkg?)
+    end
+
+    def has_pkg?(hash)
+      id = hash[pkg_key_in_hash(hash)]
+      pkgs.any? { |p| p.id == id }
+    end
+
+    def has_xccache_pkg?
+      pkgs.any?(&:xccache_pkg?)
+    end
+
+    def add_pkg(hash)
+      key = pkg_key_in_hash(hash)
+      is_local = ["relative_path", "path"].include?(key)
+
+      Log.message("Add package #{hash[key].bold} to project #{display_name.bold}")
+      cls = is_local ? XCLocalSwiftPackageReference : XCRemoteSwiftPackageReference
+      ref = new(cls)
+      hash.each { |k, v| ref.send("#{k}=", v) }
+      root_object.package_references << ref
+      ref
+    end
+
+    def add_xccache_pkg
+      sandbox_path = XCCache::Config.instance.spm_umbrella_sandbox
+      add_pkg("relative_path" => sandbox_path.relative_path_from(path.parent).to_s)
+    end
+
+    def get_target(name)
+      targets.find { |t| t.name == name }
+    end
+
+    def get_pkg(name)
+      pkgs.find { |p| p.slug == name }
+    end
+
+    private
+
+    def pkg_key_in_hash(hash)
+      ["repositoryURL", "relative_path", "path"].find { |k| hash.key?(k) }
+    end
+  end
+end

data/lib/xccache/xcodeproj/target.rb

@@ -0,0 +1,50 @@
+require "xcodeproj"
+
+module Xcodeproj
+  class Project
+    module Object
+      class PBXNativeTarget
+        alias pkg_product_dependencies package_product_dependencies
+
+        def non_xccache_pkg_product_dependencies
+          pkg_product_dependencies.reject { |d| d.pkg.xccache_pkg? }
+        end
+
+        def has_xccache_product_dependency?
+          pkg_product_dependencies.any? { |d| d.pkg.xccache_pkg? }
+        end
+
+        def has_pkg_product_dependency?(name)
+          pkg_product_dependencies.any? { |d| "#{d.pkg.slug}/#{d.name}" == name }
+        end
+
+        def add_pkg_product_dependency(name)
+          Log.message("(+) Add dependency #{name.blue} to target #{display_name.bold}")
+          pkg_name, product_name = name.split("/")
+          pkg = project.get_pkg(pkg_name)
+          pkg_product_dependencies << pkg.create_target_dependency_ref(product_name).product_ref
+        end
+
+        def add_xccache_product_dependency
+          add_pkg_product_dependency("umbrella/#{name}.xccache")
+        end
+
+        def remove_xccache_product_dependencies
+          remove_pkg_product_dependencies { |d| d.pkg.xccache_pkg? }
+        end
+
+        def remove_pkg_product_dependencies(&block)
+          package_product_dependencies.select(&block).each do |d|
+            XCCache::UI.info(
+              "(-) Remove #{d.product_name.red} from product dependencies of target #{display_name.bold}"
+            )
+            build_phases.each do |phase|
+              phase.files.select { |f| f.remove_from_project if f.product_ref == d }
+            end
+            d.remove_from_project
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xccache/xcodeproj.rb

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