cocoapods-hd 0.0.3 → 0.1.0

data/lib/cocoapods-hd/helper/podfile_options.rb

@@ -0,0 +1,130 @@
+module Pod
+
+    class Prebuild
+        def self.keyword
+            :binary
+        end
+    end
+
+    class Podfile
+      class TargetDefinition
+
+        ## --- option for setting using prebuild framework ---
+        def parse_prebuild_framework(name, requirements)
+            should_prebuild = Pod::Podfile::DSL.is_all_binary
+
+            options = requirements.last
+            if options.is_a?(Hash) && options[Pod::Prebuild.keyword] != nil 
+                should_prebuild = options.delete(Pod::Prebuild.keyword)
+                requirements.pop if options.empty?
+            end
+    
+            pod_name = Specification.root_name(name)
+            set_prebuild_for_pod(pod_name, should_prebuild)
+        end
+        
+        def set_prebuild_for_pod(pod_name, should_prebuild)
+            
+            if should_prebuild == true
+                @prebuild_framework_pod_names ||= []
+                Pod::UI.puts "prebuild_framework_pod_names -------- :#{@prebuild_framework_pod_names}"
+                @prebuild_framework_pod_names.push pod_name
+            else
+                @should_not_prebuild_framework_pod_names ||= []
+                @should_not_prebuild_framework_pod_names.push pod_name
+            end
+        end
+
+        def prebuild_framework_pod_names
+            names = @prebuild_framework_pod_names || []
+            if parent != nil and parent.kind_of? TargetDefinition
+                names += parent.prebuild_framework_pod_names
+            end
+            names
+        end
+        def should_not_prebuild_framework_pod_names
+            names = @should_not_prebuild_framework_pod_names || []
+            if parent != nil and parent.kind_of? TargetDefinition
+                names += parent.should_not_prebuild_framework_pod_names
+            end
+            names
+        end
+
+        # ---- patch method ----
+        # We want modify `store_pod` method, but it's hard to insert a line in the 
+        # implementation. So we patch a method called in `store_pod`.
+        # old_method = instance_method(:parse_inhibit_warnings)
+        #
+        # define_method(:parse_inhibit_warnings) do |name, requirements|
+        #   parse_prebuild_framework(name, requirements)
+        #   old_method.bind(self).(name, requirements)
+        # end
+        
+      end
+    end
+end
+
+
+module Pod
+    class Installer
+
+        def prebuild_pod_targets
+            @prebuild_pod_targets ||= (
+            all = []
+
+            aggregate_targets = self.aggregate_targets
+            aggregate_targets.each do |aggregate_target|
+                target_definition = aggregate_target.target_definition
+                targets = aggregate_target.pod_targets || []
+
+                # filter prebuild
+                prebuild_names = target_definition.prebuild_framework_pod_names
+                if not Podfile::DSL.is_all_binary
+                    targets = targets.select { |pod_target| prebuild_names.include?(pod_target.pod_name) } 
+                end
+                dependency_targets = targets.map {|t| t.recursive_dependent_targets }.flatten.uniq || []
+                targets = (targets + dependency_targets).uniq
+
+                # filter should not prebuild
+                explict_should_not_names = target_definition.should_not_prebuild_framework_pod_names
+                targets = targets.reject { |pod_target| explict_should_not_names.include?(pod_target.pod_name) } 
+
+                all += targets
+            end
+
+            all = all.reject {|pod_target| sandbox.local?(pod_target.pod_name) }
+            all.uniq
+            )
+        end
+
+        # the root names who needs prebuild, including dependency pods.
+        def prebuild_pod_names 
+           @prebuild_pod_names ||= self.prebuild_pod_targets.map(&:pod_name)
+        end
+
+
+        def validate_every_pod_only_have_one_form
+
+            multi_targets_pods = self.pod_targets.group_by do |t|
+                t.pod_name
+            end.select do |k, v|
+                v.map{|t| t.platform.name }.count > 1
+            end
+
+            multi_targets_pods = multi_targets_pods.reject do |name, targets|
+                contained = targets.map{|t| self.prebuild_pod_targets.include? t }
+                contained.uniq.count == 1 # all equal
+            end
+
+            return if multi_targets_pods.empty?
+
+            warnings = "One pod can only be prebuilt or not prebuilt. These pod have different forms in multiple targets:\n"
+            warnings += multi_targets_pods.map{|name, targets| "         #{name}: #{targets.map{|t|t.platform.name}}"}.join("\n")
+            raise Informative, warnings
+        end
+
+    end
+end
+
+
+

