bigkeeper 0.7.3

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

@@ -0,0 +1,24 @@
+require 'big_keeper/util/logger'
+
+module BigKeeper
+  def self.pull(path, user, type)
+    begin
+      # Parse Bigkeeper file
+      BigkeeperParser.parse("#{path}/Bigkeeper")
+      branch_name = GitOperator.new.current_branch(path)
+
+      Logger.error("Not a #{GitflowType.name(type)} branch, exit.") unless branch_name.include? GitflowType.name(type)
+
+      modules = PodfileOperator.new.modules_with_type("#{path}/Podfile",
+                                                      BigkeeperParser.module_names, ModuleType::PATH)
+
+      modules.each do |module_name|
+        ModuleService.new.pull(path, user, module_name, branch_name, type)
+      end
+
+      Logger.highlight("Pull branch '#{branch_name}' for 'Home'...")
+      GitOperator.new.pull(path)
+    ensure
+    end
+  end
+end

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

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

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

@@ -0,0 +1,27 @@
+require 'big_keeper/util/logger'
+
+module BigKeeper
+  def self.reabse(path, user, type)
+    begin
+      # Parse Bigkeeper file
+      BigkeeperParser.parse("#{path}/Bigkeeper")
+      branch_name = GitOperator.new.current_branch(path)
+
+      Logger.error("Not a #{GitflowType.name(type)} branch, exit.") unless branch_name.include? GitflowType.name(type)
+
+      modules = PodfileOperator.new.modules_with_type("#{path}/Podfile",
+                                                      BigkeeperParser.module_names, ModuleType::PATH)
+
+      modules.each do |module_name|
+        ModuleService.new.rebase(path, user, module_name, branch_name, type)
+      end
+
+      # Rebase Home
+      Logger.error("You have some changes in branch '#{home_branch_name}' \
+        for 'Home'. Use 'push' first please") if GitOperator.new.has_changes(path)
+
+      GitService.new.verify_rebase(path, GitflowType.base_branch(type), 'Home')
+    ensure
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+#!/usr/bin/ruby
+
+require 'big_keeper/util/podfile_operator'
+require 'big_keeper/util/gitflow_operator'
+require 'big_keeper/util/bigkeeper_parser'
+require 'big_keeper/util/logger'
+require 'big_keeper/util/pod_operator'
+require 'big_keeper/util/xcode_operator'
+
+require 'big_keeper/model/podfile_type'
+
+require 'big_keeper/service/stash_service'
+require 'big_keeper/service/module_service'
+
+
+module BigKeeper
+  def self.start(path, version, user, name, modules, type)
+    begin
+      # Parse Bigkeeper file
+      BigkeeperParser.parse("#{path}/Bigkeeper")
+
+      version = BigkeeperParser.version if version == 'Version in Bigkeeper file'
+      full_name = "#{version}_#{user}_#{name}"
+      branch_name = "#{GitflowType.name(type)}/#{full_name}"
+
+      GitService.new.verify_home_branch(path, branch_name, OperateType::START)
+
+      stash_modules = PodfileOperator.new.modules_with_type("#{path}/Podfile",
+                                BigkeeperParser.module_names, ModuleType::PATH)
+
+      # 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
+
+      Logger.highlight("Add branch '#{branch_name}' for 'Home'...")
+      # Start home feature
+      GitService.new.start(path, full_name, type)
+
+      # Modify podfile as path and Start modules feature
+      modules.each do |module_name|
+        ModuleService.new.add(path, user, module_name, full_name, type)
+      end
+
+      # pod install
+      PodOperator.pod_install(path, true) unless modules.empty?
+
+      # Open home workspace
+      XcodeOperator.open_workspace(path)
+
+      # Push home changes to remote
+      GitService.new.verify_push(path, "init #{GitflowType.name(type)} #{full_name}", branch_name, 'Home')
+    ensure
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+#!/usr/bin/ruby
+require 'big_stash/stash_operator'
+require 'big_keeper/util/logger'
+require 'big_keeper/util/pod_operator'
+require 'big_keeper/util/xcode_operator'
+
+module BigKeeper
+  def self.switch_to(path, version, user, name, type)
+    begin
+      # Parse Bigkeeper file
+      BigkeeperParser.parse("#{path}/Bigkeeper")
+
+      version = BigkeeperParser.version if version == 'Version in Bigkeeper file'
+      full_name = "#{version}_#{user}_#{name}"
+      branch_name = "#{GitflowType.name(type)}/#{full_name}"
+
+      GitService.new.verify_home_branch(path, branch_name, OperateType::SWITCH)
+
+      stash_modules = PodfileOperator.new.modules_with_type("#{path}/Podfile",
+                                BigkeeperParser.module_names, ModuleType::PATH)
+
+      # Stash current branch
+      StashService.new.stash_all(path, branch_name, user, stash_modules)
+
+      # Switch to new feature
+      GitOperator.new.checkout(path, branch_name)
+      GitOperator.new.pull(path)
+
+      # Apply home stash
+      StashService.new.pop_stash(path, branch_name, 'Home')
+
+      modules = PodfileOperator.new.modules_with_type("#{path}/Podfile",
+                                BigkeeperParser.module_names, ModuleType::PATH)
+
+      modules.each do |module_name|
+        ModuleService.new.switch_to(path, user, module_name, branch_name, type)
+      end
+
+      # pod install
+      PodOperator.pod_install(path, false)
+
+      # Open home workspace
+      XcodeOperator.open_workspace(path)
+    ensure
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+#!/usr/bin/ruby
+
+require 'big_keeper/util/podfile_operator'
+require 'big_keeper/util/gitflow_operator'
+require 'big_keeper/util/bigkeeper_parser'
+require 'big_keeper/util/logger'
+require 'big_keeper/util/pod_operator'
+require 'big_keeper/util/xcode_operator'
+
+require 'big_keeper/model/podfile_type'
+
+require 'big_keeper/service/stash_service'
+require 'big_keeper/service/module_service'
+
+
+module BigKeeper
+  def self.update(path, user, modules, type)
+    begin
+      # Parse Bigkeeper file
+      BigkeeperParser.parse("#{path}/Bigkeeper")
+      branch_name = GitOperator.new.current_branch(path)
+
+      Logger.error("Not a #{GitflowType.name(type)} branch, exit.") unless branch_name.include? GitflowType.name(type)
+
+      full_name = branch_name.gsub(/#{GitflowType.name(type)}\//, '')
+
+      current_modules = PodfileOperator.new.modules_with_type("#{path}/Podfile",
+                                BigkeeperParser.module_names, ModuleType::PATH)
+
+      # 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
+
+      Logger.highlight("Start to update modules for branch '#{branch_name}'...")
+
+      add_modules = modules - current_modules
+      del_modules = current_modules - 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|
+          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
+
+        # pod install
+        PodOperator.pod_install(path, false)
+
+        # Open home workspace
+        XcodeOperator.open_workspace(path)
+      end
+    ensure
+    end
+  end
+end

data/lib/big_keeper/command/pod/podfile.rb

@@ -0,0 +1,69 @@
+require 'big_keeper/util/podfile_detector'
+require 'big_keeper/util/podfile_operator'
+require 'big_keeper/util/podfile_module'
+require 'big_keeper/util/gitflow_operator'
+require 'big_keeper/util/bigkeeper_parser'
+require 'big_keeper/model/podfile_type'
+require 'big_keeper/util/logger'
+
+module BigKeeper
+
+  def self.podfile_detect(path)
+      # Parse Bigkeeper file
+      BigkeeperParser.parse("#{path}/Bigkeeper")
+      # Get modules' name
+      module_list = BigkeeperParser.module_names
+      # initialize PodfileDetector
+      detector = PodfileDetector.new(path,module_list)
+      # Get unlocked third party pods list
+      unlock_pod_list = detector.get_unlock_pod_list
+      # Print out unlock pod list
+      unlock_pod_list.each do |pod_name|
+        Logger.default("#{pod_name} should be locked.")
+      end
+      Logger.separator
+
+  end
+
+  def self.podfile_lock(path)
+      # Parse Bigkeeper file
+      BigkeeperParser.parse("#{path}/Bigkeeper")
+      # Get modules' name
+      module_list = BigkeeperParser.module_names
+      # initialize PodfileDetector
+      detector = PodfileDetector.new(path,module_list)
+      # Get unlocked third party pods list
+      unlock_pod_list = detector.get_unlock_pod_list
+      # Get Version
+      dictionary = detector.deal_lock_file(path,unlock_pod_list)
+      if dictionary.empty?
+        Logger.warning("There is nothing to be locked.")
+      else
+        PodfileOperator.new.find_and_lock("#{path}/Podfile",dictionary)
+        Logger.highlight("The Podfile has been changed.")
+        Logger.separator
+      end
+
+
+
+  end
+
+  def self.podfile_modules_update(path)
+      # Parse Bigkeeper file
+      BigkeeperParser.parse("#{path}/Bigkeeper")
+      # Get modules' name
+      module_list = BigkeeperParser.module_names
+      # initialize PodfileDetector
+      detector = PodfileModuleDetector.new(path)
+      # Get module latest version
+      module_dictionary = detector.check_version_list
+      # Check if anything should be upgrade
+      if module_dictionary.empty?
+        Logger.warning("There is nothing to be upgrade.")
+      else
+        PodfileOperator.new.find_and_upgrade("#{path}/Podfile",module_dictionary)
+        Logger.highlight("The Podfile has been changed.")
+      end
+  end
+
+end

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

@@ -0,0 +1,66 @@
+#!/usr/bin/ruby
+require 'big_keeper/util/podfile_operator'
+require 'big_keeper/util/gitflow_operator'
+require 'big_keeper/model/podfile_type'
+require 'big_keeper/util/info_plist_operator'
+require 'big_keeper/util/logger'
+
+module BigKeeper
+  def self.release_home_start(path, version, user)
+    BigkeeperParser.parse("#{path}/Bigkeeper")
+    start_release(path, version, BigkeeperParser::module_names, user)
+  end
+
+  def self.release_home_finish(path, version)
+    Dir.chdir(path) do
+      if GitOperator.new.has_branch(path, "release/#{version}")
+        if GitOperator.new.current_branch(path) == "release/#{version}"
+          GitOperator.new.commit(path, "release: V #{version}")
+          GitOperator.new.push_to_remote(path, "release/#{version}")
+          GitflowOperator.new.finish_release(path, version)
+          if GitOperator.new.current_branch(path) == "master"
+            GitOperator.new.tag(path, version)
+          else
+            GitOperator.new.checkout(path, "master")
+            GitOperator.new.tag(path, version)
+          end
+        else
+          raise Logger.error("Not in release branch, please check your branches.")
+        end
+      else
+        raise Logger.error("Not has release branch, please use release start first.")
+      end
+    end
+  end
+
+  private
+  def self.start_release(project_path, version, modules, user)
+    Dir.chdir(project_path) do
+      # step 0 Stash current branch
+      StashService.new.stash_all(project_path, GitOperator.new.current_branch(project_path), user, modules)
+
+      Logger.highlight(%Q(Start to checkout Branch release/#{version}))
+      # step 1 checkout release
+      if GitOperator.new.current_branch(project_path) != "release/#{version}"
+        if GitOperator.new.has_branch(project_path, "release/#{version}")
+          GitOperator.new.checkout(project_path, "release/#{version}")
+        else
+          GitflowOperator.new.start(project_path, version, GitflowType::RELEASE)
+          GitOperator.new.push_to_remote(project_path, "release/#{version}")
+        end
+      end
+
+      Logger.highlight(%Q(Start to release/#{version}))
+      # step 2 replace_modules
+      PodfileOperator.new.replace_all_module_release(%Q(#{project_path}/Podfile),
+                                                      modules,
+                                                      version)
+
+      # step 3 change Info.plist value
+      InfoPlistOperator.new.change_version_build(project_path, version)
+
+      PodOperator.pod_install(project_path, true)
+      `open #{project_path}/*.xcworkspace`
+    end
+  end
+end

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

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