cocoapods-binary-cache 0.1.5 → 0.1.10

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

@@ -1,135 +1,63 @@
 require "fileutils"
-require_relative "../pod-rome/build_framework"
 require_relative "../prebuild_output/output"
-require_relative "helper/passer"
-require_relative "helper/target_checker"
 require_relative "../helper/lockfile"
+require_relative "helper/target_checker"
+require_relative "helper/build"
 
-# patch prebuild ability
 module Pod
-  class PrebuildInstaller < Installer
+  class PrebuildInstaller < Installer # rubocop:disable Metrics/ClassLength
+    attr_reader :lockfile_wrapper
+
     def initialize(options)
       super(options[:sandbox], options[:podfile], options[:lockfile])
       @cache_validation = options[:cache_validation]
-      @lockfile_wrapper = PodPrebuild::Lockfile.new(lockfile)
-    end
-
-    private
-
-    def local_manifest
-      @local_manifest ||= sandbox.manifest
+      @lockfile_wrapper = lockfile && PodPrebuild::Lockfile.new(lockfile)
     end
 
-    # @return [Analyzer::SpecsState]
-    def prebuild_pods_changes
-      return nil if local_manifest.nil?
+    def run_code_gen!(targets)
+      return if PodPrebuild.config.prebuild_code_gen.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
+      Pod::UI.title("Running code generation...") do
+        PodPrebuild.config.prebuild_code_gen.call(self, targets)
       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_vendor_pods
-    end
-
-    public
-
     def prebuild_output
       @prebuild_output ||= PodPrebuild::Output.new(sandbox)
     end
 
-    # Build the needed framework files
-    def prebuild_frameworks!
-      UI.puts "Start prebuild_frameworks"
-
-      # build options
-      sandbox_path = sandbox.root
-      existed_framework_folder = sandbox.generate_framework_path
-      bitcode_enabled = Pod::Podfile::DSL.bitcode_enabled
-      targets = []
-
-      if Pod::Podfile::DSL.prebuild_all_vendor_pods
-        UI.puts "Rebuild all vendor frameworks"
-        targets = pod_targets
-      elsif !local_manifest.nil?
-        UI.puts "Update some frameworks"
-        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
-      else
-        UI.puts "Rebuild all frameworks"
-        targets = pod_targets
+    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
 
-      unless Pod::Podfile::DSL.prebuild_all_vendor_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) }
-      targets = targets.reject { |pod_target| sandbox.local?(pod_target.pod_name) } unless Podfile::DSL.dev_pods_enabled
-
-      # build!
-      Pod::UI.puts "Prebuild frameworks (total #{targets.count})"
-      Pod::UI.puts targets.map(&:name)
+    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
+
+      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)
 
-      Pod::Prebuild.remove_build_dir(sandbox_path)
       targets.each do |target|
-        unless target.should_build?
-          Pod::UI.puts "Skip prebuilding #{target.label} because of no source files".yellow
-          next
-        end
-
-        output_path = sandbox.framework_folder_path_for_target_name(target.name)
-        output_path.mkpath unless output_path.exist?
-        Pod::Prebuild.build(
-          sandbox_root_path: sandbox_path,
-          target: target,
-          configuration: Pod::Podfile::DSL.prebuild_config,
-          output_path: output_path,
-          bitcode_enabled: bitcode_enabled,
-          device_build_enabled: Pod::Podfile::DSL.device_build_enabled,
-          custom_build_options: Pod::Podfile::DSL.custom_device_build_options,
-          custom_build_options_simulator: Pod::Podfile::DSL.custom_simulator_build_options
-        )
-        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|
@@ -139,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
@@ -170,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?
@@ -186,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
@@ -212,10 +137,9 @@ 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
-      hash = @lockfile_wrapper.dev_pod_hash(target.name)
-      metadata.source_hash = hash unless hash.nil?
+      metadata.source_hash = @lockfile_wrapper && @lockfile_wrapper.dev_pod_hash(target.name)
 
       # Store root path for code-coverage support later
       # TODO: update driver code-coverage logic to use path stored here

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

