cocoapods-binary-gcp 0.0.1

data/lib/cocoapods-binary/gem_version.rb

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

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

@@ -0,0 +1,101 @@
+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 not Pod::Podfile::DSL.except_binary_list.nil?
+                    should_prebuild = !Pod::Podfile::DSL.except_binary_list.include?(name)
+                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

data/lib/cocoapods-binary/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/helper/podfile_options.rb

@@ -0,0 +1,133 @@
+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
+            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 ||= []
+                @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.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_pod_names
+                targets = targets.reject { |pod_target| explict_should_not_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
+
+                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-binary/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 = 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-binary/helper/shared_cache.rb

@@ -0,0 +1,133 @@
+require 'digest'
+require_relative '../tool/tool'
+require "google/cloud/storage"
+require 'zip'
+
+module Pod
+    class Prebuild
+        class SharedCache
+            extend Config::Mixin
+
+            # `true` if there is cache for the target
+            # `false` otherwise
+            #
+            # @return [Boolean]
+            def self.has?(target, options)
+                if Podfile::DSL.shared_cache_enabled
+                    path = framework_cache_path_for(target, options)
+                    if path.exist?
+                        Pod::UI.puts "Local cache for #{target.name} found"
+                        true
+                    else
+                        Pod::UI.puts "Local cache for #{target.name} not found"
+                        if Podfile::DSL.shared_gcp_cache_enabled
+                            cloud_path = cloud_framework_path_for(target, options)
+                            storage = Google::Cloud::Storage.new
+                            bucket = storage.bucket(Podfile::DSL.gcp_options[:bucket])
+                            file = bucket.file "#{cloud_path}"
+                            if not file.nil? 
+                                Pod::UI.puts "GCP cache for #{target.name} found, downloading..."
+                                Dir.mktmpdir {|dir|
+                                    file.download "#{dir}/framework.zip"
+                                    unzip("#{dir}/framework.zip", path)
+                                }
+                                true
+                            else
+                                Pod::UI.puts "GCP cache for #{target.name} not found"
+                                false
+                            end
+                        else
+                            false
+                        end
+                    end
+                else
+                    false
+                end
+            end
+
+            # Copies input_path to target's cache
+            def self.cache(target, input_path, options)
+                if not Podfile::DSL.shared_cache_enabled
+                    return
+                end
+                cache_path = framework_cache_path_for(target, options)
+                cache_path.mkpath unless cache_path.exist?
+                FileUtils.cp_r "#{input_path}/.", cache_path
+
+                if Podfile::DSL.shared_gcp_cache_enabled
+                    cloud_path = cloud_framework_path_for(target, options)
+                    storage = Google::Cloud::Storage.new
+                    bucket = storage.bucket(Podfile::DSL.gcp_options[:bucket])
+
+                    Pod::UI.puts "Save to remote cache"
+                    Dir.mktmpdir {|dir|
+                        zip(cache_path, "#{dir}/framework.zip")
+                        bucket.create_file "#{dir}/framework.zip",
+                                            "#{cloud_path}"     
+                    }
+                end
+            end
+
+            # Path of the target's cache
+            #
+            # @return [Pathname]
+            def self.framework_cache_path_for(target, options)
+                framework_cache_path = cache_root + xcode_version
+                framework_cache_path = framework_cache_path + target.name
+                framework_cache_path = framework_cache_path + target.version
+                options_with_platform = options + [target.platform.name]
+                framework_cache_path = framework_cache_path + Digest::MD5.hexdigest(options_with_platform.to_s).to_s
+            end
+
+            def self.cloud_framework_path_for(target, options) 
+                cloud_cache_path = Pathname.new('').to_s + xcode_version
+                cloud_cache_path = cloud_cache_path + target.name
+                cloud_cache_path = cloud_cache_path + target.version
+                options_with_platform = options + [target.platform.name]
+                cloud_cache_path = cloud_cache_path + Digest::MD5.hexdigest(options_with_platform.to_s).to_s
+            end
+
+            def self.zip(dir, zip_dir)
+                Zip::File.open(zip_dir, Zip::File::CREATE)do |zipfile|
+                    Find.find(dir) do |path|
+                        Find.prune if File.basename(path)[0] == ?.
+                        dest = /#{dir}\/(\w.*)/.match(path)
+                        # Skip files if they exists
+                        begin
+                            zipfile.add(dest[1],path) if dest
+                        rescue Zip::ZipEntryExistsError
+                        end
+                    end
+                end
+            end
+
+            def self.unzip(zip, unzip_dir, remove_after = false)
+                Zip::File.open(zip) do |zip_file|
+                    zip_file.each do |f|
+                        f_path=File.join(unzip_dir, f.name)
+                        FileUtils.mkdir_p(File.dirname(f_path))
+                        zip_file.extract(f, f_path) unless File.exist?(f_path)
+                    end
+                end
+                FileUtils.rm(zip) if remove_after
+            end
+
+            # Current xcode version.
+            #
+            # @return [String]
+            private
+            class_attr_accessor :xcode_version
+            # Converts from "Xcode 10.2.1\nBuild version 10E1001\n" to "10.2.1".
+            self.xcode_version = `xcodebuild -version`.split("\n").first.split().last || "Unkwown"
+
+            # Path of the cache folder
+            # Reusing cache_root from cocoapods's config
+            # `~Library/Caches/CocoaPods` is default value
+            #
+            # @return [Pathname]
+            private
+            class_attr_accessor :cache_root
+            self.cache_root = config.cache_root + 'Prebuilt'
+        end
+    end
+end