bigkeeper 0.7.8 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 210e43f5a2e17e8284e5ff34e33ed6245459562f
-  data.tar.gz: aaa8c7f3ba7bda0882febfc1b0c9e548ef5f8512
+  metadata.gz: 028f56615f3e793abad38eed28a1f898564632a3
+  data.tar.gz: 2143d81a7144a0611bd4bb5ec5ba3fe8d34a032d
 SHA512:
-  metadata.gz: cf8770b19b1a77de386b654504e918c84d64e4cba7f4ddfc2ff42be27991365b7fae547f7fbf1143e183b826bdc29afb829be7f3b61d0934573b4ab14e7f927a
-  data.tar.gz: 10634e889660abeb0d0dbf49ea18e4773034677b1a3f6bacfb01d7a0ac12f0fe7ddd1443875bb5982261ded895a36d22cb1b835e047cfe2864d6fbcf3f5da8db
+  metadata.gz: 767a5d482e00d1eefb7a95863d8c1990405656187ee168edb9726ab78e5f8d07398349fac58a52404c3edb9dc6f1296fbd6bbaac22a7da174ae12ae5a90e819e
+  data.tar.gz: 2dcd82312c0cb2dc2c387cff5ac9e588f216c70e4ea8311d1b1626c6fb67c84c0fe3f231f4ce4aad260ba29c011a9f71a9e017a4c7e07e5cf0d0ee2757895fd2

data/.travis.yml

@@ -1,8 +1,10 @@
 language: ruby
 
 rvm:
-  - 2.3.4
-  - 2.2.7
+  - 2.5.0
+  - 2.4.3
+  - 2.3.6
+  - 2.2.9
   - 2.1.10
 
 before_install:

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    bigkeeper (0.7.7)
+    bigkeeper (0.7.8)
       big_stash (~> 0.1)
       cocoapods
       colorize
@@ -63,7 +63,7 @@ GEM
     gh_inspector (1.0.2)
     gli (2.17.1)
     i18n (0.7.0)
-    json (1.8.3)
+    json (1.8.6)
     minitest (5.8.3)
     molinillo (0.5.7)
     nanaimo (0.2.3)

data/lib/big_keeper/command/feature&hotfix.rb

@@ -7,6 +7,7 @@ require 'big_keeper/command/feature&hotfix/push'
 require 'big_keeper/command/feature&hotfix/rebase'
 require 'big_keeper/command/feature&hotfix/publish'
 require 'big_keeper/command/feature&hotfix/delete'
+require 'big_keeper/command/feature&hotfix/list'
 
 module BigKeeper
   def self.feature_and_hotfix_command(type)
@@ -127,12 +128,10 @@ module BigKeeper
       c.desc "List all the #{GitflowType.name(type)}s"
       c.command :list do |list|
         list.action do |global_options, options, args|
+          Logger.highlight("Generating feature tree of all version...") if args.length < 1
           path = File.expand_path(global_options[:path])
-
-          branchs = GitService.new.branchs_with_type(File.expand_path(path), type)
-          branchs.each do |branch|
-            p branch
-          end
+          user = global_options[:user].gsub(/[^0-9A-Za-z]/, '').downcase
+          list(path,user,type)
         end
       end
     end

data/lib/big_keeper/command/feature&hotfix/delete.rb

@@ -25,9 +25,14 @@ module BigKeeper
 
       modules.each do |module_name|
         module_full_path = BigkeeperParser.module_full_path(path, user, module_name)
-        GitService.new.verify_del(module_full_path, branch_name, module_name, type)
+
+        if FileOperator.definitely_exists?(module_full_path)
+          StashService.new.pop_stash(module_full_path, branch_name, module_name)
+          GitService.new.verify_del(module_full_path, branch_name, module_name, type)
+        end
       end
 
+      StashService.new.pop_stash(path, branch_name, 'Home')
       GitService.new.verify_del(path, branch_name, 'Home', type)
     ensure
     end

data/lib/big_keeper/command/feature&hotfix/finish.rb

@@ -22,24 +22,30 @@ module BigKeeper
       branch_name = GitOperator.new.current_branch(path)
       Logger.error("Not a #{GitflowType.name(type)} branch, exit.") unless branch_name.include? GitflowType.name(type)
 
