bigkeeper 0.7.6 → 0.7.7

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

@@ -53,13 +53,14 @@ module BigKeeper
       Logger.highlight(%Q(Start to release/#{version}))
       # step 2 replace_modules
       PodfileOperator.new.replace_all_module_release(project_path,
+                                                     user,
                                                      modules,
                                                      version)
 
       # step 3 change Info.plist value
       InfoPlistOperator.new.change_version_build(project_path, version)
 
-      DepService.dep_operator(project_path).install(true, user)
+      DepService.dep_operator(project_path, user).install(true)
       `open #{project_path}/*.xcworkspace`
     end
   end

data/lib/big_keeper/dependency/dep_gradle_operator.rb

@@ -1,160 +1,56 @@
 require 'big_keeper/dependency/dep_operator'
+require 'big_keeper/util/gradle_operator'
 
 module BigKeeper
   # Operator for podfile
   class DepGradleOperator < DepOperator
 
     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
+      GradleOperator.new(@path).backup
     end
 
     def recover
-      cache_operator = CacheOperator.new(@path)
-
-      cache_operator.load('settings.gradle')
-      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
-
-      cache_operator.clean
-    end
-
-    def modules_with_branch(modules, branch_name)
-      full_name = branch_name.sub(/([\s\S]*)\/([\s\S]*)/){ $2 }
-      file = "#{@path}/app/build.gradle"
-
-      matched_modules = []
-      File.open(file, 'r') do |file|
-        file.each_line do |line|
-          modules.each do |module_name|
-            if line =~ /compile\s*'\S*#{module_name.downcase}:#{full_name}'\S*/
-              matched_modules << module_name
-              break
-            end
-          end
-        end
-      end
-      matched_modules
+      GradleOperator.new(@path).recover
     end
 
-    def modules_with_type(modules, module_type)
-      file = "#{@path}/app/build.gradle"
+    def update_module_config(module_name, module_type, source)
+      GradleOperator.new(@path).update_module_config(module_name, module_type, source)
 
-      matched_modules = []
-      File.open(file, 'r') do |file|
-        file.each_line do |line|
-          modules.each do |module_name|
-            if line =~ regex(module_type, module_name)
-              matched_modules << module_name
-              break
-            end
-          end
-        end
-      end
-      matched_modules
-    end
+      module_full_path = BigkeeperParser.module_full_path(@path, @user, module_name)
 
-    def regex(module_type, module_name)
       if ModuleType::PATH == module_type
-        /compile\s*project\('\S*#{module_name.downcase}'\)\S*/
-      elsif ModuleType::GIT == module_type
-        /compile\s*'\S*#{module_name.downcase}\S*'\S*/
-      elsif ModuleType::SPEC == module_type
-        /compile\s*'\S*#{module_name.downcase}\S*'\S*/
-      else
-        //
-      end
-    end
+        GradleOperator.new(module_full_path).backup
 
-    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
-          File.open(file, 'r') do |file|
-            file.each_line do |line|
-              temp_file.puts generate_build_config(line, module_name, module_type, source)
-            end
-          end
-          temp_file.close
-          FileUtils.mv(temp_file.path, file)
-        ensure
-          temp_file.close
-          temp_file.unlink
+        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
-      end
-    end
-
-    def install(should_update, user)
-      modules = modules_with_type(BigkeeperParser.module_names, ModuleType::PATH)
-
-      CacheOperator.new(@path).load('settings.gradle')
+      elsif ModuleType::GIT == module_type
+        GradleOperator.new(module_full_path).recover
 
-      begin
-        File.open("#{@path}/settings.gradle", 'a') do |file|
-          modules.each do |module_name|
-            file.puts "include ':#{module_name.downcase}'\r\n"
-            file.puts "project(':#{module_name.downcase}')." \
-              "projectDir = new File(rootProject.projectDir," \
-              "'#{BigkeeperParser.module_path(user, module_name)}/#{module_name.downcase}-lib')\r\n"
-          end
+        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
-      ensure
+      else
       end
     end
 
-    def prefix_of_module(module_name)
-      file = "#{@path}/.bigkeeper/app/build.gradle"
-      prefix = ''
+    def install(should_update)
+      modules = ModuleCacheOperator.new(@path).all_path_modules
+      GradleOperator.new(@path).update_setting_config('', @user, modules)
 
-      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*)/){
-              $3
-            }
-          end
-        end
+      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
-
-      prefix.chop
     end
 
     def open
     end
