cocoapods-binary-cache 0.1.6 → 0.1.11

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

@@ -1,12 +1,11 @@
 require "fileutils"
 require_relative "../prebuild_output/output"
 require_relative "../helper/lockfile"
-require_relative "helper/passer"
 require_relative "helper/target_checker"
 require_relative "helper/build"
 
 module Pod
-  class PrebuildInstaller < Installer
+  class PrebuildInstaller < Installer # rubocop:disable Metrics/ClassLength
     attr_reader :lockfile_wrapper
 
     def initialize(options)
@@ -15,124 +14,50 @@ module Pod
       @lockfile_wrapper = lockfile && PodPrebuild::Lockfile.new(lockfile)
     end
 
-    private
-
-    def local_manifest
-      @local_manifest ||= sandbox.manifest
-    end
-
-    # @return [Analyzer::SpecsState]
-    def prebuild_pods_changes
-      return nil if local_manifest.nil?
-
-      if @prebuild_pods_changes.nil?
-        changes = local_manifest.detect_changes_with_podfile(podfile)
-        @prebuild_pods_changes = Analyzer::SpecsState.new(changes)
-        # save the chagnes info for later stage
-        Pod::Prebuild::Passer.prebuild_pods_changes = @prebuild_pods_changes
-      end
-      @prebuild_pods_changes
-    end
-
-    def blacklisted?(name)
-      PodPrebuild::StateStore.excluded_pods.include?(name)
-    end
-
-    def cache_missed?(name)
-      @cache_validation.missed?(name)
-    end
-
-    def should_not_prebuild_vendor_pod(name)
-      return true if blacklisted?(name)
-      return false if Pod::Podfile::DSL.prebuild_all_pods?
-    end
-
     def run_code_gen!(targets)
-      return if Pod::Podfile::DSL.prebuild_code_gen.nil?
+      return if PodPrebuild.config.prebuild_code_gen.nil?
 
       Pod::UI.title("Running code generation...") do
-        Pod::Podfile::DSL.prebuild_code_gen.call(self, targets)
+        PodPrebuild.config.prebuild_code_gen.call(self, targets)
       end
     end
 
-    def targets_to_prebuild
-      existed_framework_folder = sandbox.generate_framework_path
-      targets = pod_targets
-
-      targets_from_cli = Pod::Podfile::DSL.targets_to_prebuild_from_cli
-      if !targets_from_cli.empty?
-        targets = targets.select { |target| targets_from_cli.include?(target.name) }
-      elsif !Pod::Podfile::DSL.prebuild_all_pods? && !local_manifest.nil?
-        changes = prebuild_pods_changes
-        added = changes.added
-        changed = changes.changed
-        unchanged = changes.unchanged
-
-        existed_framework_folder.mkdir unless existed_framework_folder.exist?
-        exsited_framework_pod_names = sandbox.exsited_framework_pod_names
-
-        # additions
-        missing = unchanged.reject { |pod_name| exsited_framework_pod_names.include?(pod_name) }
-
-        root_names_to_update = (added + changed + missing)
-        root_names_to_update += PodPrebuild::StateStore.cache_validation.missed
-
-        # transform names to targets
-        cache = []
-        targets = root_names_to_update.map do |pod_name|
-          tars = Pod.fast_get_targets_for_pod_name(pod_name, pod_targets, cache) || []
-          raise "There's no target named (#{pod_name}) in Pod.xcodeproj" if tars.empty?
-
-          tars
-        end.flatten
-
-        # add the dendencies
-        dependency_targets = targets.map(&:recursive_dependent_targets).flatten.uniq || []
-        targets = (targets + dependency_targets).uniq
-      end
-
-      unless Pod::Podfile::DSL.prebuild_all_pods?
-        targets = targets.select { |pod_target| cache_missed?(pod_target.name) }
-      end
-      targets = targets.reject { |pod_target| should_not_prebuild_vendor_pod(pod_target.name) }
-      unless Podfile::DSL.dev_pods_enabled?
-        targets = targets.reject { |pod_target| sandbox.local?(pod_target.pod_name) }
-      end
-      targets
-    end
-
-    public
-
     def prebuild_output
       @prebuild_output ||= PodPrebuild::Output.new(sandbox)
     end
 
-    # Build the needed framework files
+    def targets_to_prebuild
+      to_build = PodPrebuild.config.targets_to_prebuild_from_cli
+      if to_build.empty?
+        to_build = PodPrebuild.config.prebuild_all_pods? ? @cache_validation.all : @cache_validation.missed
+      end
+      pod_targets.select { |target| to_build.include?(target.name) }
+    end
+
     def prebuild_frameworks!
-      UI.puts "Start 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
 
-      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: Pod::Podfile::DSL.prebuild_config,
-          output_path: output_path,
-          bitcode_enabled: Pod::Podfile::DSL.bitcode_enabled?,
-          device_build_enabled: Pod::Podfile::DSL.device_build_enabled?,
-          disable_dsym: Pod::Podfile::DSL.disable_dsym?,
-          args: Pod::Podfile::DSL.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|
@@ -142,7 +67,6 @@ module Pod
         # If target shouldn't build, we copy all the original files
         # This is for target with only .a and .h files
         unless target.should_build?
