big_keeper 0.7.0 → 0.7.1

data/lib/big_keeper/command/feature&hotfix/{feature_push.rb → push.rb}

@@ -2,23 +2,19 @@ require 'big_keeper/util/logger'
 
 module BigKeeper
 
-  def self.feature_push(path, user, comment)
+  def self.push(path, user, comment, type)
     begin
       # Parse Bigkeeper file
       BigkeeperParser.parse("#{path}/Bigkeeper")
-
       branch_name = GitOperator.new.current_branch(path)
-      Logger.error("Not a feature branch, exit.") unless branch_name.include? 'feature'
+
+      Logger.error("Not a #{GitflowType.name(type)} branch, exit.") unless branch_name.include? GitflowType.name(type)
 
       modules = PodfileOperator.new.modules_with_type("#{path}/Podfile",
                                 BigkeeperParser.module_names, ModuleType::PATH)
 
       modules.each do |module_name|
-        module_full_path = BigkeeperParser.module_full_path(path, user, module_name)
-        module_branch_name = GitOperator.new.current_branch(module_full_path)
-
-        Logger.highlight("Push branch '#{branch_name}' for module '#{module_name}'...")
-        GitService.new.verify_push(path, comment, module_branch_name, module_name)
+        ModuleService.new.push(path, user, module_name, branch_name, type, comment)
       end
 
       Logger.highlight("Push branch '#{branch_name}' for 'Home'...")

data/lib/big_keeper/command/feature&hotfix/{feature_start.rb → start.rb}

@@ -13,16 +13,16 @@ require 'big_keeper/service/module_service'
 
 
 module BigKeeper
-  def self.feature_start(path, version, user, name, modules)
+  def self.start(path, version, user, name, modules, type)
     begin
       # Parse Bigkeeper file
       BigkeeperParser.parse("#{path}/Bigkeeper")
 
       version = BigkeeperParser.version if version == 'Version in Bigkeeper file'
-      feature_name = "#{version}_#{user}_#{name}"
-      branch_name = "#{GitflowType.name(GitflowType::FEATURE)}/#{feature_name}"
+      full_name = "#{version}_#{user}_#{name}"
+      branch_name = "#{GitflowType.name(type)}/#{full_name}"
 
-      GitService.new.verify_branch(path, branch_name, OperateType::START)
+      GitService.new.verify_home_branch(path, branch_name, OperateType::START)
 
       stash_modules = PodfileOperator.new.modules_with_type("#{path}/Podfile",
                                 BigkeeperParser.module_names, ModuleType::PATH)
@@ -41,18 +41,18 @@ module BigKeeper
 
       Logger.highlight("Add branch '#{branch_name}' for 'Home'...")
       # Start home feature
-      GitService.new.start(path, feature_name, GitflowType::FEATURE)
+      GitService.new.start(path, full_name, type)
 
       # Modify podfile as path and Start modules feature
       modules.each do |module_name|
-        ModuleService.new.add(path, user, module_name, feature_name, GitflowType::FEATURE)
+        ModuleService.new.add(path, user, module_name, full_name, type)
       end
 
       # pod install
       PodOperator.pod_install(path)
 
       # Push home changes to remote
-      GitService.new.verify_push(path, "init #{GitflowType.name(GitflowType::FEATURE)} #{feature_name}", branch_name, 'Home')
+      GitService.new.verify_push(path, "init #{GitflowType.name(type)} #{full_name}", branch_name, 'Home')
 
       # Open home workspace
       `open #{path}/*.xcworkspace`

data/lib/big_keeper/command/feature&hotfix/{feature_switch.rb → switch.rb}

@@ -4,16 +4,16 @@ require 'big_keeper/util/logger'
 require 'big_keeper/util/pod_operator'
 
 module BigKeeper
-  def self.feature_switch(path, version, user, name)
+  def self.switch_to(path, version, user, name, type)
     begin
       # Parse Bigkeeper file
       BigkeeperParser.parse("#{path}/Bigkeeper")
 
       version = BigkeeperParser.version if version == 'Version in Bigkeeper file'
-      feature_name = "#{version}_#{user}_#{name}"
-      branch_name = "#{GitflowType.name(GitflowType::FEATURE)}/#{feature_name}"
+      full_name = "#{version}_#{user}_#{name}"
+      branch_name = "#{GitflowType.name(type)}/#{full_name}"
 
-      GitService.new.verify_branch(path, branch_name, OperateType::SWITCH)
+      GitService.new.verify_home_branch(path, branch_name, OperateType::SWITCH)
 
       stash_modules = PodfileOperator.new.modules_with_type("#{path}/Podfile",
                                 BigkeeperParser.module_names, ModuleType::PATH)
