kookeeper 3.0.1 → 3.0.4

data/lib/big_keeper/util/gitflow_operator.rb

@@ -0,0 +1,51 @@
+require 'big_keeper/model/gitflow_type'
+
+module BigKeeper
+  # Operator for gitflow
+  class GitflowOperator
+    def start(path, name, type)
+      Dir.chdir(path) do
+        gitflow_type_name = GitflowType.name(type)
+        `git flow #{gitflow_type_name} start #{name}`
+      end
+    end
+
+    def verify_git_flow_command
+      has_git_flow_command = false
+      IO.popen('command -v git-flow') do |io|
+        io.each do |line|
+          has_git_flow_command = true
+        end
+      end
+      has_git_flow_command
+    end
+
+    def verify_git_flow(path)
+      has_git_flow = false
+      Dir.chdir(path) do
+        clear_flag = 'Already initialized for gitflow'
+        IO.popen('git flow init -d') do |io|
+          io.each do |line|
+            if line.include? clear_flag
+              has_git_flow = true
+              break
+            end
+          end
+        end
+      end
+      has_git_flow
+    end
+
+    def finish_release(path, release_name)
+      Dir.chdir(path) do
+        p `git checkout master`
+        p `git merge release/#{release_name}`
+        p `git push`
+        p `git checkout develop`
+        p `git merge release/#{release_name}`
+        p `git push`
+        p `git branch -d release/#{release_name}`
+      end
+    end
+  end
+end

data/lib/big_keeper/util/gradle_operator.rb

