kookeeper 3.0.0 → 3.0.1

data/lib/big_keeper/util/list_generator.rb

@@ -1,101 +0,0 @@
-require 'big_keeper/util/logger'
-require 'json'
-
-module BigKeeper
-  class ListGenerator
-    #generate tree print throught console
-    def self.generate_tree(file_path, home_branches, version)
-      module_branches_dic = {}
-      json_data = File.read(file_path, :encoding => 'UTF-8')
-      module_branches_dic = JSON.parse(json_data)
-      to_tree(module_branches_dic, home_branches, version)
-      File.delete(file_path)
-    end
-
-      #generate json print throught console
-    def self.generate_json(file_path, home_branches, version)
-      module_branches_dic = {}
-      json_data = File.read(file_path, :encoding => 'UTF-8')
-      module_branches_dic = JSON.parse(json_data)
-      json = to_json(home_branches, module_branches_dic, version)
-      puts JSON.pretty_generate(json)
-      File.delete(file_path)
-    end
-
-    def self.to_json(home_branches, module_info_list, version)
-      json_array = []
-      print_all = version == "all versions"
-      home_branches = home_branches.uniq
-      home_branches.each do | home_branch_name |
-          next unless home_branch_name.include?(version) || print_all
-          branch_dic = {}
-          involve_modules = []
-          module_info_list.collect do | module_info_dic |
-            next unless module_info_dic["branches"] != nil
-            module_name = module_info_dic["module_name"]
-            module_info_dic["branches"].each do | module_branch |
-              if module_branch.strip.delete("*") == home_branch_name.strip.delete("*")
-                module_current_info = {}
-                module_current_info["module_name"] = module_name
-                module_current_info["current_branch"] = module_info_dic["current_branch"]
-                involve_modules << module_current_info
-              end
-            end
-          end
-
-          branch_dic["is_remote"] = false
-          branch_dic["is_current"] = false
-
-          if home_branch_name =~ /^remotes\//
-            home_branch_name = $~.post_match
-            branch_dic["is_remote"] = true
-          end
-
-          if home_branch_name =~ /^origin\//
-            home_branch_name = $~.post_match
-          end
-
-          if home_branch_name.include?("*")
-            home_branch_name = home_branch_name.delete("*")
-            branch_dic["is_current"] = true
-          end
-
-          if home_branch_name =~ /^feature\//
-            home_branch_name = $~.post_match
-          end
-
-          if home_branch_name =~ /^hotfix\//
-            home_branch_name = $~.post_match
-          end
-
-          branch_dic["home_branch_name"] = home_branch_name
-          branch_dic["involve_modules"] = involve_modules
-          json_array << branch_dic
-      end
-      json_array
-    end
-
-    def self.to_tree(module_branches_dic, branches_name, version)
-      home_name = BigkeeperParser.home_name
-      print_all = version == "all versions"
-      branches_name.each do | home_branch_name |
-        next unless home_branch_name.include?(version) || print_all
-        Logger.highlight(home_branch_name.strip)
-        module_branches_dic.each do | module_info_dic |
-          module_name = module_info_dic["module_name"]
-          next if module_info_dic["branches"] == nil
-          module_info_dic["branches"].each do | module_branch |
-            if module_branch.include?(home_branch_name.strip.delete('*'))
-              if !module_branch.include?("*") && home_branch_name.include?("*")
-                Logger.warning("   ├── #{module_name} (current branch :#{module_info_dic["current_branch"]})")
-              else
-                Logger.default("   ├── #{module_name}")
-              end
-                break
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/big_keeper/util/lockfile_parser.rb

