cocoapods-binary-cache 0.1.8 → 0.1.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 939a85addd611d4a4bcd2b9ce1eeb7e036d58a937a14bdd4f772a6c8170e4394
-  data.tar.gz: 0372d8f94f6e486259669f4db5431585a08645c1a23ad363258581fc5f679eff
+  metadata.gz: 732c3a4179deba8a6f1ffe95e9035c12d80989a1b3edb0581a5d569f1b9ef542
+  data.tar.gz: c72c2d4333f1525d2078896374b2fbe239891dc404ca35dadffc2f22fc4b8aff
 SHA512:
-  metadata.gz: aa2bbc570dc6a1f462a85286578b8dc41a7ce189df2017177d083a70df9ac0d026c8ca8dea310eee2ae5b517b3418004045b8bcc782aa0440f755d8bab1dd0d4
-  data.tar.gz: c98e55ae66d034897db4969bf9c12b0386a69a5139bc78ada10298875c5a9487d499852bb77195ffca42f11b0d2ab97fad940348da90d21296f6f0d6952b64af
+  metadata.gz: 9ff71c26afc711721ce4360999a94b03a36fcd49f51ead77583c5ef4b07e86c7c841effcfdc023a4968d26d19d33f66ed9ea0891ce046584e9c4bd50e6afa375
+  data.tar.gz: 1c28065aefc4539864e5645d9d01c5b660c03a9df40ca72a05a07be80cba28c28906e11802ff4fcb676057628e4eb4f39a8eee72ec920a04d4acfc336589a9d2

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

@@ -1,7 +1,6 @@
 module Pod
   class Specification
     def empty_source_files?
-
       unless subspecs.empty?
         # return early if there are some files in subpec(s) but process the spec itself
         return false unless subspecs.all?(&:empty_source_files?)

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

@@ -5,7 +5,6 @@ module PodPrebuild
     end
 
     def run
-      edit_scheme_for_code_coverage if PodPrebuild::Env.prebuild_stage?
       diagnose if PodPrebuild::Env.integration_stage?
     end
 
@@ -20,15 +19,5 @@ module PodPrebuild
         ).run
       end
     end
-
-    def edit_scheme_for_code_coverage
-      return unless PodPrebuild.config.dev_pods_enabled?
-      return unless @installer_context.sandbox.instance_of?(Pod::PrebuildSandbox)
-
-      # Modify pods scheme to support code coverage
-      # If we don't prebuild dev pod -> no need to care about this in Pod project
-      # because we setup in the main project (ex. DriverCI scheme)
-      SchemeEditor.edit_to_support_code_coverage(@installer_context.sandbox)
-    end
   end
 end

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/main.rb

@@ -18,5 +18,4 @@ require_relative "pod-binary/prebuild_hook"
 require_relative "pod-binary/prebuild"
 require_relative "prebuild_output/metadata"
 require_relative "prebuild_output/output"
-require_relative "scheme_editor"
 require_relative "diagnosis/diagnosis"

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

@@ -1,40 +1,37 @@
 require_relative "../../pod-rome/xcodebuild_raw"
 require_relative "../../pod-rome/xcodebuild_command"
 
-module Pod
-  class Prebuild
-    def self.build(options)
-      target = options[:target]
-      return if target.nil?
+module PodPrebuild
+  def self.build(options)
+    targets = options[:targets] || []
+    return if targets.empty?
 
-      Pod::UI.puts "Building target: #{target}...".magenta
-      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 target.platform.name
-      when :ios, :tvos, :watchos
-        XcodebuildCommand.new(options).run
-      when :osx
-        xcodebuild(
-          sandbox: options[:sandbox],
-          target: target.label,
-          configuration: options[:configuration],
-          sdk: "macosx",
-          args: options[:args]
-        )
-      else
-        raise "Unsupported platform for '#{target.name}': '#{target.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

@@ -4,26 +4,43 @@ module Pod
       cache = []
       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

@@ -3,17 +3,31 @@ require_relative "../source_installer"
 module Pod
   class Installer
     # Override the download step to skip download and prepare file in target folder
-    define_method(:install_source_of_pod) do |pod_name|
-      pod_installer = create_pod_installer(pod_name)
-      # Injected code
-      # ------------------------------------------
-      if should_integrate_prebuilt_pod?(pod_name)
-        pod_installer.install_for_prebuild!(sandbox)
+    alias original_create_pod_installer create_pod_installer
+    def create_pod_installer(name)
+      if should_integrate_prebuilt_pod?(name)
+        create_prebuilt_source_installer(name)
       else
-        pod_installer.install!
+        create_normal_source_installer(name)
       end
