cocoapods-ppbuild 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 560423786a1c2f0fff91e7d25ee783420a6f18d4115c8c551427f9960a7fd4ae
+  data.tar.gz: 2b3c92a07bd963e42bcb5fd5b220c2d8f2fa26ed7152d813a7af0e110a81ac8e
+SHA512:
+  metadata.gz: b8cec8ef3b7783945f203ad4ad499ac88b7321d41e8b04112fe2a8d2feda60e3e6a5ad579c49ac58a84ba946394ff6f5db4b33502638de3a69db0ebb57170639
+  data.tar.gz: e284d38c0a277e4d6002a6c513d7eba496aa086883624733766990dbc043dc162f8d104a5204e50aff788e907e1afdaf865c1e4a104447f14993aef00ed710cf

data/lib/cocoapods-ppbuild/Integration.rb

@@ -0,0 +1,306 @@
+require_relative 'helper/podfile_options'
+require_relative 'helper/feature_switches'
+require_relative 'helper/prebuild_sandbox'
+require_relative 'helper/passer'
+require_relative 'helper/names'
+require_relative 'helper/target_checker'
+
+
+# NOTE:
+# This file will only be loaded on normal pod install step
+# so there's no need to check is_prebuild_stage
+
+
+
+# Provide a special "download" process for prebuilded pods.
+#
+# As the frameworks is already exsited in local folder. We
+# just create a symlink to the original target folder.
+#
+module Pod
+    class Installer
+        class PodSourceInstaller
+
+            def install_for_prebuild!(standard_sanbox)
+                return if standard_sanbox.local? self.name
+
+                # make a symlink to target folder
+                prebuild_sandbox = Pod::PrebuildSandbox.from_standard_sandbox(standard_sanbox)
+                # if spec used in multiple platforms, it may return multiple paths
+                target_names = prebuild_sandbox.existed_target_names_for_pod_name(self.name)
+                
+                def walk(path, &action)
+                    return unless path.exist?
+                    path.children.each do |child|
+                        result = action.call(child, &action)
+                        if child.directory?
+                            walk(child, &action) if result
+                        end
+                    end
+                end
+
+                def make_link(source, target, uselink)
+                    source = Pathname.new(source)
+                    target = Pathname.new(target)
+                    target.parent.mkpath unless target.parent.exist?
+                    relative_source = source.relative_path_from(target.parent)
+                    if uselink
+                        FileUtils.ln_sf(relative_source, target)
+                    else
+                        if File.directory?(source) 
+                            FileUtils.cp_r source, target, :remove_destination => true
+                        else
+                            FileUtils.cp source, target
+                        end        
+                    end
+                end
+
+                def mirror_with_symlink(source, basefolder, target_folder, uselink)
+                    target = target_folder + source.relative_path_from(basefolder)
+                    make_link(source, target, uselink)
+                end
+                
+                target_names.each do |name|
+
+                    # symbol link copy all substructure
+                    real_file_folder = prebuild_sandbox.framework_folder_path_for_target_name(name)
+                    
+                    # If have only one platform, just place int the root folder of this pod.
+                    # If have multiple paths, we use a sperated folder to store different
+                    # platform frameworks. e.g. AFNetworking/AFNetworking-iOS/AFNetworking.framework
+                    
+                    target_folder = standard_sanbox.pod_dir(self.name)
+                    if target_names.count > 1 
+                        target_folder += real_file_folder.basename
+                    end
+                    target_folder.rmtree if target_folder.exist?
+                    target_folder.mkpath
+
+
+                    walk(real_file_folder) do |child|
+                        source = child
+                        # only make symlink to file and `.framework` folder
+                        if child.directory?
+                            if [".framework"].include? child.extname
+                                mirror_with_symlink(source, real_file_folder, target_folder, true)
+                                next false  # return false means don't go deeper
+                            elsif [".dSYM"].include? child.extname
+                                mirror_with_symlink(source, real_file_folder, target_folder, false)
+                                next false  # return false means don't go deeper
+                            else
+                                next true
+                            end
+                        elsif child.file?
+                            mirror_with_symlink(source, real_file_folder, target_folder, false)
+                            next true
+                        else
+                            next true
+                        end
+                    end
+
+
+                    # symbol link copy resource for static framework
+                    hash = Prebuild::Passer.resources_to_copy_for_static_framework || {}
+                    path_objects = hash[name]
+                    if path_objects != nil
+                        path_objects.each do |object|
+                            if object.real_file_path != nil
+                                make_link(object.real_file_path, object.target_file_path, false)
+                            end
+                        end
+                    end
+                end # of for each 
+
+            end # of method
+
+        end
+    end
+end
+
+
+# Let cocoapods use the prebuild framework files in install process.
+#
+# the code only effect the second pod install process.
+#
+module Pod
+    class Installer
+
+
+        # Remove the old target files if prebuild frameworks changed
+        def remove_target_files_if_needed
+
+            changes = Pod::Prebuild::Passer.prebuild_pods_changes
+            updated_names = []
+            if changes == nil
+                updated_names = PrebuildSandbox.from_standard_sandbox(self.sandbox).exsited_framework_pod_names
+            else
+                added = changes.added
+                changed = changes.changed 
+                deleted = changes.deleted 
+                updated_names = added + changed + deleted
+            end
+
+            updated_names.each do |name|
+                root_name = Specification.root_name(name)
+                next if self.sandbox.local?(root_name)
+
+                # delete the cached files
+                target_path = self.sandbox.pod_dir(root_name)
+                target_path.rmtree if target_path.exist?
+
+                support_path = sandbox.target_support_files_dir(root_name)
+                support_path.rmtree if support_path.exist?
+            end
+
+        end
+
+
+        # Modify specification to use only the prebuild framework after analyzing
+        old_method2 = instance_method(:resolve_dependencies)
+        define_method(:resolve_dependencies) do
+
+            # Remove the old target files, else it will not notice file changes
+            self.remove_target_files_if_needed
+
+            # call original
+            old_method2.bind(self).()
+            # ...
+            # ...
+            # ...
+            # after finishing the very complex orginal function
+
+            # check the pods
+            # Although we have did it in prebuild stage, it's not sufficient.
+            # Same pod may appear in another target in form of source code.
+            # Prebuild.check_one_pod_should_have_only_one_target(self.prebuild_pod_targets)
+            self.validate_every_pod_only_have_one_form
+
+            
+            # prepare
+            cache = []
+
+            def add_vendered_framework(spec, platform, added_framework_file_path)
+                if spec.attributes_hash[platform] == nil
+                    spec.attributes_hash[platform] = {}
+                end
+                vendored_frameworks = spec.attributes_hash[platform]["vendored_frameworks"] || []
+                vendored_frameworks = [vendored_frameworks] if vendored_frameworks.kind_of?(String)
+                vendored_frameworks += [added_framework_file_path]
+                spec.attributes_hash[platform]["vendored_frameworks"] = vendored_frameworks
+            end
+            def empty_source_files(spec)
+                spec.attributes_hash["source_files"] = []
+                ["ios", "watchos", "tvos", "osx"].each do |plat|
+                    if spec.attributes_hash[plat] != nil
+                        spec.attributes_hash[plat]["source_files"] = []
+                    end
+                end
+            end
+
+
+            specs = self.analysis_result.specifications
+            prebuilt_specs = (specs.select do |spec|
+                self.prebuild_pod_names.include? spec.root.name
+            end)
+
+            prebuilt_specs.each do |spec|
+
+                # Use the prebuild framworks as vendered frameworks
+                # get_corresponding_targets
+                targets = Pod.fast_get_targets_for_pod_name(spec.root.name, self.pod_targets, cache)
+                targets.each do |target|
+                    # the framework_file_path rule is decided when `install_for_prebuild`,
+                    # as to compitable with older version and be less wordy.
+                    framework_file_path = target.framework_name
+                    framework_file_path = target.name + "/" + framework_file_path if targets.count > 1
+                    add_vendered_framework(spec, target.platform.name.to_s, framework_file_path)
+                end
+                # Clean the source files
+                # we just add the prebuilt framework to specific platform and set no source files 
+                # for all platform, so it doesn't support the sence that 'a pod perbuild for one
+                # platform and not for another platform.'
+                empty_source_files(spec)
+
+                # to remove the resurce bundle target. 
+                # When specify the "resource_bundles" in podspec, xcode will generate a bundle 
+                # target after pod install. But the bundle have already built when the prebuit
+                # phase and saved in the framework folder. We will treat it as a normal resource
+                # file.
+                if spec.attributes_hash["resource_bundles"]
+                    bundle_names = spec.attributes_hash["resource_bundles"].keys
+                    spec.attributes_hash["resource_bundles"] = nil 
+                    spec.attributes_hash["resources"] ||= []
+                    spec.attributes_hash["resources"] += bundle_names.map{|n| n+".bundle"}
+                end
+
+                # to avoid the warning of missing license
+                spec.attributes_hash["license"] = {}
+
+            end
+
+        end
+
+
+        # Override the download step to skip download and prepare file in target folder
+        old_method = instance_method(:install_source_of_pod)
+        define_method(:install_source_of_pod) do |pod_name|
+
+            # copy from original
+            pod_installer = create_pod_installer(pod_name)
+            # \copy from original
+
+            if self.prebuild_pod_names.include? pod_name
+                pod_installer.install_for_prebuild!(self.sandbox)
+            else
+                pod_installer.install!
+            end
+
+            # copy from original
+            @installed_specs.concat(pod_installer.specs_by_platform.values.flatten.uniq)
+            # \copy from original
+        end
+
+
+    end
+end
+
+# A fix in embeded frameworks script.
+#
+# The framework file in pod target folder is a symblink. The EmbedFrameworksScript use `readlink`
+# to read the read path. As the symlink is a relative symlink, readlink cannot handle it well. So 
+# we override the `readlink` to a fixed version.
+#
+module Pod
+    module Generator
+        class EmbedFrameworksScript
+
+            old_method = instance_method(:script)
+            define_method(:script) do
+
+                script = old_method.bind(self).()
+                patch = <<-SH.strip_heredoc
+                    #!/bin/sh
+                
+                    # ---- this is added by cocoapods-ppbuild ---
+                    # Readlink cannot handle relative symlink well, so we override it to a new one
+                    # If the path isn't an absolute path, we add a realtive prefix.
+                    old_read_link=`which readlink`
+                    readlink () {
+                        path=`$old_read_link "$1"`;
+                        if [ $(echo "$path" | cut -c 1-1) = '/' ]; then
+                            echo $path;
+                        else
+                            echo "`dirname $1`/$path";
+                        fi
+                    }
+                    # --- 
+                SH
+
+                # patch the rsync for copy dSYM symlink
+                script = script.gsub "rsync --delete", "rsync --copy-links --delete"
+                
+                patch + script
+            end
+        end
+    end
+end