data/lib/cocoapods-hd/helper/prebuild_sandbox.rb

@@ -0,0 +1,73 @@
+require_relative "names"
+
+module Pod
+  class PrebuildSandbox < Sandbox
+
+    # [String] standard_sandbox_path
+    def self.from_standard_sanbox_path(path)
+      prebuild_sandbox_path = Pathname.new(path).realpath + "_Prebuild"
+      self.new(prebuild_sandbox_path)
+    end
+
+    def self.from_standard_sandbox(sandbox)
+      self.from_standard_sanbox_path(sandbox.root)
+    end
+
+    def standard_sanbox_path
+      self.root.parent
+    end
+
+    def generate_framework_path
+      self.root + "GeneratedFrameworks"
+    end
+
+    # @param name [String] pass the target.name (may containing platform suffix)
+    # @return [Pathname] the folder containing the framework file.
+    def framework_folder_path_for_target_name(name)
+      self.generate_framework_path + name
+    end
+
+    def exsited_framework_target_names
+      exsited_framework_name_pairs.map { |pair| pair[0] }.uniq
+    end
+
+    def exsited_framework_pod_names
+      exsited_framework_name_pairs.map { |pair| pair[1] }.uniq
+    end
+
+    def existed_target_names_for_pod_name(pod_name)
+      exsited_framework_name_pairs.select { |pair| pair[1] == pod_name }.map { |pair| pair[0] }
+    end
+
+    def save_pod_name_for_target(target)
+      folder = framework_folder_path_for_target_name(target.name)
+      return unless folder.exist?
+      # flag_file_path： /Users/xingyong/Desktop/debug-binary/HDTestKit/Example/Pods/_Prebuild/GeneratedFrameworks/SVProgressHUD/SVProgressHUD.pod_name
+      flag_file_path = folder + "#{target.pod_name}.pod_name"
+
+      File.write(flag_file_path.to_s, "")
+    end
+
+    private
+
+    def pod_name_for_target_folder(target_folder_path)
+      name = Pathname.new(target_folder_path).children.find do |child|
+        child.to_s.end_with? ".pod_name"
+      end
+      name = name.basename(".pod_name").to_s unless name.nil?
+      name ||= Pathname.new(target_folder_path).basename.to_s # for compatibility with older version
+    end
+
+    # Array<[target_name, pod_name]>
+    def exsited_framework_name_pairs
+      return [] unless generate_framework_path.exist?
+      generate_framework_path.children().map do |framework_path|
+        if framework_path.directory? && (not framework_path.children.empty?)
+          [framework_path.basename.to_s, pod_name_for_target_folder(framework_path)]
+        else
+          nil
+        end
+      end.reject(&:nil?).uniq
+    end
+  end
+end

data/lib/cocoapods-hd/helper/target_checker.rb

@@ -0,0 +1,49 @@
+
+module Pod
+  class Prebuild
+
+    # Check the targets, for the current limitation of the plugin
+    #
+    # @param [Array<PodTarget>] prebuilt_targets
+    def self.check_one_pod_should_have_only_one_target(prebuilt_targets)
+
+      targets_have_different_platforms = prebuilt_targets.select {|t| t.pod_name != t.name }
+
+      if targets_have_different_platforms.count > 0
+        names = targets_have_different_platforms.map(&:pod_name)
+        raw_names = targets_have_different_platforms.map(&:name)
+        message = "Oops, you came across a limitation of cocoapods-binary.
+
+The plugin requires that one pod should have ONLY ONE target in the 'Pod.xcodeproj'. There are mainly 2 situations \
+causing this problem:
+
+1. One pod integrates in 2 or more different platforms' targets. e.g.
+    ```
+    target 'iphoneApp' do
+      pod 'A', :binary => true
+    end
+    target 'watchApp' do
+      pod 'A'
+    end
+    ```
+
+2. Use different subspecs in multiple targets. e.g.
+    ```
+    target 'iphoneApp' do
+      pod 'A/core'
+      pod 'A/network'
+    end
+    target 'iphoneAppTest' do
+      pod 'A/core'
+    end
+    ```
+
+Related pods: #{names}, target names: #{raw_names}
+        "
+        raise Informative, message
+      end
+    end
+
+
+  end
+end

