cocoapods-binary-matchup 0.0.30 → 0.0.32

data/lib/cocoapods-binary-matchup/Prebuild.rb

@@ -0,0 +1,255 @@
+require_relative 'rome/build_framework'
+require_relative 'helper/passer'
+require_relative 'helper/target_checker'
+
+
+# patch prebuild ability
+module Pod
+    class Installer
+
+        
+        private
+
+        def local_manifest 
+            if not @local_manifest_inited
+                @local_manifest_inited = true
+                raise "This method should be call before generate project" unless self.analysis_result == nil
+                @local_manifest = self.sandbox.manifest
+            end
+            @local_manifest
+        end
+
+        # @return [Analyzer::SpecsState]
+        def prebuild_pods_changes
+            return nil if local_manifest.nil?
+            UI.puts "--------------------------------"
+            UI.puts "prebuild_pods_changes"
+            UI.puts "--------------------------------"
+            if @prebuild_pods_changes.nil?
+                # detect the changes with podfile by manifest.lock
+                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
+
+        
+        public 
+
+        # check if need to prebuild
+        def have_exact_prebuild_cache?
+            # check if need build frameworks
+            return false if local_manifest == nil
+            
+            changes = prebuild_pods_changes
+            added = changes.added
+            changed = changes.changed 
+            unchanged = changes.unchanged
+            deleted = changes.deleted 
+            
+            unchange_framework_names = (added + unchanged)
+
+            exsited_framework_names = sandbox.exsited_framework_names
+            missing = unchanged.select do |pod_name|
+                not exsited_framework_names.include?(pod_name)
+            end
+
+            needed = (added + changed + deleted + missing)
+            return needed.empty?
+        end
+        
+        
+        # The install method when have completed cache
+        def install_when_cache_hit!
+            # just print log
+            self.sandbox.exsited_framework_names.each do |name|
+                UI.puts "Using #{name}"
+            end
+        end
+    
+
+        # Build the needed framework files
+        def prebuild_frameworks! 
+
+            # check
+            # give a early warning, instead of after compiling all the pods
+            Prebuild.check_one_pod_should_have_only_one_target(self.pod_targets)
+
+            # build options
+            sandbox_path = sandbox.root
+            existed_framework_folder = sandbox.generate_framework_path
+            bitcode_enabled = Pod::Podfile::DSL.bitcode_enabled
+            targets = []
+            
+            if local_manifest != nil
+
+                changes = prebuild_pods_changes
+                added = changes.added
+                changed = changes.changed 
+                unchanged = changes.unchanged
+                deleted = changes.deleted 
+    
+                existed_framework_folder.mkdir unless existed_framework_folder.exist?
+                exsited_framework_names = sandbox.exsited_framework_names
+    
+                # additions
+                missing = unchanged.select do |pod_name|
+                    not exsited_framework_names.include?(pod_name)
+                end
+
+                root_names_to_update = (added + changed + missing)
+
+                # transform names to targets
+                name_to_target_hash = self.pod_targets.reduce({}) do |sum, target|
+                    sum[target.name] = target
+                    sum
+                end
+                targets = root_names_to_update.map do |root_name|
+                    t = name_to_target_hash[root_name]
+                    raise "There's no target named (#{root_name}) in Pod.xcodeproj.\n #{name_to_target_hash.keys}" if t.nil?
+                    t
+                end || []
+
+                # add the dendencies
+                dependency_targets = targets.map {|t| t.recursive_dependent_targets }.flatten.uniq || []
+                targets = (targets + dependency_targets).uniq
+            else
+                targets = self.pod_targets
+            end
+
+            targets = targets.reject {|pod_target| sandbox.local?(pod_target.pod_name) }
+
+            Pod::PrebuildCache::Cache.remove_all_invalid_cache(sandbox, targets)
+
+            # build!
+            Pod::UI.puts "Prebuild frameworks (total #{targets.count})"
+            Pod::Prebuild.remove_build_dir(sandbox_path)
+            targets.each do |target|
+                # If target shouldn't build, we copy all the original files
+                # This is for target with only .a and .h files
+                if !target.should_build?
+                    UI.puts "Prebuilding #{target.label}"
+                    next
+                end
+
+                standard_sandbox_path = sandbox.standard_sanbox_path
+                Pod::UI.puts "📦 [#{Time.now.strftime('%Y-%m-%d %H:%M:%S')}] Prebuild Start pod: #{target.pod_name}"
+                if Pod::PrebuildCache::Cache.restore_from_pod_cache(target.pod_name, sandbox)
+                    output_path = sandbox.framework_folder_path_for_pod_name(target.name)
+                    if prebuild_resource_bundles_missing?(target, output_path)
+                        Pod::UI.puts "⚠️  Cached #{target.pod_name} missing resource_bundles; rebuilding..."
+                        output_path.rmtree if output_path.exist?
+                    else
+                        Pod::UI.puts "📦 [#{Time.now.strftime('%Y-%m-%d %H:%M:%S')}] Using exact cache from ~/.PodCache"
+                        next
+                    end
+                end
+                Pod::UI.puts "📦 [#{Time.now.strftime('%Y-%m-%d %H:%M:%S')}] Prebuild End pod: #{target.pod_name}"
+
+                output_path = sandbox.framework_folder_path_for_pod_name(target.name)
+                output_path.mkpath unless output_path.exist?
+                Pod::Prebuild.build(sandbox_path, target, output_path, bitcode_enabled,  Podfile::DSL.custom_build_options,  Podfile::DSL.custom_build_options_simulator)
+
+                # save the resource paths for later installing
+                if target.static_framework? and !target.resource_paths.empty?
+                    framework_path = output_path + target.framework_name
+                    standard_sandbox_path = sandbox.standard_sanbox_path
+
+                    resources = begin
+                        if Pod::VERSION.start_with? "1.5"
+                            target.resource_paths
+                        else
+                            # resource_paths is Hash{String=>Array<String>} on 1.6 and above
+                            # (use AFNetworking to generate a demo data)
+                            # https://github.com/leavez/cocoapods-binary/issues/50
+                            target.resource_paths.values.flatten
+                        end
+                    end
+                    raise "Wrong type: #{resources}" unless resources.kind_of? Array
+
+                    path_objects = resources.map do |path|
+                        object = Prebuild::Passer::ResourcePath.new
+                        object.real_file_path = framework_path + File.basename(path)
+                        object.target_file_path = path.gsub('${PODS_ROOT}', standard_sandbox_path.to_s) if path.start_with? '${PODS_ROOT}'
+                        object.target_file_path = path.gsub("${PODS_CONFIGURATION_BUILD_DIR}", standard_sandbox_path.to_s) if path.start_with? "${PODS_CONFIGURATION_BUILD_DIR}"
+                        object
+                    end
+                    Prebuild::Passer.resources_to_copy_for_static_framework[target.name] = path_objects
+                end
+            end            
+            Pod::Prebuild.remove_build_dir(sandbox_path)
+
+
+            # copy vendored libraries and frameworks
+            targets.each do |target|
+                root_path = self.sandbox.pod_dir(target.name)
+                target_folder = sandbox.framework_folder_path_for_pod_name(target.name)
+                
+                # If target shouldn't build, we copy all the original files
+                # This is for target with only .a and .h files
+                if not target.should_build? 
+                    Prebuild::Passer.target_names_to_skip_integration_framework << target.pod_name
+                    FileUtils.cp_r(root_path, target_folder, :remove_destination => true)
+                    next
+                end
+
+                # copy the vendored frameworks and libraries in _Prebuild to Pods/
+                target.spec_consumers.each do |consumer|
+                    file_accessor = Sandbox::FileAccessor.new(root_path, consumer)
+                    lib_paths = file_accessor.vendored_frameworks || []
+                    lib_paths += file_accessor.vendored_libraries
+                    # @TODO dSYM files
+                    lib_paths.each do |lib_path|
+                        relative = lib_path.relative_path_from(root_path)
+                        destination = target_folder + relative
+                        destination.dirname.mkpath unless destination.dirname.exist?
+                        FileUtils.cp_r(lib_path, destination, :remove_destination => true)
+                    end
+                end
+            end
+
+            # save the manifest.lock to cache
+            Pod::PrebuildCache::Cache.save_manifest_to_cache(sandbox)
+            
+            # Remove useless files
+            # remove useless pods
+            all_needed_names = self.pod_targets.map(&:name).uniq
+            useless_names = sandbox.exsited_framework_names.reject do |name| 
+                all_needed_names.include? name
+            end
+            useless_names.each do |name|
+                path = sandbox.framework_folder_path_for_pod_name(name)
+                path.rmtree if path.exist?
+            end
+
+            if not Podfile::DSL.dont_remove_source_code 
+                # only keep manifest.lock and framework folder in _Prebuild
+                to_remain_files = ["Manifest.lock", File.basename(existed_framework_folder)]
+                to_delete_files = sandbox_path.children.select do |file|
+                    filename = File.basename(file)
+                    not to_remain_files.include?(filename)
+                end
+                to_delete_files.each do |path|
+                    path.rmtree if path.exist?
+                end
+            else 
+                # just remove the tmp files
+                path = sandbox.root + 'Manifest.lock.tmp'
+                path.rmtree if path.exist?
+            end
+
+        end
+        
+        # patch the post install hook
+        old_method2 = instance_method(:run_plugins_post_install_hooks)
+        define_method(:run_plugins_post_install_hooks) do 
+            old_method2.bind(self).()
+            if Pod::is_prebuild_stage
+                self.prebuild_frameworks!
+            end
+        end
+
+    end
+end