-      ModuleCacheOperator.new(path).cache_path_modules([])
-      ModuleCacheOperator.new(path).cache_git_modules(modules)
+      # Cache git modules
+      if ModuleCacheOperator.new(path).all_path_modules.empty?
+        Logger.error("Branch '#{branch_name}' is already finished, exit.")
+      end
 
-      modules = ModuleCacheOperator.new(path).current_path_modules
+      ModuleCacheOperator.new(path).cache_git_modules(ModuleCacheOperator.new(path).all_path_modules)
 
-      # Rebase modules and modify podfile as git
+      modules = ModuleCacheOperator.new(path).remain_git_modules
+      # Rebase modules and modify module as git
       modules.each do |module_name|
         ModuleService.new.finish(path, user, module_name, branch_name, type)
       end
 
       Logger.highlight("Finish branch '#{branch_name}' for 'Home'")
 
-      # pod install
+      # Install
       DepService.dep_operator(path, user).install(false)
 
       # Open home workspace
       DepService.dep_operator(path, user).open
 
+      # Delete all path modules
+      ModuleCacheOperator.new(path).cache_path_modules([], [], [])
+
       # Push home changes to remote
       GitService.new.verify_push(path, "finish branch #{branch_name}", branch_name, 'Home')
     ensure

data/lib/big_keeper/command/feature&hotfix/list.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/ruby
+require 'big_keeper/util/bigkeeper_parser'
+require 'big_keeper/util/list_generator'
+require 'big_keeper/service/module_service'
+
+
+module BigKeeper
+  def self.list(path,user,type)
+    BigkeeperParser.parse("#{path}/Bigkeeper")
+    #get home project branches
+    branches = GitService.new.branchs_with_type(File.expand_path(path), type)
+    #get modules list
+    begin
+      modules = BigkeeperParser.module_names
+      file = File.new("#{path}/.bigkeeper/feature_list", 'w')
+      begin
+        #read git info
+        git_operator = GitOperator.new
+        modules.each do |module_name|
+          module_full_path = BigkeeperParser.module_full_path(path, user, module_name)
+          #local project verify
+          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_operator.clone(File.expand_path("#{module_full_path}/../"), module_git)
+          end
+          feature_modules_list = ModuleService.new.list(module_full_path, user, module_name)
+          dic = {}
+          dic[module_name] = feature_modules_list
+          file << dic
+          file << "\n\n"
+        end
+         file.close
+      end
+
+      #print list
+      ListGenerator.generate(file,branches)
+    ensure
+      file.close
+    end
+  end
+end

data/lib/big_keeper/command/feature&hotfix/publish.rb

@@ -25,26 +25,27 @@ module BigKeeper
       path_modules = ModuleCacheOperator.new(path).current_path_modules
       Logger.error("You have unfinished modules #{path_modules}, Use 'finish' first please.") unless path_modules.empty?
 
-      ModuleCacheOperator.new(path).cache_git_modules([])
-
+      # Push modules changes to remote then rebase
       modules = ModuleCacheOperator.new(path).current_git_modules
+      modules.each do |module_name|
+        ModuleService.new.pre_publish(path, user, module_name, branch_name, type)
+      end
+
+      # Install
+      DepService.dep_operator(path, user).install(false)
 
-      # Rebase modules and modify podfile as git
+      # Modify module as git
       modules.each do |module_name|
         ModuleService.new.publish(path, user, module_name, branch_name, type)
       end
 
       Logger.highlight("Publish branch '#{branch_name}' for 'Home'")
 
-      # pod install
-      DepService.dep_operator(path, user).install(false)
-
-      # Recover podfile
+      # Recover home
       DepService.dep_operator(path, user).recover
 
       # Push home changes to remote
       GitService.new.verify_push(path, "publish branch #{branch_name}", branch_name, 'Home')
-
       # Rebase Home
       GitService.new.verify_rebase(path, GitflowType.base_branch(type), 'Home')
 

data/lib/big_keeper/command/feature&hotfix/start.rb

@@ -28,58 +28,43 @@ module BigKeeper
 
       GitService.new.verify_home_branch(path, branch_name, OperateType::START)
 
-      stash_modules = ModuleCacheOperator.new(path).current_path_modules
+      stash_modules = ModuleCacheOperator.new(path).all_path_modules
 
       # Stash current branch
       StashService.new.stash_all(path, branch_name, user, stash_modules)
 
       # Verify input modules