-
-    def generate_build_config(line, module_name, module_type, source)
-      if ModuleType::PATH == module_type
-        line.sub(/(\s*)([\s\S]*)'(\S*)#{module_name.downcase}(\S*)'(\S*)/){
-          "#{$1}compile project(':#{module_name.downcase}')"
-        }
-      elsif ModuleType::GIT == module_type
-        branch_name = GitOperator.new.current_branch(@path)
-        full_name = ''
-
-        # Get version part of source.addition
-        if 'develop' == source.addition || 'master' == source.addition
-          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*)/){
-          "#{$1}compile '#{prefix_of_module(module_name)}#{module_name.downcase}:#{full_name}'"
-        }
-      elsif ModuleType::SPEC == module_type
-        line.sub(/(\s*)([\s\S]*)'(\S*)#{module_name.downcase}(\S*)'(\S*)/){
-          "#{$1}compile '#{prefix_of_module(module_name)}#{module_name.downcase}:#{source}'"
-        }
-      else
-        line
-      end
-    end
-
-    private :generate_build_config, :regex, :prefix_of_module
   end
 end

data/lib/big_keeper/dependency/dep_operator.rb

@@ -2,9 +2,11 @@ module BigKeeper
   # Operator for podfile
   class DepOperator
     @path
+    @user
 
-    def initialize(path)
+    def initialize(path, user)
       @path = path
+      @user = user
     end
 
     def backup
@@ -15,19 +17,11 @@ module BigKeeper
       raise "You should override this method in subclass."
     end
 
-    def modules_with_branch(modules, branch_name)
-      raise "You should override this method in subclass."
-    end
-
-    def modules_with_type(modules, module_type)
-      raise "You should override this method in subclass."
-    end
-
     def update_module_config(module_name, module_type, source)
       raise "You should override this method in subclass."
     end
 
-    def install(should_update, user)
+    def install(should_update)
       raise "You should override this method in subclass."
     end
 

data/lib/big_keeper/dependency/dep_pod_operator.rb

@@ -17,50 +17,6 @@ module BigKeeper
       cache_operator.clean
     end
 
-    def modules_with_branch(modules, branch_name)
-      file = "#{@path}/Podfile"
-      matched_modules = []
-      File.open(file, 'r') do |file|
-        file.each_line do |line|
-          modules.each do |module_name|
-            if line =~ /pod\s*'#{module_name}'\s*,\s*:git\s*=>\s*\S*\s*,\s*:branch\s*=>\s*'#{branch_name}'\s*/
-              matched_modules << module_name
-              break
-            end
-          end
-        end
-      end
-      matched_modules
-    end
-
-    def modules_with_type(modules, module_type)
-      file = "#{@path}/Podfile"
-      matched_modules = []
-      File.open(file, 'r') do |file|
-        file.each_line do |line|
-          modules.each do |module_name|
-            if line =~ /pod\s*'#{module_name}'\s*,#{regex(module_type)}/
-              matched_modules << module_name
-              break
-            end
-          end
-        end
-      end
-      matched_modules
-    end
-
-    def regex(module_type)
-      if ModuleType::PATH == module_type
-        "\s*:path\s*=>\s*"
-      elsif ModuleType::GIT == module_type
-        "\s*:git\s*=>\s*"
-      elsif ModuleType::SPEC == module_type
-        "\s*'"
-      else
-        ""
-      end
-    end
-
     def update_module_config(module_name, module_type, source)
       file = "#{@path}/Podfile"
       temp_file = Tempfile.new('.Podfile.tmp')
@@ -79,7 +35,7 @@ module BigKeeper
       end
     end
 
-    def install(should_update, user)
+    def install(should_update)
       PodOperator.pod_install(@path, should_update)
     end
 
@@ -88,29 +44,29 @@ module BigKeeper
     end
 
     def generate_module_config(line, module_name, module_type, source)