data/lib/cocoapods-ppbuild/Main.rb

@@ -0,0 +1,177 @@
+# 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 ppbuild settings
+            def use_dynamic_binary!
+                DSL.prebuild_all = true
+                DSL.static_binary = false
+            end
+            # 设置当前swift版本
+            def use_swift_version(version)
+                DSL.swift_version = version
+            end
+
+            # 设置是否使用静态库
+            def use_static_binary!
+                DSL.prebuild_all = true
+                DSL.static_binary = true
+            end
+
+            # Enable bitcode for prebuilt frameworks
+            def enable_bitcode_for_prebuilt_frameworks!
+                DSL.bitcode_enabled = 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 :prebuild_all
+            prebuild_all = false
+
+            class_attr_accessor :swift_version
+            swift_version = "5.0"   # swift版本默认5.0
+
+            class_attr_accessor :static_binary
+            static_binary = false
+
+            class_attr_accessor :bitcode_enabled
+            bitcode_enabled = false
+
+            class_attr_accessor :dont_remove_source_code
+            dont_remove_source_code = true
+
+            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 :static_build_pod_names
+            self.static_build_pod_names = []
+        end
+    end
+end
+
+Pod::HooksManager.register('cocoapods-ppbuild', :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-ppbuild 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 "火速编译中..."
+    
+    # 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
+
+Pod::HooksManager.register('cocoapods-ppbuild', :post_install) do |installer_context|
+
+    if Pod::Podfile::DSL.static_binary
+        Pod::PrebuildSandbox.replace_tagert_copy_source_sh(installer_context)
+    end
+    
+end
+