-      modules = [] unless modules
-      BigkeeperParser.verify_modules(modules)
-
-      # # Handle modules
-      # if modules
-      #   # Verify input modules
-      #   BigkeeperParser.verify_modules(modules)
-      # else
-      #   # Get all modules if not specified
-      #   modules = BigkeeperParser.module_names
-      # end
+      modules = BigkeeperParser.verify_modules(modules)
 
       Logger.highlight("Add branch '#{branch_name}' for 'Home'...")
       # Start home feature
       GitService.new.start(path, full_name, type)
 
-      ModuleCacheOperator.new(path).cache_path_modules(modules)
+      # Cache all path modules
+      ModuleCacheOperator.new(path).cache_path_modules(modules, modules, [])
+      modules = ModuleCacheOperator.new(path).remain_path_modules
 
-      # Backup podfile
+      # Backup home
       DepService.dep_operator(path, user).backup
 
-      # Modify podfile as path and Start modules feature
+      # Start modules feature and modify module as path
       modules.each do |module_name|
         ModuleService.new.add(path, user, module_name, full_name, type)
       end
 
-      # pod install
+      # install
       DepService.dep_operator(path, user).install(true)
 
       # Open home workspace
       DepService.dep_operator(path, user).open
 
       # Push home changes to remote
-      GitService.new.verify_push(path,
+      Logger.highlight("Push branch '#{branch_name}' for 'Home'...")
+      GitService.new.verify_push(
+        path,
         "init #{GitflowType.name(type)} #{full_name}",
         branch_name,
         'Home')
-
-      modules.each do |module_name|
-        module_full_path = BigkeeperParser.module_full_path(path, user, module_name)
-        # Push home changes to remote
-        GitService.new.verify_push(module_full_path,
-          "init #{GitflowType.name(type)} #{full_name}",
-          branch_name,
-          module_name)
-      end
     ensure
     end
   end

data/lib/big_keeper/command/feature&hotfix/switch.rb

@@ -18,7 +18,7 @@ module BigKeeper
 
       GitService.new.verify_home_branch(path, branch_name, OperateType::SWITCH)
 
-      stash_modules = ModuleCacheOperator.new(path).current_path_modules
+      stash_modules = ModuleCacheOperator.new(path).all_path_modules
 
       # Stash current branch
       StashService.new.stash_all(path, branch_name, user, stash_modules)
@@ -30,13 +30,13 @@ module BigKeeper
       # Apply home stash
       StashService.new.pop_stash(path, branch_name, 'Home')
 
-      modules = ModuleCacheOperator.new(path).current_path_modules
+      modules = ModuleCacheOperator.new(path).all_path_modules
 
       modules.each do |module_name|
         ModuleService.new.switch_to(path, user, module_name, branch_name, type)
       end
 
-      # pod install
+      # Install
       DepService.dep_operator(path, user).install(false)
 
       # Open home workspace

data/lib/big_keeper/command/feature&hotfix/update.rb

@@ -30,43 +30,34 @@ module BigKeeper
       current_modules = ModuleCacheOperator.new(path).current_path_modules
 
       # Verify input modules
-      modules = [] unless modules
-      BigkeeperParser.verify_modules(modules)
-
-      # # Handle modules
-      # if modules
-      #   # Verify input modules
-      #   BigkeeperParser.verify_modules(modules)
-      # else
-      #   # Get all modules if not specified
-      #   modules = BigkeeperParser.module_names
-      # end
+      modules = BigkeeperParser.verify_modules(modules)
 
       Logger.highlight("Start to update modules for branch '#{branch_name}'...")
 
       add_modules = modules - current_modules
       del_modules = current_modules - modules
 
-      ModuleCacheOperator.new(path).cache_path_modules(modules)
+      ModuleCacheOperator.new(path).cache_path_modules(modules, add_modules, del_modules)
+      remain_path_modules = ModuleCacheOperator.new(path).remain_path_modules
 
       if add_modules.empty? and del_modules.empty?
         Logger.default("There is nothing changed with modules #{modules}.")
       else
         # Modify podfile as path and Start modules feature
-        add_modules.each do |module_name|
+        remain_path_modules.each do |module_name|
           ModuleService.new.add(path, user, module_name, full_name, type)
         end
 
         del_modules.each do |module_name|
           ModuleService.new.del(path, user, module_name, full_name, type)
         end
+      end
 
-        # pod install
-        DepService.dep_operator(path, user).install(false)
+      # Install
+      DepService.dep_operator(path, user).install(false)
 
-        # Open home workspace
-        DepService.dep_operator(path, user).open
-      end
+      # Open home workspace
+      DepService.dep_operator(path, user).open
     ensure
     end
   end

data/lib/big_keeper/dependency/dep_gradle_operator.rb

@@ -7,47 +7,47 @@ module BigKeeper
 
     def backup
       GradleOperator.new(@path).backup
+      modules = ModuleCacheOperator.new(@path).all_path_modules
+      modules.each do |module_name|
+        module_full_path = BigkeeperParser.module_full_path(@path, @user, module_name)
+        GradleOperator.new(module_full_path).backup
+      end
     end
 
     def recover
-      GradleOperator.new(@path).recover
+      GradleOperator.new(@path).recover(true, false)
     end
 
-    def update_module_config(module_name, module_type, source)
-      GradleOperator.new(@path).update_module_config(module_name, module_type, source)
-
+    def update_module_config(module_name, module_operate_type)
       module_full_path = BigkeeperParser.module_full_path(@path, @user, module_name)
 
-      if ModuleType::PATH == module_type
+      # get modules
+      if ModuleOperateType::ADD == module_operate_type
         GradleOperator.new(module_full_path).backup
 
-        all_path_modules = ModuleCacheOperator.new(@path).all_path_modules
-        all_path_modules.each do |path_module_name|
-          next if path_module_name == module_name
-          module_full_path = BigkeeperParser.module_full_path(@path, @user, path_module_name)
-          GradleOperator.new(module_full_path).update_module_config(module_name, module_type, source)
-        end
-      elsif ModuleType::GIT == module_type
-        GradleOperator.new(module_full_path).recover
-
-        all_path_modules = ModuleCacheOperator.new(@path).all_path_modules
-        all_path_modules.each do |path_module_name|
-          next if path_module_name == module_name
-          module_full_path = BigkeeperParser.module_full_path(@path, @user, path_module_name)
-          GradleOperator.new(module_full_path).update_module_config(module_name, module_type, source)
-        end
-      else
+        add_modules = ModuleCacheOperator.new(@path).add_path_modules
+        GradleOperator.new(module_full_path).update_build_config(module_name, add_modules, ModuleOperateType::ADD)
+        GradleOperator.new(module_full_path).update_settings_config(module_name, add_modules, ModuleOperateType::ADD, @user)
+
+        del_modules = ModuleCacheOperator.new(@path).del_path_modules
+        GradleOperator.new(module_full_path).update_build_config(module_name, del_modules, ModuleOperateType::DELETE)
+        GradleOperator.new(module_full_path).update_settings_config(module_name, del_modules, ModuleOperateType::DELETE, @user)
+      elsif ModuleOperateType::DELETE == module_operate_type
+        GradleOperator.new(module_full_path).recover(true, true)
+      elsif ModuleOperateType::FINISH == module_operate_type
+        modules = ModuleCacheOperator.new(@path).all_path_modules
+        GradleOperator.new(module_full_path).update_build_config(module_name, modules, ModuleOperateType::FINISH)
+      elsif ModuleOperateType::PUBLISH == module_operate_type
+        modules = ModuleCacheOperator.new(@path).all_git_modules
+        GradleOperator.new(module_full_path).update_build_config(module_name, modules, ModuleOperateType::PUBLISH)
+        GradleOperator.new(module_full_path).recover(true, false)
       end
+
+      GradleOperator.new(@path).update_build_config('', [module_name], module_operate_type)
+      GradleOperator.new(@path).update_settings_config('', [module_name], module_operate_type, @user)
     end
 
     def install(should_update)
-      modules = ModuleCacheOperator.new(@path).all_path_modules
-      GradleOperator.new(@path).update_setting_config('', @user, modules)
-
-      modules.each do |module_name|
-        module_full_path = BigkeeperParser.module_full_path(@path, @user, module_name)
-        GradleOperator.new(module_full_path).update_setting_config(module_name, @user, modules)
-      end
     end
 
     def open

data/lib/big_keeper/dependency/dep_operator.rb

@@ -17,7 +17,7 @@ module BigKeeper
       raise "You should override this method in subclass."
     end
 
-    def update_module_config(module_name, module_type, source)
+    def update_module_config(module_name, module_operate_type)
       raise "You should override this method in subclass."
     end
 

data/lib/big_keeper/dependency/dep_pod_operator.rb

@@ -17,14 +17,14 @@ module BigKeeper
       cache_operator.clean
     end
 
-    def update_module_config(module_name, module_type, source)
+    def update_module_config(module_name, module_operate_type)
       file = "#{@path}/Podfile"
       temp_file = Tempfile.new('.Podfile.tmp')
 
       begin
         File.open(file, 'r') do |file|
           file.each_line do |line|
-            temp_file.puts generate_module_config(line, module_name, module_type, source)
+            temp_file.puts generate_module_config(line, module_name, module_operate_type)
           end
         end
         temp_file.close
@@ -43,30 +43,48 @@ module BigKeeper
       XcodeOperator.open_workspace(@path)
     end
 
-    def generate_module_config(line, module_name, module_type, source)
+    def generate_module_config(line, module_name, module_operate_type)
       line.sub(/(\s*)pod(\s*)('|")#{module_name}('|")([\s\S]*)/){
-        if ModuleType::PATH == module_type
-          "#{$1}pod '#{module_name}', :path => '#{source}'"
-        elsif ModuleType::GIT == module_type
-          # puts source.base
-          # puts source.addition
-          if GitType::BRANCH == source.type
-            "#{$1}pod '#{module_name}', :git => '#{source.base}', :branch => '#{source.addition}'"
-          elsif GitType::TAG == source.type
-            "#{$1}pod '#{module_name}', :git => '#{source.base}', :tag => '#{source.addition}'"
-          elsif GitType::COMMIT == source.type
-            "#{$1}pod '#{module_name}', :git => '#{source.base}', :commit => '#{source.addition}'"
+        if ModuleOperateType::ADD == module_operate_type
+          module_path = BigkeeperParser.module_path(@user, module_name)
+          "#{$1}pod '#{module_name}', :path => '#{module_path}'"
+        elsif ModuleOperateType::DELETE == module_operate_type
+          origin_config_of_module = origin_config_of_module(module_name)
+          if origin_config_of_module.empty?
+            line
           else
-            "#{$1}pod '#{module_name}', :git => '#{source.base}'"
+            origin_config_of_module
           end
-        elsif ModuleType::SPEC == module_type
-          "#{$1}pod '#{module_name}', '#{source}'"
+        elsif ModuleOperateType::FINISH == module_operate_type
+          module_git = BigkeeperParser.module_git(module_name)
+          branch_name = GitOperator.new.current_branch(@path)
+          "#{$1}pod '#{module_name}', :git => '#{module_git}', :branch => '#{branch_name}'"
+        elsif ModuleOperateType::PUBLISH == module_operate_type
+          module_git = BigkeeperParser.module_git(module_name)
+          branch_name = GitOperator.new.current_branch(@path)
+          base_branch_name = GitflowType.base_branch(GitService.new.current_branch_type(@path))
+          "#{$1}pod '#{module_name}', :git => '#{module_git}', :branch => '#{base_branch_name}'"
         else
           line
         end
       }
     end
 
-    private :generate_module_config
+    def origin_config_of_module(module_name)
+      origin_config = ''
+
+      File.open("#{@path}/.bigkeeper/Podfile", 'r') do |file|
+        file.each_line do |line|
+          if line =~ /(\s*)pod(\s*)('|")#{module_name}('|")([\s\S]*)/
+            origin_config = line
+            break
+          end
+        end
+      end
+
+      origin_config.chop
+    end
+
+    private :generate_module_config, :origin_config_of_module
   end
 end

data/lib/big_keeper/dependency/dep_type.rb

@@ -30,35 +30,4 @@ module BigKeeper
       end
     end
   end
-
-  module ModuleType
-    PATH = 1
-    GIT = 2
-    SPEC = 3
-  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/model/operate_type.rb

@@ -16,4 +16,12 @@ module BigKeeper
       end
     end
   end
+
+  module ModuleOperateType
+    ADD = 1
+    DELETE = 2
+    FINISH = 3
+    PUBLISH = 4
+    RELEASE = 5
+  end
 end

data/lib/big_keeper/service/git_service.rb

@@ -59,6 +59,10 @@ module BigKeeper
         verify_checkout(path, name)
         git.push_to_remote(path, name)
       end
+
+      if FileOperator.definitely_exists?("#{path}/.bigkeeper/module.cache")
+        Logger.error(%Q('#{name}' has '.bigkeeper/module.cache' cache path, you should fix it manually...))
+      end
     end
 
     def verify_home_branch(path, branch_name, type)
@@ -93,6 +97,19 @@ module BigKeeper
       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

data/lib/big_keeper/service/module_service.rb

@@ -69,18 +69,27 @@ module BigKeeper
       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}'...")
 
-      verify_module(path, user, module_name, home_branch_name, type)
+      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)
-      GitService.new.verify_rebase(module_full_path, GitflowType.base_branch(type), module_name)
 
       `open #{BigkeeperParser.module_pulls(module_name)}`
 
-      ModuleCacheOperator.new(path).del_branch_module(module_name)
+      ModuleCacheOperator.new(path).del_git_module(module_name)
     end
 
     def finish(path, user, module_name, home_branch_name, type)
@@ -88,31 +97,25 @@ module BigKeeper
 
       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)
 
