cocoapods-hd 0.0.7 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fb80241605ac54c86b3a1770e0cd87fa7d63a5e7e84040301d55199f4190bf5b
-  data.tar.gz: 85f2e7154ef052f35bd40655d6861f0102958bab7bb1c2235e2582bcfcc6f563
+  metadata.gz: 7e8b9d1f1fd6f4b04751faac0ac3a6ed4ea5d819095007d4a5cb955bdfce7bb2
+  data.tar.gz: 85d409df189fed53fe5cb0cc92d8198928360a27b9ead0f2f573d45d5ecd8476
 SHA512:
-  metadata.gz: a5f23b369a48b02bb6b8ef60b02860bfe5f589aa260f75d1647e1e16f38efc69a700286b3d30e41f55c8e943333e908d4b019a0dbb5ba61efd581603263bc362
-  data.tar.gz: 2c5ffa3f1739c93f7b459a4732493ae6da54ea90a3458ce89a06dae219475d25f0c039bf8adf83b86f7a6ae1bacb90e82f942f02caeedff50e039f87676bb9f1
+  metadata.gz: 2605374c2c6c36cadb810b316a34dcd02976f5eb045430ff6fc00d074d1e9f462291d771698d3dd5661c3972f7b57912dc53f0607dc8834d3380c6d350b04f0b
+  data.tar.gz: 8dfaefcd7a30dfec524fac14bee7bb4612ffdf67e1e3e2f4644b77dfdd97810539a366839135a5bec1f97ab2a05eea4c6e92dd2b6a4a7a9e4d1a2e2e5959e9f0

data/lib/cocoapods-hd/Integration.rb

