cocoapods-binary-cache 0.1.7 → 0.1.12

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

@@ -1,5 +1,3 @@
-require_relative "tool/tool"
-
 module Pod
   class Podfile
     module DSL

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,252 @@
 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
+      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
-    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 sdks
+      @sdks ||= begin
+        sdks_ = []
+        sdks_ << simulator if build_types.include?(:simulator)
+        sdks_ << device if build_types.include?(:device)
+        sdks_
+      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 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 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 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
 
-    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 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_fat_binary(options)
-    cmd = ["lipo", " -create"]
-    cmd << "-output" << options[:simulator]
-    cmd << options[:simulator] << options[:device]
-    Pod::UI.puts `#{cmd.join(" ")}`
-  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 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
+      output = "#{output_path(target)}/#{target.product_module_name}.xcframework"
+      FileUtils.rm_rf(output)
 
-  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)
+      cmd = ["xcodebuild", "-create-xcframework", "-allow-internal-distribution"]
 
-    FileUtils.cp_r(
-      device_swift_module_path + "/.",
-      simulator_swift_module_path
-    )
-  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
+
+      cmd << "-output" << output
 
-  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)
+      Pod::UI.puts "- Create xcframework: #{target}".magenta
+      Pod::UI.puts_indented "$ #{cmd.join(' ')}" unless PodPrebuild.config.silent_build?
+
+      `#{cmd.join(" ")}`
     end
-  end
 
-  def target_products_dir_of(sdk)
-    "#{build_dir}/#{configuration}-#{sdk}/#{target.name}"
-  end
+    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) + "/*"])
 
-  def framework_path_of(sdk)
-    "#{target_products_dir_of(sdk)}/#{module_name}.framework"
-  end
+      merge_framework_binary(target)
+      merge_framework_dsym(target)
+      merge_swift_headers(target)
+      merge_swift_modules(target)
+    end
 
-  def module_name
-    target.product_module_name
-  end
+    def merge_framework_binary(target)
+      merge_contents(target, "/#{target.product_module_name}", &method(:create_fat_binary))
+    end
 
-  def sandbox
-    @options[:sandbox]
-  end
+    def merge_framework_dsym(target)
+      merge_contents(
+        target,
+        ".dSYM/Contents/Resources/DWARF/#{target.product_module_name}",
+        &method(:create_fat_binary)
+      )
+    end
 
-  def build_dir
-    @options[:build_dir]
-  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 output_path
-    @options[:output_path]
-  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 target
-    @options[:target]
-  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 configuration
-    @options[:configuration]
-  end
+      merger.call(simulator: simulator_, device: device_, output: output_)
+    end
 
-  def bitcode_enabled?
-    @options[:bitcode_enabled]
-  end
+    def create_fat_binary(options)
+      cmd = ["lipo", " -create"]
+      cmd << "-output" << options[:output]
+      cmd << options[:simulator] << options[:device]
+      `#{cmd.join(" ")}`
+    end
 
-  def device_build_enabled?
-    @options[:device_build_enabled]
-  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 device
-    @options[:device] || "iphoneos"
-  end
+    def target_products_dir_of(target, sdk)
+      "#{build_dir}/#{configuration}-#{sdk}/#{target.name}"
+    end
 
-  def simulator
-    @options[:simulator] || "iphonesimulator"
-  end
+    def framework_path_of(target, sdk)
+      "#{target_products_dir_of(target, sdk)}/#{target.product_module_name}.framework"
+    end
 
-  def disable_dsym?
-    @options[:disable_dsym]
+    def dsym_paths_of(target, sdk)
+      Dir["#{target_products_dir_of(target, sdk)}/*.dSYM"]
+    end
+
+    def bcsymbolmap_paths_of(target, sdk)
+      Dir["#{target_products_dir_of(target, sdk)}/*.bcsymbolmap"]
+    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

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

@@ -1,43 +1,56 @@
 require "fourflusher"
 
-PLATFORM_OF_SDK = {
-  "iphonesimulator" => "iOS",
-  "appletvsimulator" => "tvOS",
-  "watchsimulator" => "watchOS"
-}.freeze
+module PodPrebuild
+  class XcodebuildCommand
+    PLATFORM_OF_SDK = {
+      "iphonesimulator" => "iOS",
+      "appletvsimulator" => "tvOS",
+      "watchsimulator" => "watchOS"
+    }.freeze
 
-def xcodebuild(options)
-  sdk = options[:sdk] || "iphonesimulator"
-  platform = PLATFORM_OF_SDK[sdk]
+    DESTINATION_OF_SDK = {
+      "iphoneos" => "\"generic/platform=iOS\"",
+      "iphonesimulator" => "\"generic/platform=iOS Simulator\""
+    }.freeze
 
-  cmd = ["xcodebuild"]
-  cmd << "-project" << options[:sandbox].project_path.realdirpath
-  cmd << "-scheme" << options[: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 << "2>&1"
-  cmd = cmd.join(" ")
+    def self.xcodebuild(options)
+      sdk = options[:sdk] || "iphonesimulator"
+      targets = options[:targets] || [options[:target]]
+      platform = PLATFORM_OF_SDK[sdk]
 
-  puts "xcodebuild command: #{cmd}"
-  log = `#{cmd}`
+      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
+        cmd << Fourflusher::SimControl.new.destination(:oldest, platform, options[:deployment_target]) unless platform.nil?
+      end
+      cmd += options[:args] if options[:args]
+      cmd << "build"
+      cmd << "2>&1"
+      cmd = cmd.join(" ")
+
+      Pod::UI.puts_indented "$ #{cmd}" unless PodPrebuild.config.silent_build?
 
-  succeeded = $?.exitstatus.zero?
-  unless succeeded
-    begin
-      raise "Unexpected error" unless log.include?("** BUILD FAILED **")
+      log = `#{cmd}`
+      return if $?.exitstatus.zero? # rubocop:disable Style/SpecialGlobalVars
 
-      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)
+      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
-    rescue
-      puts log.red
     end
   end
-  [succeeded, log]
 end