kookeeper 3.0.0 → 3.0.3

data/lib/big_keeper/dependency/dep_gradle_operator.rb

@@ -1,71 +1,53 @@
 require 'big_keeper/dependency/dep_operator'
-require 'big_keeper/util/gradle_module_operator'
-require 'big_keeper/util/gradle_file_operator'
-require 'big_keeper/model/operate_type'
-require 'big_keeper/util/version_config_operator'
+require 'big_keeper/util/gradle_operator'
 
 module BigKeeper
   # Operator for podfile
   class DepGradleOperator < DepOperator
 
-    BUILD_GRADLE = "app/build.gradle"
-    SETTINGS_GRADLE = "settings.gradle"
-
     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
-      build_file = "#{@path}/#{BUILD_GRADLE}"
-      settings_file = "#{@path}/#{SETTINGS_GRADLE}"
-      GradleFileOperator.new(@path, @user).recover_bigkeeper_config_file(build_file)
-      GradleFileOperator.new(@path, @user).recover_bigkeeper_config_file(settings_file)
-
-      cache_operator = CacheOperator.new(@path)
-      cache_operator.clean
+      GradleOperator.new(@path).recover(true, false)
     end
 
     def update_module_config(module_name, module_operate_type)
+      module_full_path = BigkeeperParser.module_full_path(@path, @user, module_name)
+
+      # get modules
       if ModuleOperateType::ADD == module_operate_type
-        GradleModuleOperator.new(@path, @user, module_name).update_module(ModuleOperateType::ADD)
+        GradleOperator.new(module_full_path).backup
+
+        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
-        GradleModuleOperator.new(@path, @user, module_name).recover()
+        GradleOperator.new(module_full_path).recover(true, true)
       elsif ModuleOperateType::FINISH == module_operate_type
-        GradleModuleOperator.new(@path, @user, module_name).update_module(ModuleOperateType::FINISH)
+        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
-        GradleModuleOperator.new(@path, @user, module_name).recover()
+        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
-    end
-
-    def install(modules, type, should_update)
-      if OperateType::START == type || OperateType::UPDATE == type || OperateType::SWITCH == type || OperateType::FINISH == type
-        GradleFileOperator.new(@path, @user).update_home_depends("#{@path}/#{BUILD_GRADLE}", "#{@path}/#{SETTINGS_GRADLE}",type)
-      elsif OperateType::PUBLISH == type
-        recover()
-      end
-    end
-
-    def release_module_start(modules, module_name, version)
-        module_full_path = BigkeeperParser.module_full_path(@path, @user, module_name)
-        version_config_file = "#{module_full_path}/doc/config/version-config.gradle"
-        version = "#{version}-SNAPSHOT" unless version.include?'SNAPSHOT'
-        VersionConfigOperator.change_version(version_config_file, modules, version)
-    end
-
-    def release_module_finish(modules, module_name, version)
-        module_full_path = BigkeeperParser.module_full_path(@path, @user, module_name)
-        version_config_file = "#{module_full_path}/doc/config/version-config.gradle"
-        VersionConfigOperator.change_version(version_config_file, modules, version)
-    end
 
-    def release_home_start(modules, version)
-      version_config_file = "#{@path}/doc/config/version-config.gradle"
-      version = "#{version}-SNAPSHOT" unless version.include?'SNAPSHOT'
-      VersionConfigOperator.change_version(version_config_file, modules, version)
+      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 release_home_finish(modules, version)
-      version_config_file = "#{@path}/doc/config/version-config.gradle"
-      VersionConfigOperator.change_version(version_config_file, modules, version)
+    def install(should_update)
     end
 
     def open

data/lib/big_keeper/dependency/dep_operator.rb

@@ -21,23 +21,7 @@ module BigKeeper
       raise "You should override this method in subclass."
     end
 
-    def release_module_start(modules, module_name, version)
-      raise "You should override this method in subclass."
-    end
-
-    def release_module_finish(modules, module_name, version)
-      raise "You should override this method in subclass."
-    end
-
-    def release_home_start(modules, version)
-      raise "You should override this method in subclass."
-    end
-
-    def release_home_finish(modules, version)
-      raise "You should override this method in subclass."
-    end
-
-    def install(modules, type, should_update)
+    def install(should_update)
       raise "You should override this method in subclass."
     end
 

