shkeeper 1.0.0

data/lib/big_keeper/util/git_operator.rb

@@ -0,0 +1,226 @@
+require 'big_keeper/util/logger'
+
+module BigKeeper
+  # Operator for got
+  class GitOperator
+    def current_branch(path)
+      Dir.chdir(path) do
+        `git rev-parse --abbrev-ref HEAD`.chop
+      end
+    end
+
+    def has_remote_branch(path, branch_name)
+      has_branch = false
+      IO.popen("cd '#{path}'; git branch -r") do |io|
+        io.each do |line|
+          has_branch = true if line.include? branch_name
+        end
+      end
+      has_branch
+    end
+
+    def has_local_branch(path, branch_name)
+      has_branch = false
+      IO.popen("cd '#{path}'; git branch") do |io|
+        io.each do |line|
+          has_branch = true if line.include? branch_name
+        end
+      end
+      has_branch
+    end
+
+    def has_branch(path, branch_name)
+      has_branch = false
+      IO.popen("cd '#{path}'; git branch -a") do |io|
+        io.each do |line|
+          has_branch = true if line.include? branch_name
+        end
+      end
+      has_branch
+    end
+
+    def checkout(path, branch_name)
+      Dir.chdir(path) do
+        p "----------cd：#{path}"
+        p "----------git checkout #{branch_name}"
+        IO.popen("git checkout #{branch_name}") do |io|
+          io.each do |line|
+            Logger.error("Checkout #{branch_name} failed.") if line.include? 'error'
+          end
+        end
+      end
+    end
+
+    def fetch(path)
+      Dir.chdir(path) do
+        `git fetch origin`
+      end
+    end
+
+    def rebase(path, branch_name)
+      Dir.chdir(path) do
+        `git rebase origin/#{branch_name}`
+      end
+    end
+
+    def clone(path, git_base)
+      Dir.chdir(path) do
+        `git clone #{git_base}`
+      end
+    end
+
+    def commit(path, message)
+      Dir.chdir(path) do
+        `git add .`
+        `git commit -m "#{Logger.formatter_output(message)}"`
+      end
+    end
+
+    def push_to_remote(path, branch_name)
+      Dir.chdir(path) do
+        p  "git push -u origin #{branch_name}"
+        `git push -u origin #{branch_name}`
+      end
+      GitOperator.new.check_push_success(path, branch_name, "origin/#{branch_name}")
+    end
+
+    def pull(path)
+      Dir.chdir(path) do
+        p "----------cd：#{path}"
+        p "----------git pull"
+        `git pull`
+      end
+    end
+
+    def has_commits(path, branch_name)
+      has_commits = false
+      IO.popen("cd '#{path}'; git log --branches --not --remotes") do |io|
+        io.each do |line|
+          has_commits = true if line.include? "(#{branch_name})"
+        end
+      end
+      has_commits
+    end
+
+    def has_changes(path)
+      has_changes = true
+      clear_flag = 'nothing to commit, working tree clean'
+      IO.popen("cd '#{path}'; git status") do |io|
+        io.each do |line|
+          has_changes = false if line.include? clear_flag
+        end
+      end
+      has_changes
+    end
+
+    def discard(path)
+      Dir.chdir(path) do
+        `git checkout . && git clean -xdf`
+      end
+    end
+
+    def del_local(path, branch_name)
+      Dir.chdir(path) do
+        `git branch -D #{branch_name}`
+      end
+    end
+
+    def del_remote(path, branch_name)
+      Dir.chdir(path) do
+        `git push origin --delete #{branch_name}`
+      end
+    end
+
+    def user
+      `git config user.name`.chop
+    end
+
+    def tag(path, version)
+      tags = Array.new
+      IO.popen("cd '#{path}'; git tag") do |io|
+        io.each do |line|
+          tags << line
+        end
+      end
+      unless tags.include? "#{version}\n"
+        Dir.chdir(path) do
+          `git tag -a #{version} -m "release: V #{version}" master;`
+          `git push --tags`
+        end
+        return
+      end
+      Logger.highlight("tag already exists in the remote, skip this step")
+    end
+
+    def tag_list(path)
+      tag_list = Array.new
+      IO.popen("cd '#{path}'; git tag -l") do |io|
+        io.each do |line|
+          unless line=~(/[a-zA-Z]/)
+            tag_list << line
+          end
+        end
+      end
+      tag_list
+    end
+
+    def check_merge(path, condition)
+      unmerged_branch = Array.new
+      IO.popen("cd '#{path}'; git branch --no-merged") do |io|
+        io.each do |line|
+          unmerged_branch.push(line) if line.include? "#{condition}"
+        end
+      end
+      if (unmerged_branch.size > 0)
+        unmerged_branch.map { |item|
+            Logger.default(item)
+        }
+        Logger.error("Still has unmerged feature branch, please check")
+      end
+    end
+
+    def check_diff(path, branch, compare_branch)
+      compare_branch_commits = Array.new
+      IO.popen("cd '#{path}'; git log --left-right #{branch}...#{compare_branch} --pretty=oneline") do |io|
+        io.each do |line|
+          compare_branch_commits.push(line) if (line.include? '>') && (line.include? "Merge branch #{branch} into #{compare_branch}")
+        end
+      end
+      if compare_branch_commits.size > 0
+        compare_branch_commits.map { |item|
+            Logger.default(item)
+        }
+        Logger.error("#{compare_branch} branch has commit doesn't committed in #{branch}, please check")
+      else
+        Logger.highlight("#{compare_branch} branch doesn't have commit before #{branch}")
+      end
+    end
+
+    def merge(path, branch_name)
+      IO.popen("cd '#{path}'; git merge #{branch_name}") do |line|
+        Logger.error("Merge conflict in #{branch_name}") if line.include? 'Merge conflict'
+      end
+    end
+
+    def check_push_success(path, branch, compare_branch)
+      compare_branch_commits = Array.new
+      IO.popen("cd '#{path}'; git log --left-right #{branch}...#{compare_branch} --pretty=oneline") do |io|
+        io.each do |line|
+          compare_branch_commits.push(line) if (line.include? '>') || (line.include? 'fatal')
+        end
+      end
+      if compare_branch_commits.size > 0
+        compare_branch_commits.map { |item|
+            Logger.default(item)
+        }
+        Logger.error("#{branch} branch push unsuccess, please check")
+      else
+        Logger.highlight("#{branch} branch push success")
+      end
+    end
+
+  end
+
+  # p GitOperator.new.user
+  # BigStash::StashOperator.new("/Users/mmoaay/Documents/eleme/BigKeeperMain").list
+end

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