data/lib/cocoapods-hd/main.rb

@@ -0,0 +1,226 @@
+# encoding: UTF-8
+require_relative 'helper/podfile_options'
+require_relative 'tool/tool'
+
+module Pod
+  class Podfile
+    module DSL
+
+      # Enable prebuiding for all pods
+      # it has a lower priority to other binary settings
+      def hd_all_binary!
+        DSL.is_all_binary = true
+      end
+
+      def hd_use_source_pods(pods)
+        DSL.source_pods = Array(pods)
+      end
+
+      # Enable bitcode for prebuilt frameworks
+      def enable_bitcode_for_prebuilt_frameworks!
+        DSL.bitcode_enabled = true
+      end
+
+      # Don't remove source code of prebuilt pods
+      # It may speed up the pod install if git didn't
+      # include the `Pods` folder
+      def keep_source_code_for_prebuilt_frameworks!
+        DSL.dont_remove_source_code = true
+      end
+
+      # Add custom xcodebuild option to the prebuilding action
+      #
+      # You may use this for your special demands. For example: the default archs in dSYMs
+      # of prebuilt frameworks is 'arm64 armv7 x86_64', and no 'i386' for 32bit simulator.
+      # It may generate a warning when building for a 32bit simulator. You may add following
+      # to your podfile
+      #
+      #  ` set_custom_xcodebuild_options_for_prebuilt_frameworks :simulator => "ARCHS=$(ARCHS_STANDARD)" `
+      #
+      # Another example to disable the generating of dSYM file:
+      #
+      #  ` set_custom_xcodebuild_options_for_prebuilt_frameworks "DEBUG_INFORMATION_FORMAT=dwarf"`
+      #
+      #
+      # @param [String or Hash] options
+      #
+      #   If is a String, it will apply for device and simulator. Use it just like in the commandline.
+      #   If is a Hash, it should be like this: { :device => "XXXXX", :simulator => "XXXXX" }
+      #
+      def set_custom_xcodebuild_options_for_prebuilt_frameworks(options)
+        if options.kind_of? Hash
+          DSL.custom_build_options = [options[:device]] unless options[:device].nil?
+          DSL.custom_build_options_simulator = [options[:simulator]] unless options[:simulator].nil?
+        elsif options.kind_of? String
+          DSL.custom_build_options = [options]
+          DSL.custom_build_options_simulator = [options]
+        else
+          raise "Wrong type."
+        end
+      end
+
+      private
+
+      # 是否全部二进库
+      class_attr_accessor :is_all_binary
+      is_all_binary = false
+
+      class_attr_accessor :bitcode_enabled
+      bitcode_enabled = false
+
+      class_attr_accessor :dont_remove_source_code
+      dont_remove_source_code = false
+
+      class_attr_accessor :custom_build_options
+      class_attr_accessor :custom_build_options_simulator
+      self.custom_build_options = []
+      self.custom_build_options_simulator = []
+
+      # 用户指定源码集合
+      class_attr_accessor :source_pods
+      source_pods = []
+
+    end
+  end
+end
+
+def run_pod_install
+  podfile = Pathname.new('Podfile')
+  if !podfile.exist?
+    STDERR.puts "[!] Podfile file did not exist".red
+    exit
+  end
+  argvs = []
+  gen = Pod::Command::Install.new(CLAide::ARGV.new(argvs))
+  gen.validate!
+  gen.run
+end
+
+# Pod::HooksManager.register('cocoapods-hd', :post_install) do |installer_context|
+#
+#   Pod::UI.puts "cocoapods-hd: post_install"
+#   if Pod.is_ignore_hook_install == nil || Pod.is_ignore_hook_install == true
+#     Pod::UI.puts "cocoapods-hd: hook post_install"
+#     next
+#   end
+#   # installer_context.pods_project -> Xcodeproj::Project
+#   installer_context.pods_project.targets.each do |target|
+#     target.build_configurations.each do |config|
+#       if config.name == 'Release'
+#         config.build_settings['ARCHS'] = "$(ARCHS_STANDARD)"
+#       end
+#     end
+#   end
+#   installer_context.pods_project.save
+#   Pod::UI.puts "cocoapods-hd: set build configurations"
+# end
+#
+Pod::HooksManager.register('cocoapods-hd', :pre_install) do |installer_context|
+
+  require_relative 'helper/feature_switches'
+  require_relative 'resolver'
+
+  Pod::UI.puts "cocoapods-hd: pre_install"
+
+  if !Pod.is_prebuild_stage
+    Pod::UI.puts "cocoapods-hd: update repo"
+
+    sources_manager = Pod::Config.instance.sources_manager
+    argvs = [sources_manager.binary_source.name]
+    repo_update = Pod::Command::Repo::Update.new(CLAide::ARGV.new(argvs))
+    repo_update.validate!
+    repo_update.run
+  end
+
+  if Pod.is_ignore_hook_install == nil || Pod.is_ignore_hook_install == true
+    Pod::UI.puts "cocoapods-hd: hook pre_install"
+    next
+  end
+
+  if Pod.is_prebuild_stage
+    next
+  end
+
+  # [Check Environment]
+  # check user_framework is on
+  podfile = installer_context.podfile
+  podfile.target_definition_list.each do |target_definition|
+
+    next if target_definition.prebuild_framework_pod_names.empty?
+    if not target_definition.uses_frameworks?
+      STDERR.puts "[!] Cocoapods-hd requires `use_frameworks!`".red
+      exit
+    end
+  end
+
+  # -- step 1: prebuild framework ---
+  # Execute a sperated pod install, to generate targets for building framework,
+  # then compile them to framework files.
+  require_relative 'helper/prebuild_sandbox'
+  require_relative 'prebuild'
+
+  Pod::UI.puts "️🍎 Prebuild frameworks"
+
+  # Fetch original installer (which is running this pre-install hook) options,
+  # then pass them to our installer to perform update if needed
+  # Looks like this is the most appropriate way to figure out that something should be updated
+
+  update = nil
+  repo_update = nil
+
+  include ObjectSpace
+  ObjectSpace.each_object(Pod::Installer) { |installer|
+    update = installer.update
+    repo_update = installer.repo_update
+  }
+
+  # control features
+  Pod.is_prebuild_stage = true
+  Pod::Podfile::DSL.enable_prebuild_patch true # enable sikpping for prebuild targets
+  Pod::Installer.force_disable_integration true # don't integrate targets
+  Pod::Config.force_disable_write_lockfile true # disbale write lock file for perbuild podfile
+  Pod::Installer.disable_install_complete_message true # disable install complete message
+
+  # make another custom sandbox
+  standard_sandbox = installer_context.sandbox
+  prebuild_sandbox = Pod::PrebuildSandbox.from_standard_sandbox(standard_sandbox)
+
+  # get the podfile for prebuild
+  prebuild_podfile = Pod::Podfile.from_ruby(podfile.defined_in_file)
+  prebuild_podfile.use_frameworks!(:linkage => :static)
+  # Pod::UI.puts "prebuild_podfile --------- :  #{prebuild_podfile}"
+
+  # install
+  lockfile = installer_context.lockfile
+  # Pod::UI.puts "lockfile --------- :  #{lockfile}"
+
+  binary_installer = Pod::Installer.new(prebuild_sandbox, prebuild_podfile, lockfile)
+  # Pod::UI.puts "binary_installer --------- :  #{binary_installer}"
+
+  binary_installer.have_exact_prebuild_cache?
+  binary_installer.install!
+
+  # if binary_installer.have_exact_prebuild_cache? && !update
+  #     binary_installer.install_when_cache_hit!
+  # else
+  #     binary_installer.update = update
+  #     binary_installer.repo_update = repo_update
+  #     binary_installer.install!
+  # end
+
+  # reset the environment
+  Pod.is_prebuild_stage = false
+  Pod::Installer.force_disable_integration false
+  Pod::Podfile::DSL.enable_prebuild_patch false
+  Pod::Config.force_disable_write_lockfile false
+  Pod::Installer.disable_install_complete_message false
+  Pod::UserInterface.warnings = [] # clean the warning in the prebuild step, it's duplicated.
+
+  # -- step 2: pod install ---
+  # install
+  Pod::UI.puts "\n"
+  Pod::UI.puts "🍓 Pod Install"
+  require_relative 'Integration'
+  # go on the normal install step ...
+end
+