-      # ------------------------------------------
-      @installed_specs.concat(pod_installer.specs_by_platform.values.flatten.uniq)
+    end
+
+    private
+
+    def create_normal_source_installer(name)
+      original_create_pod_installer(name)
+    end
+
+    def create_prebuilt_source_installer(name)
+      source_installer = PodSourceInstaller.new(sandbox, podfile, specs_for_pod(name))
+      pod_installer = PrebuiltSourceInstaller.new(
+        sandbox,
+        podfile,
+        specs_for_pod(name),
+        source_installer: source_installer
+      )
+      pod_installers << pod_installer
+      pod_installer
     end
 
     def should_integrate_prebuilt_pod?(name)

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

@@ -1,21 +1,27 @@
-# NOTE:
-# This file will only be loaded on normal pod install step
-# so there's no need to check is_prebuild_stage
-
-# Provide a special "download" process for prebuilded pods.
-#
-# As the frameworks is already exsited in local folder. We
-# just create a symlink to the original target folder.
-#
 module Pod
   class Installer
-    class PodSourceInstaller
-      def install_for_prebuild!(standard_sanbox)
-        return if !PodPrebuild.config.dev_pods_enabled? && standard_sanbox.local?(name)
+    class PrebuiltSourceInstaller < PodSourceInstaller
+      def initialize(*args, **kwargs)
+        @source_installer = kwargs.delete(:source_installer)
+        super(*args, **kwargs)
+      end
+
+      def prebuild_sandbox
+        @prebuild_sandbox ||= Pod::PrebuildSandbox.from_standard_sandbox(sandbox)
+      end
+
+      def install!
+        @source_installer.install!
+        install_prebuilt_framework!
+      end
+
+      private
+
+      def install_prebuilt_framework!
+        return if !PodPrebuild.config.dev_pods_enabled? && sandbox.local?(name)
 
         # make a symlink to target folder
         # TODO (bang): Unify to 1 sandbox to optimize and avoid inconsistency
-        prebuild_sandbox = Pod::PrebuildSandbox.from_standard_sandbox(standard_sanbox)
         # if spec used in multiple platforms, it may return multiple paths
         target_names = prebuild_sandbox.existed_target_names_for_pod_name(name)
         target_names.each do |name|
@@ -24,7 +30,7 @@ module Pod
           # If have only one platform, just place int the root folder of this pod.
           # If have multiple paths, we use a sperated folder to store different
           # platform frameworks. e.g. AFNetworking/AFNetworking-iOS/AFNetworking.framework
-          target_folder = standard_sanbox.pod_dir(self.name)
+          target_folder = sandbox.pod_dir(self.name)
           target_folder += real_file_folder.basename if target_names.count > 1
           target_folder += PodPrebuild.config.prebuilt_path
           target_folder.rmtree if target_folder.exist?
@@ -33,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
@@ -52,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
@@ -73,8 +86,6 @@ module Pod
         end
       end
 
-      private
-
       def walk(path, &action)
         return unless path.exist?
 

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

@@ -1,7 +1,6 @@
 require "fileutils"
 require_relative "../prebuild_output/output"
 require_relative "../helper/lockfile"
-require_relative "../helper/prebuild_order"
 require_relative "helper/target_checker"
 require_relative "helper/build"
 
@@ -15,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?
 
@@ -38,27 +44,27 @@ module Pod
     def prebuild_frameworks!
       existed_framework_folder = sandbox.generate_framework_path
       sandbox_path = sandbox.root
+      targets = targets_to_prebuild
+      Pod::UI.puts "Prebuild frameworks (total #{targets.count}): #{targets.map(&:name)}".magenta
 
-      targets = PodPrebuild::BuildOrder.order_targets(targets_to_prebuild)
-      Pod::UI.puts "Prebuild frameworks (total #{targets.count}): #{targets.map(&:name)}"
-      Pod::Prebuild.remove_build_dir(sandbox_path)
       run_code_gen!(targets)
+
+      PodPrebuild.remove_build_dir(sandbox_path)
+      PodPrebuild.build(
+        sandbox: sandbox_path,
+        targets: targets,
+        configuration: PodPrebuild.config.prebuild_config,
+        output_path: sandbox.generate_framework_path,
+        bitcode_enabled: PodPrebuild.config.bitcode_enabled?,
+        device_build_enabled: PodPrebuild.config.device_build_enabled?,
+        disable_dsym: PodPrebuild.config.disable_dsym?,
+        args: PodPrebuild.config.build_args
+      )
+      PodPrebuild.remove_build_dir(sandbox_path)
+
       targets.each do |target|