@@ -0,0 +1,283 @@
+require_relative 'helper/podfile_options'
+require_relative 'helper/feature_switches'
+require_relative 'helper/prebuild_sandbox'
+require_relative 'helper/passer'
+require_relative 'helper/names'
+require_relative 'helper/target_checker'
+
+# 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 standard_sanbox.local? self.name
+
+        # make a symlink to target folder
+        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(self.name)
+
+        def walk(path, &action)
+          return unless path.exist?
+          path.children.each do |child|
+            result = action.call(child, &action)
+            if child.directory?
+              walk(child, &action) if result
+            end
+          end
+        end
+
+        def make_link(source, target)
+          source = Pathname.new(source)
+          target = Pathname.new(target)
+          target.parent.mkpath unless target.parent.exist?
+          relative_source = source.relative_path_from(target.parent)
+          FileUtils.ln_sf(relative_source, target)
+        end
+
+        def mirror_with_symlink(source, basefolder, target_folder)
+          target = target_folder + source.relative_path_from(basefolder)
+          make_link(source, target)
+        end
+
+        target_names.each do |name|
+
+          # symbol link copy all substructure
+          real_file_folder = prebuild_sandbox.framework_folder_path_for_target_name(name)
+
+          # 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)
+          if target_names.count > 1
+            target_folder += real_file_folder.basename
+          end
+          target_folder.rmtree if target_folder.exist?
+          target_folder.mkpath
+
+          walk(real_file_folder) do |child|
+            source = child
+            # only make symlink to file and `.framework` folder
+            if child.directory? and [".framework", ".dSYM"].include? child.extname
+              mirror_with_symlink(source, real_file_folder, target_folder)
+              next false # return false means don't go deeper
+            elsif child.file?
+              mirror_with_symlink(source, real_file_folder, target_folder)
+              next true
+            else
+              next true
+            end
+          end
+
+          # symbol link copy resource for static framework
+          hash = Prebuild::Passer.resources_to_copy_for_static_framework || {}
+
+          path_objects = hash[name]
+          if path_objects != nil
+            path_objects.each do |object|
+              make_link(object.real_file_path, object.target_file_path)
+            end
+          end
+        end # of for each
+
+      end
+
+      # of method
+
+    end
+  end
+end
+
+# Let cocoapods use the prebuild framework files in install process.
+#
+# the code only effect the second pod install process.
+#
+module Pod
+  class Installer
+
+    # Remove the old target files if prebuild frameworks changed
+    # def remove_target_files_if_needed
+    #
+    #     changes = Pod::Prebuild::Passer.prebuild_pods_changes
+    #     updated_names = []
+    #     if changes == nil
+    #         updated_names = PrebuildSandbox.from_standard_sandbox(self.sandbox).exsited_framework_pod_names
+    #     else
+    #         added = changes.added
+    #         changed = changes.changed
+    #         deleted = changes.deleted
+    #         updated_names = added + changed + deleted
+    #     end
+    #
+    #     updated_names.each do |name|
+    #         root_name = Specification.root_name(name)
+    #         next if self.sandbox.local?(root_name)
+    #
+    #         # delete the cached files
+    #         target_path = self.sandbox.pod_dir(root_name)
+    #         target_path.rmtree if target_path.exist?
+    #
+    #         support_path = sandbox.target_support_files_dir(root_name)
+    #         support_path.rmtree if support_path.exist?
+    #     end
+    #
+    # end
+
+    # Modify specification to use only the prebuild framework after analyzing
+    old_method2 = instance_method(:resolve_dependencies)
+    define_method(:resolve_dependencies) do
+
+      # Remove the old target files, else it will not notice file changes
+      # self.remove_target_files_if_needed
+
+      # call original
+      old_method2.bind(self).()
+      # ...
+      # ...
+      # ...
+      # after finishing the very complex orginal function
+
+      # check the pods
+      # Although we have did it in prebuild stage, it's not sufficient.
+      # Same pod may appear in another target in form of source code.
+      # Prebuild.check_one_pod_should_have_only_one_target(self.prebuild_pod_targets)
+      # self.validate_every_pod_only_have_one_form
+      #
+      #
+      # # prepare
+      # cache = []
+      #
+      # def add_vendered_framework(spec, platform, added_framework_file_path)
+      #     if spec.attributes_hash[platform] == nil
+      #         spec.attributes_hash[platform] = {}
+      #     end
+      #     vendored_frameworks = spec.attributes_hash[platform]["vendored_frameworks"] || []
+      #     vendored_frameworks = [vendored_frameworks] if vendored_frameworks.kind_of?(String)
+      #     vendored_frameworks += [added_framework_file_path]
+      #     spec.attributes_hash[platform]["vendored_frameworks"] = vendored_frameworks
+      # end
+      # def empty_source_files(spec)
+      #     spec.attributes_hash["source_files"] = []
+      #     ["ios", "watchos", "tvos", "osx"].each do |plat|
+      #         if spec.attributes_hash[plat] != nil
+      #             spec.attributes_hash[plat]["source_files"] = []
+      #         end
+      #     end
+      # end
+      #
+      #
+      # specs = self.analysis_result.specifications
+      # prebuilt_specs = (specs.select do |spec|
+      #     self.prebuild_pod_names.include? spec.root.name
+      # end)
+      #
+      # prebuilt_specs.each do |spec|
+      #
+      #     # Use the prebuild framworks as vendered frameworks
+      #     # get_corresponding_targets
+      #     targets = Pod.fast_get_targets_for_pod_name(spec.root.name, self.pod_targets, cache)
+      #     targets.each do |target|
+      #         # the framework_file_path rule is decided when `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
+      #         add_vendered_framework(spec, target.platform.name.to_s, framework_file_path)
+      #     end
+      #     # Clean the source files
+      #     # we just add the prebuilt framework to specific platform and set no source files
+      #     # for all platform, so it doesn't support the sence that 'a pod perbuild for one
+      #     # platform and not for another platform.'
+      #     empty_source_files(spec)
+      #
+      #     # to remove the resurce bundle target.
+      #     # When specify the "resource_bundles" in podspec, xcode will generate a bundle
+      #     # target after pod install. But the bundle have already built when the prebuit
+      #     # phase and saved in the framework folder. We will treat it as a normal resource
+      #     # file.
+      #     # https://github.com/leavez/cocoapods-binary/issues/29
+      #     if spec.attributes_hash["resource_bundles"]
+      #         bundle_names = spec.attributes_hash["resource_bundles"].keys
+      #         spec.attributes_hash["resource_bundles"] = nil
+      #         spec.attributes_hash["resources"] ||= []
+      #         spec.attributes_hash["resources"] += bundle_names.map{|n| n+".bundle"}
+      #     end
+      #
+      #     # to avoid the warning of missing license
+      #     spec.attributes_hash["license"] = {}
+      #
+      # end
+
+    end
+
+    # Override the download step to skip download and prepare file in target folder
+    old_method = instance_method(:install_source_of_pod)
+    define_method(:install_source_of_pod) do |pod_name|
+
+      # copy from original
+      pod_installer = create_pod_installer(pod_name)
+      # \copy from original
+
+      # if self.prebuild_pod_names.include? pod_name
+      #     pod_installer.install_for_prebuild!(self.sandbox)
+      # else
+      pod_installer.install!
+      # end
+
+      # copy from original
+      @installed_specs.concat(pod_installer.specs_by_platform.values.flatten.uniq)
+      # \copy from original
+    end
+
+  end
+end
+
+# A fix in embeded frameworks script.
+#
+# The framework file in pod target folder is a symblink. The EmbedFrameworksScript use `readlink`
+# to read the read path. As the symlink is a relative symlink, readlink cannot handle it well. So 
+# we override the `readlink` to a fixed version.
+#
+module Pod
+  module Generator
+    class EmbedFrameworksScript
+
+      old_method = instance_method(:script)
+      define_method(:script) do
+
+        script = old_method.bind(self).()
+        patch = <<-SH.strip_heredoc
+                    #!/bin/sh
+                
+                    # ---- this is added by cocoapods-binary ---
+                    # Readlink cannot handle relative symlink well, so we override it to a new one
+                    # If the path isn't an absolute path, we add a realtive prefix.
+                    old_read_link=`which readlink`
+                    readlink () {
+                        path=`$old_read_link "$1"`;
+                        if [ $(echo "$path" | cut -c 1-1) = '/' ]; then
+                            echo $path;
+                        else
+                            echo "`dirname $1`/$path";
+                        fi
+                    }
+                    # --- 
+        SH
+
+        # patch the rsync for copy dSYM symlink
+        script = script.gsub "rsync --delete", "rsync --copy-links --delete"
+
+        patch + script
+      end
+    end
+  end
+end