-      module_git = BigkeeperParser.module_git(module_name)
-
-      DepService.dep_operator(path, user).update_module_config(
-                                           module_name,
-                                           ModuleType::GIT,
-                                           GitInfo.new(module_git, GitType::BRANCH, home_branch_name))
-
-      ModuleCacheOperator.new(path).add_branch_module(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)
 
-      module_path = BigkeeperParser.module_path(user, module_name)
-      DepService.dep_operator(path, user).update_module_config(
-                                           module_name,
-                                           ModuleType::PATH,
-                                           module_path)
+      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
@@ -122,20 +125,28 @@ module BigKeeper
 
       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)
+      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))
-      # GitOperator.new.del(module_full_path, home_branch_name)
-
-      module_git = BigkeeperParser.module_git(module_name)
-      DepService.dep_operator(path, user).update_module_config(
-                                           module_name,
-                                           ModuleType::GIT,
-                                           GitInfo.new(module_git, GitType::BRANCH, GitflowType.base_branch(type)))
 
       ModuleCacheOperator.new(path).del_path_module(module_name)
     end
+
+    def list(path, user, module_path)
+      branches_name = []
+      IO.popen("cd #{path}; git branch -a") do |io|
+        io.each do |line|
+          branches_name << line.strip if line.include? 'feature'
+        end
+      end
+      branches_name
+    end
+
+    private :verify_module
   end
 end