-        output_path = sandbox.framework_folder_path_for_target_name(target.name)
-        output_path.mkpath unless output_path.exist?
-        Pod::Prebuild.build(
-          sandbox: sandbox_path,
-          target: target,
-          configuration: PodPrebuild.config.prebuild_config,
-          output_path: output_path,
-          bitcode_enabled: PodPrebuild.config.bitcode_enabled?,
-          device_build_enabled: PodPrebuild.config.device_build_enabled?,
-          disable_dsym: PodPrebuild.config.disable_dsym?,
-          args: PodPrebuild.config.build_args
-        )
-        collect_metadata(target, output_path)
+        collect_metadata(target, sandbox.framework_folder_path_for_target_name(target.name))
       end
-      Pod::Prebuild.remove_build_dir(sandbox_path)
 
       # copy vendored libraries and frameworks
       targets.each do |target|

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

@@ -1,192 +1,252 @@
 require_relative "xcodebuild_raw"
 
-class XcodebuildCommand # rubocop:disable Metrics/ClassLength
-  def initialize(options)
-    @options = options
-    case options[:target].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)
+    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
 
-    case build_types
-    when [:simulator]
-      collect_output(Dir[target_products_dir_of(simulator) + "/*"])
-    when [:device]
-      collect_output(Dir[target_products_dir_of(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(Dir[target_products_dir_of(device) + "/*"])
-      create_universal_framework
+    private
+
+    def sdks
+      @sdks ||= begin
+        sdks_ = []
+        sdks_ << simulator if build_types.include?(:simulator)
+        sdks_ << device if build_types.include?(:device)
+        sdks_
+      end
     end
-  end
 
-  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
+      end
+    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
+    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
-  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 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,
+        args: sdk == simulator ? @build_args[:simulator] : @build_args[:device]
+      )
+    end
 
-  def build_for_sdk(sdk)
-    framework_path = framework_path_of(sdk)
-    if Dir.exist?(framework_path)
-      Pod::UI.puts_indented "--> Framework already exists at: #{framework_path}"
-      return
-    end
-
-    succeeded, = xcodebuild(
-      sandbox: sandbox,
-      target: target.label,
-      configuration: configuration,
-      sdk: sdk,
-      deployment_target: target.platform.deployment_target.to_s,
-      args: sdk == simulator ? @build_args[:simulator] : @build_args[:device]
-    )
-    raise "Build framework failed: #{target.label}" unless succeeded
-  end
+    def create_xcframework(target)
+      non_framework_paths = Dir[target_products_dir_of(target, sdks[0]) + "/*"] \
+        - [framework_path_of(target, sdks[0])] \
+        - dsym_paths_of(target, sdks[0]) \
+        - bcsymbolmap_paths_of(target, sdks[0])
+      collect_output(target, non_framework_paths)
 
-  def create_universal_framework
-    merge_framework_binary
-    merge_framework_dsym
-    merge_swift_headers
-    merge_swift_modules
-  end
+      output = "#{output_path(target)}/#{target.product_module_name}.xcframework"
+      FileUtils.rm_rf(output)
 
-  def merge_framework_binary
-    merge_contents("/#{module_name}", &method(:create_fat_binary))
-  end
+      cmd = ["xcodebuild", "-create-xcframework", "-allow-internal-distribution"]
 
-  def merge_framework_dsym
-    merge_contents(".dSYM/Contents/Resources/DWARF/#{module_name}", &method(:create_fat_binary))
-  end
+      # 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
 
-  def merge_swift_headers
-    merge_contents("/Headers/#{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)
+      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
-    merge_contents("/Modules/#{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(path_suffix, &merger)
-    simulator_, device_, output_ = [
-      framework_path_of(simulator),
-      framework_path_of(device),
-      "#{output_path}/#{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]
-    Pod::UI.puts `#{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(paths)
-    paths = [paths] unless paths.is_a?(Array)
-    paths.each do |path|
-      FileUtils.rm_rf(File.join(output_path, File.basename(path)))
-      FileUtils.cp_r(path, output_path)
+    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(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(sdk)
-    "#{target_products_dir_of(sdk)}/#{module_name}.framework"
-  end
+      merger.call(simulator: simulator_, device: device_, output: output_)
+    end
 
-  def module_name
-    target.product_module_name
-  end
+    def create_fat_binary(options)
+      cmd = ["lipo", " -create"]
+      cmd << "-output" << options[:output]
+      cmd << options[:simulator] << options[:device]
+      `#{cmd.join(" ")}`
+    end
 
-  def sandbox
-    @options[:sandbox]
-  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 build_dir
-    @options[:build_dir]
-  end
+    def target_products_dir_of(target, sdk)
+      "#{build_dir}/#{configuration}-#{sdk}/#{target.name}"
+    end
 
-  def output_path
-    @options[:output_path]
-  end
+    def framework_path_of(target, sdk)
+      "#{target_products_dir_of(target, sdk)}/#{target.product_module_name}.framework"
+    end
 
-  def target
-    @options[:target]
-  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 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]
+    def disable_dsym?
+      @options[:disable_dsym]
+    end
   end
 end