cocoapods-binary-gcp 0.0.1

data/lib/cocoapods-binary/Main.rb

@@ -0,0 +1,199 @@
+# 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
+
+            # - excepts: an array of name
+            def all_binary_except(excepts)
+                DSL.prebuild_all = true
+                DSL.except_binary_list = excepts
+            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
+
+            # Enable shared cache of prebuild frameworks
+            # Frameworks are stored inside cocoapods cache folder
+            #
+            # Location: ~/Library/Caches/CocoaPods/Prebuilt/
+            # Structure: <xcode-version>/<framework-name>/<framework-version>/<options hash>/
+            # Options hash depends on:
+            # - bitcode(enable_bitcode_for_prebuilt_frameworks!);
+            # - custom options(set_custom_xcodebuild_options_for_prebuilt_frameworks);
+            # - platform name(ios, osx);
+            # def use_shared_cache!
+            #     DSL.shared_cache_enabled = true
+            # end
+            
+
+            # Options hash depends on:
+            # - bucket: bucketName
+            def use_gcp_cache(options)
+                DSL.shared_cache_enabled = true
+                DSL.shared_gcp_cache_enabled = true
+                DSL.gcp_options = options
+            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 :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
+
+            class_attr_accessor :shared_cache_enabled
+            shared_cache_enabled = false
+
+            class_attr_accessor :shared_gcp_cache_enabled
+            shared_gcp_cache_enabled = false
+
+            class_attr_accessor :gcp_options
+            gcp_options = {}
+
+            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 :except_binary_list
+            self.except_binary_list = []
+        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"
+    
+    # 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)
+    
+    # install
+    lockfile = installer_context.lockfile
+    binary_installer = Pod::Installer.new(prebuild_sandbox, prebuild_podfile, lockfile)
+    
+    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
+

data/lib/cocoapods-binary/Prebuild.rb

@@ -0,0 +1,273 @@
+require_relative 'rome/build_framework'
+require_relative 'helper/passer'
+require_relative 'helper/target_checker'
+require_relative 'helper/shared_cache'
+
+
+# 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
+            
+            options = [
+                Podfile::DSL.bitcode_enabled,
+                Podfile::DSL.custom_build_options,
+                Podfile::DSL.custom_build_options_simulator
+            ]
+            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|
+                    tars = Pod.fast_get_targets_for_pod_name(pod_name, self.pod_targets, cache)
+                    if tars.nil? || tars.empty?
+                        raise "There's no target named (#{pod_name}) in Pod.xcodeproj.\n #{self.pod_targets.map(&:name)}" if t.nil?
+                    end
+                    tars
+                end.flatten
+
+                # add the dependencies
+                dependency_targets = targets.map {|t| t.recursive_dependent_targets }.flatten.uniq || []
+                # filter already built dependencies
+                dependency_targets = dependency_targets.reject { |t|
+                    local_manifest.version(t.name).to_s.eql? t.version.to_s
+                }
+
+                targets = (targets + dependency_targets).uniq
+            else
+                targets = self.pod_targets
+            end
+
+             # frameworks which mark binary true, should be filtered before prebuild
+
+             prebuild_framework_pod_names = []
+             podfile.target_definition_list.each do |target_definition|
+                 next if target_definition.prebuild_framework_pod_names.empty?
+                 prebuild_framework_pod_names += target_definition.prebuild_framework_pod_names
+             end
+
+ 
+             targets = targets
+             .reject {|pod_target| sandbox.local?(pod_target.pod_name) }
+             .select {|pod_target| prebuild_framework_pod_names.include?(pod_target.pod_name) }
+            
+            #  if not Pod::Podfile::DSL.except_binary_list.nil?
+            #     targets = targets.reject { |pod_target| Pod::Podfile::DSL.except_binary_list.include?(pod_target.pod_name) } 
+            #  end
+             
+            # build!
+            Pod::UI.puts "Prebuild frameworks (total #{targets.count})"
+            Pod::Prebuild.remove_build_dir(sandbox_path)
+            targets.each do |target|
+                if !target.should_build?
+                    UI.puts "Prebuilding #{target.label}"
+                    next
+                end
+
+                output_path = sandbox.framework_folder_path_for_target_name(target.name)
+                output_path.mkpath unless output_path.exist?
+
+                if Prebuild::SharedCache.has?(target, options)
+                    framework_cache_path = Prebuild::SharedCache.framework_cache_path_for(target, options)
+                    UI.puts "Using #{target.label} from cache"
+                    FileUtils.cp_r "#{framework_cache_path}/.", output_path
+                else
+                    min_deployment_target = aggregate_targets
+                        .select { |t| t.pod_targets.include?(target) }
+                        .map(&:platform)
+                        .map(&:deployment_target)
+                        .max
+
+                    Pod::Prebuild.build(sandbox_path, target, output_path, min_deployment_target, *options)
+                    Prebuild::SharedCache.cache(target, output_path, options)
+                end
+
+                # 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_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