cocoapods-binary-cache 0.1.9 → 0.1.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ffcf342c1552381e28baebabf84a328ee30b744beb832740d04b3125be23f2fe
-  data.tar.gz: 77d55d695ad65749fe94d2238361ac76b290e7f6873ceec2286b9020f236f804
+  metadata.gz: e14f6a05df17d10b35b5ddfb5d263cdeaed50e4e3bf348b6606c27036317c173
+  data.tar.gz: 856426aa42021e6fc6b69f1de0be1e1fbc2dc96f0ac50b146f380280a3dee236
 SHA512:
-  metadata.gz: 00c13ec5a3bbc3df1ea0071cb1a90a91a85eb9a75f8a33853a5b60c4fcaf85dd6c5e3ac8aaaf0a6db6ceeb8e27d19bc6c5ede34b3d68e93cdeb4db2e808233b4
-  data.tar.gz: a39d29b292d9878fd808fb3aa61c7ae6c1b323b132dfa30810c71d32e3d6089cf80109f23fc1c4f57399df1d187c102ef78f23847ff97635b513a7f42a735702
+  metadata.gz: '090730e3c268eb4f3dc0a1d0d07546e9ed4bc92dae2962a4ebc1d65f58996762aa1866414a683cf94ebee6894ebaec3d916a62cd7fe65295d9e2d6a576fb7488'
+  data.tar.gz: ee499933ce3bb03ec19eefcd52e50dc2170ed92e7f8f9c557e8a7c8d38f9ee1730402666937a494efe655604b320b5b6d012f31a982eb21051fab891a7367a69

data/lib/cocoapods-binary-cache/cache/validator_dependencies_graph.rb

@@ -8,7 +8,7 @@ module PodPrebuild
     def validate(accumulated)
       return accumulated if library_evolution_supported? || @pod_lockfile.nil?
 
-      dependencies_graph = DependenciesGraph.new(@pod_lockfile.lockfile)
+      dependencies_graph = DependenciesGraph.new(lockfile: @pod_lockfile.lockfile, invert_edge: true)
       clients = dependencies_graph.get_clients(accumulated.discard(@ignored_pods).missed.to_a)
       unless PodPrebuild.config.dev_pods_enabled?
         clients = clients.reject { |client| @pod_lockfile.dev_pods.keys.include?(client) }

data/lib/cocoapods-binary-cache/dependencies_graph/dependencies_graph.rb

@@ -10,10 +10,12 @@ require_relative "graph_visualizer"
 # https://github.com/monora/rgl/blob/master/lib/rgl/adjacency.rb
 
 class DependenciesGraph
-  def initialize(lockfile)
-    @lockfile = lockfile
+  def initialize(options)
+    @lockfile = options[:lockfile]
+    @devpod_only = options[:devpod_only]
+    @max_deps = options[:max_deps].to_i if options[:max_deps]
     # A normal edge is an edge (one direction) from library A to library B which is a dependency of A.
-    @invert_edge = true
+    @invert_edge = options[:invert_edge] || false
   end
 
   # Input : a list of library names.
@@ -40,6 +42,10 @@ class DependenciesGraph
     @dependencies ||= (@lockfile && @lockfile.to_hash["PODS"])
   end
 
+  def dev_pod_sources
+    @dev_pod_sources ||= @lockfile.to_hash["EXTERNAL SOURCES"].select { |_, attributes| attributes.key?(:path) } || {}
+  end
+
   # Convert array of dictionaries -> a dictionary with format {A: [A's dependencies]}
   def pod_to_dependencies
     dependencies
@@ -49,6 +55,8 @@ class DependenciesGraph
 
   def add_vertex(graph, pod)
     node_name = sanitized_pod_name(pod)
+    return if @devpod_only && dev_pod_sources[node_name].nil?
+
     graph.add_vertex(node_name)
     node_name
   end
@@ -57,10 +65,20 @@ class DependenciesGraph
     Pod::Dependency.from_string(name).name
   end
 
+  def reach_max_deps(deps)
+    return unless @max_deps
+    return deps.count > @max_deps unless @devpod_only
+
+    deps = deps.reject { |name| dev_pod_sources[name].nil? }
+    deps.count > @max_deps
+  end
+
   def graph
     @graph ||= begin
       graph = RGL::DirectedAdjacencyGraph.new
       pod_to_dependencies.each do |pod, dependencies|
+        next if reach_max_deps(dependencies)
+
         pod_node = add_vertex(graph, pod)
         next if pod_node.nil?
 

data/lib/cocoapods-binary-cache/helper/checksum.rb

@@ -5,7 +5,7 @@ require "digest/md5"
 
 class FolderChecksum
   def self.git_checksum(dir)
-    checksum_of_files(`git ls-files #{dir}`.split("\n"))
+    checksum_of_files(`git ls-files #{File.realdirpath(dir).shellescape}`.split("\n"))
   rescue => e
     Pod::UI.warn "Cannot get checksum of tracked files under #{dir}: #{e}"
     checksum_of_files(Dir["#{dir}/**/*"].reject { |f| File.directory?(f) })

data/lib/cocoapods-binary-cache/hooks/pre_install.rb

@@ -2,13 +2,14 @@ module PodPrebuild
   class PreInstallHook
     include ObjectSpace
 
-    attr_reader :installer_context, :podfile, :prebuild_sandbox, :cache_validation
+    attr_reader :installer_context, :podfile, :prebuild_sandbox, :standard_sandbox, :cache_validation
 
     def initialize(installer_context)
       @installer_context = installer_context
       @podfile = installer_context.podfile
       @pod_install_options = {}
       @prebuild_sandbox = nil
+      @standard_sandbox = installer_context.sandbox
       @cache_validation = nil
     end
 
@@ -24,6 +25,7 @@ module PodPrebuild
       prebuild! if PodPrebuild.config.prebuild_job?
 
       PodPrebuild::Env.next_stage!
