bigkeeper 0.7.3

data/lib/big_keeper/model/gitflow_type.rb

@@ -0,0 +1,31 @@
+module BigKeeper
+  module GitflowType
+    FEATURE = 1
+    HOTFIX = 2
+    RELEASE = 3
+
+    def self.name(type)
+      if FEATURE == type
+        "feature"
+      elsif HOTFIX == type
+        "hotfix"
+      elsif RELEASE == type
+        "release"
+      else
+        "feature"
+      end
+    end
+
+    def self.base_branch(type)
+      if FEATURE == type
+        "develop"
+      elsif HOTFIX == type
+        "master"
+      elsif RELEASE == type
+        "develop"
+      else
+        "master"
+      end
+    end
+  end
+end

data/lib/big_keeper/model/operate_type.rb

@@ -0,0 +1,19 @@
+module BigKeeper
+  module OperateType
+    START = 1
+    UPDATE = 2
+    SWITCH = 3
+
+    def self.name(type)
+      if START == type
+        "start"
+      elsif UPDATE == type
+        "update"
+      elsif SWITCH == type
+        "switch"
+      else
+        name
+      end
+    end
+  end
+end

data/lib/big_keeper/model/podfile_model.rb

@@ -0,0 +1,33 @@
+
+module BigKeeper
+
+class Podfile_Modle
+  attr_accessor :name,:git,:path,:configurations,:branch,:tag,:comment
+  def initialize(sentence)
+    if sentence.include?('#')
+      list = sentence.split('#')
+      @comment = list[1]
+      sentence = list[0]
+    end
+
+    sentence_slip_list = sentence.split(',')
+    return if sentence_slip_list.size.zero?
+    for piece in sentence_slip_list do
+        if /:git =>/ =~ piece
+          @git = $~.post_match.strip
+        elsif /:path =>/ =~ piece
+          @path = $~.post_match.strip
+        elsif /:configurations =>/ =~ piece
+          @configurations = $~.post_match.strip
+        elsif /:branch =>/ =~ piece
+          @branch = $~.post_match.strip
+        elsif /:tag =>/ =~ piece
+          @tag = $~.post_match.strip
+        elsif /pod /=~ piece
+          @name = $~.post_match.delete("'\n ")
+        end
+      #  p %Q{model name:#{@name},git:#{@git},path:#{@path},config:#{@configurations},branch:#{@branch},tag:#{@tag},comment:#{@comment}}
+    end
+  end
+end
+end

data/lib/big_keeper/model/podfile_type.rb

@@ -0,0 +1,44 @@
+module BigKeeper
+  module ModuleType
+    PATH = 1
+    GIT = 2
+    SPEC = 3
+
+    def self.regex(type)
+      if PATH == type
+        "\s*:path\s*=>\s*"
+      elsif GIT == type
+        "\s*:git\s*=>\s*"
+      elsif SPEC == type
+        "\s*'"
+      else
+        name
+      end
+    end
+  end
+
+  module GitType
+    MASTER = 1
+    BRANCH = 2
+    TAG = 3
+    COMMIT = 4
+  end
+
+  class GitInfo
+    def initialize(base, type, addition)
+      @base, @type, @addition = base, type, addition
+    end
+
+    def type
+      @type
+    end
+
+    def base
+      @base
+    end
+
+    def addition
+      @addition
+    end
+  end
+end

data/lib/big_keeper/service/git_service.rb

@@ -0,0 +1,186 @@
+require 'big_keeper/util/git_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.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_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 branchs_with_type(path, type)
+      branchs = []
+      Dir.chdir(path) do
+        IO.popen('git branch -a') do |io|
+          io.each do |line|
+            branchs << line.rstrip if line =~ /(\* |  )#{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.dicard(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
+      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`
+          GitOperator.new.checkout(path, branch_name)
+        end
+      end
+    end
+  end
+end

data/lib/big_keeper/service/module_service.rb

@@ -0,0 +1,124 @@
+require 'big_keeper/service/git_service'
+require 'big_keeper/util/logger'
+
+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.new.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 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)
+
+      module_git = BigkeeperParser.module_git(module_name)
+      PodfileOperator.new.find_and_replace("#{path}/Podfile",
+                                           module_name,
+                                           ModuleType::GIT,
+                                           GitInfo.new(module_git, GitType::BRANCH, home_branch_name))
+
+      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)
+
+      GitService.new.verify_rebase(module_full_path, GitflowType.base_branch(type), module_name)
+
+      `open #{BigkeeperParser.module_pulls(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)
+
+      module_path = BigkeeperParser.module_path(user, module_name)
+      PodfileOperator.new.find_and_replace("#{path}/Podfile",
+                                           module_name,
+                                           ModuleType::PATH,
+                                           module_path)
+    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_full_path = BigkeeperParser.module_full_path(path, user, module_name)
+
+      StashService.new.stash(module_full_path, home_branch_name, module_name)
+
+      GitOperator.new.checkout(module_full_path, GitflowType.base_branch(type))
+      # GitOperator.new.del(module_full_path, home_branch_name)
+
+      module_git = BigkeeperParser.module_git(module_name)
+
+      PodfileOperator.new.find_and_replace("#{path}/Podfile",
+                                           module_name,
+                                           ModuleType::GIT,
+                                           GitInfo.new(module_git, GitType::BRANCH, GitflowType.base_branch(type)))
+    end
+  end
+end

data/lib/big_keeper/service/stash_service.rb

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