class PodsOrz::BinaryBuilder

Attributes

http_host[RW]
kx_binary_path[RW]
main_path[RW]
pod_repo[RW]
podfile_io[RW]
remote_binary_directory[RW]

Public Class Methods

new(main_path, podfile_io) click to toggle source
# File lib/podsorz/core/Binary/binary_builder.rb, line 11
def initialize(main_path, podfile_io)
        @main_path = main_path
        @kx_binary_path = File.expand_path("../kx_binary", main_path)

        @podfile_io = podfile_io
        @pod_repo = PodsOrz::PodsRepo.new(main_path)

        @http_host = "http://192.168.6.127:8899"
        @remote_binary_directory = "binary_pod"
end

Public Instance Methods

build_static_library(pod) click to toggle source
# File lib/podsorz/core/Binary/binary_builder.rb, line 135
def build_static_library(pod)
        is_build_success = true
        command = Thread.new do 
                pod_version = @podfile_io.get_podfile_pod_version(pod)

                dest_dir = detect_version_directory(pod, pod_version)
                dest_file_path = File.expand_path("#{pod}.podspec", dest_dir)

                cmd_list = []
                cmd_list << "cd #{dest_dir}"
                cmd_list << "pod package #{pod}.podspec --exclude-deps --no-mangle --force --embedded --spec-sources=git@gitlab.91banban.com:ios_pods/Specs.git"

                Open3.popen3(cmd_list.join(";")) do |stdin , stdout , stderr, wait_thr|
                        while line = stdout.gets
                                puts line
                    end
            end
        end
        command.join
        
        is_build_success
end
check_directory() click to toggle source
# File lib/podsorz/core/Binary/binary_builder.rb, line 91
def check_directory()
        is_directory = File.directory?(@main_path)
        Logger.error("Detect failure, it is not a directory path: #{@main_path}") unless is_directory

        is_directory
end
copy_podspec(pod) click to toggle source

copy

# File lib/podsorz/core/Binary/binary_builder.rb, line 119
def copy_podspec(pod)
        command = Thread.new do 
                pod_version = @podfile_io.get_podfile_pod_version(pod)
                source_podspec_dir = @pod_repo.directory_pod_version(pod, pod_version)
                source_file_path = File.expand_path("#{pod}.podspec", source_podspec_dir)

                dest_dir = detect_version_directory(pod, pod_version)
                dest_file_path = File.expand_path("#{pod}.podspec", dest_dir)

                `cp -f #{source_file_path} #{dest_file_path}`

                Logger.highlight("Copy file Success.\n Source file path:#{source_file_path} \n dest_file_path:#{dest_file_path}")
        end
        command.join
end
delete_build_files(pod) click to toggle source
# File lib/podsorz/core/Binary/binary_builder.rb, line 292
def delete_build_files(pod)
        command = Thread.new do 
                pod_version = @podfile_io.get_podfile_pod_version(pod)

                origin_spec_dir = detect_version_directory(pod, pod_version)
                package_dir_name = "#{pod}-#{pod_version}"

                cmd_list = []
                cmd_list << "cd #{origin_spec_dir}"
                cmd_list << "rm -f -r #{package_dir_name}"

                IO.popen(cmd_list.join(";")) do |io|
                        io.close
                end
        end

        command.join
end
detect_kx_binary() click to toggle source

detect

# File lib/podsorz/core/Binary/binary_builder.rb, line 78
def detect_kx_binary()

        result = check_directory()

        if result
                binary_result = File.directory?(@kx_binary_path)
                unless binary_result
                        Logger.warning("kx_binary directory not exist, generate default 'kx_binary' directory")    
                        FileUtils.mkdir_p(@kx_binary_path, :mode => 0777)
                end
        end
end
detect_pod_directory(pod) click to toggle source
# File lib/podsorz/core/Binary/binary_builder.rb, line 98
def detect_pod_directory(pod)
        pod_path = File.expand_path("#{pod}", @kx_binary_path)
        pod_result = File.directory?(pod_path)
        unless pod_result
                Logger.warning("#{pod_path} directory not exist, generate default '#{pod_path}' directory") 
                FileUtils.mkdir_p(pod_path, :mode => 0777)
        end
end
detect_version_directory(pod, pod_version) click to toggle source
# File lib/podsorz/core/Binary/binary_builder.rb, line 107
def detect_version_directory(pod, pod_version)
        pod_version_path = File.expand_path("#{pod}/#{pod_version}", @kx_binary_path)
        pod_version_result = File.directory?(pod_version_path)
        unless pod_version_result
                Logger.warning("#{pod_version_path} directory not exist, generate default '#{pod_version_path}' directory")
                FileUtils.mkdir_p(pod_version_path, :mode => 0777)
        end

        pod_version_path
end
mv_embedded_framework(pod) click to toggle source
# File lib/podsorz/core/Binary/binary_builder.rb, line 187
def mv_embedded_framework(pod)
        is_mv_success = true

        command = Thread.new do 
                pod_version = @podfile_io.get_podfile_pod_version(pod)

                origin_spec_dir = detect_version_directory(pod, pod_version)
                package_dir = File.expand_path("#{pod}-#{pod_version}", origin_spec_dir)
                embedded_framework_dir = File.expand_path("ios/#{pod}.embeddedframework", package_dir)

                cmd_list = []
                cmd_list << "cd #{embedded_framework_dir}"
                cmd_list << "mv -f #{pod}.framework.zip #{origin_spec_dir}"

                IO.popen(cmd_list.join(";")) do |io|
                        io_lines = io.readlines
                        io_lines.each do |line|
                                puts line
                                is_mv_success = false if line.include? "mv:"
                        end
                        io.close
                end
        end
                command.join

        is_mv_success