+      prepare_for_integration
       log_section "🤖  Resume pod installation"
       require_relative "../pod-binary/integration"
     end
@@ -51,7 +53,6 @@ module PodPrebuild
     end
 
     def create_prebuild_sandbox
-      standard_sandbox = installer_context.sandbox
       @prebuild_sandbox = Pod::PrebuildSandbox.from_standard_sandbox(standard_sandbox)
       Pod::UI.message "Create prebuild sandbox at #{@prebuild_sandbox.root}"
     end
@@ -102,6 +103,15 @@ module PodPrebuild
       end
     end
 
+    def prepare_for_integration
+      # Remove local podspec of external sources so that it downloads sources correctly.
+      # Otherwise, with incremental pod installation, CocoaPods downloads the sources
+      # based on the `s.source` declaration in the podspecs which are sometimes incorrect.
+      PodPrebuild.config.prebuilt_pod_names.each do |name|
+        @standard_sandbox.remove_local_podspec(name) if @standard_sandbox.checkout_sources.key?(name)
+      end
+    end
+
     def log_section(message)
       Pod::UI.puts "-----------------------------------------"
       Pod::UI.puts message

data/lib/cocoapods-binary-cache/pod-binary/helper/build.rb

@@ -1,39 +1,37 @@
 require_relative "../../pod-rome/xcodebuild_raw"
 require_relative "../../pod-rome/xcodebuild_command"
 
-module Pod
-  class Prebuild
-    def self.build(options)
-      targets = options[:targets] || []
-      return if targets.empty?
+module PodPrebuild
+  def self.build(options)
+    targets = options[:targets] || []
+    return if targets.empty?
 
-      options[:sandbox] = Pod::Sandbox.new(Pathname(options[:sandbox])) unless options[:sandbox].is_a?(Pod::Sandbox)
-      options[:build_dir] = build_dir(options[:sandbox].root)
+    options[:sandbox] = Pod::Sandbox.new(Pathname(options[:sandbox])) unless options[:sandbox].is_a?(Pod::Sandbox)
+    options[:build_dir] = build_dir(options[:sandbox].root)
 
-      case targets[0].platform.name
-      when :ios, :tvos, :watchos
-        XcodebuildCommand.new(options).run
-      when :osx
-        xcodebuild(
-          sandbox: options[:sandbox],
-          targets: targets,
-          configuration: options[:configuration],
-          sdk: "macosx",
-          args: options[:args]
-        )
-      else
-        raise "Unsupported platform for '#{targets[0].name}': '#{targets[0].platform.name}'"
-      end
-      raise "The build directory was not found in the expected location" unless options[:build_dir].directory?
+    case targets[0].platform.name
+    when :ios, :tvos, :watchos
+      PodPrebuild::XcodebuildCommand.new(options).run
+    when :osx
+      xcodebuild(
+        sandbox: options[:sandbox],
+        targets: targets,
+        configuration: options[:configuration],
+        sdk: "macosx",
+        args: options[:args]
+      )
+    else
+      raise "Unsupported platform for '#{targets[0].name}': '#{targets[0].platform.name}'"
     end
+    raise "The build directory was not found in the expected location" unless options[:build_dir].directory?
+  end
 
-    def self.remove_build_dir(sandbox_root)
-      path = build_dir(sandbox_root)
-      path.rmtree if path.exist?
-    end
+  def self.remove_build_dir(sandbox_root)
+    path = build_dir(sandbox_root)
+    path.rmtree if path.exist?
+  end
 
-    def self.build_dir(sandbox_root)
-      sandbox_root.parent + "build"
-    end
+  def self.build_dir(sandbox_root)
+    sandbox_root.parent + "build"
   end
 end

data/lib/cocoapods-binary-cache/pod-binary/integration/alter_specs.rb

@@ -2,28 +2,50 @@ module Pod
   class Installer
     def alter_specs_for_prebuilt_pods
       cache = []
+
+      @original_specs = analysis_result.specifications
+        .map { |spec| [spec.name, Pod::Specification.from_file(spec.defined_in_file)] }
+        .to_h
+
       analysis_result.specifications
         .select { |spec| should_integrate_prebuilt_pod?(spec.root.name) }
-        .each { |spec| alter_spec(spec, cache) }
+        .group_by(&:root)
+        .each do |_, specs|
+          first_subspec_or_self = specs.find(&:subspec?) || specs[0]
+          specs.each do |spec|
+            alterations = {
+              :source_files => true,
+              :resources => true,
+              :license => true,
+              :vendored_framework => spec == first_subspec_or_self
+            }
+            alter_spec(spec, alterations, cache)
+          end
+        end
     end
 
-    def alter_spec(spec, cache)
+    private
+
+    def alter_spec(spec, alterations, cache)
       targets = Pod.fast_get_targets_for_pod_name(spec.root.name, pod_targets, cache)
-      targets.each do |target|
-        # Use the prebuild framworks as vendered frameworks.
-        # The framework_file_path rule is decided in `install_for_prebuild`,
-        # as to compitable with older version and be less wordy.
-        framework_file_path = target.framework_name
-        framework_file_path = target.name + "/" + framework_file_path if targets.count > 1
-        framework_file_path = PodPrebuild.config.prebuilt_path(path: framework_file_path)
-        add_vendered_framework(spec, target.platform.name.to_s, framework_file_path)
+      platforms = targets.map { |target| target.platform.name.to_s }.uniq
+
+      if alterations[:vendored_framework]
+        targets.each do |target|
+          # Use the prebuilt frameworks as vendered frameworks.
+          # The framework_file_path rule is decided in `install_for_prebuild`,
+          # as to compitable with older version and be less wordy.
+          framework_file_path = target.framework_name
+          framework_file_path = target.name + "/" + framework_file_path if targets.count > 1
+          framework_file_path = PodPrebuild.config.prebuilt_path(path: framework_file_path)
+          add_vendered_framework(spec, target.platform.name.to_s, framework_file_path)
+        end
       end
 
