cocoapods-precompile 0.1.0

data/lib/cocoapods-binary/Main.rb

@@ -0,0 +1,110 @@
+# 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 all_binary!
+                DSL.prebuild_all = true
+            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
+
+            private
+            class_attr_accessor :prebuild_all
+            prebuild_all = false
+
+            class_attr_accessor :bitcode_enabled
+            bitcode_enabled = false
+
+            class_attr_accessor :dont_remove_source_code
+            dont_remove_source_code = false
+        end
+    end
+end
+
+Pod::HooksManager.register('cocoapods-binary', :pre_install) do |installer_context|
+
+    require_relative 'helper/feature_switches'
+    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-binary 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"
+    
+    
+    # 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)
+    
+    # install
+    binary_installer = Pod::Installer.new(prebuild_sandbox, prebuild_podfile , nil)
+    
+    if binary_installer.have_exact_prebuild_cache?
+        binary_installer.install_when_cache_hit!
+    else
+        binary_installer.repo_update = false
+        binary_installer.update = false
+        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
+

data/lib/cocoapods-binary/Prebuild.rb

@@ -0,0 +1,212 @@
+require_relative 'rome/build_framework'
+require_relative 'helper/passer'
+
+# 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?
+            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 
+            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 
+            
+            exsited_framework_pod_names = sandbox.exsited_framework_pod_names
+            missing = unchanged.select do |pod_name|
+                not exsited_framework_pod_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_target_names.each do |name|
+                UI.puts "Using #{name}"
+            end
+        end
+    
+
+        # Build the needed framework files
+        def prebuild_frameworks! 
+
+            # 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_pod_names = sandbox.exsited_framework_pod_names
+    
+                # additions
+                missing = unchanged.select do |pod_name|
+                    not exsited_framework_pod_names.include?(pod_name)
+                end
+
+
+                root_names_to_update = (added + changed + missing)
+
+                # transform names to targets
+                cache = []
+                targets = root_names_to_update.map do |pod_name|
+                    Pod.fast_get_targets_for_pod_name(pod_name, self.pod_targets, cache)
+                end.flatten
+
+                # 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) }
+
+            
+            
+            # build!
+            Pod::UI.puts "Prebuild frameworks (total #{targets.count})"
+            Pod::Prebuild.remove_build_dir(sandbox_path)
+            targets.each do |target|
+                next unless target.should_build?
+                output_path = sandbox.framework_folder_path_for_target_name(target.name)
+
+                output_path.mkpath unless output_path.exist?
+                Pod::Prebuild.build(sandbox_path, target, output_path, bitcode_enabled)
+
+                # 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
+                    path_objects = target.resource_paths.select{|f| f.start_with? "${PODS_ROOT}"}.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)
+                        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_target_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.name
+                    FileUtils.cp_r(root_path, target_folder, :remove_destination => true)
+                    next
+                end
+
+                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 pod_name for prebuild framwork in sandbox 
+            targets.each do |target|
+                sandbox.save_pod_name_for_target target
+            end
+            
+            # Remove useless files
+            # remove useless pods
+            all_needed_names = self.pod_targets.map(&:name).uniq
+            useless_target_names = sandbox.exsited_framework_target_names.reject do |name| 
+                all_needed_names.include? name
+            end
+            useless_target_names.each do |name|
+                path = sandbox.framework_folder_path_for_target_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/gem_version.rb

@@ -0,0 +1,3 @@
+module CocoapodsPrecompile
+    VERSION = "0.1.0"
+end

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

@@ -0,0 +1,97 @@
+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 ---
+            old_method = instance_method(:pod)
+
+            define_method(:pod) do |name, *args|
+                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)
+                    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
+        
+        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.
+                return PrebuildSandbox.from_standard_sanbox_path(sandbox_root).root + 'Manifest.lock.tmp'
+            else
+                return old_method.bind(self).()
+            end
+        end
+    end
+    
+end

data/lib/cocoapods-binary/helper/names.rb

@@ -0,0 +1,78 @@
+# ABOUT NAMES
+#
+# There are many kinds of name in cocoapods. Two main names are widely used in this plugin.
+# - root_spec.name (spec.root_name, targe.pod_name):
+#   aka "pod_name"
+#   the name we use in podfile. the concept.
+# 
+# - target.name:
+#   aka "target_name"
+#   the name of the final target in xcode project. the final real thing.
+#
+# One pod may have multiple targets in xcode project, due to one pod can be used in mutiple 
+# platform simultaneously. So one `root_spec.name` may have multiple coresponding `target.name`s.
+# Therefore, map a spec to/from targets is a little complecated. It's one to many.
+#
+
+# Tool to transform Pod_name to target efficiently
+module Pod
+    def self.fast_get_targets_for_pod_name(pod_name, targets, cache)
+        pod_name_to_targets_hash = nil
+        if cache.empty?
+            pod_name_to_targets_hash = targets.reduce({}) do |sum, target|
+                array = sum[target.pod_name] || []
+                array << target
+                sum[target.pod_name] = array
+                sum
+            end
+            cache << pod_name_to_targets_hash
+        else
+            pod_name_to_targets_hash = cache.first
+        end
+        
+        pod_name_to_targets_hash[pod_name] || []
+    end
+end
+
+
+
+
+
+
+# Target:
+   
+#     def pod_name
+#       root_spec.name
+#     end
+
+#     def name
+# 	    pod_name + #{scope_suffix}
+#     end	
+
+#     def product_module_name
+#       root_spec.module_name
+#     end
+  
+#     def framework_name
+#       "#{product_module_name}.framework"
+#     end
+
+#    def product_name
+#       if requires_frameworks?
+#         framework_name
+#       else
+#         static_library_name
+#       end
+#     end
+
+#     def product_basename
+#       if requires_frameworks?
+#         product_module_name
+#       else
+#         label
+#       end
+#     end
+
+#     def framework_name
+#       "#{product_module_name}.framework"
+#     end