@@ -1,143 +0,0 @@
-require 'big_keeper/util/bigkeeper_parser'
-require 'big_keeper/util/logger'
-require 'big_keeper/util/podfile_detector'
-require 'Singleton'
-
-module BigKeeper
-  class LockfileParser
-    include Singleton
-    attr_accessor :main_path, :dependencies, :pods, :podfile_hash
-    $mode = 'PODS'
-
-    def initialize
-      self.pods = {}
-      self.dependencies = []
-    end
-
-    def parse(main_path)
-      self.main_path = main_path
-      $mode = 'PODS'
-      podfile_lock_lines = File.readlines("#{main_path}/Podfile.lock", :encoding => 'UTF-8')
-      Logger.highlight("Analyzing Podfile.lock...")
-      podfile_lock_lines.each do |sentence|
-        if sentence.include?('PODS')
-          $mode = 'PODS'
-        elsif sentence.include?('DEPENDENCIES')
-          $mode = 'DEPENDENCIES'
-        elsif sentence.include?('SPEC REPOS')
-          $mode = 'SPEC REPOS'
-        elsif sentence.include?('SPEC CHECKSUMS')
-          $mode = 'SPEC CHECKSUMS'
-        elsif sentence.include?('CHECKOUT OPTIONS')
-          $mode = 'CHECKOUT OPTIONS'
-        elsif sentence.include?('EXTERNAL SOURCES')
-          $mode = 'EXTERNAL SOURCES'
-        elsif sentence.include?('PODFILE CHECKSUM')
-          $mode = 'PODFILE CHECKSUM'
-        else
-          if $mode == 'PODS'
-             deal_pod(sentence.strip.delete('\n'))
-          end
-          if $mode == 'SPEC CHECKSUMS'
-             deal_spec(sentence.strip.delete('\n'))
-          end
-        end
-       end
-     end
-
-     def get_unlock_pod_list(is_all)
-       result = {}
-       pod_parser = PodfileParser.instance
-       #podfile 中 unlock pods
-       unlock_pods = pod_parser.get_unlock_pod_list
-       # @unlock_pod_list << pod_name unless @module_list.include pod_name
-       if is_all
-         self.dependencies.each do |pod_name|
-           if pod_parser.pod_list.include?(pod_name)
-             next
-           end
-           if self.pods[pod_name] != nil
-             result[pod_name] = self.pods[pod_name]
-           end
-         end
-
-         unlock_pods.each do |pod_name|
-           if self.pods[pod_name] != nil
-             result[pod_name] = self.pods[pod_name]
-           end
-         end
-         return result
-       else
-         unlock_pods.each do |pod_name|
-           if self.pods[pod_name] != nil
-             result[pod_name] = self.pods[pod_name]
-           end
-         end
-         return result
-       end
-     end
-
-    #处理PODS
-    # TODO 去除重复
-    def deal_pod(s)
-      pod_name = get_lock_podname(s)
-      return if pod_name == nil
-      pod_version = get_lock_version(s)
-      if self.pods.keys.include?(pod_name)
-        current_version = self.pods[pod_name]
-        if pod_version != nil && current_version != nil
-            self.pods[pod_name] = chose_version(current_version, pod_version)
-        else
-            self.pods[pod_name] = pod_version unless pod_version == nil
-        end
-      end
-      self.pods[pod_name] = pod_version unless pod_version == nil
-    end
-    #
-    # #处理EXTERNAL SOURCES
-    # def deal_sources(s)
-    #
-    # end
-    # #处理CHECKOUT OPTIONS
-    # def deal_checkout(s)
-    #
-    # end
-
-    #处理SPEC CHECKSUMS
-    def deal_spec(s)
-        if /: +/ =~ s
-        dependency = $~.pre_match.strip
-        self.dependencies << dependency unless self.dependencies.include?(dependency)
-        end
-    end
-
-    def get_lock_podname(sentence) #获得lock pod名称
-      match_result = /(\d+.){1,2}\d+/.match(sentence.delete('- :~>='))
-      pod_name = match_result.pre_match unless match_result == nil
-      return pod_name.delete('()') unless pod_name == nil
-    end
-
-    def get_lock_version(sentence)#获得lock pod版本号
-      match_result = /(\d+.){1,2}\d+/.match(sentence)
-      return match_result[0].strip unless match_result == nil
-    end
-
-    def chose_version(cur_version,temp_version)
-      # p "cur:#{cur_version},temp:#{temp_version}"
-      cur_list = cur_version.split('.')
-      temp_list = temp_version.split('.')
-      cur_list << 0.to_s if cur_list.size == 2
-      temp_list << 0.to_s if temp_list.size == 2
-      if cur_list[0] >= temp_list[0]
-        if cur_list[1] >= temp_list[1]
-          if cur_list[2] > temp_list[2]
-            return cur_version
-          end
-          return temp_version
-        end
-        return temp_version
-      end
-      return temp_version
-     end
-  end
-end