-          Prebuild::Passer.target_names_to_skip_integration_framework << target.name
           FileUtils.cp_r(root_path, target_folder, :remove_destination => true)
           next
         end
@@ -173,12 +97,12 @@ module Pod
         all_needed_names.include? name
       end
       useless_target_names.each do |name|
-        UI.puts "Remove: #{name}"
+        Pod::UI.message "Remove: #{name}"
         path = sandbox.framework_folder_path_for_target_name(name)
         path.rmtree if path.exist?
       end
 
-      if Podfile::DSL.dont_remove_source_code?
+      if PodPrebuild.config.dont_remove_source_code?
         # just remove the tmp files
         path = sandbox.root + "Manifest.lock.tmp"
         path.rmtree if path.exist?
@@ -189,12 +113,10 @@ module Pod
         to_delete_files.each { |file| file.rmtree if file.exist? }
       end
 
-      updated_target_names = targets.map { |target| target.label.to_s }
-      deleted_target_names = useless_target_names
-      Pod::UI.puts "Targets to prebuild: #{updated_target_names}"
-      Pod::UI.puts "Targets to cleanup: #{deleted_target_names}"
-
-      prebuild_output.write_delta_file(updated_target_names, deleted_target_names)
+      prebuild_output.write_delta_file(
+        updated: targets.map { |target| target.label.to_s },
+        deleted: useless_target_names
+      )
     end
 
     def clean_delta_file
@@ -215,7 +137,7 @@ module Pod
       metadata.build_settings = pods_project.targets
         .detect { |native_target| native_target.name == target.name }
         .build_configurations
-        .detect { |config| config.name == Pod::Podfile::DSL.prebuild_config }
+        .detect { |config| config.name == PodPrebuild.config.prebuild_config }
         .build_settings
       metadata.source_hash = @lockfile_wrapper && @lockfile_wrapper.dev_pod_hash(target.name)
 

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

@@ -1,73 +1,9 @@
-require_relative "tool/tool"
-
 module Pod
   class Podfile
     module DSL
-      @binary_cache_config = {}
-      @binary_cache_cli_config = {}
       def config_cocoapods_binary_cache(options)
-        Pod::Podfile::DSL.binary_cache_config = options
-      end
-
-      class << self
-        attr_accessor :binary_cache_config
-        attr_accessor :binary_cache_cli_config
-
-        def prebuild_config
-          @binary_cache_config[:prebuild_config] || "Debug"
-        end
-
-        def prebuild_job?
-          @binary_cache_cli_config[:prebuild_job] || @binary_cache_config[:prebuild_job]
-        end
-
-        def prebuild_all_pods?
-          @binary_cache_cli_config[:prebuild_all_pods] || @binary_cache_config[:prebuild_all_pods]
-        end
-
-        def excluded_pods
-          @binary_cache_config[:excluded_pods] || Set.new
-        end
-
-        def dev_pods_enabled?
-          @binary_cache_config[:dev_pods_enabled]
-        end
-
-        def bitcode_enabled?
-          @binary_cache_config[:bitcode_enabled]
-        end
-
-        def device_build_enabled?
-          @binary_cache_config[:device_build_enabled]
-        end
-
-        def disable_dsym?
-          @binary_cache_config[:disable_dsym]
-        end
-
-        def dont_remove_source_code?
-          @binary_cache_config[:dont_remove_source_code]
-        end
-
-        def build_args
-          @binary_cache_config[:build_args]
-        end
-
-        def save_cache_validation_to
-          @binary_cache_config[:save_cache_validation_to]
-        end
-
-        def validate_prebuilt_settings
-          @binary_cache_config[:validate_prebuilt_settings]
-        end
-
-        def prebuild_code_gen
-          @binary_cache_config[:prebuild_code_gen]
-        end
-
-        def targets_to_prebuild_from_cli
-          @binary_cache_cli_config[:prebuild_targets] || []
-        end
+        PodPrebuild.config.dsl_config = options
+        PodPrebuild.config.validate_dsl_config
       end
     end
   end

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

@@ -1,4 +1,3 @@
-require_relative "helper/passer"
 require_relative "helper/podfile_options"
 require_relative "helper/prebuild_sandbox"
 

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

@@ -1,176 +1,196 @@
 require_relative "xcodebuild_raw"
 
-class XcodebuildCommand
-  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 device_build_enabled?
-      build_for_sdk(device)
-      create_universal_framework
-      merge_dsym unless disable_dsym?
-      merge_swift_headers
-      merge_swift_modules
+    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)
+        end
+      end
     end
-    collect_output(Dir[target_products_dir_of(simulator) + "/*"])
-  end
 
-  private
-
-  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
+    private
 
-  def build_for_sdk(sdk)
-    framework_path = framework_path_of(sdk)
-    if Dir.exist?(framework_path)
-      Pod::UI.puts "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 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
-    create_fat_binary(
-      simulator: "#{framework_path_of(simulator)}/#{module_name}",
-      device: "#{framework_path_of(device)}/#{module_name}"
-    )
-  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] += ["ONLY_ACTIVE_ARCH=NO"]
+      args_[:device] += args_[:default]
+      args_
+    end
 