data/lib/cocoapods-binary-matchup/gem_version.rb

@@ -0,0 +1,3 @@
+module CocoapodsBinary
+    VERSION = "0.0.32"
+end

data/lib/cocoapods-binary-matchup/helper/feature_switches.rb

@@ -0,0 +1,109 @@
+require_relative '../tool/tool'
+require_relative 'prebuild_sandbox'
+
+module Pod
+
+    # a flag that indicate stages
+    class_attr_accessor :is_prebuild_stage
+
+
+    # a switch for the `pod` DSL to make it only valid for ':binary => true'
+    class Podfile
+        module DSL
+            
+            @@enable_prebuild_patch = false
+
+            # when enable, `pod` function will skip all pods without 'prebuild => true'
+            def self.enable_prebuild_patch(value)
+                @@enable_prebuild_patch = value
+            end
+
+            # --- patch ---
+            # filter the pods that should be prebuild(all_binary! or binary => true)，remember the pod is must remote pod
+            # this will be effective when enable_prebuild_patch is true(the binary prebuild step)
+            # when in system step, the enable_prebuild_patch is false, so the original method will be called
+            old_method = instance_method(:pod)
+            define_method(:pod) do |name, *args|
+                # if not enable, just call the original method
+                if !@@enable_prebuild_patch
+                    old_method.bind(self).(name, *args)
+                    return
+                end
+
+                # patched content
+                should_prebuild = Pod::Podfile::DSL.prebuild_all
+                local = false
+                
+                options = args.last
+                if options.is_a?(Hash) and options[Pod::Prebuild.keyword] != nil
+                    should_prebuild = options[Pod::Prebuild.keyword]
+                    local = (options[:path] != nil)
+                end
+                
+                if should_prebuild and (not local)
+                    if current_target_definition.platform == :watchos
+                        # watchos isn't supported currently
+                        Pod::UI.warn "Binary doesn't support watchos currently: #{name}. You can manually set `binary => false` for this pod to suppress this warning."
+                        return
+                    end
+                    old_method.bind(self).(name, *args)
+                end
+            end
+         end
+    end
+    
+    
+    # a force disable option for integral 
+    class Installer
+        def self.force_disable_integration(value)
+            @@force_disable_integration = value
+        end
+        
+        # prebuild step's purpose is to build source target code or copy the prebuild framework to the target, 
+        # so we need to disable the original method
+        old_method = instance_method(:integrate_user_project)
+        define_method(:integrate_user_project) do 
+            if @@force_disable_integration
+                return
+            end
+            old_method.bind(self).()
+        end
+    end
+
+    # a option to disable install complete message
+    class Installer
+        def self.disable_install_complete_message(value)
+            @@disable_install_complete_message = value
+        end
+        
+        old_method = instance_method(:print_post_install_message)
+        define_method(:print_post_install_message) do 
+            if @@disable_install_complete_message
+                return
+            end
+            old_method.bind(self).()
+        end
+    end
+
+    # option to disable write lockfiles
+    class Config
+
+        @@force_disable_write_lockfile = false
+        def self.force_disable_write_lockfile(value)
+            @@force_disable_write_lockfile = value
+        end
+        
+        old_method = instance_method(:lockfile_path)
+        define_method(:lockfile_path) do 
+            if @@force_disable_write_lockfile
+                # As config is a singleton, sandbox_root refer to the standard sandbox.
+                manifest_lock_path = PrebuildSandbox.from_standard_sanbox_path(sandbox_root).root + 'Manifest.lock.tmp'
+                UI.puts "manifest_lock_path: #{manifest_lock_path}"
+                return manifest_lock_path
+            else
+                return old_method.bind(self).()
+            end
+        end
+    end
+    
+end