@@ -1,70 +1,9 @@
-require_relative "tool/tool"
-
 module Pod
   class Podfile
     module DSL
       def config_cocoapods_binary_cache(options)
-        apply_config = lambda do |config|
-          DSL.send("#{config}=", options[config]) unless options[config].nil?
-        end
-
-        apply_config.call(:prebuild_config)
-        apply_config.call(:prebuild_all) # TODO (thuyen): Revise this option
-        apply_config.call(:prebuild_all_vendor_pods)
-        apply_config.call(:excluded_pods)
-        apply_config.call(:dev_pods_enabled)
-        apply_config.call(:bitcode_enabled)
-        apply_config.call(:device_build_enabled)
-        apply_config.call(:dont_remove_source_code)
-        apply_config.call(:custom_device_build_options)
-        apply_config.call(:custom_simulator_build_options)
-        apply_config.call(:save_cache_validation_to)
-        apply_config.call(:validate_prebuilt_settings)
-      end
-
-      @prebuild_config = "Debug"
-      @prebuild_job = false
-      @prebuild_all = false
-      @prebuild_all_vendor_pods = false
-      @excluded_pods = Set.new
-      @dev_pods_enabled = false
-      @bitcode_enabled = false
-      @device_build_enabled = false
-      @dont_remove_source_code = false
-      @custom_device_build_options = []
-      @custom_simulator_build_options = []
-      @save_cache_validation_to = nil
-      # A proc to validate the provided build settings (per target) with the build settings of the prebuilt frameworks
-      # For example, in Podfile:
-      # -----------------------------------------------
-      #   validate_prebuilt_settings do |target|
-      #     settings = {}
-      #     settings["MACH_O_TYPE"] == "staticlib"
-      #     settings["SWIFT_VERSION"] == swift_version_of(target)
-      #     settings
-      #   end
-      # -----------------------------------------------
-      @validate_prebuilt_settings = nil
-
-      class << self
-        attr_accessor :prebuild_config
-        attr_accessor :prebuild_job
-        attr_accessor :prebuild_all
-        attr_accessor :prebuild_all_vendor_pods
-        attr_accessor :excluded_pods
-        attr_accessor :dev_pods_enabled
-        attr_accessor :bitcode_enabled
-        attr_accessor :device_build_enabled
-        attr_accessor :dont_remove_source_code
-        attr_accessor :custom_device_build_options
-        attr_accessor :custom_simulator_build_options
-        attr_accessor :save_cache_validation_to
-        attr_accessor :validate_prebuilt_settings
-
-        alias prebuild_job? prebuild_job
-        alias prebuild_all? prebuild_all
-        alias prebuild_all_vendor_pods? prebuild_all_vendor_pods
-        alias dev_pods_enabled? dev_pods_enabled
+        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

@@ -0,0 +1,195 @@
+require_relative "xcodebuild_raw"
+
+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)
+        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 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 create_universal_framework(target)
+      merge_framework_binary(target)
+      merge_framework_dsym(target)
+      merge_swift_headers(target)
+      merge_swift_modules(target)
+    end
+
+    def merge_framework_binary(target)
+      merge_contents(target, "/#{target.product_module_name}", &method(:create_fat_binary))
+    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(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
+
+    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_)
+
+      merger.call(simulator: simulator_, device: device_, output: output_)
+    end
+
+    def create_fat_binary(options)
+      cmd = ["lipo", " -create"]
+      cmd << "-output" << options[:output]
+      cmd << options[:simulator] << options[:device]
+      `#{cmd.join(" ")}`
+    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 target_products_dir_of(target, sdk)
+      "#{build_dir}/#{configuration}-#{sdk}/#{target.name}"
+    end
+
+    def framework_path_of(target, sdk)
+      "#{target_products_dir_of(target, sdk)}/#{target.product_module_name}.framework"
+    end
+
+    def sandbox
+      @options[:sandbox]
+    end
+
+    def build_dir
+      @options[:build_dir]
+    end
+
+    def output_path(target)
+      "#{@options[:output_path]}/#{target.label}"
+    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]
+    end
+  end
+end