xccache 0.0.2 → 1.0.0

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

@@ -1,110 +0,0 @@
-module XCCache
-  module SPM
-    class Package
-      module UmbrellaCachemapMixin
-        def sync_cachemap(sdks: [])
-          UI.section("Syncing cachemap (sdks: #{sdks.map(&:name)})")
-          nodes, edges, parents = xccache_desc.traverse
-          cache_data = gen_cache_data(nodes, parents, sdks)
-          targets_data, macros_data, deps_data = {}, {}, {}
-          xccache_desc.targets.each do |agg_target|
-            targets, macros = [], []
-            agg_target.direct_dependencies.each do |d|
-              all_hit = d.recursive_targets.all? { |t| cache_data[t] == :hit }
-              # 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(&:xccache_id)
-              targets << (all_hit ? "#{d.full_name}.binary" : d.full_name)
-              macros += d.recursive_targets.select(&:macro?).map(&:full_name) if all_hit
-            end
-            targets_data[agg_target.name] = targets.uniq.sort_by(&:downcase)
-            macros_data[agg_target.name] = macros.uniq
-          end
-
-          config.cachemap.raw = {
-            "manifest" => {
-              "targets" => targets_data,
-              "macros" => macros_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, sdks)
-          result = nodes.to_h do |node|
-            res = if config.ignore?(node.full_name) then :ignored
-                  else
-                    verify_binary?(node, sdks) ? :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.reject { |k, _| k.name.end_with?(".xccache") }
-        end
-
-        def verify_binary?(target, sdks)
-          return true if target.binary?
-
-          bpath = binary_path(target.xccache_id)
-          bpath_with_checksum = binary_path(target.xccache_id, checksum: target.checksum, in_repo: true)
-
-          check = proc do
-            # For macro, we just need the tool binary to exist
-            # For regular targets, the xcframework must satisfy the sdk constraints (ie. containing all the slices)
-            next bpath_with_checksum.exist? if target.macro?
-
-            metadata = XCFramework::Metadata.new(bpath_with_checksum / "Info.plist")
-            expected_triples = sdks.map { |sdk| sdk.triple(without_vendor: true) }
-            missing_triples = expected_triples - metadata.triples
-            missing_triples.empty?
-          end
-
-          # If requirements are meet, create symlink `A-abc123.xcframework` -> `A.framework`
-          # Otherwise, remove symlink `A.xcframework`
-          if check.call
-            bpath_with_checksum.symlink_to(bpath)
-          elsif bpath.exist?
-            bpath.rmtree
-          end
-          bpath.exist?
-        end
-
-        def binary_path(name, checksum: nil, in_repo: false)
-          suffix = checksum.nil? ? "" : "-#{checksum}"
-          ext = File.extname(name) == ".macro" ? ".macro" : ".xcframework"
-          binaries_dir = in_repo ? config.spm_cache_dir : config.spm_binaries_dir
-          p = binaries_dir / File.basename(name, ".*")
-          p / "#{p.basename}#{suffix}#{ext}"
-        end
-
-        def target_to_cytoscape_node(x, cache_data)
-          h = { :id => x.full_name, :cache => cache_data[x] }
-          h[:type] = if x.name.end_with?(".xccache") then "agg"
-                     elsif x.macro? then "macro" end
-          h[:checksum] = x.checksum
-          h[:binary] = binary_path(x.xccache_id) if cache_data[x] == :hit
-          h
-        end
-      end
-    end
-  end
-end

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

@@ -1,35 +0,0 @@
-module XCCache
-  module SPM
-    class Package
-      module UmbrellaDescsMixin
-        def gen_metadata
-          UI.section("Generating metadata of packages", timing: true) do
-            @descs, @descs_by_name = Description.descs_in_dir(root_dir, save_to_dir: config.spm_metadata_dir)
-          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

@@ -1,83 +0,0 @@
-module XCCache
-  module SPM
-    class Package
-      module UmbrellaManifestMixin
-        def write_manifest(no_cache: false)
-          UI.info("Writing Package.swift (package: #{root_dir.basename})")
-          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

@@ -1,40 +0,0 @@
-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.info("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_dir.to_s,
-              :binaries_dir_short => to_relative.call(config.spm_binaries_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/xcconfigs.rb

@@ -1,31 +0,0 @@
-module XCCache
-  module SPM
-    class Package
-      module UmbrellaXCConfigsMixin
-        def gen_xcconfigs
-          UI.section("Generating xcconfigs") do
-            macros_config_by_targets.each do |target, hash|
-              xcconfig_path = config.spm_xcconfig_dir / "#{target}.xcconfig"
-              UI.message("XCConfig of target #{target} at: #{xcconfig_path}")
-              Xcodeproj::Config.new(hash).save_as(xcconfig_path)
-            end
-          end
-        end
-
-        private
-
-        def macros_config_by_targets
-          config.cachemap.manifest_data["macros"].to_h do |target, macros|
-            swift_flags = macros.map do |m|
-              basename = File.basename(m, ".*")
-              binary_path = config.spm_binaries_dir / basename / "#{basename}.macro"
-              "-load-plugin-executable #{binary_path}##{basename}"
-            end
-            hash = { "OTHER_SWIFT_FLAGS" => "$(inherited) #{swift_flags.join(' ')}" }
-            [File.basename(target, ".*"), hash]
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,91 +0,0 @@
-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 UmbrellaBuildMixin
-        include UmbrellaManifestMixin
-        include UmbrellaVizMixin
-        include UmbrellaXCConfigsMixin
-
-        def initialize(options = {})
-          super
-          @descs = []
-          @descs_by_name = {}
-          @dependency_targets_by_products = {}
-        end
-
-        def prepare(options = {})
-          create
-          resolve unless options[:skip_resolving_dependencies]
-          create_symlinks_for_convenience
-          create_symlinks_to_local_pkgs
-          gen_metadata
-          resolve_recursive_dependencies
-          create_symlinks_to_artifacts
-          sync_cachemap(sdks: options[:sdks])
-        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_for_convenience
-          # 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_local_pkgs
-          pkg_desc.dependencies.select(&:local?).each do |dep|
-            # For metadata generation
-            dep.path.symlink_to(root_dir / ".build/checkouts/#{dep.slug}")
-            # For convenience, synced group under `xccache.config` group in xcodeproj
-            dep.path.symlink_to(Config.instance.spm_local_pkgs_dir / dep.slug)
-          end
-        end
-
-        def create_symlinks_to_artifacts
-          # Clean up symlinks beforehand
-          config.spm_binaries_dir.glob("*/*.{xcframework,macro}").each do |p|
-            p.rmtree if p.symlink?
-          end
-
-          binary_targets.each do |target|
-            dst_path = config.spm_binaries_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