data/lib/big_keeper/dependency/dep_pod_operator.rb

@@ -20,10 +20,10 @@ module BigKeeper
 
     def update_module_config(module_name, module_operate_type)
       file = "#{@path}/Podfile"
-      temp_file = Tempfile.new('.Podfile.tmp', :encoding => 'UTF-8')
+      temp_file = Tempfile.new('.Podfile.tmp')
 
       begin
-        File.open(file, 'r', :encoding => 'UTF-8') do |file|
+        File.open(file, 'r') do |file|
           file.each_line do |line|
             temp_file.puts generate_module_config(line, module_name, module_operate_type)
           end
@@ -36,7 +36,7 @@ module BigKeeper
       end
     end
 
-    def install(modules, type, should_update)
+    def install(should_update)
       PodOperator.pod_install(@path, should_update)
     end
 
@@ -45,10 +45,10 @@ module BigKeeper
     end
 
     def generate_module_config(line, module_name, module_operate_type)
-      line.sub(/(\s*)pod(\s*)('|")#{module_name}((\/[_a-zA-Z0-9]+)?)('|")([\s\S]*)/){
+      line.sub(/(\s*)pod(\s*)('|")#{module_name}('|")([\s\S]*)/){
         if ModuleOperateType::ADD == module_operate_type
           module_path = BigkeeperParser.module_path(@user, module_name)
-          "#{$1}pod '#{module_name}#{$4}', :path => '#{module_path}'"
+          "#{$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?
@@ -59,21 +59,21 @@ module BigKeeper
         elsif ModuleOperateType::FINISH == module_operate_type
           module_git = BigkeeperParser.module_git(module_name)
           branch_name = GitOperator.new.current_branch(@path)
-          "#{$1}pod '#{module_name}#{$4}', :git => '#{module_git}', :branch => '#{branch_name}'"
+          "#{$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}#{$4}', :git => '#{module_git}', :branch => '#{base_branch_name}'"
+          "#{$1}pod '#{module_name}', :git => '#{module_git}', :branch => '#{base_branch_name}'"
         elsif ModuleOperateType::RELEASE == module_operate_type
           module_git = BigkeeperParser.module_git(module_name)
           lastest_tag, is_spec = find_lastest_tag(module_name)
           if is_spec == true
             Logger.default("#{module_name} lastest tag is #{lastest_tag}, this tag has published.")
-            "#{$1}pod '#{module_name}#{$4}', '#{lastest_tag}'"
+            "#{$1}pod '#{module_name}', '#{lastest_tag}'"
           else
             Logger.default("#{module_name} lastest tag is #{lastest_tag}, this tag not publish.")
-            "#{$1}pod '#{module_name}#{$4}', :git => '#{module_git}', :tag => '#{lastest_tag}'"
+            "#{$1}pod '#{module_name}', :git => '#{module_git}', :tag => '#{lastest_tag}'"
           end
         else
           line
@@ -84,7 +84,7 @@ module BigKeeper
     def origin_config_of_module(module_name)
       origin_config = ''
 
-      File.open("#{@path}/.bigkeeper/Podfile", 'r', :encoding => 'UTF-8') do |file|
+      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

data/lib/big_keeper/model/operate_type.rb

@@ -3,9 +3,6 @@ module BigKeeper
     START = 1
     UPDATE = 2
     SWITCH = 3
-    FINISH = 4
-    PUBLISH = 5
-    RELEASE = 6
 
     def self.name(type)
       if START == type

data/lib/big_keeper/service/git_service.rb

@@ -14,7 +14,7 @@ module BigKeeper
       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')
+        #verify_special_branch(path, 'develop')
 
         GitflowOperator.new.verify_git_flow(path)
 
@@ -114,9 +114,8 @@ module BigKeeper
     def branchs_with_type(path, type)
       branchs = []
       Dir.chdir(path) do
-        IO.popen('git branch -a') do | io |
+        IO.popen('git branch -r') do | io |
           io.each do | line |
-            branchs << line.gsub('\n', '') if line.include?('develop')
             branchs << line.gsub(/\s/, '') if line =~ /[\s\S]*#{GitflowType.name(type)}*/
           end
         end

data/lib/big_keeper/service/module_service.rb

@@ -154,71 +154,6 @@ module BigKeeper
       result_dic
     end
 
-    def release_check_changed(path, user, module_name)
-      module_full_path = BigkeeperParser.module_full_path(path, user, module_name)
-
-      git = GitOperator.new
-      if !File.exist? module_full_path
-        Logger.default("No local repository for module '#{module_name}', clone it...")
-        module_git = BigkeeperParser.module_git(module_name)
-        git.clone(File.expand_path("#{module_full_path}/../"), module_git)
-      end
-      GitService.new.verify_checkout_pull(module_full_path, 'develop')
-      git.check_remote_branch_diff(module_full_path, 'develop', 'master')
-    end
-
-    def release_start(path, user, modules, module_name, version)
-      module_full_path = BigkeeperParser.module_full_path(path, user, module_name)
-
-      git = GitOperator.new
-      if !File.exist? module_full_path
-        Logger.default("No local repository for module '#{module_name}', clone it...")
-        module_git = BigkeeperParser.module_git(module_name)
-        git.clone(File.expand_path("#{module_full_path}/../"), module_git)
-      end
-      #stash module
-      StashService.new.stash(module_full_path, GitOperator.new.current_branch(module_full_path), module_name)
-      # delete cache
-      CacheOperator.new(module_full_path).clean()
-      # checkout develop
-      GitService.new.verify_checkout_pull(module_full_path, 'develop')
-      DepService.dep_operator(path, user).release_module_start(modules, module_name, version)
-
-      # Push home changes to remote
-      Logger.highlight("Push branch 'develop' for #{module_name}...")
-      GitService.new.verify_push(
-        module_full_path,
-        "release start for #{version}",
-        'develop',
-        "#{module_name}")
-    end
-
-    def release_finish(path, user, modules, module_name, version)
-      module_full_path = BigkeeperParser.module_full_path(path, user, module_name)
-
-      git = GitOperator.new
-      if !File.exist? module_full_path
-        Logger.default("No local repository for module '#{module_name}', clone it...")
-        module_git = BigkeeperParser.module_git(module_name)
-        git.clone(File.expand_path("#{module_full_path}/../"), module_git)
-      end
-      #stash module
-      StashService.new.stash(module_full_path, GitOperator.new.current_branch(module_full_path), module_name)
-      # delete cache
-      CacheOperator.new(module_full_path).clean()
-      # checkout develop
-      GitService.new.verify_checkout_pull(module_full_path, 'develop')
-      DepService.dep_operator(path, user).release_module_finish(modules, module_name, version)
-
-      # Push home changes to remote
-      Logger.highlight("Push branch 'develop' for #{module_name}...")
-      GitService.new.verify_push(
-        module_full_path,
-        "release finish for #{version}",
-        'develop',
-        "#{module_name}")
-    end
-
     private :verify_module
   end
 end

data/lib/big_keeper/util/bigkeeper_parser.rb

@@ -50,7 +50,7 @@ module BigKeeper
 
         Logger.error("Can't find a Bigkeeper file in current directory.") if !FileOperator.definitely_exists?(bigkeeper)
 
-        content = File.read(bigkeeper, :encoding => 'UTF-8')
+        content = File.read bigkeeper
         content.gsub!(/version\s/, 'BigKeeper::version ')
         content.gsub!(/user\s/, 'BigKeeper::user ')
         content.gsub!(/home\s/, 'BigKeeper::home ')
@@ -219,22 +219,6 @@ module BigKeeper
       @@config[:modules][module_name][:git]
     end
 
-    def self.module_source(module_name)
-      @@config[:modules][module_name][:mod_path]
-    end
-
-    def self.module_maven(module_name)
-      @@config[:modules][module_name][:maven_group] + ':' + @@config[:modules][module_name][:maven_artifact]
-    end
-
-    def self.module_maven_artifact(module_name)
-      @@config[:modules][module_name][:maven_artifact]
-    end
-
-    def self.module_version_alias(module_name)
-      @@config[:modules][module_name][:version_alias]
-    end
-
     def self.module_pulls(module_name)
       @@config[:modules][module_name][:pulls]
     end

data/lib/big_keeper/util/cache_operator.rb

@@ -19,9 +19,7 @@ module BigKeeper
     end
 
     def clean
-      if File.exist?(@cache_path)
-        FileUtils.rm_r(@cache_path)
-      end
+      FileUtils.rm_r(@cache_path)
     end
   end
 
@@ -32,8 +30,8 @@ module BigKeeper
       FileUtils.mkdir_p(@cache_path) unless File.exist?(@cache_path)
 
       if File.exist?("#{@cache_path}/module.cache")
-        file = File.open("#{@cache_path}/module.cache", 'r', :encoding => 'UTF-8')
-        @modules = JSON.load(file.read(), :encoding => 'UTF-8')
+        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" => []}}
@@ -110,7 +108,7 @@ module BigKeeper
     end
 
     def cache_modules
-      file = File.new("#{@cache_path}/module.cache", 'w', :encoding => 'UTF-8')
+      file = File.new("#{@cache_path}/module.cache", 'w')
       file << @modules.to_json
       file.close
     end

data/lib/big_keeper/util/file_operator.rb

@@ -29,5 +29,5 @@ module BigKeeper
       return header_file_list+m_file_list
     end
   end
-
+  
 end

data/lib/big_keeper/util/git_operator.rb

@@ -110,7 +110,7 @@ module BigKeeper
 
     def discard(path)
       Dir.chdir(path) do
-        `git checkout . && git clean -df`
+        `git checkout . && git clean -xdf`
       end
     end
 
@@ -127,14 +127,7 @@ module BigKeeper
     end
 
     def user
-      name = `git config user.name`.chop
-      cn_reg = /[\u4e00-\u9fa5]{1}/
-      cn_arr = name.scan(cn_reg)
-      if cn_arr.count > 0
-        Logger.error("git config user.name has Chinese character")
-      else
-        name.gsub(/[^0-9A-Za-z]/, '').downcase
-      end
+      `git config user.name`.chop
     end
 
     def tag(path, version)
@@ -181,22 +174,6 @@ module BigKeeper
       end
     end
 
-    def check_remote_branch_diff(path, branch, compare_branch)
-      fetch(path)
-      compare_branch_commits = Array.new
-      IO.popen("cd '#{path}';git log --left-right #{branch}...origin/#{compare_branch} --pretty=oneline") do |io|
-        io.each do |line|
-          compare_branch_commits.push(line) unless (line.include? '>') && (line.include? "Merge branch \'#{branch}\'")
-        end
-      end
-      if compare_branch_commits.size > 0
-        return true
-      else
-        return false
-      end
-    end
-
-    # TODO: 需要改造，util方法不应该有业务逻辑
     def check_diff(path, branch, compare_branch)
       compare_branch_commits = Array.new
       IO.popen("cd '#{path}'; git log --left-right #{branch}...#{compare_branch} --pretty=oneline") do |io|
@@ -239,4 +216,6 @@ module BigKeeper
 
   end
 
+  # p GitOperator.new.user
+  # BigStash::StashOperator.new("/Users/mmoaay/Documents/eleme/BigKeeperMain").list
 end

data/lib/big_keeper/util/gradle_operator.rb

@@ -0,0 +1,209 @@
+require 'big_keeper/util/cache_operator'
+
+module BigKeeper
+  # Operator for podfile
+  class GradleOperator
+    def initialize(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(settings_config, build_config)
+      cache_operator = CacheOperator.new(@path)
+
+      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_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
+      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_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
+        end
+      end
+    end
+
+    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 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}"
+        }
+      else
+        line
+      end
+    end
+
+    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 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 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.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}:#{full_name}-SNAPSHOT'"
+          end
+        }
+      else
+        line
+      end
+    end
+
+    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