-      line.sub(/(\s*)pod(\s*)'(\S*)#{module_name}(\S*)'([\s\S]*)#([\s\S]*)/){
+      line.sub(/(\s*)pod(\s*)('|")#{module_name}('|")([\s\S]*)/){
         if ModuleType::PATH == module_type
-          "#{$1}pod '#{module_name}', :path => '#{source}' ##{$6}"
+          "#{$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}' ##{$6}"
+            "#{$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}' ##{$6}"
+            "#{$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}' ##{$6}"
+            "#{$1}pod '#{module_name}', :git => '#{source.base}', :commit => '#{source.addition}'"
           else
-            "#{$1}pod '#{module_name}', :git => '#{source.base}' ##{$6}"
+            "#{$1}pod '#{module_name}', :git => '#{source.base}'"
           end
         elsif ModuleType::SPEC == module_type
-          "#{$1}pod '#{module_name}', '#{source}' ##{$6}"
+          "#{$1}pod '#{module_name}', '#{source}'"
         else
           line
         end
       }
     end
 
-    private :generate_module_config, :regex
+    private :generate_module_config
   end
 end

data/lib/big_keeper/dependency/dep_service.rb

@@ -7,8 +7,8 @@ require 'big_keeper/dependency/dep_type'
 module BigKeeper
   # Operator for podfile
   class DepService
-    def self.dep_operator(path)
-      DepType.operator(path)
+    def self.dep_operator(path, user)
+      DepType.operator(path, user)
     end
   end
 end

data/lib/big_keeper/dependency/dep_type.rb

@@ -19,14 +19,14 @@ module BigKeeper
       end
     end
 
-    def self.operator(path)
+    def self.operator(path, user)
       operator_type = type(path)
       if COCOAPODS == operator_type
-        DepPodOperator.new(path)
+        DepPodOperator.new(path, user)
       elsif GRADLE == operator_type
-        DepGradleOperator.new(path)
+        DepGradleOperator.new(path, user)
       else
-        DepOperator.new(path)
+        DepOperator.new(path, user)
       end
     end
   end

data/lib/big_keeper/model/gitflow_type.rb

@@ -16,6 +16,18 @@ module BigKeeper
       end
     end
 
+    def self.command(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"

data/lib/big_keeper/service/git_service.rb

@@ -13,11 +13,11 @@ module BigKeeper
       branch_name = "#{GitflowType.name(type)}/#{name}"
       if !git.has_remote_branch(path, branch_name) && !git.has_local_branch(path, branch_name)
 
-        GitflowOperator.new.verify_git_flow(path)
-
         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

data/lib/big_keeper/service/module_service.rb

@@ -1,5 +1,7 @@
 require 'big_keeper/service/git_service'
+
 require 'big_keeper/util/logger'
+require 'big_keeper/util/cache_operator'
 
 module BigKeeper
   # Operator for got
@@ -72,12 +74,13 @@ module BigKeeper
 
       verify_module(path, user, module_name, home_branch_name, type)
 
-      GitService.new.verify_push(module_full_path, "publish branch #{home_branch_name}", home_branch_name, module_name)
-
       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)
     end
 
     def finish(path, user, module_name, home_branch_name, type)
@@ -89,10 +92,13 @@ module BigKeeper
       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).update_module_config(
+
+      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)
     end
 
     def add(path, user, module_name, name, type)
@@ -103,10 +109,12 @@ module BigKeeper
       verify_module(path, user, module_name, home_branch_name, type)
 
       module_path = BigkeeperParser.module_path(user, module_name)
-      DepService.dep_operator(path).update_module_config(
+      DepService.dep_operator(path, user).update_module_config(
                                            module_name,
                                            ModuleType::PATH,
                                            module_path)
+
+      ModuleCacheOperator.new(path).add_path_module(module_name)
     end
 
     def del(path, user, module_name, name, type)
@@ -122,11 +130,12 @@ module BigKeeper
       # GitOperator.new.del(module_full_path, home_branch_name)
 
       module_git = BigkeeperParser.module_git(module_name)
-
-      DepService.dep_operator(path).update_module_config(
+      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
   end
 end