data/lib/big_keeper/util/bigkeeper_parser.rb

@@ -164,9 +164,12 @@ module BigKeeper
     end
 
     def self.verify_modules(modules)
+      modules = [] unless modules
+      modules = modules.uniq
       modules.each do |item|
         Logger.error("Can not find module #{item} in Bigkeeper file") unless @@config[:modules][item]
       end
+      modules
     end
 
     def self.module_names

data/lib/big_keeper/util/cache_operator.rb

@@ -26,7 +26,6 @@ module BigKeeper
   class ModuleCacheOperator
     def initialize(path)
       @cache_path = File.expand_path("#{path}/.bigkeeper")
-      @modules = {"git" => {"all" => [], "current" => []}, "path" => {"all" => [], "current" => []}}
 
       FileUtils.mkdir_p(@cache_path) unless File.exist?(@cache_path)
 
@@ -34,6 +33,8 @@ module BigKeeper
         file = File.open("#{@cache_path}/module.cache", 'r')
         @modules = JSON.load(file.read())
         file.close
+      else
+        @modules = {"git" => {"all" => [], "current" => []}, "path" => {"all" => [], "add" => [], "del" => [], "current" => []}}
       end
     end
 
@@ -41,10 +42,22 @@ module BigKeeper
       @modules["path"]["all"]
     end
 