-  def merge_dsym
-    simulator_dsym = framework_path_of(simulator) + ".dSYM"
-    device_dsym = framework_path_of(device) + ".dSYM"
-    return unless File.exist?(simulator_dsym) && File.exist?(device_dsym)
+    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
 
-    create_fat_binary(
-      simulator: "#{simulator_dsym}/Contents/Resources/DWARF/#{module_name}",
-      device: "#{device_dsym}/Contents/Resources/DWARF/#{module_name}"
-    )
-    collect_output(simulator_dsym)
-  end
+    def create_universal_framework(target)
+      merge_framework_binary(target)
+      merge_framework_dsym(target)
+      merge_swift_headers(target)
+      merge_swift_modules(target)
+    end
 
-  def create_fat_binary(options)
-    cmd = ["lipo", " -create"]
-    cmd << "-output" << options[:simulator]
-    cmd << options[:simulator] << options[:device]
-    Pod::UI.puts `#{cmd.join(" ")}`
-  end
+    def merge_framework_binary(target)
+      merge_contents(target, "/#{target.product_module_name}", &method(:create_fat_binary))
+    end
 
-  def merge_swift_headers
-    simulator_header_path = framework_path_of(simulator) + "/Headers/#{module_name}-Swift.h"
-    device_header_path = framework_path_of(device) + "/Headers/#{module_name}-Swift.h"
-    return unless File.exist?(simulator_header_path) && File.exist?(device_header_path)
-
-    merged_header = <<~HEREDOC
-      #if TARGET_OS_SIMULATOR // merged by cocoapods-binary
-      #{File.read(simulator_header_path)}
-      #else // merged by cocoapods-binary
-      #{File.read(device_header_path)}
-      #endif // merged by cocoapods-binary
-    HEREDOC
-    File.write(simulator_header_path, merged_header.strip)
-  end
+    def merge_framework_dsym(target)
+      merge_contents(
+        target,
+        ".dSYM/Contents/Resources/DWARF/#{target.product_module_name}",
+        &method(:create_fat_binary)
+      )
+    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 merge_swift_modules
-    simulator_swift_module_path = framework_path_of(simulator) + "/Modules/#{module_name}.swiftmodule"
-    device_swift_module_path = framework_path_of(device) + "/Modules/#{module_name}.swiftmodule"
-    return unless File.exist?(simulator_swift_module_path) && File.exist?(device_swift_module_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
 
-    FileUtils.cp_r(
-      device_swift_module_path + "/.",
-      simulator_swift_module_path
-    )
-  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 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.mv(path, output_path)
+      merger.call(simulator: simulator_, device: device_, output: output_)
     end
-  end
 
-  def target_products_dir_of(sdk)
-    "#{build_dir}/#{configuration}-#{sdk}/#{target.name}"
-  end
+    def create_fat_binary(options)
+      cmd = ["lipo", " -create"]
+      cmd << "-output" << options[:output]
+      cmd << options[:simulator] << options[:device]
+      `#{cmd.join(" ")}`
+    end
 
-  def framework_path_of(sdk)
-    "#{target_products_dir_of(sdk)}/#{module_name}.framework"
-  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 module_name
-    target.product_module_name
-  end
+    def target_products_dir_of(target, sdk)
+      "#{build_dir}/#{configuration}-#{sdk}/#{target.name}"
+    end
 
-  def sandbox
-    @options[:sandbox]
-  end
+    def framework_path_of(target, sdk)
+      "#{target_products_dir_of(target, sdk)}/#{target.product_module_name}.framework"
+    end
 
-  def build_dir
-    @options[:build_dir]
-  end
+    def sandbox
+      @options[:sandbox]
+    end
 
-  def output_path
-    @options[:output_path]
-  end
+    def build_dir
+      @options[:build_dir]
+    end
 
-  def target
-    @options[:target]
-  end
+    def output_path(target)
+      "#{@options[:output_path]}/#{target.label}"
+    end
 
-  def configuration
-    @options[:configuration]
-  end
+    def scheme
+      @options[:scheme]
+    end
 
-  def bitcode_enabled?
-    @options[:bitcode_enabled]
-  end
+    def targets
+      @options[:targets]
+    end
 
-  def device_build_enabled?
-    @options[:device_build_enabled]
-  end
+    def configuration
+      @options[:configuration]
+    end
 
-  def device
-    @options[:device] || "iphoneos"
-  end
+    def bitcode_enabled?
+      @options[:bitcode_enabled]
+    end
 
-  def simulator
-    @options[:simulator] || "iphonesimulator"
-  end
+    def device_build_enabled?
+      @options[:device_build_enabled]
+    end
+
+    def device
+      @options[:device] || "iphoneos"
+    end
 
-  def disable_dsym?
-    @options[:disable_dsym]
+    def simulator
+      @options[:simulator] || "iphonesimulator"
+    end
+
+    def disable_dsym?
+      @options[:disable_dsym]
+    end
   end
 end