xccache 0.0.1a1 → 0.0.1a3

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

@@ -0,0 +1,91 @@
+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

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/xcframework/metadata.rb

@@ -0,0 +1,41 @@
+require "xccache/core/syntax/plist"
+
+module XCCache
+  module SPM
+    class XCFramework
+      class Metadata < PlistRepresentable
+        class Library < Hash
+          def id
+            self["LibraryIdentifier"]
+          end
+
+          def platform
+            self["SupportedPlatform"]
+          end
+
+          def archs
+            self["SupportedArchitectures"]
+          end
+
+          def simulator?
+            self["SupportedPlatformVariant"] == "simulator"
+          end
+
+          def triples
+            @triples ||= archs.map do |arch|
+              simulator? ? "#{arch}-#{platform}-simulator" : "#{arch}-#{platform}"
+            end
+          end
+        end
+
+        def available_libraries
+          @available_libraries ||= raw.fetch("AvailableLibraries", []).map { |h| Library.new.merge(h) }
+        end
+
+        def triples
+          @triples ||= available_libraries.flat_map(&:triples)
+        end
+      end
+    end
+  end
+end

data/lib/xccache/spm/xcframework/slice.rb

@@ -0,0 +1,180 @@
+require "xccache/utils/template"
+
+module XCCache
+  module SPM
+    class FrameworkSlice < Buildable
+      def build(_options = {})
+        UI.section("Building slice: #{name} (#{config}, #{sdk})".bold) do
+          swift_build
+          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
+        copy_headers
+      end
+
+      def create_modules
+        copy_swiftmodules unless use_clang?
+
+        UI.message("Creating framework modulemap")
+        Template.new("framework.modulemap").render(
+          { :module_name => module_name, :target => name },
+          save_to: modules_dir / "module.modulemap"
+        )
+      end
+
+      def copy_headers
+        UI.message("Copying headers")
+        swift_header_paths = products_dir.glob("#{module_name}.build/*-Swift.h")
+        paths = swift_header_paths + pkg_target.header_paths
+        paths.each { |p| process_header(p) }
+
+        umbrella_header_content = paths.map { |p| "#include <#{module_name}/#{p.basename}>" }.join("\n")
+        (headers_dir / "#{name}-umbrella.h").write(umbrella_header_content)
+      end
+
+      def process_header(path)
+        handle_angle_bracket_import = proc do |statement, header|
+          next statement if header.include?("/")
+
+          # NOTE: If importing a header with flat angle-bracket style (ex. `#import <foo.h>`)
+          # The header `foo.h` may belong to a dependency's headers.
+          # When packaging into xcframework, `#import <foo.h>` no longer works because `foo.h`
+          # coz it's not visible within the framework's headers
+          # -> We need to explicitly specify the module it belongs to, ex. `#import <foo/foo.h>`
+          targets = [pkg_target] + pkg_target.recursive_targets
+          target = targets.find { |t| t.header_paths.any? { |p| p.basename.to_s == header } }
+          next statement if target.nil?
+
+          corrected_statement = statement.sub("<#{header}>", "<#{target.module_name}/#{header}>")
+          <<~CONTENT
+            // -------------------------------------------------------------------------------------------------
+            // NOTE: This import was corrected by xccache, from flat angle-bracket to nested angle-bracket style
+            // Original: `#{statement}`
+            #{corrected_statement}
+            // -------------------------------------------------------------------------------------------------
+          CONTENT
+        end
+
+        content = path.read.gsub(/^ *#import <(.+)>/) { |m| handle_angle_bracket_import.call(m, $1) }
+        (headers_dir / path.basename).write(content)
+      end
+
+      def copy_swiftmodules
+        UI.message("Copying swiftmodules")
+        swiftmodule_dir = Dir.prepare("#{modules_dir}/#{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 use_clang?
+        pkg_target.use_clang?
+      end
+
+      def resource_bundle_product_path
+        @resource_bundle_product_path ||= products_dir / pkg_target.resource_bundle_name
+      end
+
+      def headers_dir
+        @headers_dir ||= Dir.prepare(path / "Headers")
+      end
+
+      def modules_dir
+        @modules_dir ||= Dir.prepare(path / "Modules")
+      end
+    end
+  end
+end

data/lib/xccache/spm/xcframework/xcframework.rb

@@ -0,0 +1,56 @@
+require "xccache/spm/build"
+
+module XCCache
+  module SPM
+    class XCFramework < Buildable
+      attr_reader :slices
+
+      def initialize(options = {})
+        super
+        @slices ||= @sdks.map do |sdk|
+          FrameworkSlice.new(
+            **options,
+            sdks: [sdk],
+            path: Dir.prepare(tmpdir / sdk.triple / "#{module_name}.framework"),
+          )
+        end
+      end
+
+      def build(merge_slices: false, **_options)
+        tmp_new_path = tmpdir / "new.xcframework"
+        tmp_existing_path = tmpdir / "existing.framework"
+
+        slices.each(&:build)
+        UI.section("Creating #{name}.xcframework from slices") do
+          create_xcframework(from: slices.map(&:path), to: tmp_new_path)
+        end
+
+        path.copy(to: tmp_existing_path) if path.exist? && merge_slices
+        path.rmtree if path.exist?
+
+        if merge_slices && tmp_existing_path.exist?
+          UI.section("Merging #{name}.xcframework with existing slices") do
+            framework_paths =
+              [tmp_new_path, tmp_existing_path]
+              .flat_map { |p| p.glob("*/*.framework") }
+              .uniq { |p| p.parent.basename.to_s } # uniq by id (ex. ios-arm64), preferred new ones
+            create_xcframework(from: framework_paths, to: path)
+          end
+        else
+          path.parent.mkpath
+          tmp_new_path.copy(to: path)
+        end
+        UI.info("-> XCFramework: #{path.to_s.dark}")
+      end
+
+      def create_xcframework(options = {})
+        cmd = ["xcodebuild", "-create-xcframework"]
+        cmd << "-allow-internal-distribution" unless library_evolution?
+        cmd << "-output" << options[:to]
+        options[:from].each { |p| cmd << "-framework" << p }
+        cmd << "> /dev/null" # Only care about errors
+        Sh.run(cmd)
+      end
+    end
+  end
+end

data/lib/xccache/spm/xcframework.rb

@@ -0,0 +1,2 @@
+require_relative "build"
+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/storage/base.rb

@@ -0,0 +1,26 @@
+module XCCache
+  class Storage
+    include Config::Mixin
+
+    def initialize(options = {}); end
+
+    def pull
+      print_warnings
+    end
+
+    def push
+      print_warnings
+    end
+
+    private
+
+    def print_warnings
+      UI.warn <<~DESC
+        Do nothing as remote cache is not set up yet.
+
+        To set it up, specify `remote` in `xccache.yml`.
+        See: https://github.com/trinhngocthuyen/xccache/blob/main/docs/configuration.md#remote
+      DESC
+    end
+  end
+end

data/lib/xccache/storage/git.rb

@@ -0,0 +1,46 @@
+require_relative "base"
+
+module XCCache
+  class GitStorage < Storage
+    attr_reader :branch
+
+    def initialize(options = {})
+      super
+      if (@remote = options[:remote])
+        @remote = File.expand_path(@remote) unless ["http", "https", "git"].include?(URI.parse(@remote).scheme)
+        ensure_remote
+      end
+      @branch = options[:branch]
+    end
+
+    def pull
+      git.fetch("--depth 1 origin #{branch}")
+      git.switch("--detach FETCH_HEAD", capture: true)
+      git.clean("-dfx", capture: true)
+      # Re-create local branch so that it has the latest from remote
+      git.branch("-D #{branch} || true", capture: true)
+      git.checkout("-b #{branch}", capture: true)
+    end
+
+    def push
+      return UI.info("No changes to push, cache repo is clean".magenta) if git.clean?
+
+      git.add(".")
+      git.commit("-m \"Update cache at #{Time.new}\"")
+      git.push("origin #{branch}")
+    end
+
+    private
+
+    def git
+      @git ||= Git.new(config.spm_repo_dir)
+    end
+
+    def ensure_remote
+      existing = git.remote("get-url origin || true", capture: true, log_cmd: false)[0].strip
+      return if @remote == existing
+      return git.remote("add origin #{@remote}") if existing.empty?
+      git.remote("set-url origin #{@remote}")
+    end
+  end
+end

data/lib/xccache/storage/s3.rb

@@ -0,0 +1,53 @@
+require_relative "base"
+
+module XCCache
+  class S3Storage < Storage
+    def initialize(options = {})
+      super
+      @uri = options[:uri]
+      @creds_path = Pathname(options[:creds_path] || "~/.xccache/s3.creds.json").expand_path
+      creds = JSONRepresentable.new(@creds_path)
+      @access_key_id = creds["access_key_id"]
+      @secret_access_key = creds["secret_access_key"]
+    end
+
+    def pull
+      s3_sync(src: @uri, dst: config.spm_repo_dir)
+    end
+
+    def push
+      s3_sync(src: config.spm_repo_dir, dst: @uri)
+    end
+
+    private
+
+    def s3_sync(src: nil, dst: nil)
+      validate!
+      UI.info("Syncing cache from #{src.to_s.bold} to #{dst.to_s.bold}...")
+      env = {
+        "AWS_ACCESS_KEY_ID" => @access_key_id,
+        "AWS_SECRET_ACCESS_KEY" => @secret_access_key,
+      }
+      cmd = ["aws", "s3", "sync"]
+      cmd << "--exact-timestamps" << "--delete"
+      cmd << "--include" << "*.xcframework"
+      cmd << "--include" << "*.macro"
+      cmd << src << dst
+      Sh.run(cmd, env: env)
+    end
+
+    def validate!
+      if File.which("awsss").nil?
+        raise GeneralError, "awscli is not installed. Please install it via brew: `brew install awscli`"
+      end
+      return unless @access_key_id.nil? || @secret_access_key.nil?
+      raise GeneralError, <<~DESC
+        Please ensure the credentials json at #{@creds_path}. Example:
+        {
+          "access_key_id": <ACCESS_KEY_ID>,
+          "secret_access_key": <SECRET_ACCESS_KEY>
+        }
+      DESC
+    end
+  end
+end

data/lib/xccache/storage.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,49 @@
+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",
+        :macosx => "arm64-apple-macosx",
+      }.freeze
+
+      def initialize(name)
+        @name = name
+      end
+
+      def to_s
+        name
+      end
+
+      def triple(without_vendor: false)
+        res = NAME_TO_TRIPLE[name.to_sym]
+        res = res.sub("-apple", "") if without_vendor
+        res
+      end
+
+      def sdk_path
+        # rubocop:disable Layout/LineLength
+        # /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator.sdk
+        # rubocop:enable Layout/LineLength
+        @sdk_path ||= Pathname(Sh.capture_output("xcrun --sdk #{name} --show-sdk-path")).realpath
+      end
+
+      def sdk_platform_developer_path
+        @sdk_platform_developer_path ||= sdk_path.parent.parent # iPhoneSimulator.platform/Developer
+      end
+
+      def swiftc_args
+        developer_library_frameworks_path = sdk_platform_developer_path / "Library" / "Frameworks"
+        developer_usr_lib_path = sdk_platform_developer_path / "usr" / "lib"
+        [
+          "-F#{developer_library_frameworks_path}",
+          "-I#{developer_usr_lib_path}",
+        ]
+      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/build_configuration.rb

@@ -0,0 +1,20 @@
+require "xcodeproj"
+
+module Xcodeproj
+  class Project
+    module Object
+      class XCBuildConfiguration
+        def base_configuration_xcconfig
+          path = base_configuration_xcconfig_path
+          Config.new(path) if path
+        end
+
+        def base_configuration_xcconfig_path
+          return base_configuration_reference.real_path if base_configuration_reference
+          return unless base_configuration_reference_anchor && base_configuration_reference_relative_path
+          project.dir / base_configuration_reference_anchor.path / base_configuration_reference_relative_path
+        end
+      end
+    end
+  end
+end

data/lib/xccache/xcodeproj/config.rb

@@ -0,0 +1,9 @@
+require "xcodeproj"
+
+module Xcodeproj
+  class Config
+    def path
+      @filepath
+    end
+  end
+end

data/lib/xccache/xcodeproj/file_system_synchronized_root_group.rb

@@ -0,0 +1,17 @@
+require "xcodeproj"
+
+module Xcodeproj
+  class Project
+    module Object
+      class PBXFileSystemSynchronizedRootGroup
+        attribute :name, String
+
+        def display_name
+          return name if name
+          return File.basename(path) if path
+          super
+        end
+      end
+    end
+  end
+end

data/lib/xccache/xcodeproj/group.rb

@@ -0,0 +1,26 @@
+require "xcodeproj"
+
+module Xcodeproj
+  class Project
+    module Object
+      class PBXGroup
+        def synced_groups
+          children.grep(PBXFileSystemSynchronizedRootGroup)
+        end
+
+        def ensure_synced_group(name: nil, path: nil)
+          synced_groups.find { |g| g.name == name } || new_synced_group(name: name, path: path)
+        end
+
+        def new_synced_group(name: nil, path: nil)
+          path = path.relative_path_from(project.dir) unless path.relative?
+          synced_group = project.new(PBXFileSystemSynchronizedRootGroup)
+          synced_group.path = path.to_s
+          synced_group.name = name || path.basename.to_s
+          self << synced_group
+          synced_group
+        end
+      end
+    end
+  end
+end