+    def add_path_modules
+      @modules["path"]["add"]
+    end
+
+    def del_path_modules
+      @modules["path"]["del"]
+    end
+
     def current_path_modules
       @modules["path"]["current"]
     end
 
+    def remain_path_modules
+      @modules["path"]["all"] - @modules["path"]["current"]
+    end
+
     def all_git_modules
       @modules["git"]["all"]
     end
@@ -53,35 +66,39 @@ module BigKeeper
       @modules["git"]["current"]
     end
 
-    def cache_path_modules(modules)
-      @modules["path"]["all"] = modules
+    def remain_git_modules
+      @modules["git"]["all"] - @modules["git"]["current"]
+    end
+
+    def cache_path_modules(modules, add_modules, del_modules)
+      @modules["path"]["all"] = modules.uniq
+      @modules["path"]["add"] = add_modules.uniq
+      @modules["path"]["del"] = del_modules.uniq
       cache_modules
     end
 
     def cache_git_modules(modules)
-      @modules["git"]["all"] = modules
+      @modules["git"]["all"] = modules.uniq
       cache_modules
     end
 
-    def add_branch_module(module_name)
-      @modules["path"]["current"].delete(module_name)
-      @modules["git"]["current"] << module_name
+    def add_git_module(module_name)
+      @modules["git"]["current"] << module_name unless @modules["git"]["current"].include?(module_name)
       cache_modules
     end
 