@@ -22,7 +22,7 @@ module BigKeeper
       StashService.new.stash_all(path, branch_name, user, stash_modules)
 
       # Switch to new feature
-      GitOperator.new.git_checkout(path, branch_name)
+      GitOperator.new.checkout(path, branch_name)
       GitOperator.new.pull(path)
 
       # Apply home stash
@@ -32,7 +32,7 @@ module BigKeeper
                                 BigkeeperParser.module_names, ModuleType::PATH)
 
       modules.each do |module_name|
-        ModuleService.new.switch(path, user, module_name, branch_name)
+        ModuleService.new.switch_to(path, user, module_name, branch_name, type)
       end
 
       # pod install

data/lib/big_keeper/command/feature&hotfix/{feature_update.rb → update.rb}

@@ -13,15 +13,15 @@ require 'big_keeper/service/module_service'
 
 
 module BigKeeper
-  def self.feature_update(path, user, modules)
+  def self.update(path, user, modules, type)
     begin
       # Parse Bigkeeper file
       BigkeeperParser.parse("#{path}/Bigkeeper")
-
       branch_name = GitOperator.new.current_branch(path)
-      Logger.error("Not a feature branch, exit.") unless branch_name.include? 'feature'
 
-      feature_name = branch_name.gsub(/feature\//, '')
+      Logger.error("Not a #{GitflowType.name(type)} branch, exit.") unless branch_name.include? GitflowType.name(type)
+
+      full_name = branch_name.gsub(/#{GitflowType.name(type)}\//, '')
 
       current_modules = PodfileOperator.new.modules_with_type("#{path}/Podfile",
                                 BigkeeperParser.module_names, ModuleType::PATH)
@@ -41,15 +41,15 @@ module BigKeeper
       del_modules = current_modules - modules
 
       if add_modules.empty? and del_modules.empty?
-        Logger.info("There is nothing changed with modules #{modules}.")
+        Logger.default("There is nothing changed with modules #{modules}.")
       else
         # Modify podfile as path and Start modules feature
         add_modules.each do |module_name|
-          ModuleService.new.add(path, user, module_name, feature_name, GitflowType::FEATURE)
+          ModuleService.new.add(path, user, module_name, full_name, type)
         end
 
         del_modules.each do |module_name|
-          ModuleService.new.del(path, user, module_name, feature_name, GitflowType::FEATURE)
+          ModuleService.new.del(path, user, module_name, full_name, type)
         end
 
         # pod install

data/lib/big_keeper/command/release/{release_home.rb → home.rb}

@@ -16,12 +16,12 @@ module BigKeeper
       if GitOperator.new.has_branch(path, "release/#{version}")
         if GitOperator.new.current_branch(path) == "release/#{version}"
           GitOperator.new.commit(path, "release: V #{version}")
-          GitOperator.new.first_push(path, "release/#{version}")
+          GitOperator.new.push_to_remote(path, "release/#{version}")
           GitflowOperator.new.finish_release(path, version)
           if GitOperator.new.current_branch(path) == "master"
             GitOperator.new.tag(path, version)
           else
-            GitOperator.new.git_checkout(path, "master")
+            GitOperator.new.checkout(path, "master")
             GitOperator.new.tag(path, version)
           end
         else
@@ -43,10 +43,10 @@ module BigKeeper
       # step 1 checkout release
       if GitOperator.new.current_branch(project_path) != "release/#{version}"
         if GitOperator.new.has_branch(project_path, "release/#{version}")
-          GitOperator.new.git_checkout(project_path, "release/#{version}")
+          GitOperator.new.checkout(project_path, "release/#{version}")
         else
           GitflowOperator.new.start(project_path, version, GitflowType::RELEASE)
-          GitOperator.new.first_push(project_path, "release/#{version}")
+          GitOperator.new.push_to_remote(project_path, "release/#{version}")
         end
       end
 

data/lib/big_keeper/command/release/module.rb

@@ -0,0 +1,106 @@
+#!/usr/bin/ruby
+require 'big_keeper/util/podfile_operator'
+require 'big_keeper/util/gitflow_operator'
+require 'big_keeper/model/podfile_type'
+require 'big_keeper/util/info_plist_operator'
+require 'big_keeper/util/git_operator'
+require 'big_keeper/util/logger'
+
+module BigKeeper
+  def self.release_module_start(path, version, user, module_name)
+    BigkeeperParser.parse("#{path}/Bigkeeper")
+
+    Dir.chdir(path) do
+      git_info = GitInfo.new(BigkeeperParser::home_git, GitType::TAG, version)
+      module_path = self.get_module_path_default(path, user, module_name)
+      start_module_release(module_path, version, module_name, git_info, user)
+    end
+  end
+
+  def self.release_module_finish(path, version, user, module_name)
+    BigkeeperParser.parse("#{path}/Bigkeeper")
+    module_path = self.get_module_path_default(path, user, module_name)
+
+    Logger.error("current branch has changed") unless GitOperator.new.has_changes(module_path)
+    # check out master
+    if GitOperator.new.current_branch(module_path) != "master"
+      current_name = GitOperator.new.current_branch(module_path)
+      GitOperator.new.checkout(module_path, "master")
+      Logger.highlight("Push branch '#{current_name}' for '#{module_name}'...")
+      GitService.new.verify_push(module_path, "finish #{GitflowType.name(GitflowType::RELEASE)} #{current_name}", "master", "#{module_name}")
+    end
+    return
+
+    Dir.chdir(module_path) do
+      # rebase develop to master
+      Logger.highlight(%Q(Rebase develop to master))
+
+      #修改 podspec 文件
+      # TO DO: - advanced to use Regular Expression
+      PodfileOperator.new.podspec_change(%Q(#{module_path}/#{module_name}.podspec), version, module_name)
+
+      GitService.new.verify_rebase(module_path, 'develop', "#{module_name}")
+      GitOperator.new.verify_push(module_path, "finish rebase develop to master", "master", "#{module_name}")
+      GitOperator.new.tag(module_path, version)
+
+      Logger.highlight(%Q(Start Pod repo push #{module_name}))
+      IO.popen("pod repo push #{module_name} #{module_name}.podspec --allow-warnings --sources=#{BigkeeperParser::sourcemodule_path}") do |io|
+        io.each do |line|
+          has_error = true if line.include? "ERROR"
+        end
+      end
+      if has_error
+        Logger.error("Pod repo push in '#{module_name}'")
+        return
+      end
+
+      Logger.highlight(%Q(Success release #{module_name} V#{version}))
+    end
+  end
+
+  private
+  def self.start_module_release(module_path, version, module_name, source, user)
+    if GitOperator.new.has_changes(module_path)
+      StashService.new.stash_all(module_path, GitOperator.new.current_branch(module_path), user, module_name.split())
+    end
+
+    # step 1 checkout to develop branch
+    Logger.highlight(%Q(Start checkout #{module_name} to Branch develop))
+    if GitOperator.new.current_branch(module_path) != "develop"
+      if GitOperator.new.has_branch(module_path, "develop")
+        GitOperator.new.checkout(module_path, "develop")
+      else
+        Logger.error("Cann't find develop branch, please check.")
+      end
+    end
+
+    Dir.chdir(module_path) do
+      # Pod lib lint
+      Logger.highlight(%Q(Start Pod lib lint #{module_name}))
+      has_error = false
+      IO.popen("pod lib lint --allow-warnings --verbose --use-libraries --sources=#{BigkeeperParser::sourcemodule_path}") do |io|
+        io.each do |line|
+          has_error = true if line.include? "ERROR"
+        end
+      end
+      if has_error
+        Logger.error("Pod lib error in '#{module_name}'")
+        return
+      end
+    end
+
+    GitOperator.new.commit(module_path, "update podspec")
+    GitOperator.new.first_push(module_path, GitOperator.new.current_branch(module_path))
+    Logger.highlight(%Q(Pod lib lint success))
+  end
+
+  def self.get_module_path_default(path, user, module_name)
+    module_path = BigkeeperParser::module_path(user, module_name)
+    if module_path == "../#{module_name}"
+      path_array = path.split('/')
+      path_array.pop()
+      module_path = path_array.join('/') + "/#{module_name}"
+    end
+    module_path
+  end
+end

data/lib/big_keeper/model/gitflow_type.rb

@@ -12,7 +12,19 @@ module BigKeeper
       elsif RELEASE == type
         "release"
       else
-        name
+        "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

data/lib/big_keeper/service/git_service.rb

@@ -7,70 +7,82 @@ module BigKeeper
   # Operator for got
   class GitService
     def start(path, name, type)
-      if GitOperator.new.has_remote_branch(path, 'master')
-        if GitOperator.new.has_local_branch(path, 'master')
-          if GitOperator.new.has_commits(path, 'master')
-            Logger.error(%Q('master' has unpushed commits, you should fix it))
-          else
-            GitOperator.new.git_checkout(path, 'master')
-            GitOperator.new.pull(path)
-          end
-        else
-          GitOperator.new.git_checkout(path, 'master')
+      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
 
-      if GitOperator.new.has_remote_branch(path, 'develop')
-        if GitOperator.new.has_local_branch(path, 'develop')
-          if GitOperator.new.has_commits(path, 'develop')
-            Logger.error(%Q('develop' has unpushed commits, you should fix it))
-          else
-            GitOperator.new.git_checkout(path, 'develop')
-            GitOperator.new.pull(path)
+    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
-        else
-          GitOperator.new.git_checkout(path, 'develop')
         end
       end
+    end
 
-      if !GitflowOperator.new.verify_git_flow(path)
-        GitOperator.new.first_push(path, 'develop') if !GitOperator.new.has_remote_branch(path, 'develop')
-        GitOperator.new.first_push(path, 'master') if !GitOperator.new.has_remote_branch(path, 'master')
-      end
+    def verify_special_branch(path, name)
+      git = GitOperator.new
 
-      branch_name = "#{GitflowType.name(type)}/#{name}"
-      if GitOperator.new.has_branch(path, branch_name)
-        GitOperator.new.git_checkout(path, branch_name)
-        GitOperator.new.pull(path)
+      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
-        GitflowOperator.new.start(path, name, type)
-        GitOperator.new.first_push(path, branch_name)
+        verify_checkout(path, name)
+        git.push_to_remote(path, name)
       end
     end
 
-    def verify_branch(path, branch_name, type)
+    def verify_home_branch(path, branch_name, type)
       Logger.highlight('Sync local branchs from remote, waiting...')
-      GitOperator.new.git_fetch(path)
+      git = GitOperator.new
+
+      git.fetch(path)
 
       if OperateType::START == type
-        if GitOperator.new.current_branch(path) == branch_name
+        if git.current_branch(path) == branch_name
           Logger.error(%(Current branch is '#{branch_name}' already. Use 'update' please))
         end
-        if GitOperator.new.has_branch(path, branch_name)
+        if git.has_branch(path, branch_name)
           Logger.error(%(Branch '#{branch_name}' already exists. Use 'switch' please))
         end
       elsif OperateType::SWITCH == type
-        if !GitOperator.new.has_branch(path, branch_name)
+        if !git.has_branch(path, branch_name)
           Logger.error(%(Can't find a branch named '#{branch_name}'. Use 'start' please))
         end
-        if GitOperator.new.current_branch(path) == branch_name
+        if git.current_branch(path) == branch_name
           Logger.error(%(Current branch is '#{branch_name}' already. Use 'update' please))
         end
       elsif OperateType::UPDATE == type
-        if !GitOperator.new.has_branch(path, branch_name)
+        if !git.has_branch(path, branch_name)
           Logger.error(%(Can't find a branch named '#{branch_name}'. Use 'start' please))
         end
-        if GitOperator.new.current_branch(path) != branch_name
+        if git.current_branch(path) != branch_name
           Logger.error(%(Current branch is not '#{branch_name}'. Use 'switch' please))
         end
       else
@@ -90,14 +102,46 @@ module BigKeeper
       branchs
     end
 
+    def pull(path, branch_name)
+      git = GitOperator.new
+      if git.current_branch(path) == branch_name
+        git.pull(path)
+      else
+        Dir.chdir(path) do
+          `git pull origin #{branch_name}:#{branch_name}`
+        end
+      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.commit(path, comment)
         if git.has_remote_branch(path, branch_name)
-          git.push(path)
+          Dir.chdir(path) do
+            `git push`
+          end
         else
-          git.first_push(path, branch_name)
+          git.push_to_remote(path, branch_name)
         end
       else
         Logger.default("Nothing to push for '#{name}'.")
@@ -126,7 +170,7 @@ module BigKeeper
           end
         end
         `git push -f origin #{branch_name}`
-        GitOperator.new.git_checkout(path, 'develop')
+        GitOperator.new.checkout(path, 'develop')
       end
     end
   end

data/lib/big_keeper/service/module_service.rb

@@ -4,91 +4,81 @@ require 'big_keeper/util/logger'
 module BigKeeper
   # Operator for got
   class ModuleService
-    def pull(path, user, module_name, branch_name)
-      module_full_path = BigkeeperParser.module_full_path(path, user, module_name)
 
-      Logger.highlight("Pull branch '#{branch_name}' for module '#{module_name}'...")
+    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)
-        GitOperator.new.clone(File.expand_path("#{module_full_path}/../"), module_git)
-        GitOperator.new.git_checkout(module_full_path, branch_name)
-      else
-        current_branch_name = GitOperator.new.current_branch(module_full_path)
-        if current_branch_name != branch_name
-          Logger.default("Current branch of '#{module_name}' is '#{current_branch_name}',\
-            stash it and checkout '#{branch_name}'...")
-
-          StashService.new.stash(module_full_path, current_branch_name, module_name)
-
-          GitOperator.new.git_checkout(module_full_path, branch_name)
-        end
-        GitOperator.new.pull(module_full_path)
+        git.new.clone(File.expand_path("#{module_full_path}/../"), module_git)
       end
-    end
 
-    def switch(path, user, module_name, branch_name)
-      module_full_path = BigkeeperParser.module_full_path(path, user, module_name)
+      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)
 
-      Logger.highlight("Switch to branch '#{branch_name}' for module '#{module_name}'...")
+        GitService.new.start(module_full_path, name, type)
 
-      if !File.exist? module_full_path
-        Logger.default("No local repository for module '#{module_name}', clone it...")
-        module_git = BigkeeperParser.module_git(module_name)
-        GitOperator.new.clone(File.expand_path("#{module_full_path}/../"), module_git)
-        GitOperator.new.git_checkout(module_full_path, branch_name)
-      else
-        GitOperator.new.git_checkout(module_full_path, branch_name)
-        GitOperator.new.pull(module_full_path)
+        StashService.new.pop_stash(module_full_path, home_branch_name, module_name)
       end
-
-      StashService.new.pop_stash(module_full_path, branch_name, module_name)
     end
 
-    def finish(path, user, module_name)
-      module_git = BigkeeperParser.module_git(module_name)
+    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)
-      branch_name = GitOperator.new.current_branch(module_full_path)
+      GitService.new.verify_push(module_full_path, comment, home_branch_name, module_name)
+    end
 
-      Logger.highlight("Finish branch '#{branch_name}' for module '#{module_name}'...")
+    def pull(path, user, module_name, home_branch_name, type)
+      Logger.highlight("Pull branch '#{home_branch_name}' for module '#{module_name}'...")
 
-      PodfileOperator.new.find_and_replace("#{path}/Podfile",
-                                           module_name,
-                                           ModuleType::GIT,
-                                           GitInfo.new(module_git, GitType::BRANCH, branch_name))
+      verify_module(path, user, module_name, home_branch_name, type)
 
-      GitService.new.verify_rebase(module_full_path, 'develop', module_name)
+      module_full_path = BigkeeperParser.module_full_path(path, user, module_name)
+      GitOperator.new.pull(module_full_path)
+    end
 
-      `open #{BigkeeperParser.module_pulls(module_name)}`
+    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 add(path, user, module_name, name, type)
-      branch_name = "#{GitflowType.name(type)}/#{name}"
+    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)
 
-      Logger.highlight("Add branch '#{branch_name}' for module '#{module_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, home_branch_name))
 
       module_full_path = BigkeeperParser.module_full_path(path, user, module_name)
 
-      # clone module if not exist
-      if !File.exist? module_full_path
-        Logger.default("No local repository for module #{module_name}, clone it...")
-        module_git = BigkeeperParser.module_git(module_name)
-        GitOperator.new.clone(File.expand_path("#{module_full_path}/../"), module_git)
-      end
+      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)
 
-      # stash current branch
-      current_branch_name = GitOperator.new.current_branch(module_full_path)
+      `open #{BigkeeperParser.module_pulls(module_name)}`
+    end
 
-      StashService.new.stash(module_full_path, current_branch_name, module_name)
+    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}'...")
 
-      # start new feature/hotfix
-      GitService.new.start(module_full_path, name, type)
 
-      StashService.new.pop_stash(module_full_path, branch_name, 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,
@@ -96,23 +86,23 @@ module BigKeeper
     end
 
     def del(path, user, module_name, name, type)
-      branch_name = "#{GitflowType.name(type)}/#{name}"
+      home_branch_name = "#{GitflowType.name(type)}/#{name}"
 
-      Logger.highlight("Delete branch '#{branch_name}' for module '#{module_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, branch_name, module_name)
+      StashService.new.stash(module_full_path, home_branch_name, module_name)
 
-      GitOperator.new.git_checkout(module_full_path, 'develop')
-      GitOperator.new.del(module_full_path, branch_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, 'develop'))
+                                           GitInfo.new(module_git, GitType::BRANCH, GitflowType.base_branch(type)))
     end
   end
 end