data/lib/big_keeper/util/logger.rb

@@ -1,47 +0,0 @@
-require 'colorize'
-require 'big_keeper/util/leancloud_logger'
-
-module BigKeeper
-  DEFAULT_LOG = 1
-  HIGHLIGHT_LOG = 2
-  ERROR_LOG = 3
-  WARNING_LOG = 4
-
-  class Logger
-
-    def self.log_with_type(sentence,type)
-      case type
-      when DEFAULT_LOG then puts sentence.to_s.colorize(:default)
-      when HIGHLIGHT_LOG then puts sentence.to_s.colorize(:green)
-      when ERROR_LOG then raise sentence.to_s.colorize(:red)
-      when WARNING_LOG then puts sentence.to_s.colorize(:yellow)
-      end
-    end
-
-    def self.default(sentence)
-      puts formatter_output(sentence).colorize(:default)
-    end
-
-    def self.highlight(sentence)
-      puts formatter_output(sentence).colorize(:green)
-    end
-
-    def self.error(sentence)
-      is_need_log = LeanCloudLogger.instance.is_need_log
-      LeanCloudLogger.instance.end_log(false, is_need_log)
-      raise formatter_output(sentence).colorize(:red)
-    end
-
-    def self.warning(sentence)
-      puts formatter_output(sentence).colorize(:yellow)
-    end
-
-    def self.separator
-      puts "- - - - - - - - - - - - - - - - - - - - - - - - - - -".colorize(:light_blue)
-    end
-
-    def self.formatter_output(sentence)
-      "[big] ".concat(sentence.to_s).to_s
-    end
-  end
-end

data/lib/big_keeper/util/pod_operator.rb