-    def del_branch_module(module_name)
-      @modules["git"]["current"].delete(module_name)
+    def del_git_module(module_name)
+      @modules["git"]["current"].delete(module_name) if @modules["git"]["current"].include?(module_name)
       cache_modules
     end
 
     def add_path_module(module_name)
-      @modules["git"]["current"].delete(module_name)
-      @modules["path"]["current"] << module_name
+      @modules["path"]["current"] << module_name unless @modules["path"]["current"].include?(module_name)
       cache_modules
     end
 
     def del_path_module(module_name)
-      @modules["path"]["current"].delete(module_name)
+      @modules["path"]["current"].delete(module_name) if @modules["path"]["current"].include?(module_name)
       cache_modules
     end
 

data/lib/big_keeper/util/git_operator.rb

@@ -13,7 +13,7 @@ module BigKeeper
       has_branch = false
       IO.popen("cd #{path}; git branch -r") do |io|
         io.each do |line|
-          has_branch = true if line.include? branch_name
+          has_branch = true if line =~ /([\s\S]*)#{branch_name}$/
         end
       end
       has_branch
@@ -23,7 +23,7 @@ module BigKeeper
       has_branch = false
       IO.popen("cd #{path}; git branch") do |io|
         io.each do |line|
-          has_branch = true if line.include? branch_name
+          has_branch = true if line =~ /([\s\S]*)#{branch_name}$/
         end
       end
       has_branch
@@ -33,7 +33,7 @@ module BigKeeper
       has_branch = false
       IO.popen("cd #{path}; git branch -a") do |io|
         io.each do |line|
-          has_branch = true if line.include? branch_name
+          has_branch = true if line =~ /([\s\S]*)#{branch_name}$/
         end
       end
       has_branch
@@ -88,7 +88,7 @@ module BigKeeper
 
     def has_commits(path, branch_name)
       has_commits = false
-      IO.popen("cd #{path}; git log --branches --not --remotes") do |io|
+      IO.popen("cd #{path}; git log #{branch_name} --not --remotes") do |io|
         io.each do |line|
           has_commits = true if line.include? branch_name
         end

data/lib/big_keeper/util/gradle_operator.rb

@@ -4,141 +4,173 @@ module BigKeeper
   # Operator for podfile
   class GradleOperator
     def initialize(path)
-      @path = File.expand_path(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
+    def recover(settings_config, build_config)
       cache_operator = CacheOperator.new(@path)
-      cache_operator.load('settings.gradle')
+
+      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_setting_config(current_module_name, user, modules)
-      CacheOperator.new(@path).load('settings.gradle')
-      begin
-        File.open("#{@path}/settings.gradle", 'a') do |file|
-          modules.each do |module_name|
-            next if current_module_name == module_name
+    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
-      ensure
+      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_module_config(module_name, module_type, source)
-      Dir.glob("#{@path}/*/build.gradle").each do |file|
-        temp_file = Tempfile.new('.build.gradle.tmp')
-        begin
-          version_flag = false
-          version_index = 0
-
-          File.open(file, 'r') do |file|
-            file.each_line do |line|
-              version_flag = true if line.include? 'modifyPom'
-              if version_flag
-                version_index += 1 if line.include? '{'
-                version_index -= 1 if line.include? '}'
-
-                version_flag = false if 0 == version_flag
-
-                temp_file.puts generate_version_config(line, module_name, module_type, source)
-              else
-                temp_file.puts generate_compile_config(line, module_name, module_type, source)
+    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
-          temp_file.close
-          FileUtils.mv(temp_file.path, file)
-        ensure
-          temp_file.close
-          temp_file.unlink
         end
       end
     end
 
-    def generate_version_config(line, module_name, module_type, source)
-      if ModuleType::GIT == module_type
+    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 'develop' == source.addition || 'master' == 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}"
         }