data/lib/cocoapods-hd/build/build_framework.rb

@@ -0,0 +1,205 @@
+require 'fourflusher'
+require 'xcpretty'
+
+CONFIGURATION = "Release"
+PLATFORMS = { 'iphonesimulator' => 'iOS',
+              'appletvsimulator' => 'tvOS',
+              'watchsimulator' => 'watchOS' }
+
+#  Build specific target to framework file
+#  @param [PodTarget] target
+#         a specific pod target
+#
+def build_for_iosish_platform(sandbox,
+                              build_dir,
+                              output_path,
+                              target,
+                              device,
+                              simulator,
+                              bitcode_enabled,
+                              custom_build_options = [], # Array<String>
+                              custom_build_options_simulator = [] # Array<String>
+)
+
+  deployment_target = target.platform.deployment_target.to_s
+
+  target_label = target.label # name with platform if it's used in multiple platforms
+  Pod::UI.puts "Prebuilding-------- #{target_label}..."
+
+  other_options = []
+  # bitcode enabled
+  other_options += ['BITCODE_GENERATION_MODE=bitcode'] if bitcode_enabled
+  # make less arch to iphone simulator for faster build
+  custom_build_options_simulator += ['ARCHS=x86_64', 'ONLY_ACTIVE_ARCH=NO'] if simulator == 'iphonesimulator'
+
+  is_succeed, _ = xcodebuild(sandbox, target_label, device, deployment_target, other_options + custom_build_options)
+  exit 1 unless is_succeed
+  is_succeed, _ = xcodebuild(sandbox, target_label, simulator, deployment_target, other_options + custom_build_options_simulator)
+  exit 1 unless is_succeed
+
+  # paths
+  target_name = target.name # equals target.label, like "AFNeworking-iOS" when AFNetworking is used in multiple platforms.
+  module_name = target.product_module_name
+  device_framework_path = "#{build_dir}/#{CONFIGURATION}-#{device}/#{target_name}/#{module_name}.framework"
+  simulator_framework_path = "#{build_dir}/#{CONFIGURATION}-#{simulator}/#{target_name}/#{module_name}.framework"
+
+  device_binary = device_framework_path + "/#{module_name}"
+  simulator_binary = simulator_framework_path + "/#{module_name}"
+  return unless File.file?(device_binary) && File.file?(simulator_binary)
+
+  # the device_lib path is the final output file path
+  # combine the binaries
+  tmp_lipoed_binary_path = "#{build_dir}/#{target_name}"
+  lipo_log = `lipo -create -output #{tmp_lipoed_binary_path} #{device_binary} #{simulator_binary}`
+  puts lipo_log unless File.exist?(tmp_lipoed_binary_path)
+  FileUtils.mv tmp_lipoed_binary_path, device_binary, :force => true
+
+  # collect the swiftmodule file for various archs.
+  device_swiftmodule_path = device_framework_path + "/Modules/#{module_name}.swiftmodule"
+  simulator_swiftmodule_path = simulator_framework_path + "/Modules/#{module_name}.swiftmodule"
+  if File.exist?(device_swiftmodule_path)
+    FileUtils.cp_r simulator_swiftmodule_path + "/.", device_swiftmodule_path
+  end
+
+  # combine the generated swift headers
+  # (In xcode 10.2, the generated swift headers vary for each archs)
+  # https://github.com/leavez/cocoapods-binary/issues/58
+  simulator_generated_swift_header_path = simulator_framework_path + "/Headers/#{module_name}-Swift.h"
+  device_generated_swift_header_path = device_framework_path + "/Headers/#{module_name}-Swift.h"
+  if File.exist? simulator_generated_swift_header_path
+    device_header = File.read(device_generated_swift_header_path)
+    simulator_header = File.read(simulator_generated_swift_header_path)
+    # https://github.com/Carthage/Carthage/issues/2718#issuecomment-473870461
+    combined_header_content = %Q{
+#if TARGET_OS_SIMULATOR // merged by cocoapods-binary
+
+#{simulator_header}
+
+#else // merged by cocoapods-binary
+
+#{device_header}
+
+#endif // merged by cocoapods-binary
+}
+    File.write(device_generated_swift_header_path, combined_header_content.strip)
+  end
+
+  # handle the dSYM files
+  device_dsym = "#{device_framework_path}.dSYM"
+  if File.exist? device_dsym
+    # lipo the simulator dsym
+    simulator_dsym = "#{simulator_framework_path}.dSYM"
+    if File.exist? simulator_dsym
+      tmp_lipoed_binary_path = "#{output_path}/#{module_name}.draft"
+      lipo_log = `lipo -create -output #{tmp_lipoed_binary_path} #{device_dsym}/Contents/Resources/DWARF/#{module_name} #{simulator_dsym}/Contents/Resources/DWARF/#{module_name}`
+      puts lipo_log unless File.exist?(tmp_lipoed_binary_path)
+      FileUtils.mv tmp_lipoed_binary_path, "#{device_framework_path}.dSYM/Contents/Resources/DWARF/#{module_name}", :force => true
+    end
+    # move
+    FileUtils.mv device_dsym, output_path, :force => true
+  end
+
+  # output
+  output_path.mkpath unless output_path.exist?
+  FileUtils.mv device_framework_path, output_path, :force => true
+
+end
+
+def xcodebuild(sandbox, target, sdk = 'macosx', deployment_target = nil, other_options = [])
+  args = %W(-project #{sandbox.project_path.realdirpath} -scheme #{target} -configuration #{CONFIGURATION} -sdk #{sdk} )
+  platform = PLATFORMS[sdk]
+  args += Fourflusher::SimControl.new.destination(:oldest, platform, deployment_target) unless platform.nil?
+  args += other_options
+  log = `xcodebuild #{args.join(" ")} 2>&1`
+  exit_code = $?.exitstatus # Process::Status
+  is_succeed = (exit_code == 0)
+
+  if !is_succeed
+    begin
+      if log.include?('** BUILD FAILED **')
+        # 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
+      else
+        raise "shouldn't be handle by xcpretty"
+      end
+    rescue
+      puts log.red
+    end
+  end
+  [is_succeed, log]
+end
+
+module Pod
+  class Prebuild
+
+    # Build the frameworks with sandbox and targets
+    #
+    # @param  [String] sandbox_root_path
+    #         The sandbox root path where the targets project place
+    #         
+    #         [PodTarget] target
+    #         The pod targets to build
+    #
+    #         [Pathname] output_path
+    #         output path for generated frameworks
+    #
+    def self.build(sandbox_root_path, target, output_path, bitcode_enabled = false, custom_build_options = [], custom_build_options_simulator = [])
+
+      return if target.nil?
+
+      sandbox_root = Pathname(sandbox_root_path)
+      sandbox = Pod::Sandbox.new(sandbox_root)
+      build_dir = self.build_dir(sandbox_root)
+
+      # -- build the framework
+      case target.platform.name
+      when :ios then
+        build_for_iosish_platform(sandbox, build_dir, output_path, target, 'iphoneos', 'iphonesimulator', bitcode_enabled, custom_build_options, custom_build_options_simulator)
+      when :osx then
+        xcodebuild(sandbox, target.label, 'macosx', nil, custom_build_options)
+        # when :tvos then build_for_iosish_platform(sandbox, build_dir, target, 'appletvos', 'appletvsimulator')
+      when :watchos then
+        build_for_iosish_platform(sandbox, build_dir, output_path, target, 'watchos', 'watchsimulator', true, custom_build_options, custom_build_options_simulator)
+      else
+        raise "Unsupported platform for '#{target.name}': '#{target.platform.name}'"
+      end
+
+      raise Pod::Informative, 'The build directory was not found in the expected location.' unless build_dir.directory?
+
+      # # --- copy the vendored libraries and framework
+      # frameworks = build_dir.children.select{ |path| File.extname(path) == ".framework" }
+      # Pod::UI.puts "Built #{frameworks.count} #{'frameworks'.pluralize(frameworks.count)}"
+
+      # pod_target = target
+      # consumer = pod_target.root_spec.consumer(pod_target.platform.name)
+      # file_accessor = Pod::Sandbox::FileAccessor.new(sandbox.pod_dir(pod_target.pod_name), consumer)
+      # frameworks += file_accessor.vendored_libraries
+      # frameworks += file_accessor.vendored_frameworks
+
+      # frameworks.uniq!
+
+      # frameworks.each do |framework|
+      #   FileUtils.mkdir_p destination
+      #   FileUtils.cp_r framework, destination, :remove_destination => true
+      # end
+      # build_dir.rmtree if build_dir.directory?
+    end
+
+    def self.remove_build_dir(sandbox_root)
+      path = build_dir(sandbox_root)
+      path.rmtree if path.exist?
+    end
+
+    private
+
+    def self.build_dir(sandbox_root)
+      # don't know why xcode chose this folder
+      sandbox_root.parent + 'build'
+    end
+
+  end
+end