data/lib/cocoapods-binary-matchup/helper/passer.rb

@@ -0,0 +1,41 @@
+require_relative '../tool/tool'
+
+module Pod    
+    class Prebuild
+
+        # Pass the data between the 2 steps
+        #
+        # At step 2, the normal pod install, it needs some info of the
+        # prebuilt step. So we store it here.
+        #
+        class Passer
+
+            # indicate the add/remove/update of prebuit pods
+            # @return [Analyzer::SpecsState] 
+            #
+            class_attr_accessor :prebuild_pods_changes
+
+
+            # represent the path of resurces to copy
+            class ResourcePath
+                attr_accessor :real_file_path
+                attr_accessor :target_file_path
+            end
+            # Save the resoures for static framework, and used when installing the prebuild framework
+            # static framework needs copy the resurces mannully
+            #
+            # @return [Hash<String, [Passer::ResourcePath]>]
+            class_attr_accessor :resources_to_copy_for_static_framework
+            self.resources_to_copy_for_static_framework = {}
+
+            # Some pod won't be build in prebuild stage even if it have `binary=>true`.
+            # The targets of this pods have `oshould_build? == true`.
+            # We should skip integration (patch spec) for this pods
+            #
+            # @return [Array<String>]
+            class_attr_accessor :target_names_to_skip_integration_framework
+            self.target_names_to_skip_integration_framework = []
+
+        end
+    end
+end

