class Pod::Installer

a force disable option for integral

a option to disable install complete message

Public Class Methods

disable_install_complete_message(value) click to toggle source
# File lib/cocoapods-binary/helper/feature_switches.rb, line 65
def self.disable_install_complete_message(value)
    @@disable_install_complete_message = value
end
force_disable_integration(value) click to toggle source
# File lib/cocoapods-binary/helper/feature_switches.rb, line 50
def self.force_disable_integration(value)
    @@force_disable_integration = value
end

Public Instance Methods

add_vendered_framework(spec, platform, added_framework_file_path) click to toggle source
# File lib/cocoapods-binary/Integration.rb, line 161
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
empty_source_files(spec) click to toggle source
# File lib/cocoapods-binary/Integration.rb, line 170
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
have_exact_prebuild_cache?() click to toggle source

check if need to prebuild

# File lib/cocoapods-binary/Prebuild.rb, line 36
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
install_when_cache_hit!() click to toggle source

The install method when have completed cache

# File lib/cocoapods-binary/Prebuild.rb, line 57
def install_when_cache_hit!
    # just print log
    self.sandbox.exsited_framework_target_names.each do |name|
        UI.puts "Using #{name}"
    end
end
prebuild_frameworks!() click to toggle source

Build the needed framework files

# File lib/cocoapods-binary/Prebuild.rb, line 66
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
prebuild_pod_names() click to toggle source

the root names who needs prebuild, including dependency pods.

# File lib/cocoapods-binary/helper/podfile_options.rb, line 101
def prebuild_pod_names 
   @prebuild_pod_names ||= self.prebuild_pod_targets.map(&:pod_name)
end
prebuild_pod_targets() click to toggle source
# File lib/cocoapods-binary/helper/podfile_options.rb, line 71
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) } 

        all += targets
    end

    all = all.reject {|pod_target| sandbox.local?(pod_target.pod_name) }
    all.uniq
    )
end
remove_target_files_if_needed() click to toggle source

Remove the old target files if prebuild frameworks changed

# File lib/cocoapods-binary/Integration.rb, line 111
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
validate_every_pod_only_have_one_form() click to toggle source
# File lib/cocoapods-binary/helper/podfile_options.rb, line 106
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

Private Instance Methods

local_manifest() click to toggle source
# File lib/cocoapods-binary/Prebuild.rb, line 11
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
prebuild_pods_changes() click to toggle source

@return [Analyzer::SpecsState]

# File lib/cocoapods-binary/Prebuild.rb, line 21
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