-      platforms = targets.map { |target| target.platform.name.to_s }.uniq
-      empty_source_files(spec, platforms)
-      tweak_resources_for_xib(spec, platforms)
-      tweak_resources_for_resource_bundles(spec, platforms)
-      empty_liscence(spec) # to avoid the warning of missing license
+      empty_source_files(spec, platforms) if alterations[:source_files]
+      tweak_resources_for_xib(spec, platforms) if alterations[:resources]
+      tweak_resources_for_resource_bundles(spec, platforms) if alterations[:resources]
+      empty_liscence(spec) if alterations[:license]
     end
 
     def tweak_resources_for_xib(spec, platforms)

data/lib/cocoapods-binary-cache/pod-binary/integration/patch/embed_framework_script.rb

@@ -17,7 +17,7 @@ module Pod
           # If the path isn't an absolute path, we add a realtive prefix.
           old_read_link=`which readlink`
           readlink () {
-            path=`$old_read_link $1`;
+            path=`$old_read_link "$1"`;
             if [ $(echo "$path" | cut -c 1-1) = '/' ]; then
               echo $path;
             else

data/lib/cocoapods-binary-cache/pod-binary/integration/patch/source_installation.rb

@@ -18,8 +18,18 @@ module Pod
       original_create_pod_installer(name)
     end
 
+    def original_specs_by_platform(name)
+      specs_for_pod(name).map do |platform, specs|
+        specs_ = specs.map { |spec| @original_specs[spec.name] }
+        [platform, specs_]
+      end.to_h
+    end
+
     def create_prebuilt_source_installer(name)
-      source_installer = PodSourceInstaller.new(sandbox, podfile, specs_for_pod(name))
+      # A source installer needs to install with the original spec (instead of the altered spec).
+      # Otherwise, the cache will be corrupted because CocoaPods packs necessary dirs/files from temp dir
+      # to the cache dir based on the spec.
+      source_installer = PodSourceInstaller.new(sandbox, podfile, original_specs_by_platform(name))
       pod_installer = PrebuiltSourceInstaller.new(
         sandbox,
         podfile,

data/lib/cocoapods-binary-cache/pod-binary/integration/source_installer.rb

@@ -11,7 +11,7 @@ module Pod
       end
 
       def install!
-        @source_installer.install! if PodPrebuild.config.still_download_sources?(name)
+        @source_installer.install!
         install_prebuilt_framework!
       end
 
@@ -39,8 +39,10 @@ module Pod
           walk(real_file_folder) do |child|
             source = child
             # only make symlink to file and `.framework` folder
-            if child.directory? && [".framework", ".dSYM"].include?(child.extname)
-              mirror_with_symlink(source, real_file_folder, target_folder) if child.extname == ".framework"
+            if child.directory? && [".framework", ".xcframework", ".dSYM"].include?(child.extname)
+              if [".framework", ".xcframework"].include?(child.extname)
+                mirror_with_symlink(source, real_file_folder, target_folder)
+              end
               # Ignore dsym here to avoid cocoapods from adding install_dsym to buildphase-script
               # That can cause duplicated output files error in Xcode 11 (warning in Xcode 10)
               # We need more setup to support local debuging with prebuilt dSYM
@@ -58,10 +60,15 @@ module Pod
           next unless metadata.static_framework?
 
           metadata.resources.each do |path|
-            target_file_path = path
+            target_file_path = Pathname(path)
               .sub("${PODS_ROOT}", sandbox.root.to_path)
               .sub("${PODS_CONFIGURATION_BUILD_DIR}", sandbox.root.to_path)
+            next if target_file_path.exist?
+
             real_file_path = real_file_folder + metadata.framework_name + File.basename(path)
+
+            # TODO (thuyen): Fix https://github.com/grab/cocoapods-binary-cache/issues/45
+
             case File.extname(path)
             when ".xib"
               # https://github.com/grab/cocoapods-binary-cache/issues/7

data/lib/cocoapods-binary-cache/pod-binary/prebuild.rb

@@ -14,6 +14,13 @@ module Pod
       @lockfile_wrapper = lockfile && PodPrebuild::Lockfile.new(lockfile)
     end
 
+    def installation_options
+      # Skip integrating user targets for prebuild Pods project.
+      @installation_options ||= Pod::Installer::InstallationOptions.new(
+        super.to_h.merge(:integrate_targets => false)
+      )
+    end
+
     def run_code_gen!(targets)
       return if PodPrebuild.config.prebuild_code_gen.nil?
 
@@ -42,8 +49,8 @@ module Pod
 
       run_code_gen!(targets)
 
-      Pod::Prebuild.remove_build_dir(sandbox_path)
-      Pod::Prebuild.build(
+      PodPrebuild.remove_build_dir(sandbox_path)
+      PodPrebuild.build(
         sandbox: sandbox_path,
         targets: targets,
         configuration: PodPrebuild.config.prebuild_config,
@@ -51,9 +58,10 @@ module Pod
         bitcode_enabled: PodPrebuild.config.bitcode_enabled?,
         device_build_enabled: PodPrebuild.config.device_build_enabled?,
         disable_dsym: PodPrebuild.config.disable_dsym?,
+        log_path: PodPrebuild.config.xcodebuild_log_path,
         args: PodPrebuild.config.build_args
       )
-      Pod::Prebuild.remove_build_dir(sandbox_path)
+      PodPrebuild.remove_build_dir(sandbox_path)
 
       targets.each do |target|
         collect_metadata(target, sandbox.framework_folder_path_for_target_name(target.name))

data/lib/cocoapods-binary-cache/pod-rome/xcodebuild_command.rb

@@ -1,189 +1,261 @@
 require_relative "xcodebuild_raw"
 
-class XcodebuildCommand # rubocop:disable Metrics/ClassLength
-  def initialize(options)
-    @options = options
-    case options[:targets][0].platform.name
-    when :ios
-      @options[:device] = "iphoneos"
-      @options[:simulator] = "iphonesimulator"
-    when :tvos
-      @options[:device] = "appletvos"
-      @options[:simulator] = "appletvsimulator"
-    when :watchos
-      @options[:device] = "watchos"
-      @options[:simulator] = "watchsimulator"
-    end
-    @build_args = make_up_build_args(options[:args] || {})
-  end
+module PodPrebuild
+  class XcodebuildCommand # rubocop:disable Metrics/ClassLength
+    def initialize(options)
+      @options = options
+      case options[:targets][0].platform.name
+      when :ios
+        @options[:device] = "iphoneos"
+        @options[:simulator] = "iphonesimulator"
+      when :tvos
+        @options[:device] = "appletvos"
+        @options[:simulator] = "appletvsimulator"
+      when :watchos
+        @options[:device] = "watchos"
+        @options[:simulator] = "watchsimulator"
+      end
+      @build_args = make_up_build_args(options[:args] || {})
+    end
 
-  def run
-    build_for_sdk(simulator) if build_types.include?(:simulator)
-    build_for_sdk(device) if build_types.include?(:device)
-
-    targets.each do |target|
-      case build_types
-      when [:simulator]
-        collect_output(target, Dir[target_products_dir_of(target, simulator) + "/*"])
-      when [:device]
-        collect_output(target, Dir[target_products_dir_of(target, device) + "/*"])
-      else
-        # When merging contents of `simulator` & `device`, prefer contents of `device` over `simulator`
-        # https://github.com/grab/cocoapods-binary-cache/issues/25
-        collect_output(target, Dir[target_products_dir_of(target, device) + "/*"])
-        create_universal_framework(target)
+    def run
+      sdks.each { |sdk| build_for_sdk(sdk) }
+
+      targets.each do |target|
+        if PodPrebuild.config.xcframework?
+          create_xcframework(target)
+        elsif sdks.count > 1
+          create_fat_framework(target)
+        else
+          collect_output(target, Dir[target_products_dir_of(target, sdks[0]) + "/*"])
+        end
       end
     end
-  end
 
-  private
+    private
 
-  def build_types
-    @build_types ||= begin
-      # TODO (thuyen): Add DSL options `build_for_types` to specify build types
-      types = [:simulator]
-      types << :device if device_build_enabled?
-      types
+    def sdks
+      @sdks ||= begin
+        sdks_ = []
+        sdks_ << simulator if build_types.include?(:simulator)
+        sdks_ << device if build_types.include?(:device)
+        sdks_
+      end
     end
-  end
 
-  def make_up_build_args(args)
-    args_ = args.clone
-    args_[:default] ||= []
-    args_[:simulator] ||= []
-    args_[:device] ||= []
-    args_[:default] += ["BITCODE_GENERATION_MODE=bitcode"] if bitcode_enabled?
-    args_[:default] += ["DEBUG_INFORMATION_FORMAT=dwarf"] if disable_dsym?
-    args_[:simulator] += ["ARCHS=x86_64", "ONLY_ACTIVE_ARCH=NO"] if simulator == "iphonesimulator"
-    args_[:simulator] += args_[:default]
-    args_[:device] += args_[:default]
-    args_
-  end
+    def preferred_sdk
+      @preferred_sdk ||= sdks.include?(device) ? device : sdks[0]
+    end
 
-  def build_for_sdk(sdk)
-    xcodebuild(
-      sandbox: sandbox,
-      scheme: scheme,
-      targets: targets.map(&:label),
-      configuration: configuration,
-      sdk: sdk,
-      deployment_target: targets.map { |t| t.platform.deployment_target }.max.to_s,
-      args: sdk == simulator ? @build_args[:simulator] : @build_args[:device]
-    )
-  end
+    def build_types
+      @build_types ||= begin
+        # TODO (thuyen): Add DSL options `build_for_types` to specify build types
+        types = [:simulator]
+        types << :device if device_build_enabled?
+        types
+      end
+    end
 
-  def create_universal_framework(target)
-    merge_framework_binary(target)
-    merge_framework_dsym(target)
-    merge_swift_headers(target)
-    merge_swift_modules(target)
-  end
+    def make_up_build_args(args)
+      # Note: The build arguments explicitly passed from config_cocoapods_binary_cache
+      # should be preceded by the default arguments so that they could take higher priority
+      # when there are argument collisions in the xcodebuild command.
+      # For ex. `xcodebuild AN_ARG=1 AN_ARG=2` should use `AN_ARG=2` instead.
+      args_ = args.clone
+      args_[:default] ||= []
+      args_[:simulator] ||= []
+      args_[:device] ||= []
+      args_[:default].prepend("BITCODE_GENERATION_MODE=bitcode") if bitcode_enabled?
+      args_[:default].prepend("DEBUG_INFORMATION_FORMAT=dwarf") if disable_dsym?
+      args_[:simulator].prepend("ARCHS=x86_64", "ONLY_ACTIVE_ARCH=NO") if simulator == "iphonesimulator"
+      args_[:simulator] += args_[:default]
+      args_[:device].prepend("ONLY_ACTIVE_ARCH=NO")
+      args_[:device] += args_[:default]
+      args_
+    end
 
-  def merge_framework_binary(target)
-    merge_contents(target, "/#{target.product_module_name}", &method(:create_fat_binary))
-  end
+    def build_for_sdk(sdk)
+      PodPrebuild::XcodebuildCommand.xcodebuild(
+        sandbox: sandbox,
+        scheme: scheme,
+        targets: targets.map(&:label),
+        configuration: configuration,
+        sdk: sdk,
+        deployment_target: targets.map { |t| t.platform.deployment_target }.max.to_s,
+        log_path: log_path(sdk),
+        args: sdk == simulator ? @build_args[:simulator] : @build_args[:device]
+      )
+    end
 
-  def merge_framework_dsym(target)
-    merge_contents(target, ".dSYM/Contents/Resources/DWARF/#{target.product_module_name}", &method(:create_fat_binary))
-  end
+    def create_xcframework(target)
+      non_framework_paths = Dir[target_products_dir_of(target, preferred_sdk) + "/*"] \
+        - [framework_path_of(target, preferred_sdk)] \
+        - dsym_paths_of(target, preferred_sdk) \
+        - bcsymbolmap_paths_of(target, preferred_sdk)
+      collect_output(target, non_framework_paths)
+
+      output = "#{output_path(target)}/#{target.product_module_name}.xcframework"
+      FileUtils.rm_rf(output)
+
+      cmd = ["xcodebuild", "-create-xcframework", "-allow-internal-distribution"]
 
-  def merge_swift_headers(target)
-    merge_contents(target, "/Headers/#{target.product_module_name}-Swift.h") do |options|
-      merged_header = <<~HEREDOC
-        #if TARGET_OS_SIMULATOR // merged by cocoapods-binary
-        #{File.read(options[:simulator])}
-        #else // merged by cocoapods-binary
-        #{File.read(options[:device])}
-        #endif // merged by cocoapods-binary
-      HEREDOC
-      File.write(options[:output], merged_header.strip)
+      # for each sdk, the order of params must be -framework then -debug-symbols
+      # to prevent duplicated file error when copying dSYMs
+      sdks.each do |sdk|
+        cmd << "-framework" << framework_path_of(target, sdk)
+
+        unless disable_dsym?
+          dsyms = dsym_paths_of(target, sdk)
+          cmd += dsyms.map { |dsym| "-debug-symbols #{dsym}" }
+        end
+
+        if bitcode_enabled?
+          bcsymbolmaps = bcsymbolmap_paths_of(target, sdk)
+          cmd += bcsymbolmaps.map { |bcsymbolmap| "-debug-symbols #{bcsymbolmap}" }
+        end
+      end
+
+      cmd << "-output" << output
+
+      Pod::UI.puts "- Create xcframework: #{target}".magenta
+      Pod::UI.puts_indented "$ #{cmd.join(' ')}" unless PodPrebuild.config.silent_build?
+
+      `#{cmd.join(" ")}`
     end
-  end
 
-  def merge_swift_modules(target)
-    merge_contents(target, "/Modules/#{target.product_module_name}.swiftmodule") do |options|
-      # Note: swiftmodules of `device` were copied beforehand,
-      # here, we only need to copy swiftmodules of `simulator`
-      FileUtils.cp_r(options[:simulator] + "/.", options[:output])
+    def create_fat_framework(target)
+      # When merging contents of `simulator` & `device`, prefer contents of `device` over `simulator`
+      # https://github.com/grab/cocoapods-binary-cache/issues/25
+      collect_output(target, Dir[target_products_dir_of(target, device) + "/*"])
+
+      merge_framework_binary(target)
+      merge_framework_dsym(target)
+      merge_swift_headers(target)
+      merge_swift_modules(target)
     end
-  end
 
-  def merge_contents(target, path_suffix, &merger)
-    simulator_, device_, output_ = [
-      framework_path_of(target, simulator),
-      framework_path_of(target, device),
-      "#{output_path(target)}/#{target.product_module_name}.framework"
-    ].map { |p| p + path_suffix }
-    return unless File.exist?(simulator_) && File.exist?(device_)
+    def merge_framework_binary(target)
+      merge_contents(target, "/#{target.product_module_name}", &method(:create_fat_binary))
+    end
 
-    merger.call(simulator: simulator_, device: device_, output: output_)
-  end
+    def merge_framework_dsym(target)
+      merge_contents(
+        target,
+        ".dSYM/Contents/Resources/DWARF/#{target.product_module_name}",
+        &method(:create_fat_binary)
+      )
+    end
 
-  def create_fat_binary(options)
-    cmd = ["lipo", " -create"]
-    cmd << "-output" << options[:output]
-    cmd << options[:simulator] << options[:device]
-    `#{cmd.join(" ")}`
-  end
+    def merge_swift_headers(target)
+      merge_contents(target, "/Headers/#{target.product_module_name}-Swift.h") do |options|
+        merged_header = <<~HEREDOC
+          #if TARGET_OS_SIMULATOR // merged by cocoapods-binary
+          #{File.read(options[:simulator])}
+          #else // merged by cocoapods-binary
+          #{File.read(options[:device])}
+          #endif // merged by cocoapods-binary
+        HEREDOC
+        File.write(options[:output], merged_header.strip)
+      end
+    end
 
-  def collect_output(target, paths)
-    FileUtils.mkdir_p(output_path(target))
-    paths = [paths] unless paths.is_a?(Array)
-    paths.each do |path|
-      FileUtils.rm_rf(File.join(output_path(target), File.basename(path)))
-      FileUtils.cp_r(path, output_path(target))
+    def merge_swift_modules(target)
+      merge_contents(target, "/Modules/#{target.product_module_name}.swiftmodule") do |options|
+        # Note: swiftmodules of `device` were copied beforehand,
+        # here, we only need to copy swiftmodules of `simulator`
+        FileUtils.cp_r(options[:simulator] + "/.", options[:output])
+      end
     end
-  end
 
-  def target_products_dir_of(target, sdk)
-    "#{build_dir}/#{configuration}-#{sdk}/#{target.name}"
-  end
+    def merge_contents(target, path_suffix, &merger)
+      simulator_, device_, output_ = [
+        framework_path_of(target, simulator),
+        framework_path_of(target, device),
+        "#{output_path(target)}/#{target.product_module_name}.framework"
+      ].map { |p| p + path_suffix }
+      return unless File.exist?(simulator_) && File.exist?(device_)
 
-  def framework_path_of(target, sdk)
-    "#{target_products_dir_of(target, sdk)}/#{target.product_module_name}.framework"
-  end
+      merger.call(simulator: simulator_, device: device_, output: output_)
+    end
 
-  def sandbox
-    @options[:sandbox]
-  end
+    def create_fat_binary(options)
+      cmd = ["lipo", " -create"]
+      cmd << "-output" << options[:output]
+      cmd << options[:simulator] << options[:device]
+      `#{cmd.join(" ")}`
+    end
 
-  def build_dir
-    @options[:build_dir]
-  end
+    def collect_output(target, paths)
+      FileUtils.mkdir_p(output_path(target))
+      paths = [paths] unless paths.is_a?(Array)
+      paths.each do |path|
+        FileUtils.rm_rf(File.join(output_path(target), File.basename(path)))
+        FileUtils.cp_r(path, output_path(target))
+      end
+    end
 
-  def output_path(target)
-    "#{@options[:output_path]}/#{target.label}"
-  end
+    def target_products_dir_of(target, sdk)
+      "#{build_dir}/#{configuration}-#{sdk}/#{target.name}"
+    end
 
-  def scheme
-    @options[:scheme]
-  end
+    def framework_path_of(target, sdk)
+      "#{target_products_dir_of(target, sdk)}/#{target.product_module_name}.framework"
+    end
 
-  def targets
-    @options[:targets]
-  end
+    def dsym_paths_of(target, sdk)
+      Dir["#{target_products_dir_of(target, sdk)}/*.dSYM"]
+    end
 
-  def configuration
-    @options[:configuration]
-  end
+    def bcsymbolmap_paths_of(target, sdk)
+      Dir["#{target_products_dir_of(target, sdk)}/*.bcsymbolmap"]
+    end
 
-  def bitcode_enabled?
-    @options[:bitcode_enabled]
-  end
+    def sandbox
+      @options[:sandbox]
+    end
 
-  def device_build_enabled?
-    @options[:device_build_enabled]
-  end
+    def build_dir
+      @options[:build_dir]
+    end
 
-  def device
-    @options[:device] || "iphoneos"
-  end
+    def output_path(target)
+      "#{@options[:output_path]}/#{target.label}"
+    end
 
-  def simulator
-    @options[:simulator] || "iphonesimulator"
-  end
+    def scheme
+      @options[:scheme]
+    end
+
+    def targets
+      @options[:targets]
+    end
+
+    def configuration
+      @options[:configuration]
+    end
+
+    def bitcode_enabled?
+      @options[:bitcode_enabled]
+    end
 
-  def disable_dsym?
-    @options[:disable_dsym]
+    def device_build_enabled?
+      @options[:device_build_enabled]
+    end
+
+    def device
+      @options[:device] || "iphoneos"
+    end
+
+    def simulator
+      @options[:simulator] || "iphonesimulator"
+    end
+
+    def disable_dsym?
+      @options[:disable_dsym]
+    end
+
+    def log_path(sdk)
+      @options[:log_path].nil? ? nil : "#{@options[:log_path]}_#{sdk}"
+    end
   end
 end

data/lib/cocoapods-binary-cache/pod-rome/xcodebuild_raw.rb

@@ -1,42 +1,64 @@
 require "fourflusher"
 
-PLATFORM_OF_SDK = {
-  "iphonesimulator" => "iOS",
-  "appletvsimulator" => "tvOS",
-  "watchsimulator" => "watchOS"
-}.freeze
-
-def xcodebuild(options)
-  sdk = options[:sdk] || "iphonesimulator"
-  targets = options[:targets] || [options[:target]]
-  platform = PLATFORM_OF_SDK[sdk]
-
-  cmd = ["xcodebuild"]
-  cmd << "-project" << options[:sandbox].project_path.realdirpath
-  targets.each { |target| cmd << "-target" << target }
-  cmd << "-configuration" << options[:configuration]
-  cmd << "-sdk" << sdk
-  cmd << Fourflusher::SimControl.new.destination(:oldest, platform, options[:deployment_target]) unless platform.nil?
-  cmd += options[:args] if options[:args]
-  cmd << "build"
-  cmd << "2>&1"
-  cmd = cmd.join(" ")
-
-  Pod::UI.puts_indented "$ #{cmd}"
-  log = `#{cmd}`
-  return if $?.exitstatus.zero? # rubocop:disable Style/SpecialGlobalVars
-
-  begin
-    require "xcpretty" # TODO (thuyen): Revise this dependency
-    # use xcpretty to print build log
-    # 64 represent command invalid. http://www.manpagez.com/man/3/sysexits/
-    printer = XCPretty::Printer.new({:formatter => XCPretty::Simple, :colorize => "auto"})
-    log.each_line do |line|
-      printer.pretty_print(line)
+module PodPrebuild
+  class XcodebuildCommand
+    PLATFORM_OF_SDK = {
+      "iphonesimulator" => "iOS",
+      "appletvsimulator" => "tvOS",
+      "watchsimulator" => "watchOS"
+    }.freeze
+
+    DESTINATION_OF_SDK = {
+      "iphoneos" => "\"generic/platform=iOS\"",
+      "iphonesimulator" => "\"generic/platform=iOS Simulator\""
+    }.freeze
+
+    def self.xcodebuild(options)
+      sdk = options[:sdk] || "iphonesimulator"
+      targets = options[:targets] || [options[:target]]
+      platform = PLATFORM_OF_SDK[sdk]
+
+      cmd = ["xcodebuild"]
+      cmd << "-project" << options[:sandbox].project_path.realdirpath.shellescape
+      targets.each { |target| cmd << "-target" << target }
+      cmd << "-configuration" << options[:configuration]
+      cmd << "-sdk" << sdk
+      if DESTINATION_OF_SDK.key?(sdk)
+        cmd << "-destination" << DESTINATION_OF_SDK[sdk]
+      else
+        unless platform.nil?
+          cmd << Fourflusher::SimControl.new.destination(:oldest, platform, options[:deployment_target])
+        end
+      end
+      cmd += options[:args] if options[:args]
+      cmd << "build"
+
+      if options[:log_path].nil?
+        cmd << "2>&1"
+      else
+        FileUtils.mkdir_p(File.dirname(options[:log_path]))
+        cmd << "> #{options[:log_path].shellescape}"
+      end
+      cmd = cmd.join(" ")
+
+      Pod::UI.puts_indented "$ #{cmd}" unless PodPrebuild.config.silent_build?
+
+      log = `#{cmd}`
+      return if $?.exitstatus.zero? # rubocop:disable Style/SpecialGlobalVars
+
+      begin
+        require "xcpretty" # TODO (thuyen): Revise this dependency
+        # use xcpretty to print build log
+        # 64 represent command invalid. http://www.manpagez.com/man/3/sysexits/
+        printer = XCPretty::Printer.new({:formatter => XCPretty::Simple, :colorize => "auto"})
+        log.each_line do |line|
+          printer.pretty_print(line)
+        end
+      rescue
+        Pod::UI.puts log.red
+      ensure
+        raise "Fail to build targets: #{targets}"
+      end
     end
-  rescue
-    Pod::UI.puts log.red
-  ensure
-    raise "Fail to build targets: #{targets}"
   end
 end

data/lib/command/config.rb

@@ -29,6 +29,10 @@ module PodPrebuild
       @cache_repo ||= cache_repo_config["remote"]
     end
 
+    def local_cache?
+      cache_repo.nil?
+    end
+
     def cache_path
       @cache_path ||= File.expand_path(cache_repo_config["local"])
     end
@@ -54,7 +58,9 @@ module PodPrebuild
     end
 
     def prebuilt_path(path: nil)
-      path.nil? ? "_Prebuilt" : "_Prebuilt/#{path}"
+      p = Pathname.new(path.nil? ? "_Prebuilt" : "_Prebuilt/#{path}")
+      p = p.sub_ext(".xcframework") if xcframework? && p.extname == ".framework"
+      p.to_s
     end
 
     def validate_dsl_config
@@ -99,19 +105,22 @@ module PodPrebuild
       @dsl_config[:device_build_enabled]
     end
 
-    def disable_dsym?
-      @dsl_config[:disable_dsym]
+    def xcframework?
+      @dsl_config[:xcframework]
     end
 
-    def still_download_sources?(name)
-      option = @dsl_config[:still_download_sources]
-      option.is_a?(Array) ? option.include?(name) : option
+    def disable_dsym?
+      @dsl_config[:disable_dsym]
     end
 
     def dont_remove_source_code?
       @dsl_config[:dont_remove_source_code]
     end
 
+    def xcodebuild_log_path
+      @dsl_config[:xcodebuild_log_path]
+    end
+
     def build_args
       @dsl_config[:build_args]
     end
@@ -132,6 +141,10 @@ module PodPrebuild
       @dsl_config[:strict_diagnosis]
     end
 
+    def silent_build?
+      @dsl_config[:silent_build]
+    end
+
     def targets_to_prebuild_from_cli
       @cli_config[:prebuild_targets] || []
     end
@@ -166,14 +179,16 @@ module PodPrebuild
         :dev_pods_enabled,
         :bitcode_enabled,
         :device_build_enabled,
+        :xcframework,
         :disable_dsym,
-        :still_download_sources,
         :dont_remove_source_code,
+        :xcodebuild_log_path,
         :build_args,
         :save_cache_validation_to,
         :validate_prebuilt_settings,
         :prebuild_code_gen,
-        :strict_diagnosis
+        :strict_diagnosis,
+        :silent_build
       ]
     end
 

data/lib/command/executor/base.rb

@@ -2,6 +2,7 @@ module PodPrebuild
   class CommandExecutor
     def initialize(options)
       @config = options[:config]
+      prepare_cache_dir
     end
 
     def installer
@@ -11,6 +12,14 @@ module PodPrebuild
       end
     end
 
+    def use_local_cache?
+      @config.cache_repo.nil?
+    end
+
+    def prepare_cache_dir
+      FileUtils.mkdir_p(@config.cache_path) if @config.cache_path
+    end
+
     def git(cmd, options = {})
       comps = ["git"]
       comps << "-C" << @config.cache_path unless options[:cache_repo] == false

data/lib/command/executor/fetcher.rb

@@ -1,8 +1,11 @@
+require "parallel"
 require_relative "base"
 require_relative "../helper/zip"
 
 module PodPrebuild
   class CacheFetcher < CommandExecutor
+    attr_reader :cache_branch
+
     def initialize(options)
       super(options)
       @cache_branch = options[:cache_branch]
@@ -10,14 +13,28 @@ module PodPrebuild
 
     def run
       Pod::UI.step("Fetching cache") do
-        fetch_cache(@config.cache_repo, @cache_branch, @config.cache_path)
+        if @config.local_cache?
+          print_message_for_local_cache(@config.cache_path)
+        else
+          fetch_remote_cache(@config.cache_repo, @cache_branch, @config.cache_path)
+        end
         unzip_cache
       end
     end
 
     private
 
-    def fetch_cache(repo, branch, dest_dir)
+    def print_message_for_local_cache(cache_dir)
+      Pod::UI.puts "You're using local cache at: #{cache_dir}.".yellow
+      message = <<~HEREDOC
+        To enable remote cache (with a git repo), add the `remote` field to the repo config in the `cache_repo` option.
+        For more details, check out this doc:
+          https://github.com/grab/cocoapods-binary-cache/blob/master/docs/configure_cocoapods_binary_cache.md#cache_repo-
+      HEREDOC
+      Pod::UI.puts message
+    end
+
+    def fetch_remote_cache(repo, branch, dest_dir)
       Pod::UI.puts "Fetching cache from #{repo} (branch: #{branch})".green
       if Dir.exist?(dest_dir + "/.git")
         git("fetch origin #{branch}")
@@ -41,7 +58,8 @@ module PodPrebuild
           @config.manifest_path
         )
       end
-      Dir[@config.generated_frameworks_dir(in_cache: true) + "/*.zip"].each do |path|
+      zip_paths = Dir[@config.generated_frameworks_dir(in_cache: true) + "/*.zip"]
+      Parallel.each(zip_paths, in_threads: 8) do |path|
         ZipUtils.unzip(path, to_dir: @config.generated_frameworks_dir)
       end
     end

data/lib/command/executor/prebuilder.rb

@@ -4,23 +4,23 @@ require_relative "pusher"
 
 module PodPrebuild
   class CachePrebuilder < CommandExecutor
+    attr_reader :repo_update, :fetcher, :pusher
+
     def initialize(options)
       super(options)
-      @cache_branch = options[:cache_branch]
-      @push_cache = options[:push_cache]
       @repo_update = options[:repo_update]
-      @fetcher = PodPrebuild::CacheFetcher.new(options)
-      @pusher = PodPrebuild::CachePusher.new(options)
+      @fetcher = PodPrebuild::CacheFetcher.new(options) unless options[:no_fetch]
+      @pusher = PodPrebuild::CachePusher.new(options) if options[:push_cache]
     end
 
     def run
-      @fetcher.run
+      @fetcher&.run
       prebuild
       changes = PodPrebuild::JSONFile.new(@config.prebuild_delta_path)
       return if changes.empty?
 
       sync_cache(changes)
-      @pusher.run if @push_cache
+      @pusher&.run
     end
 
     private

data/lib/command/executor/pusher.rb

@@ -2,6 +2,8 @@ require_relative "base"
 
 module PodPrebuild
   class CachePusher < CommandExecutor
+    attr_reader :cache_branch
+
     def initialize(options)
       super(options)
       @cache_branch = options[:cache_branch]
@@ -9,11 +11,25 @@ module PodPrebuild
 
     def run
       Pod::UI.step("Pushing cache") do
-        commit_message = "Update prebuilt cache".shellescape
-        git("add .")
-        git("commit -m '#{commit_message}'")
-        git("push origin #{@cache_branch}")
+        if @config.local_cache?
+          print_message_for_local_cache
+        else
+          commit_and_push_cache
+        end
       end
     end
+
+    private
+
+    def print_message_for_local_cache
+      Pod::UI.puts "Skip pushing cache as you're using local cache".yellow
+    end
+
+    def commit_and_push_cache
+      commit_message = "Update prebuilt cache"
+      git("add .")
+      git("commit -m '#{commit_message}'")
+      git("push origin #{@cache_branch}")
+    end
   end
 end

data/lib/command/executor/visualizer.rb

@@ -8,11 +8,13 @@ module PodPrebuild
       @lockfile = options[:lockfile]
       @open = options[:open]
       @output_dir = options[:output_dir]
+      @devpod_only = options[:devpod_only]
+      @max_deps = options[:max_deps]
     end
 
     def run
       FileUtils.mkdir_p(@output_dir)
-      graph = DependenciesGraph.new(@lockfile)
+      graph = DependenciesGraph.new(lockfile: @lockfile, devpod_only: @devpod_only, max_deps: @max_deps)
       output_path = "#{@output_dir}/graph.png"
       graph.write_graphic_file(output_path: output_path)
       system("open #{@output_path}") if @open

data/lib/command/prebuild.rb

@@ -5,11 +5,14 @@ module Pod
   class Command
     class Binary < Command
       class Prebuild < Binary
+        attr_reader :prebuilder
+
         self.arguments = [CLAide::Argument.new("CACHE-BRANCH", false)]
         def self.options
           [
             ["--config", "Config (Debug, Test...) to prebuild"],
             ["--repo-update", "Update pod repo before installing"],
+            ["--no-fetch", "Do not perform a cache fetch beforehand"],
             ["--push", "Push cache to repo upon completion"],
             ["--all", "Prebuild all binary pods regardless of cache validation"],
             ["--targets", "Targets to prebuild. Use comma (,) to specify a list of targets"]
@@ -30,6 +33,7 @@ module Pod
             config: prebuild_config,
             cache_branch: argv.shift_argument || "master",
             repo_update: argv.flag?("repo-update"),
+            no_fetch: argv.flag?("fetch") == false,
             push_cache: argv.flag?("push")
           )
         end

data/lib/command/visualize.rb

@@ -7,7 +7,9 @@ module Pod
         self.arguments = [CLAide::Argument.new("OUTPUT-DIR", false)]
         def self.options
           [
-            ["--open", "Open the graph upon completion"]
+            ["--open", "Open the graph upon completion"],
+            ["--devpod_only", "Only include development pod"],
+            ["--max_deps", "Only include pod with number of dependencies <= max_deps"]
           ]
         end
 
@@ -17,7 +19,9 @@ module Pod
             config: prebuild_config,
             lockfile: config.lockfile,
             output_dir: argv.shift_argument || ".",
-            open: argv.flag?("open")
+            open: argv.flag?("open"),
+            devpod_only: argv.flag?("devpod_only"),
+            max_deps: argv.option("max_deps")
           )
         end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cocoapods-binary-cache
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.1.14
 platform: ruby
 authors:
 - Bang Nguyen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-10-23 00:00:00.000000000 Z
+date: 2021-04-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cocoapods
@@ -66,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.3.0
+- !ruby/object:Gem::Dependency
+  name: parallel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -186,7 +200,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Reduce build time by building pod frameworks and cache to remote storage,