@@ -0,0 +1,209 @@
+require 'big_keeper/util/cache_operator'
+
+module BigKeeper
+  # Operator for podfile
+  class GradleOperator
+    def initialize(path)
+      @path = path
+    end
+
+    def backup
+      cache_operator = CacheOperator.new(@path)
+
+      cache_operator.save('settings.gradle')
+
+      Dir.glob("#{@path}/*/build.gradle").each do |build_gradle_file_path|
+        build_gradle_file = build_gradle_file_path.gsub!(/#{@path}/, '')
+        cache_operator.save(build_gradle_file)
+      end
+    end
+
+    def recover(settings_config, build_config)
+      cache_operator = CacheOperator.new(@path)
+
+      cache_operator.load('settings.gradle') if settings_config
+
+      if build_config
+        Dir.glob("#{@path}/*/build.gradle").each do |build_gradle_file_path|
+          build_gradle_file = build_gradle_file_path.gsub!(/#{@path}/, '')
+          cache_operator.load(build_gradle_file)
+        end
+      end
+
+      cache_operator.clean
+    end
+
+    def update_settings_config(current_module_name, modules, module_operate_type, user)
+      return if modules.empty?
+
+      if ModuleOperateType::ADD == module_operate_type
+        modules.each do |module_name|
+          next if current_module_name == module_name
+
+          File.open("#{@path}/settings.gradle", 'a') do |file|
+            file.puts "\r\ninclude ':module:#{module_name.downcase}'\r\n"
+            file.puts "project(':module:#{module_name.downcase}')." \
+              "projectDir = new File(rootProject.projectDir," \
+              "'#{BigkeeperParser.module_path(user, module_name)}/#{module_name.downcase}-lib')\r\n"
+          end
+        end
+      else
+        modules.each do |module_name|
+          next if current_module_name == module_name
+          temp_file = Tempfile.new('.settings.gradle.tmp')
+          begin
+            File.open("#{@path}/settings.gradle", 'r') do |file|
+              file.each_line do |line|
+                unless line =~ /(\s*)include(\s*)('|")(\S*):#{module_name.downcase}('|")(\S*)/ ||
+                  line =~ /(\s*)project\(('|")(\S*):#{module_name.downcase}('|")\).(\S*)/
+                  temp_file.puts(line)
+                end
+              end
+            end
+            temp_file.close
+            FileUtils.mv(temp_file.path, "#{@path}/settings.gradle")
+          ensure
+            temp_file.close
+            temp_file.unlink
+          end
+        end
+      end
+    end
+
+    def update_build_config(current_module_name, modules, module_operate_type)
+      return if modules.empty?
+
+      Dir.glob("#{@path}/*/build.gradle").each do |file_path|
+        modules.each do |module_name|
+          next if current_module_name == module_name
+
+          temp_file = Tempfile.new('.build.gradle.tmp')
+          begin
+            version_flag = false
+            version_index = 0
+
+            File.open(file_path, 'r') do |file|
+              file.each_line do |line|
+                new_line, version_index, version_flag = generate_build_config(
+                  line,
+                  module_name,
+                  module_operate_type,
+                  version_index,
+                  version_flag)
+
+                temp_file.puts(new_line)
+              end
+            end
+            temp_file.close
+            FileUtils.mv(temp_file.path, file_path)
+          ensure
+            temp_file.close
+            temp_file.unlink
+          end
+        end
+      end
+    end
+
+    def generate_build_config(line, module_name, module_operate_type, version_index, version_flag)
+      new_line = line
+
+      version_flag = true if line.downcase.include? 'modifypom'
+      if version_flag
+        version_index += 1 if line.include? '{'
+        version_index -= 1 if line.include? '}'
+
+        version_flag = false if 0 == version_flag
+
+        new_line = generate_version_config(line, module_name, module_operate_type)
+      else
+        new_line = generate_compile_config(line, module_name, module_operate_type)
+      end
+
+      [new_line, version_index, version_flag]
+    end
+
+    def generate_version_config(line, module_name, module_operate_type)
+      if ModuleOperateType::FINISH == module_operate_type || ModuleOperateType::PUBLISH == module_operate_type
+        branch_name = GitOperator.new.current_branch(@path)
+        full_name = ''
+
+        # Get version part of source.addition
+        if ModuleOperateType::PUBLISH == module_operate_type
+          full_name = branch_name.sub(/([\s\S]*)\/(\d+.\d+.\d+)_([\s\S]*)/){ $2 }
+        else
+          full_name = branch_name.sub(/([\s\S]*)\/([\s\S]*)/){ $2 }
+        end
+
+        line.sub(/(\s*)version ('|")(\S*)('|")([\s\S]*)/){
+          "#{$1}version '#{full_name}'#{$5}"
+        }
+      else
+        line
+      end
+    end
+
+    def generate_compile_config(line, module_name, module_operate_type)
+      if ModuleOperateType::ADD == module_operate_type
+        line.sub(/(\s*)compile(\s*)('|")(\S*):#{module_name.downcase}:(\S*)('|")(\S*)/){
+          "#{$1}compile project(':module:#{module_name.downcase}')"
+        }
+      elsif ModuleOperateType::DELETE == module_operate_type
+        line.sub(/(\s*)([\s\S]*)('|")(\S*):#{module_name.downcase}:(\S*)('|")(\S*)/){
+          origin_config_of_module = origin_config_of_module(module_name)
+          if origin_config_of_module.empty?
+            line
+          else
+            origin_config_of_module
+          end
+        }
+      elsif ModuleOperateType::FINISH == module_operate_type || ModuleOperateType::PUBLISH == module_operate_type
+        branch_name = GitOperator.new.current_branch(@path)
+        full_name = ''
+
+        # Get version part of source.addition
+        if ModuleOperateType::PUBLISH == module_operate_type
+          full_name = branch_name.sub(/([\s\S]*)\/(\d+.\d+.\d+)_([\s\S]*)/){ $2 }
+        else
+          full_name = branch_name.sub(/([\s\S]*)\/([\s\S]*)/){ $2 }
+        end
+        line.sub(/(\s*)([\s\S]*)('|")(\S*):#{module_name.downcase}(:\S*)*('|")(\S*)/){
+          if $2.downcase.include? 'modulecompile'
+            "#{$1}moduleCompile '#{prefix_of_module(module_name)}:#{module_name.downcase}:#{full_name}-SNAPSHOT'"
+          else
+            "#{$1}compile '#{prefix_of_module(module_name)}:#{module_name.downcase}:#{full_name}-SNAPSHOT'"
+          end
+        }
+      else
+        line
+      end
+    end
+
+    def origin_config_of_module(module_name)
+      origin_config = ''
+
+      Dir.glob("#{@path}/.bigkeeper/*/build.gradle").each do |file|
+        File.open(file, 'r') do |file|
+          file.each_line do |line|
+            if line =~ /(\s*)([\s\S]*)('|")(\S*):#{module_name.downcase}:(\S*)('|")(\S*)/
+              origin_config = line
+              break
+            end
+          end
+        end
+        break unless origin_config.empty?
+      end
+
+      origin_config.chop
+    end
+
+    def prefix_of_module(module_name)
+      origin_config = origin_config_of_module(module_name)
+      prefix = origin_config.sub(/(\s*)([\s\S]*)('|")(\S*)#{module_name.downcase}(\S*)('|")(\S*)/){
+        $4
+      }
+      prefix.chop
+    end
+
+    private :generate_build_config, :generate_compile_config, :generate_version_config, :origin_config_of_module, :prefix_of_module
+  end
+end

data/lib/big_keeper/util/info_plist_operator.rb

@@ -0,0 +1,46 @@
+#!/usr/bin/ruby
+require 'plist' # gem install plist
+require 'big_stash/stash_operator'
+require 'pathname'
+
+module BigKeeper
+  # Operator for Info.plist
+  class InfoPlistOperator
+    def change_version_build(path, version)
+      if find_infoPlist_filePath(path) == ''
+        raise %(Not find be Info.plist at #{path})
+      end
+      info_plist_path = find_infoPlist_filePath(path)
+      result = Plist.parse_xml(info_plist_path)
+      result['CFBundleVersion'] = getBuildVersion(version, result['CFBundleShortVersionString'], result['CFBundleVersion']).to_s
+      result['CFBundleShortVersionString'] = version.to_s
+      Plist::Emit.save_plist(result, info_plist_path)
+      puts %Q('Version has changed to #{version}')
+    end
+
+    # Find Info.plist file path
+    # @return [String] pathName of info.plist
+    def find_infoPlist_filePath(path)
+      paths = Pathname.new(path).children.select { |pn| pn.extname == '.xcodeproj' }
+      xcodePath = paths[0].to_s.split('/')[-1]
+      projectName = xcodePath.split('.')[0]
+      projectPath = ''
+      Pathname.new("#{path}/#{projectName}").children.select { |pn|
+        if pn.to_s == "#{path}/#{projectName}/Info.plist"
+          projectPath = "#{path}/#{projectName}/Info.plist"
+        end
+      }
+      projectPath
+    end
+
+    private
+    def getBuildVersion(build_string, old_build_string, old_build_version)
+      if build_string == old_build_string
+        return old_build_version.to_i + 1
+      else
+        version_arr = build_string.split('.')
+        return version_arr[0].to_i * 1000 + version_arr[1].to_i * 100 + version_arr[2].to_i * 10
+      end
+    end
+  end
+end

data/lib/big_keeper/util/leancloud_logger.rb

@@ -0,0 +1,72 @@
+require 'Singleton'
+require 'net/http'
+require 'net/https'
+require 'big_keeper/util/logger'
+
+module BigKeeper
+  class LeanCloudLogger
+    include Singleton
+
+    attr_accessor :user, :version, :start_timestamp, :end_timestamp, :command, :parameter, :is_success, :path
+
+    def set_command(set_command)
+      @command = set_command
+    end
+
+    def start_log(global_options, args)
+      @start_timestamp = Time.new.to_i
+      @user = global_options['user'].to_s
+      @parameter = args.join(",")
+      @version = global_options['ver']
+      @path = global_options['path']
+    end
+
+    def end_log(is_success)
+      @end_timestamp = Time.new.to_i
+      @is_success = is_success
+      @version = BigkeeperParser.version if @version == 'Version in Bigkeeper file'
+
+      # require
+      parameter = {'start_timestamp' => @start_timestamp, 'end_timestamp' =>@end_timestamp, 'user' =>@user, 'is_success' =>@is_success}
+
+      # optional
+      parameter = parameter.merge('command' => @command) unless @command == nil
+      parameter = parameter.merge('version' => @version) unless @version == nil || @version == ""
+      parameter = parameter.merge('parameter' => @parameter) unless @parameter == nil || @parameter == ""
+
+      leancloud_file = @command.split("/").first
+
+      send_log_cloud(leancloud_file, parameter)
+    end
+
+    def send_log_cloud(file_name, parameter)
+      if file_name == nil
+        return
+      end
+
+      if BigkeeperParser.global_configs("LeanCloudId") == nil || BigkeeperParser.global_configs("LeanCloudKey") == nil
+        return
+      end
+
+      header = assemble_request
+
+      uri = URI.parse("https://api.leancloud.cn/1.1/classes/#{file_name}")
+
+      https = Net::HTTP.new(uri.host, 443)
+      https.use_ssl = true
+      https.ssl_version = :TLSv1
+      https.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      req = Net::HTTP::Post.new(uri.path, header)
+      req.body = parameter.to_json
+      res = https.request(req)
+
+      Logger.highlight("Send LeanCloud success, response #{res.body}")
+    end
+
+    def assemble_request
+      return {'Content-Type' =>'application/json', 'X-LC-Id' =>BigkeeperParser.global_configs("LeanCloudId"), 'X-LC-Key' =>BigkeeperParser.global_configs("LeanCloudKey")}
+    end
+
+    protected :send_log_cloud, :assemble_request
+    end
+  end

data/lib/big_keeper/util/list_generator.rb

@@ -0,0 +1,101 @@
+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)
+      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)
+      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/logger.rb

@@ -0,0 +1,46 @@
+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)
+      LeanCloudLogger.instance.end_log(false)
+      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

@@ -0,0 +1,70 @@
+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