@@ -1,70 +0,0 @@
-require 'big_keeper/util/logger'
-require 'open3'
-
-module BigKeeper
-  class PodOperator
-    def self.pod_install(path, repo_update)
-      # pod install
-      if repo_update
-        PodOperator.pod_update_private_repos(true)
-      end
-      Logger.highlight('Start pod install, waiting...')
-      cmd = "pod install --project-directory='#{path}'"
-      Open3.popen3(cmd) do |stdin, stdout, stderr, wait_thr|
-        while line = stdout.gets
-          p line
-        end
-      end
-      Logger.highlight('Finish pod install.')
-    end
-
-    def self.pod_repo_push(path, module_name, source, version)
-      Logger.highlight(%Q(Start Pod repo push #{module_name}))
-      Dir.chdir(path) do
-        command = ""
-        p BigkeeperParser.source_spec_name(module_name)
-        if source.length > 0
-          command = "pod repo push #{BigkeeperParser.source_spec_name(module_name)} #{module_name}.podspec --allow-warnings --sources=#{source} --verbose --use-libraries"
-        else
-          command = "pod repo push #{BigkeeperParser.source_spec_name(module_name)} #{module_name}.podspec --allow-warnings --verbose --use-libraries"
-        end
-
-        IO.popen(command) do |io|
-          is_success = false
-          error_info = Array.new
-          io.each do |line|
-            error_info.push(line)
-            is_success = true if line.include? "Updating spec repo"
-          end
-          unless is_success
-            puts error_info
-            Logger.error("Fail: '#{module_name}' Pod repo fail")
-          end
-          Logger.highlight(%Q(Success release #{module_name} V#{version}))
-        end
-      end
-    end
-
-    def self.pod_update_private_repos(update_private)
-      if update_private
-        BigkeeperParser.sources.map { |spec|
-          Logger.highlight('Start pod repo update, waiting...')
-          cmd = "pod repo update #{spec}"
-          cmd(cmd)
-        }
-      else
-        cmd = "pod repo update"
-        cmd(cmd)
-      end
-    end
-
-    def self.cmd(cmd)
-      Open3.popen3(cmd) do |stdin , stdout , stderr, wait_thr|
-        while line = stdout.gets
-          puts line
-        end
-      end
-    end
-
-  end
-end

data/lib/big_keeper/util/podfile_detector.rb

@@ -1,102 +0,0 @@
-require 'big_keeper/util/bigkeeper_parser'
-require 'big_keeper/model/podfile_model'
-require 'big_keeper/util/logger'
-require 'Singleton'
-module BigKeeper
-
-class PodfileParser
-  include Singleton
-  attr_accessor :module_list, :main_path, :pod_list
-  $unlock_pod_list = []
-  $modify_pod_list = {}
-
-  def initialize
-    @module_list = BigkeeperParser.module_names
-    @pod_list = []
-  end
-
-  def parse(path)
-    @main_path = path
-    podfile_lines = File.readlines("#{@main_path}/Podfile", :encoding => 'UTF-8')
-    Logger.highlight("Analyzing Podfile...") unless podfile_lines.size.zero?
-    podfile_lines.collect do |sentence|
-      if /pod / =~ sentence
-        pod_name = get_pod_name(sentence)
-        @pod_list << pod_name
-      end
-    end
-  end
-
-  def get_unlock_pod_list
-    podfile_lines = File.readlines("#{@main_path}/Podfile", :encoding => 'UTF-8')
-    #Logger.highlight("Analyzing Podfile...") unless podfile_lines.size.zero?
-    podfile_lines.collect do |sentence|
-    deal_podfile_line(sentence) unless sentence =~(/'(\d+.){1,2}\d+'/)
-    end
-    $unlock_pod_list
-  end
-
-  def deal_podfile_line(sentence)
-    return unless !sentence.strip.start_with?("#")
-    if sentence.strip.include?('pod ')
-      pod_model = PodfileModel.new(sentence)
-      if !pod_model.name.empty? &&
-         pod_model.configurations != '[\'Debug\']' &&
-         pod_model.path == nil &&
-         pod_model.tag == nil
-            pod_names = pod_model.name.split('/')
-            if pod_names.size > 1
-              pod_name = pod_names[0]
-            else
-              pod_name = pod_model.name
-            end
-            $unlock_pod_list << pod_name unless @module_list.include?(pod_name)
-      end
-      pod_model
-    end
-  end
-
-  def get_pod_name(sentence)
-
-    pod_model = deal_podfile_line(sentence)
-    if pod_model != nil
-      return pod_model.name
-    end
-  end
-
-  def self.get_pod_model(sentence)
-    if sentence.include?('pod ')
-      pod_model = PodfileModel.new(sentence)
-      return pod_model
-    end
-  end
-
-  def get_lock_podname(sentence) #获得pod名称
-    match_result = /(\d+.){1,2}\d+/.match(sentence.delete('- :~>='))
-    pod_name = match_result.pre_match unless match_result == nil
-    return pod_name.delete('()') unless pod_name == nil
-  end
-
-  def get_lock_version(sentence)#获得pod版本号
-    match_result = /(\d+.){1,2}\d+/.match(sentence)
-    return match_result[0] unless match_result == nil
-  end
-
-  def chose_version(cur_version,temp_version)
-    # p "cur:#{cur_version},temp:#{temp_version}"
-    cur_list = cur_version.split('.')
-    temp_list = temp_version.split('.')
-    temp_list << 0.to_s if temp_list.size == 2
-    if cur_list[0] >= temp_list[0]
-      if cur_list[1] >= temp_list[1]
-        if cur_list[2] > temp_list[2]
-          return cur_version
-        end
-        return temp_version
-      end
-      return temp_version
-    end
-    return temp_version
-  end
-end
-end

data/lib/big_keeper/util/podfile_module.rb

@@ -1,63 +0,0 @@
-require 'big_keeper/util/bigkeeper_parser'
-require 'big_keeper/util/podfile_detector'
-require 'big_keeper/model/podfile_model'
-require 'big_keeper/util/logger'
-
-module BigKeeper
-
-class PodfileModuleDetector
-  @module_list = []
-
-  def initialize(main_path)
-    @module_list = BigkeeperParser.module_names
-    @main_path = main_path
-    @update_modules = {}
-    # check_version_list
-  end
-
-  #检查需要更新业务库列表
-  def check_version_list
-    if @module_list.empty?
-      Logger.highlight('There is not any module should to be check.')
-      return
-    else
-      Logger.highlight('Checking..')
-      @module_list.each do |module_name|
-        get_pod_search_result(module_name)
-      end
-
-      #获得pod信息后
-      deal_module_info
-    end
-  end
-
-  def get_pod_search_result(pod_name)
-    #输入pod Search 结果
-    `pod search #{pod_name} --ios --simple >> #{@main_path}/bigKeeperPodInfo.tmp`
-  end
-
-  def deal_module_info
-    podfile_lines = File.readlines("#{@main_path}/bigKeeperPodInfo.tmp", :encoding => 'UTF-8')
-    Logger.highlight("Analyzing modules info...") unless podfile_lines.size.zero?
-      podfile_lines.collect do |sentence|
-        if sentence =~(/pod/)
-          sentence = sentence.sub('pod', '')
-          sentence = sentence.delete('\n\'')
-          match_result = sentence.split(',')
-          pod_name = match_result[0].strip
-          latest_version = match_result[1].strip
-          @update_modules[pod_name] = latest_version  unless @update_modules.include?(pod_name)
-        end
-      end
-    p @update_modules
-    File.delete("#{@main_path}/bigKeeperPodInfo.tmp")
-    @update_modules
-  end
-
-  def get_module_latest_version(pod_model)
-
-  end
-
-end
-
-end

data/lib/big_keeper/util/podfile_operator.rb

@@ -1,125 +0,0 @@
-require 'tempfile'
-require 'fileutils'
-require 'big_keeper/dependency/dep_type'
-require 'big_keeper/util/podfile_detector'
-
-module BigKeeper
-  # Operator for podfile
-  class PodfileOperator
-    def has(podfile, module_name)
-      File.open(podfile, 'r') do |file|
-        file.each_line do |line|
-          if line.include?module_name
-            return true
-          end
-        end
-      end
-      false
-    end
-
-    def generate_pod_config(pod_name, version, comment)
-      module_config = ''
-      if comment != nil
-        module_config = "  pod '#{pod_name}' , '#{version}' # #{comment}"
-      else
-        module_config =  "  pod '#{pod_name}' , '#{version}'"
-      end
-    end
-
-    def replace_all_module_release(path, user, module_names, version)
-      module_names.each do |module_name|
-        DepService.dep_operator(path, user).update_module_config(
-                                             module_name,
-                                             ModuleOperateType::RELEASE)
-      end
-
-    end
-
-    def find_and_lock(podfile, dictionary)
-      temp_file = Tempfile.new('.Podfile.tmp', :encoding => 'UTF-8')
-      begin
-        File.open(podfile, 'r') do |file|
-          file.each_line do |line|
-            pod_model = PodfileParser.get_pod_model(line)
-            if pod_model != nil && pod_model.name != nil && dictionary[pod_model.name] != nil
-                temp_file.puts generate_pod_config(pod_model.name, dictionary[pod_model.name], pod_model.comment)
-                dictionary.delete(pod_model.name)
-            else
-                temp_file.puts line
-            end
-          end
-        end
-        if !dictionary.empty?
-          temp_file.puts 'def sub_dependency'
-          dictionary.keys.each do |sub_pod|
-            temp_file.puts generate_pod_config(sub_pod, dictionary[sub_pod], 'bigkeeper')
-          end
-          temp_file.puts 'end'
-        end
-        temp_file.close
-        FileUtils.mv(temp_file.path, podfile)
-      ensure
-        temp_file.close
-        temp_file.unlink
-      end
-    end
-
-    def find_and_upgrade(podfile, dictionary)
-      temp_file = Tempfile.new('.Podfile.tmp', :encoding => 'UTF-8')
-      begin
-        File.open(podfile, 'r', :encoding => 'UTF-8') do |file|
-          file.each_line do |line|
-            pod_model = PodfileParser.get_pod_model(line)
-            if pod_model != nil && pod_model.name != nil && dictionary[pod_model.name] != nil
-                #替换
-                temp_file.puts generate_pod_config(pod_model.name, dictionary[pod_model.name], pod_model.comment)
-            else
-                temp_file.puts line
-            end
-          end
-        end
-        temp_file.close
-        FileUtils.mv(temp_file.path, podfile)
-      ensure
-        temp_file.close
-        temp_file.unlink
-      end
-    end
-
-    def podspec_change(podspec_file, version, module_name)
-      temp_file = Tempfile.new(".#{module_name}.podspec", :encoding => 'UTF-8')
-      has_change = false
-      begin
-        File.open(podspec_file, 'r', :encoding => 'UTF-8') do |file|
-          file.each_line do |line|
-            if line.include?("s.version")
-              temp_line = line
-              temp_line_arr = temp_line.split("=")
-              if temp_line_arr[0].delete(" ") == "s.version"
-                unless temp_line_arr[temp_line_arr.length - 1].include? "#{version}"
-                    temp_file.puts "s.version = '#{version}'"
-                    has_change = true
-                else
-                    temp_file.puts line
-                    Logger.highlight("The version in PodSpec is equal your input version")
-                end
-              else
-                temp_file.puts line
-              end
-            else
-                temp_file.puts line
-            end
-          end
-        end
-        temp_file.close
-        FileUtils.mv(temp_file.path, podspec_file)
-      ensure
-        temp_file.close
-        temp_file.unlink
-      end
-      has_change
-    end
-
-    private :generate_pod_config
-  end
-end

data/lib/big_keeper/util/verify_operator.rb

@@ -1,17 +0,0 @@
-module BigKeeper
-  # Operator for got
-  class VerifyOperator
-    def self.already_in_process?
-      already_in_process = false
-      Open3.popen3('ps aux | grep \<big\> -c') do |stdin , stdout , stderr, wait_thr|
-        while line = stdout.gets
-          if line.rstrip.to_i > 2
-            already_in_process = true
-            break
-          end
-        end
-      end
-      already_in_process
-    end
-  end
-end

data/lib/big_keeper/util/version_config_operator.rb

@@ -1,29 +0,0 @@
-module BigKeeper
-  class VersionConfigOperator
-    def self.change_version(version_config_file, modules, version)
-      temp_file = Tempfile.new('.version-config.gradle.tmp')
-      begin
-        File.open(version_config_file, 'r') do |file|
-          file.each_line do |line|
-            temp_file.puts(replace_module_version(line, modules, version))
-          end
-        end
-        temp_file.close
-        FileUtils.mv(temp_file.path, version_config_file)
-      ensure
-        temp_file.close
-        temp_file.unlink
-      end
-    end
-
-    def self.replace_module_version(line, modules, version)
-      modules.each do |module_name|
-        version_alias = BigkeeperParser.module_version_alias(module_name)
-        if !version_alias.nil? && !version_alias.empty? && line.match(/\s*#{version_alias}\s*=\s*('|")([\s\S]*)('|")\s*/)
-          return line.sub(/(\s*#{version_alias}\s*=\s*)('|")([\s\S]*)('|")\s*/){"#{$1}\'#{version}\'"}
-        end
-      end
-      line
-    end
-  end
-end