-      elsif ModuleType::SPEC == module_type
-        line.sub(/(\s*)version ('|")(\S*)('|")([\s\S]*)/){
-          "#{$1}version '#{source}'#{$5}"
-        }
       else
         line
       end
     end
 
-    def prefix_of_module(module_name)
-      prefix = ''
-      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*)/
-              prefix = line.sub(/(\s*)([\s\S]*)('|")(\S*)#{module_name.downcase}(\S*)('|")(\S*)/){
-                $4
-              }
-              break
-            end
-          end
-        end
-        break unless prefix.empty?
-      end
-
-      prefix.chop
-    end
-
-    def generate_compile_config(line, module_name, module_type, source)
-      if ModuleType::PATH == module_type
-        line.sub(/(\s*)compile(\s*)('|")(\S*)#{module_name.downcase}(\S*)('|")(\S*)/){
+    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 ModuleType::GIT == module_type
+      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 'develop' == source.addition || 'master' == 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.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
-        }
-      elsif ModuleType::SPEC == module_type
-        line.sub(/(\s*)([\s\S]*)('|")(\S*)#{module_name.downcase}(\S*)('|")(\S*)/){
-          if $2.include? 'moduleCompile'
-            "#{$1}moduleCompile '#{prefix_of_module(module_name)}#{module_name.downcase}:#{source}'"
+        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}:#{source}'"
+            "#{$1}compile '#{prefix_of_module(module_name)}:#{module_name.downcase}:#{full_name}-SNAPSHOT'"
           end
         }
       else
@@ -146,6 +178,32 @@ module BigKeeper
       end
     end
 
-    private :generate_compile_config, :generate_version_config, :prefix_of_module
+    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/list_generator.rb

@@ -0,0 +1,29 @@
+require 'big_keeper/util/logger'
+
+module BigKeeper
+  class ListGenerator
+    def self.generate(file_path,branches_name)
+      module_branches_dic = {}
+      home_name = BigkeeperParser.home_name
+      File.open(file_path, 'r') do |file|
+        file.each_line do |line|
+          if /=>/ =~ line.delete('{}"')
+            module_branches_dic[$~.pre_match] = $~.post_match.delete('[]"').split(',')
+          end
+        end
+      end
+
+      branches_name.each do |branch_name|
+        Logger.highlight(" #{home_name} - #{branch_name} ")
+        module_branches_dic.keys.each do |module_name|
+          module_branches_dic[module_name].each do |module_branch|
+            if module_branch.include?(branch_name.strip.delete('*'))
+              Logger.default("   |_ _ _ #{module_name} - #{branch_name}")
+                break
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/big_keeper/version.rb

@@ -1,3 +1,3 @@
 module BigKeeper
-  VERSION = "0.7.8"
+  VERSION = "0.8.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bigkeeper
 version: !ruby/object:Gem::Version
-  version: 0.7.8
+  version: 0.8.0
 platform: ruby
 authors:
 - mmoaay
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-08 00:00:00.000000000 Z
+date: 2018-04-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gli
@@ -227,6 +227,7 @@ files:
 - lib/big_keeper/command/feature&hotfix.rb
 - lib/big_keeper/command/feature&hotfix/delete.rb
 - lib/big_keeper/command/feature&hotfix/finish.rb
+- lib/big_keeper/command/feature&hotfix/list.rb
 - lib/big_keeper/command/feature&hotfix/publish.rb
 - lib/big_keeper/command/feature&hotfix/pull.rb
 - lib/big_keeper/command/feature&hotfix/push.rb
@@ -257,6 +258,7 @@ files:
 - lib/big_keeper/util/gitflow_operator.rb
 - lib/big_keeper/util/gradle_operator.rb
 - lib/big_keeper/util/info_plist_operator.rb
+- lib/big_keeper/util/list_generator.rb
 - lib/big_keeper/util/logger.rb
 - lib/big_keeper/util/pod_operator.rb
 - lib/big_keeper/util/podfile_detector.rb