data/lib/cocoapods-binary-matchup/helper/podfile_options.rb

@@ -0,0 +1,122 @@
+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.prebuild_all
+
+            options = requirements.last
+            # 如果options是hash，并且包含Pod::Prebuild.keyword，则设置should_prebuild为true
+            if options.is_a?(Hash) && options[Pod::Prebuild.keyword] != nil 
+                # [DINetwork', { :binary => true, :configurations => ['Debug'] }]
+                should_prebuild = options.delete(Pod::Prebuild.keyword)
+                # [DINetwork', { :configurations => ['Debug'] }]，避免干扰其他配置，不删除可能让后续cocoapods本身解析报错
+                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
+                # watchos isn't supported currently
+                return if self.platform == :watchos
+
+                @prebuild_framework_names ||= []
+                @prebuild_framework_names.push pod_name
+            else
+                @should_not_prebuild_framework_names ||= []
+                @should_not_prebuild_framework_names.push pod_name
+            end
+        end
+
+        def prebuild_framework_names
+            names = @prebuild_framework_names || []
+            if parent != nil and parent.kind_of? TargetDefinition
+                names += parent.prebuild_framework_names
+            end
+            names
+        end
+        def should_not_prebuild_framework_names
+            names = @should_not_prebuild_framework_names || []
+            if parent != nil and parent.kind_of? TargetDefinition
+                names += parent.should_not_prebuild_framework_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`.
+        # use this method to parse prebuild framework(:binary => true)
+        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
+
+            all = []
+            aggregate_targets = (self.aggregate_targets || []).select { |a| a.platform != :watchos }
+            aggregate_targets.each do |aggregate_target|
+                target_definition = aggregate_target.target_definition
+                targets = aggregate_target.pod_targets || []
+                
+                UI.puts "🔍 Processing #{aggregate_target.name}:"
+                UI.puts "🔍   pod_targets count: #{targets.count}"
+
+                # filter prebuild
+                prebuild_names = target_definition.prebuild_framework_names
+                if not Podfile::DSL.prebuild_all
+                    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_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
+        
+        # 强制重新计算 prebuild_pod_names（用于主安装阶段）
+        def refresh_prebuild_pod_names!
+            @prebuild_pod_names = nil
+            prebuild_pod_names
+        end
+
+    end
+end
+
+
+

data/lib/cocoapods-binary-matchup/helper/prebuild_sandbox.rb

@@ -0,0 +1,53 @@
+module Pod
+    class PrebuildSandbox < Sandbox
+
+        # [String] standard_sandbox_path
+        def self.from_standard_sanbox_path(path)
+            # 将预构建目录设置到项目根目录，而不是Pods目录旁边
+            # 这样可以避免在删除Pods目录时丢失预构建的框架
+            project_root = Pathname.new(path).realpath.parent
+            prebuild_sandbox_path = project_root + "_Prebuild"
+            UI.puts "prebuild_sandbox_path: #{prebuild_sandbox_path}"
+            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
+        end
+        
+        def generate_framework_path
+            self.root + "GeneratedFrameworks"
+        end
+
+        def framework_folder_path_for_pod_name(name)
+            self.generate_framework_path + name
+        end
+
+        def exsited_framework_names
+            return [] unless generate_framework_path.exist?
+            generate_framework_path.children().map do |framework_name|
+                if framework_name.directory?
+                    if not framework_name.children.empty?
+                        File.basename(framework_name)
+                    else
+                        nil
+                    end
+                else
+                    nil
+                end
+            end.reject(&:nil?)
+        end
+
+        def framework_existed?(root_name)
+            return false unless generate_framework_path.exist?
+            generate_framework_path.children().any? do |child|
+                child.basename.to_s == root_name
+            end
+        end
+
+    end
+end

data/lib/cocoapods-binary-matchup/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-matchup.
+
+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