end
override_podspec(pod) click to toggle source
# File lib/podsorz/core/Binary/binary_builder.rb, line 215
def override_podspec(pod)
        is_override_success = true

        command = Thread.new do 
                pod_version = @podfile_io.get_podfile_pod_version(pod)

                origin_spec_dir = detect_version_directory(pod, pod_version)
                origin_spec_file_path = File.expand_path("#{pod}.podspec", origin_spec_dir)
                origin_podspec_model = PodsOrz::PodspecModel.new(origin_spec_file_path)


                package_dir = File.expand_path("#{pod}-#{pod_version}", origin_spec_dir)
                static_pod_spec_path = File.expand_path("#{pod}.podspec", package_dir)

                static_podspec_totoal_sentences = []
                File.open(static_pod_spec_path, "r") {|io|
                        static_podspec_totoal_sentences = io.readlines
                }

                File.open(static_pod_spec_path, "w+") {|io|
                        static_podspec_totoal_sentences.each do |sentence|
                                sentence_content = sentence.strip.chomp.to_s
                        
                                is_sentence_content_empty = sentence_content.empty?
                                is_sentence_content_size_zero = sentence_content.size.zero?

                                unless is_sentence_content_empty || is_sentence_content_size_zero
                                        unless sentence_content.start_with?("#")
                                                mt = /.*s.source = /.match(sentence)
                                                unless mt.nil?
                                                        sentence = mt[0] + "{:http => \'#{@http_host}/#{remote_binary_directory}/#{pod}/#{pod_version}/#{pod}.framework.zip\'}"
                                                end

                                                mt = /.*s.ios.vendored_framework   = /.match(sentence)
                                                #behind vendored_framework add extra lines
                                                unless mt.nil?
                                                        sentence = mt[0] + "\'#{pod}.framework\'" + "\n"

                                                        #add Resource
                                                        if origin_podspec_model.have_resources
                                                                sentence += "  " + "s.resources = \'#{pod}.framework/Versions/A/Resources/*.{png,bundle,xib}\'" + "\n\n"
                                                        end

                                                        #add dependency
                                                        origin_podspec_model.dependency_list.each do |d|
                                                                sentence += "  " + "s.dependency " + "#{d}" + "\n"
                                                        end

                                                        sentence += "\n"

                                                end

                                        end
                                end

                                io.write(sentence.chomp + "\n")
                        end
                }

                cmd_list = []
                cmd_list << "cd #{package_dir}"
                cmd_list << "mv -f #{pod}.podspec #{origin_spec_dir}"

                IO.popen(cmd_list.join(";")) do |io|
                        io_lines = io.readlines
                        io_lines.each do |line|
                                puts line
                                is_override_success = false if line.include? "mv:"
                        end
                        io.close
                end
        end
        command.join

        is_override_success
end
start_package_pod(pod) click to toggle source
# File lib/podsorz/core/Binary/binary_builder.rb, line 22
def start_package_pod(pod)
        is_package_success = true

        #1.创建kx_binary
        detect_kx_binary()

        #2.创建Pod文件夹
        detect_pod_directory(pod)

        #3.创建version文件夹
        pod_version = @podfile_io.get_podfile_pod_version(pod)
        detect_version_directory(pod, pod_version)

        #4.copy kuxiu_specs中对应的podspec
        copy_podspec(pod)

        #5.build static library
        is_build_success = build_static_library(pod)
        unless is_build_success
                Logger.error("【#{pod}】build version:#{pod_version} static library failure!")
                is_package_success = false
                return is_package_success
        end

        #6.zip framework
        is_zip_success = zip_framework(pod)
        unless is_zip_success
                Logger.error("【#{pod}】zip framework failure!")
                is_package_success = false
                return is_package_success
        end

        #7.mv framework
        is_mv_success = mv_embedded_framework(pod)
        unless is_mv_success
                Logger.error("【#{pod} mv #{pod}.framework.zip failure!")
                is_package_success = false
                return is_package_success
        end

        #8.override .podspec
        is_override_success = override_podspec(pod)
        unless is_override_success
                Logger.error("【#{pod} mv #{pod}.podspec failure!")
                is_package_success = false
                return is_package_success
        end

        #9.delete build files
        delete_build_files(pod)


        is_package_success
end
zip_framework(pod) click to toggle source
# File lib/podsorz/core/Binary/binary_builder.rb, line 158
def zip_framework(pod)
        is_zip_success = true

        command = Thread.new do 
                pod_version = @podfile_io.get_podfile_pod_version(pod)

                origin_spec_dir = detect_version_directory(pod, pod_version)
                package_dir = File.expand_path("#{pod}-#{pod_version}", origin_spec_dir)
                embedded_framework_dir = File.expand_path("ios/#{pod}.embeddedframework", package_dir)

                cmd_list = []
                cmd_list << "cd #{embedded_framework_dir}"
                cmd_list << "zip -q -r -y -o #{pod}.framework.zip #{pod}.framework"

                IO.popen(cmd_list.join(";")) do |io|
                        io_lines = io.readlines
                        io_lines.each do |line|
                                puts line
                                is_zip_success = false if line.include? "zip error"
                        end
                        io.close
                end
        end

        command.join

        is_zip_success
end