kookeeper 3.0.0 → 3.0.1

data/lib/big_keeper/service/git_service.rb

@@ -1,211 +0,0 @@
-require 'big_keeper/util/git_operator'
-require 'big_keeper/util/gitflow_operator'
-require 'big_keeper/model/gitflow_type'
-require 'big_keeper/model/operate_type'
-require 'big_keeper/util/logger'
-
-module BigKeeper
-  # Operator for got
-  class GitService
-    def start(path, name, type)
-      git = GitOperator.new
-
-      branch_name = "#{GitflowType.name(type)}/#{name}"
-      if !git.has_remote_branch(path, branch_name) && !git.has_local_branch(path, branch_name)
-
-        verify_special_branch(path, 'master')
-        verify_special_branch(path, 'develop')
-
-        GitflowOperator.new.verify_git_flow(path)
-
-        GitflowOperator.new.start(path, name, type)
-        git.push_to_remote(path, branch_name)
-      else
-        verify_checkout(path, branch_name)
-
-        if !git.has_remote_branch(path, branch_name)
-          git.push_to_remote(path, branch_name)
-        end
-      end
-    end
-
-    def verify_checkout(path, branch_name)
-      Dir.chdir(path) do
-        cmd = "git checkout -b #{branch_name}"
-        if GitOperator.new.has_branch(path, branch_name)
-          cmd = "git checkout #{branch_name}"
-        end
-        IO.popen(cmd) do |io|
-          io.each do |line|
-            Logger.error("Checkout #{branch_name} failed.") if line.include? 'error'
-          end
-        end
-      end
-    end
-
-    def verify_checkout_pull(path, branch_name)
-      GitService.new.verify_checkout(path, branch_name)
-      GitService.new.pull(path, branch_name)
-    end
-
-    def verify_special_branch(path, name)
-      git = GitOperator.new
-
-      if git.has_remote_branch(path, name)
-        if git.has_local_branch(path, name)
-          if git.has_commits(path, name)
-            Logger.error(%Q('#{name}' has unpushed commits, you should fix it manually...))
-          end
-          pull(path, name)
-        else
-          git.checkout(path, name)
-        end
-      else
-        verify_checkout(path, name)
-        git.push_to_remote(path, name)
-      end
-    end
-
-    def verify_home_branch(path, branch_name, type)
-      Logger.highlight('Sync local branchs from remote, waiting...')
-      git = GitOperator.new
-
-      git.fetch(path)
-
-      if OperateType::START == type
-        if git.current_branch(path) == branch_name
-          Logger.error(%(Current branch is '#{branch_name}' already. Use 'update' please))
-        end
-        if git.has_branch(path, branch_name)
-          Logger.error(%(Branch '#{branch_name}' already exists. Use 'switch' please))
-        end
-      elsif OperateType::SWITCH == type
-        if !git.has_branch(path, branch_name)
-          Logger.error(%(Can't find a branch named '#{branch_name}'. Use 'start' please))
-        end
-        if git.current_branch(path) == branch_name
-          Logger.error(%(Current branch is '#{branch_name}' already. Use 'update' please))
-        end
-      elsif OperateType::UPDATE == type
-        if !git.has_branch(path, branch_name)
-          Logger.error(%(Can't find a branch named '#{branch_name}'. Use 'start' please))
-        end
-        if git.current_branch(path) != branch_name
-          Logger.error(%(Current branch is not '#{branch_name}'. Use 'switch' please))
-        end
-      else
-        Logger.error(%(Not a valid command for '#{branch_name}'.))
-      end
-    end
-
-    def current_branch_type(path)
-      branch_name = GitOperator.new.current_branch(path)
-      if branch_name =~ /^feature\/S*/
-        GitflowType::FEATURE
-      elsif branch_name =~ /^hotfix\/S*/
-        GitflowType::HOTFIX
-      elsif branch_name =~ /^release\/S*/
-        GitflowType::RELEASE
-      else
-        GitflowType::FEATURE
-      end
-    end
-
-    def branchs_with_type(path, type)
-      branchs = []
-      Dir.chdir(path) do
-        IO.popen('git branch -a') do | io |
-          io.each do | line |
-            branchs << line.gsub('\n', '') if line.include?('develop')
-            branchs << line.gsub(/\s/, '') if line =~ /[\s\S]*#{GitflowType.name(type)}*/
-          end
-        end
-      end
-      branchs
-    end
-
-    def pull(path, branch_name)
-      git = GitOperator.new
-      current_branch_name = git.current_branch(path)
-      if current_branch_name == branch_name
-        git.pull(path)
-      else
-        git.checkout(path, branch_name)
-        git.pull(path)
-        git.checkout(path, current_branch_name)
-      end
-    end
-
-    def verify_del(path, branch_name, name, type)
-      git = GitOperator.new
-
-      if git.has_local_branch(path, branch_name)
-        Logger.highlight("Delete local branch '#{branch_name}' for '#{name}'...")
-
-        if git.current_branch(path) == branch_name
-          git.discard(path)
-          git.checkout(path, GitflowType.base_branch(type))
-        end
-        git.del_local(path, branch_name)
-      end
-
-      if git.has_remote_branch(path, branch_name)
-        Logger.highlight("Delete remote branch '#{branch_name}' for '#{name}'...")
-        git.del_remote(path, branch_name)
-      end
-    end
-
-    def verify_push(path, comment, branch_name, name)
-      git = GitOperator.new
-      if git.has_changes(path) || git.has_commits(path, branch_name)
-
-        git.commit(path, comment) if git.has_changes(path)
-
-        if git.has_remote_branch(path, branch_name)
-          Dir.chdir(path) do
-            `git push`
-          end
-        else
-          git.push_to_remote(path, branch_name)
-        end
-
-        GitOperator.new.check_push_success(path, branch_name, "origin/#{branch_name}")
-      else
-        Logger.default("Nothing to push for '#{name}'.")
-      end
-    end
-
-    def verify_rebase(path, branch_name, name)
-
-      # pull rebased branch
-      pull(path, branch_name)
-
-      Dir.chdir(path) do
-        IO.popen("git rebase #{branch_name} --ignore-whitespace") do |io|
-          unless io.gets
-            Logger.error("#{name} is already in a rebase-apply, Please:\n"\
-                         "  1.Resolve it;\n"\
-                         "  2.Commit the changes;\n"\
-                         "  3.Push to remote;\n"\
-                         "  4.Create a MR;\n"\
-                         "  5.Run 'finish' again.")
-          end
-          io.each do |line|
-            next unless line.include? 'Merge conflict'
-            Logger.error("Merge conflict in #{name}, Please:\n"\
-                         "  1.Resolve it;\n"\
-                         "  2.Commit the changes;\n"\
-                         "  3.Push to remote;\n"\
-                         "  4.Create a MR;\n"\
-                         "  5.Run 'finish' again.")
-          end
-        end
-        if GitOperator.new.current_branch(path) != 'develop' && GitOperator.new.current_branch(path) != 'master'
-          `git push -f`
-        else
-          Logger.error("You should not push 'master' or 'develop'")
-        end
-      end
-    end
-  end
-end

data/lib/big_keeper/service/module_service.rb

@@ -1,224 +0,0 @@
-require 'big_keeper/service/git_service'
-
-require 'big_keeper/util/logger'
-require 'big_keeper/util/cache_operator'
-
-module BigKeeper
-  # Operator for got
-  class ModuleService
-
-    def verify_module(path, user, module_name, home_branch_name, type)
-      name = home_branch_name.gsub(/#{GitflowType.name(type)}\//, '')
-      module_full_path = BigkeeperParser.module_full_path(path, user, module_name)
-
-      git = GitOperator.new
-      if !File.exist? module_full_path
-        Logger.default("No local repository for module '#{module_name}', clone it...")
-        module_git = BigkeeperParser.module_git(module_name)
-        git.clone(File.expand_path("#{module_full_path}/../"), module_git)
-      end
-
-      current_branch_name = git.current_branch(module_full_path)
-      if current_branch_name != home_branch_name
-        # stash current branch
-        StashService.new.stash(module_full_path, current_branch_name, module_name)
-
-        GitService.new.start(module_full_path, name, type)
-
-        StashService.new.pop_stash(module_full_path, home_branch_name, module_name)
-      end
-    end
-
-    def push(path, user, module_name, home_branch_name, type, comment)
-      Logger.highlight("Push branch '#{home_branch_name}' for module '#{module_name}'...")
-
-      verify_module(path, user, module_name, home_branch_name, type)
-
-      module_full_path = BigkeeperParser.module_full_path(path, user, module_name)
-      GitService.new.verify_push(module_full_path, comment, home_branch_name, module_name)
-    end
-
-    def rebase(path, user, module_name, home_branch_name, type)
-      Logger.highlight("Rebase '#{GitflowType.base_branch(type)}' "\
-        "to branch '#{home_branch_name}' for module "\
-        "'#{module_name}'...")
-
-      verify_module(path, user, module_name, home_branch_name, type)
-
-      module_full_path = BigkeeperParser.module_full_path(path, user, module_name)
-
-      Logger.error("You have some changes in branch "\
-        "'#{home_branch_name}' for module '#{module_name}'. "\
-        "Use 'push' first please") if GitOperator.new.has_changes(module_full_path)
-
-      GitService.new.verify_rebase(module_full_path, GitflowType.base_branch(type), module_name)
-    end
-
-    def pull(path, user, module_name, home_branch_name, type)
-      Logger.highlight("Pull branch '#{home_branch_name}' for module '#{module_name}'...")
-
-      verify_module(path, user, module_name, home_branch_name, type)
-
-      module_full_path = BigkeeperParser.module_full_path(path, user, module_name)
-      GitOperator.new.pull(module_full_path)
-    end
-
-    def switch_to(path, user, module_name, home_branch_name, type)
-      Logger.highlight("Switch to branch '#{home_branch_name}' for module '#{module_name}'...")
-
-      verify_module(path, user, module_name, home_branch_name, type)
-    end
-
-    def pre_publish(path, user, module_name, home_branch_name, type)
-      Logger.highlight("Prepare to publish branch '#{home_branch_name}' for module '#{module_name}'...")
-
-      verify_module(path, user, module_name, home_branch_name, type)
-
-      module_full_path = BigkeeperParser.module_full_path(path, user, module_name)
-      GitService.new.verify_push(module_full_path, "prepare to rebase '#{GitflowType.base_branch(type)}'", home_branch_name, module_name)
-      GitService.new.verify_rebase(module_full_path, GitflowType.base_branch(type), module_name)
-    end
-
-    def publish(path, user, module_name, home_branch_name, type)
-      Logger.highlight("Publish branch '#{home_branch_name}' for module '#{module_name}'...")
-
-      DepService.dep_operator(path, user).update_module_config(module_name, ModuleOperateType::PUBLISH)
-
-      module_full_path = BigkeeperParser.module_full_path(path, user, module_name)
-      GitService.new.verify_push(module_full_path, "publish branch #{home_branch_name}", home_branch_name, module_name)
-
-      `open #{BigkeeperParser.module_pulls(module_name)}`
-
-      ModuleCacheOperator.new(path).del_git_module(module_name)
-    end
-
-    def finish(path, user, module_name, home_branch_name, type)
-      Logger.highlight("Finish branch '#{home_branch_name}' for module '#{module_name}'...")
-
-      verify_module(path, user, module_name, home_branch_name, type)
-
-      DepService.dep_operator(path, user).update_module_config(module_name, ModuleOperateType::FINISH)
-
-      module_full_path = BigkeeperParser.module_full_path(path, user, module_name)
-      GitService.new.verify_push(module_full_path, "finish branch #{home_branch_name}", home_branch_name, module_name)
-
-      ModuleCacheOperator.new(path).add_git_module(module_name)
-      ModuleCacheOperator.new(path).del_path_module(module_name)
-    end
-
-    def add(path, user, module_name, name, type)
-      home_branch_name = "#{GitflowType.name(type)}/#{name}"
-      Logger.highlight("Add branch '#{home_branch_name}' for module '#{module_name}'...")
-
-      verify_module(path, user, module_name, home_branch_name, type)
-
-      DepService.dep_operator(path, user).update_module_config(module_name, ModuleOperateType::ADD)
-
-      module_full_path = BigkeeperParser.module_full_path(path, user, module_name)
-      GitService.new.verify_push(module_full_path, "init #{GitflowType.name(type)} #{name}", home_branch_name, module_name)
-
-      ModuleCacheOperator.new(path).add_path_module(module_name)
-    end
-
-    def del(path, user, module_name, name, type)
-      home_branch_name = "#{GitflowType.name(type)}/#{name}"
-
-      Logger.highlight("Delete branch '#{home_branch_name}' for module '#{module_name}'...")
-
-      module_git = BigkeeperParser.module_git(module_name)
-      DepService.dep_operator(path, user).update_module_config(module_name, ModuleOperateType::DELETE)
-
-      # Stash module current branch
-      module_full_path = BigkeeperParser.module_full_path(path, user, module_name)
-      current_branch_name = GitOperator.new.current_branch(module_full_path)
-      StashService.new.stash(module_full_path, current_branch_name, module_name)
-      GitOperator.new.checkout(module_full_path, GitflowType.base_branch(type))
-
-      ModuleCacheOperator.new(path).del_path_module(module_name)
-    end
-
-    def module_info(module_path, home_branch_name, user, type, module_name, version)
-      result_dic = {}
-      matched_branches = []
-      branches = GitService.new.branchs_with_type(module_path, type)
-      if version == 'all versions'
-        matched_branches = branches
-      else
-        branches.each do | branch |
-          matched_branches << branch if branch.include?(version)
-        end
-      end
-      result_dic[:module_name] = module_name
-      result_dic[:current_branch] = GitOperator.new.current_branch(module_path)
-      result_dic[:branches] = matched_branches
-      result_dic
-    end
-
-    def release_check_changed(path, user, module_name)
-      module_full_path = BigkeeperParser.module_full_path(path, user, module_name)
-
-      git = GitOperator.new
-      if !File.exist? module_full_path
-        Logger.default("No local repository for module '#{module_name}', clone it...")
-        module_git = BigkeeperParser.module_git(module_name)
-        git.clone(File.expand_path("#{module_full_path}/../"), module_git)
-      end
-      GitService.new.verify_checkout_pull(module_full_path, 'develop')
-      git.check_remote_branch_diff(module_full_path, 'develop', 'master')
-    end
-
-    def release_start(path, user, modules, module_name, version)
-      module_full_path = BigkeeperParser.module_full_path(path, user, module_name)
-
-      git = GitOperator.new
-      if !File.exist? module_full_path
-        Logger.default("No local repository for module '#{module_name}', clone it...")
-        module_git = BigkeeperParser.module_git(module_name)
-        git.clone(File.expand_path("#{module_full_path}/../"), module_git)
-      end
-      #stash module
-      StashService.new.stash(module_full_path, GitOperator.new.current_branch(module_full_path), module_name)
-      # delete cache
-      CacheOperator.new(module_full_path).clean()
-      # checkout develop
-      GitService.new.verify_checkout_pull(module_full_path, 'develop')
-      DepService.dep_operator(path, user).release_module_start(modules, module_name, version)
-
-      # Push home changes to remote
-      Logger.highlight("Push branch 'develop' for #{module_name}...")
-      GitService.new.verify_push(
-        module_full_path,
-        "release start for #{version}",
-        'develop',
-        "#{module_name}")
-    end
-
-    def release_finish(path, user, modules, module_name, version)
-      module_full_path = BigkeeperParser.module_full_path(path, user, module_name)
-
-      git = GitOperator.new
-      if !File.exist? module_full_path
-        Logger.default("No local repository for module '#{module_name}', clone it...")
-        module_git = BigkeeperParser.module_git(module_name)
-        git.clone(File.expand_path("#{module_full_path}/../"), module_git)
-      end
-      #stash module
-      StashService.new.stash(module_full_path, GitOperator.new.current_branch(module_full_path), module_name)
-      # delete cache
-      CacheOperator.new(module_full_path).clean()
-      # checkout develop
-      GitService.new.verify_checkout_pull(module_full_path, 'develop')
-      DepService.dep_operator(path, user).release_module_finish(modules, module_name, version)
-
-      # Push home changes to remote
-      Logger.highlight("Push branch 'develop' for #{module_name}...")
-      GitService.new.verify_push(
-        module_full_path,
-        "release finish for #{version}",
-        'develop',
-        "#{module_name}")
-    end
-
-    private :verify_module
-  end
-end

data/lib/big_keeper/service/stash_service.rb

@@ -1,45 +0,0 @@
-require 'big_stash/stash_operator'
-require 'big_keeper/util/bigkeeper_parser'
-require 'big_keeper/util/git_operator'
-require 'big_keeper/util/logger'
-
-module BigKeeper
-  # Operator for got
-  class StashService
-    def pop_stash(path, branch_name, name)
-      # pop stash
-      if BigStash::StashOperator.new(path).stash_for_name(branch_name)
-        Logger.highlight(%Q(Branch '#{branch_name}' of '#{name}' has stash , start to pop...))
-        BigStash::StashOperator.new(path).pop_stash(branch_name)
-      end
-    end
-
-    def stash(path, branch_name, name)
-      # stash
-      if GitOperator.new.has_changes(path)
-        Logger.highlight(%Q(Branch '#{branch_name}' of '#{name}' needs stash , start to stash...))
-        BigStash::StashOperator.new(path).stash(branch_name)
-      end
-    end
-
-    def stash_all(path, new_branch_name, user, modules)
-      # Stash modules
-      Logger.highlight('Stash for current workspace...')
-
-      modules.each do |module_name|
-        module_path = BigkeeperParser.module_full_path(path, user, module_name)
-        branch_name = GitOperator.new.current_branch(module_path)
-
-        if branch_name != new_branch_name
-          stash(module_path, branch_name, module_name)
-        end
-      end
-
-      # Stash home
-      branch_name = GitOperator.new.current_branch(path)
-      if branch_name != new_branch_name
-        stash(path, branch_name, 'Home')
-      end
-    end
-  end
-end