shkeeper 1.0.0

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

@@ -0,0 +1,91 @@
+#!/usr/bin/ruby
+require 'big_keeper/util/podfile_operator'
+require 'big_keeper/util/gitflow_operator'
+require 'big_keeper/dependency/dep_type'
+require 'big_keeper/util/info_plist_operator'
+require 'big_keeper/util/logger'
+require 'big_keeper/util/xcode_operator'
+
+module BigKeeper
+  def self.release_home_start(path, version, user)
+    BigkeeperParser.parse("#{path}/Bigkeeper")
+
+    version = BigkeeperParser.version if version == 'Version in Bigkeeper file'
+    modules = BigkeeperParser.module_names
+
+    #stash
+    StashService.new.stash_all(path, GitOperator.new.current_branch(path), user, modules)
+
+    # delete cache
+    CacheOperator.new(path).clean()
+    # cache Podfile
+    CacheOperator.new(path).save('Podfile')
+
+    # check
+    GitOperator.new.check_diff(path, "develop", "master")
+
+    #checkout release branch
+    Logger.highlight(%Q(Start to checkout Branch release/#{version}))
+    if GitOperator.new.current_branch(path) != "release/#{version}"
+      if GitOperator.new.has_branch(path, "release/#{version}")
+        GitOperator.new.checkout(path, "release/#{version}")
+      else
+        GitflowOperator.new.start(path, version, GitflowType::RELEASE)
+        GitOperator.new.push_to_remote(path, "release/#{version}")
+      end
+    end
+
+    Logger.highlight(%Q(Start to release/#{version}))
+    # step 2 replace_modules
+    PodfileOperator.new.replace_all_module_release(path,
+                                                   user,
+                                                   modules,
+                                                   ModuleOperateType::RELEASE)
+
+    # step 3 change Info.plist value
+    InfoPlistOperator.new.change_version_build(path, version)
+
+    GitService.new.verify_push(path, "Change version to #{version}", "release/#{version}", 'Home')
+    DepService.dep_operator(path, user).install(true)
+    XcodeOperator.open_workspace(path)
+  end
+
+  def self.release_home_finish(path, version)
+    BigkeeperParser.parse("#{path}/Bigkeeper")
+    version = BigkeeperParser.version if version == 'Version in Bigkeeper file'
+    Logger.highlight("Start finish release home for #{version}")
+
+    if GitOperator.new.has_branch(path, "release/#{version}")
+      if GitOperator.new.current_branch(path) != "release/#{version}"
+        GitOperator.new.checkout(path, "release/#{version}")
+      end
+
+      GitService.new.verify_push(path, "finish release branch", "release/#{version}", 'Home')
+
+      # master
+      GitOperator.new.checkout(path, "master")
+      GitOperator.new.merge(path, "release/#{version}")
+      GitService.new.verify_push(path, "release V#{version}", "master", 'Home')
+
+      GitOperator.new.tag(path, version)
+
+      # release branch
+      GitOperator.new.checkout(path, "release/#{version}")
+      CacheOperator.new(path).load('Podfile')
+      CacheOperator.new(path).clean()
+      GitOperator.new.commit(path, "reset #{version} Podfile")
+      GitService.new.verify_push(path, "reset #{version} Podfile", "release/#{version}", 'Home')
+
+      # develop
+      GitOperator.new.checkout(path, "develop")
+      GitOperator.new.merge(path, "release/#{version}")
+      GitService.new.verify_push(path, "merge release/#{version} to develop", "develop", 'Home')
+      GitOperator.new.check_diff(path, "develop", "master")
+
+      Logger.highlight("Finish release home for #{version}")
+    else
+      raise Logger.error("There is no release/#{version} branch, please use release home start first.")
+    end
+  end
+
+end

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

@@ -0,0 +1,61 @@
+#!/usr/bin/ruby
+require 'big_keeper/util/podfile_operator'
+require 'big_keeper/util/gitflow_operator'
+require 'big_keeper/dependency/dep_type'
+require 'big_keeper/util/info_plist_operator'
+require 'big_keeper/util/git_operator'
+require 'big_keeper/util/logger'
+require 'big_keeper/util/pod_operator'
+
+module BigKeeper
+  def self.release_module_start(path, version, user, module_name, ignore)
+    BigkeeperParser.parse("#{path}/Bigkeeper")
+    module_path = BigkeeperParser.module_full_path(path, user, module_name)
+
+    # stash
+    StashService.new.stash(module_path, GitOperator.new.current_branch(module_path), module_name)
+
+    #check
+    if ignore != true
+      GitOperator.new.check_merge(module_path, "feature/#{version}")
+      GitOperator.new.check_diff(module_path, "develop", "master")
+      Logger.highlight(%Q(#{module_name} release check finish))
+    end
+
+    # checkout to develop branch
+    Logger.highlight(%Q(Start checkout #{module_name} to Branch develop))
+    GitService.new.verify_checkout_pull(module_path, "develop")
+
+    Logger.highlight(%Q(#{module_name} release start finish))
+  end
+
+## release finish
+  def self.release_module_finish(path, version, user, module_name, spec)
+    BigkeeperParser.parse("#{path}/Bigkeeper")
+    module_path = BigkeeperParser.module_full_path(path, user, module_name)
+
+    # check commit
+    Logger.error("current branch has unpush files") if GitOperator.new.has_changes(module_path)
+
+    #修改 podspec 文件
+    # TO DO: - advanced to use Regular Expression
+    has_change = PodfileOperator.new.podspec_change(%Q(#{module_path}/#{module_name}.podspec), version, module_name)
+    GitService.new.verify_push(module_path, "Change version number", "develop", "#{module_name}") if has_change == true
+
+    # check out master
+    Logger.highlight("'#{module_name}' checkout branch to master...")
+    GitService.new.verify_checkout_pull(module_path, "master")
+
+    Logger.highlight(%Q(Merge develop to master))
+    # merge develop to master
+    GitOperator.new.merge(module_path, "develop")
+    GitOperator.new.push_to_remote(module_path, "master")
+
+    GitOperator.new.tag(module_path, version)
+    # pod repo push
+    if spec == true
+      PodOperator.pod_repo_push(module_path, module_name, BigkeeperParser.source_spec_path(module_name), version)
+    end
+  end
+
+end

data/lib/big_keeper/command/release.rb

@@ -0,0 +1,75 @@
+require 'big_keeper/command/release/home'
+require 'big_keeper/command/release/module'
+require 'big_keeper/util/leancloud_logger'
+
+module BigKeeper
+  def self.release_command
+    desc 'Gitflow release operations'
+    command :release do |c|
+
+      c.desc 'Release home project operations'
+      c.command :home do |home|
+        home.desc 'Start release home project'
+        home.command :start do |start|
+          start.action do |global_options, options, args|
+            path = File.expand_path(global_options[:path])
+            version = global_options[:ver]
+            user = global_options[:user].gsub(/[^0-9A-Za-z]/, '').downcase
+            LeanCloudLogger.instance.set_command("release/home/start")
+
+            help_now!('user name is required') if user and user.empty?
+            raise Logger.error("release version is required") if version == nil
+            release_home_start(path, version, user)
+          end
+        end
+
+        home.desc 'Finish release home project'
+        home.command :finish do |finish|
+          finish.action do |global_options, options, args|
+            path = File.expand_path(global_options[:path])
+            version = global_options[:ver]
+            LeanCloudLogger.instance.set_command("release/home/finish")
+
+            raise Logger.error("release version is required") if version == nil
+            release_home_finish(path, version)
+          end
+        end
+      end
+
+      c.desc 'release module'
+      c.switch [:i,:ignore]
+      c.command :module do |m|
+        m.desc 'Start release module project'
+        m.command :start do |start|
+          start.action do |global_options, options, args|
+            path = File.expand_path(global_options[:path])
+            version = global_options[:ver]
+            user = global_options[:user].gsub(/[^0-9A-Za-z]/, '').downcase
+            LeanCloudLogger.instance.set_command("release/module/start")
+
+            help_now!('module name is required') if args.length != 1
+            raise Logger.error("release version is required") if version == nil
+            module_name = args[0]
+            release_module_start(path, version, user, module_name, options[:ignore])
+          end
+        end
+
+        m.desc 'finish release module project'
+        m.switch [:s,:spec]
+        m.command :finish do |finish|
+          finish.action do |global_options, options, args|
+            path = File.expand_path(global_options[:path])
+            version = global_options[:ver]
+            user = global_options[:user].gsub(/[^0-9A-Za-z]/, '').downcase
+            LeanCloudLogger.instance.set_command("release/module/finish")
+
+            help_now!('module name is required') if args.length != 1
+            raise Logger.error("release version is required") if version == nil
+            module_name = args[0]
+            release_module_finish(path, version, user, module_name, options[:spec])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/big_keeper/command/spec/add.rb

@@ -0,0 +1,9 @@
+require 'big_keeper/util/bigkeeper_parser'
+require 'big_keeper/dependency/dep_type'
+require 'big_keeper/util/logger'
+
+module BigKeeper
+  def self.spec_add
+    Logger.default('Coming soon.')
+  end
+end

data/lib/big_keeper/command/spec/analyze.rb

@@ -0,0 +1,88 @@
+require 'big_keeper/util/bigkeeper_parser'
+require 'big_keeper/dependency/dep_type'
+require 'big_keeper/util/logger'
+require 'big_keeper/model/library_model'
+
+module BigKeeper
+  def self.spec_analyze(path,is_all,find_module_names)
+    # Parse Bigkeeper file
+    BigkeeperParser.parse("#{path}/Bigkeeper")
+    
+    is_default = !is_all&&find_module_names.size==0
+    if is_all && find_module_names.size>0
+      Logger.error("parameter conflict: [--all] | [module_names]")
+      return
+    end
+    Logger.highlight('Start spec analyze...')
+    Logger.default(Time.now.to_s)
+
+    # Parse Bigkeeper file
+    # BigkeeperParser.parse("#{path}/Bigkeeper")
+    # module_names = BigkeeperParser.module_names
+
+    # find modules
+    Logger.highlight('Get all modules...')
+    module_names = []
+    pod_path = path+"/Pods/"
+    dir = Dir.open(pod_path)
+    dir.each do |dir_name|
+      if !dir_name.include?(".") && dir_name != "Headers" && dir_name != "Local Podspecs" && dir_name != "Target Support Files"
+        module_names[module_names.size]=dir_name
+      end
+    end
+
+    for input_moudle_name in find_module_names do
+      if !module_names.include?(input_moudle_name)
+        Logger.error("["+input_moudle_name+"] not exist.")
+      end
+    end
+
+    # setup modules
+    module_list = []
+    module_keyword_map = Hash.new
+    file_count = 0
+    for module_name in module_names do
+      library = LibraryModel.new(module_name)
+      library.get_all_public_file(path)
+      module_list[module_list.size]=library
+      module_keyword_map[module_name]=library.keyword_list
+      if is_all || find_module_names.include?(library.name)
+        file_count = file_count + library.file_list.size
+      end
+    end
+    # analyze modules spec
+
+    Logger.highlight('Analyze modules...')
+    Logger.default(Time.now.to_s)
+    file_index = 0
+    for library in module_list do
+      if is_all || find_module_names.include?(library.name)
+        Logger.default('Analyzing ' + library.name)
+        file_index = file_index + library.file_list.size
+        library.spec_dependece_library(module_keyword_map.clone)#(Hash.new(module_keyword_map)).to_hash)
+        progress = (file_index*100.0)/file_count
+        progress = format("%.02f", progress).to_f
+        Logger.default('progress >>>> ' + String(progress) + '% [' + library.name + ' done] ')
+      end
+    end
+    Logger.highlight('Analyze complete.')
+    Logger.default(Time.now.to_s)
+
+    # log spec info
+    for library in module_list do
+      if is_all || find_module_names.include?(library.name)
+        Logger.highlight("\n-"+library.name+":")
+        for spec_library in library.spec_library do
+          puts " -"+spec_library
+        end
+      end
+    end
+
+    # save cache to file
+    if is_all
+
+    end
+
+  end
+
+end

data/lib/big_keeper/command/spec/delete.rb

@@ -0,0 +1,9 @@
+require 'big_keeper/util/bigkeeper_parser'
+require 'big_keeper/dependency/dep_type'
+require 'big_keeper/util/logger'
+
+module BigKeeper
+  def self.spec_delete
+    Logger.default('Coming soon.')
+  end
+end

data/lib/big_keeper/command/spec/list.rb

@@ -0,0 +1,19 @@
+require 'logger'
+require 'json'
+
+module BigKeeper
+  def self.spec_list(path, user, options)
+      BigkeeperParser.parse("#{path}/Bigkeeper")
+      
+      module_dic = BigkeeperParser.parse_modules
+      module_list = Array.new
+      module_dic.keys.each do | key |
+        dic = Hash["module_name" => key,
+                           "git" => module_dic[key][:git],
+                         "pulls" => module_dic[key][:pulls]]
+        module_list << dic
+      end
+      json = JSON.pretty_generate(module_list)
+      puts json
+  end
+end

data/lib/big_keeper/command/spec/search.rb

@@ -0,0 +1,9 @@
+require 'big_keeper/util/bigkeeper_parser'
+require 'big_keeper/dependency/dep_type'
+require 'big_keeper/util/logger'
+
+module BigKeeper
+  def self.spec_search
+    Logger.default('Coming soon.')
+  end
+end

data/lib/big_keeper/command/spec/sync.rb

@@ -0,0 +1,12 @@
+require 'big_keeper/util/bigkeeper_parser'
+require 'big_keeper/dependency/dep_type'
+require 'big_keeper/util/logger'
+
+module BigKeeper
+  def self.spec_sync(path, version, user, module_name)
+    # Parse Bigkeeper file
+    BigkeeperParser.parse("#{path}/Bigkeeper")
+
+    Logger.default('Coming soon.')
+  end
+end

data/lib/big_keeper/command/spec.rb

@@ -0,0 +1,78 @@
+require 'big_keeper/command/spec/analyze'
+require 'big_keeper/command/spec/list'
+require 'big_keeper/command/spec/add'
+require 'big_keeper/command/spec/delete'
+require 'big_keeper/command/spec/search'
+require 'big_keeper/command/spec/sync'
+require 'big_keeper/util/leancloud_logger'
+
+module BigKeeper
+
+  def self.spec_command
+    desc 'Spec operations'
+
+    command :spec do |spec|
+      spec.switch [:a,:all]
+      spec.desc 'Analyze spec dependency infomation.'
+      spec.command :analyze do |analyze|
+        analyze.action do |global_options, options, args|
+          LeanCloudLogger.instance.set_command("spec/analyze")
+
+          path = File.expand_path(global_options[:path])
+          is_all = options[:all]
+          module_names = args
+          spec_analyze(path, is_all, module_names)
+        end
+      end
+
+      spec.desc 'List all the specs.'
+      spec.command :list do | list |
+        list.action do |global_options, options, args|
+          LeanCloudLogger.instance.set_command("spec/list")
+
+          path = File.expand_path(global_options[:path])
+          version = global_options[:ver]
+          user = global_options[:user].gsub(/[^0-9A-Za-z]/, '').downcase
+
+          spec_list(path, user, options)
+        end
+      end
+
+      spec.desc 'Sync Module dependency from Home.'
+      spec.command :sync do | sync|
+        sync.action do |global_options, options, args|
+          LeanCloudLogger.instance.set_command("spec/sync")
+
+          path = File.expand_path(global_options[:path])
+          version = global_options[:ver]
+          user = global_options[:user].gsub(/[^0-9A-Za-z]/, '').downcase
+          module_name = args
+
+          spec_sync(path, version, user, module_name)
+        end
+      end
+
+      spec.desc 'Add a spec (Coming soon).'
+      spec.command :add do |add|
+        add.action do
+          spec_add()
+        end
+      end
+
+      spec.desc 'Delete a spec (Coming soon).'
+      spec.command :delete do |delete|
+        delete.action do
+          spec_delete()
+        end
+      end
+
+      spec.desc 'Search a spec with name (Coming soon).'
+      spec.command :search do |search|
+        search.action do
+          spec_search()
+        end
+      end
+
+    end
+  end
+end

data/lib/big_keeper/dependency/dep_gradle_operator.rb

@@ -0,0 +1,56 @@
+require 'big_keeper/dependency/dep_operator'
+require 'big_keeper/util/gradle_operator'
+
+module BigKeeper
+  # Operator for podfile
+  class DepGradleOperator < DepOperator
+
+    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(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
+        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
+        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)
+    end
+
+    def open
+    end
+  end
+end

data/lib/big_keeper/dependency/dep_operator.rb

@@ -0,0 +1,32 @@
+module BigKeeper
+  # Operator for podfile
+  class DepOperator
+    @path
+    @user
+
+    def initialize(path, user)
+      @path = path
+      @user = user
+    end
+
+    def backup
+      raise "You should override this method in subclass."
+    end
+
+    def recover
+      raise "You should override this method in subclass."
+    end
+
+    def update_module_config(module_name, module_operate_type)
+      raise "You should override this method in subclass."
+    end
+
+    def install(should_update)
+      raise "You should override this method in subclass."
+    end
+
+    def open
+      raise "You should override this method in subclass."
+    end
+  end
+end

data/lib/big_keeper/dependency/dep_pod_operator.rb

@@ -0,0 +1,131 @@
+require 'big_keeper/dependency/dep_operator'
+
+require 'big_keeper/util/pod_operator'
+require 'big_keeper/util/xcode_operator'
+require 'big_keeper/util/cache_operator'
+require 'big_keeper/util/file_operator'
+
+module BigKeeper
+  # Operator for podfile
+  class DepPodOperator < DepOperator
+    def backup
+      CacheOperator.new(@path).save('Podfile')
+    end
+
+    def recover
+      cache_operator = CacheOperator.new(@path)
+      cache_operator.load('Podfile')
+      cache_operator.clean
+    end
+
+    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_operate_type)
+          end
+        end
+        temp_file.close
+        FileUtils.mv(temp_file.path, file)
+      ensure
+        temp_file.close
+        temp_file.unlink
+      end
+    end
+
+    def install(should_update)
+      PodOperator.pod_install(@path, should_update)
+    end
+
+    def open
+      XcodeOperator.open_workspace(@path)
+    end
+
+    def generate_module_config(line, module_name, module_operate_type)
+      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}', :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
+            origin_config_of_module
+          end
+        elsif ModuleOperateType::FINISH == module_operate_type
+          module_git = BigkeeperParser.module_git(module_name)
+          #branch_name = GitOperator.new.current_branch(@path)
+          branch_name = ModuleCacheOperator.new(@path).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}', :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}', '#{lastest_tag}'"
+          else
+            Logger.default("#{module_name} lastest tag is #{lastest_tag}, this tag not publish.")
+            "#{$1}pod '#{module_name}', :git => '#{module_git}', :tag => '#{lastest_tag}'"
+          end
+        else
+          line
+        end
+      }
+    end
+
+    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
+
+    def find_lastest_tag(module_name)
+      username = FileOperator.new.current_username
+      tags_repos_pwd = Array.new
+      tags_spec_list = Array.new
+      tags_module_list = Array.new
+
+      IO.popen("find /Users/#{username}/.cocoapods/repos -type d -name #{module_name}") do |io|
+        io.each do |line|
+          tags_repos_pwd.push(line) if line.include? "#{module_name}"
+        end
+      end
+      for pwd in tags_repos_pwd do
+        path = pwd.chomp
+        IO.popen("cd '#{path}'; ls") do |io|
+          io.each do |line|
+            tags_spec_list.push(line)
+          end
+        end
+      end
+
+      tags_module_list = GitOperator.new.tag_list(BigkeeperParser.module_full_path(@path, @user, module_name))
+      last_tag = tags_module_list[tags_module_list.length - 1]
+      if tags_module_list.include?(last_tag) && tags_spec_list.include?(last_tag)
+        return [last_tag.chomp, true]
+      else
+        return [last_tag.chomp, false]
+      end
+    end
+
+    private :generate_module_config, :origin_config_of_module, :find_lastest_tag
+  end
+end