shkeeper 1.0.0

data/lib/big_keeper/dependency/dep_service.rb

@@ -0,0 +1,14 @@
+require 'big_keeper/util/git_operator'
+require 'big_keeper/model/gitflow_type'
+require 'big_keeper/model/operate_type'
+require 'big_keeper/util/logger'
+require 'big_keeper/dependency/dep_type'
+
+module BigKeeper
+  # Operator for podfile
+  class DepService
+    def self.dep_operator(path, user)
+      DepType.operator(path, user)
+    end
+  end
+end

data/lib/big_keeper/dependency/dep_type.rb

@@ -0,0 +1,33 @@
+require 'big_keeper/dependency/dep_operator'
+require 'big_keeper/dependency/dep_pod_operator'
+require 'big_keeper/dependency/dep_gradle_operator'
+require 'big_keeper/util/file_operator'
+
+module BigKeeper
+  module DepType
+    NONE = 0
+    COCOAPODS = 1
+    GRADLE = 2
+
+    def self.type(path)
+      if FileOperator.definitely_exists?("#{path}/Podfile")
+        COCOAPODS
+      elsif FileOperator.definitely_exists?("#{path}/build.gradle")
+        GRADLE
+      else
+        NONE
+      end
+    end
+
+    def self.operator(path, user)
+      operator_type = type(path)
+      if COCOAPODS == operator_type
+        DepPodOperator.new(path, user)
+      elsif GRADLE == operator_type
+        DepGradleOperator.new(path, user)
+      else
+        DepOperator.new(path, user)
+      end
+    end
+  end
+end

data/lib/big_keeper/model/gitflow_type.rb

@@ -0,0 +1,43 @@
+module BigKeeper
+  module GitflowType
+    FEATURE = 1
+    HOTFIX = 2
+    RELEASE = 3
+
+    def self.name(type)
+      if FEATURE == type
+        "feature"
+      elsif HOTFIX == type
+        "hotfix"
+      elsif RELEASE == type
+        "release"
+      else
+        "feature"
+      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"
+      elsif HOTFIX == type
+        "master"
+      elsif RELEASE == type
+        "develop"
+      else
+        "master"
+      end
+    end
+  end
+end

data/lib/big_keeper/model/library_model.rb

@@ -0,0 +1,116 @@
+require 'big_keeper/util/file_operator'
+require 'big_keeper/util/code_operator'
+
+
+module BigKeeper
+  class LibraryModel
+    attr_accessor :name, :file_list, :header_file_list, :keyword_list, :spec_library
+    def initialize(name)
+      @name = name
+      @file_list = []
+      @header_file_list = []
+      @spec_library = []
+      @keyword_list = []
+    end
+
+    def get_all_public_file(path)
+      all_header = FileOperator.find_all_header_file("#{path}/Pods/#{@name}")
+      for file_path in all_header do
+        @header_file_list[@header_file_list.size] = file_path
+        file_name = File.basename(file_path)
+        @keyword_list[@keyword_list.size] = file_name
+        in_note = false
+        File.foreach(file_path) { |line|
+          hash = Hash.new
+          hash["in_note"]=in_note
+          hash["line"]=line
+          OCCodeOperator.in_note_code(hash)
+          in_note = hash["in_note"]
+          line = hash["line"]
+          if line.empty?
+            next
+          end
+          if line.include?("@interface ")
+            line[0,line.index("@interface ")+11]=""
+            column = line.split(/:/)
+            if column.size > 1
+              class_name = column[0]
+              if class_name.include?("<")
+                class_name = class_name[0, class_name.index("<")]
+              end
+              class_name = class_name.strip
+              if (@keyword_list.include?(class_name+".h"))
+                @keyword_list.delete(class_name+".h")
+              end
+              @keyword_list[@keyword_list.size] = class_name
+            end
+          end
+        }
+      end
+      # if @name == ""
+      #   puts @keyword_list
+      # end
+      @file_list = FileOperator.find_all_code_file("#{path}/Pods/#{@name}")
+    end
+
+    def spec_dependece_library(library_keywords_hash)
+      if library_keywords_hash.include?(@name)
+        library_keywords_hash.delete(@name)
+      end
+
+      for file_path in @file_list do
+        # note for coding
+        in_note = false
+        File.foreach(file_path) { |line|
+          hash = Hash.new
+          hash["in_note"]=in_note
+          hash["line"]=line
+          OCCodeOperator.in_note_code(hash)
+          in_note = hash["in_note"]
+          line = hash["line"]
+          if line.empty?
+            next
+          end
+          library_keywords_hash.each {|library_name, keyword_list|
+            is_dependence = false
+            tip = ""
+            for keyword in keyword_list do
+              if line.include?(keyword)
+                last_char = '.'
+                last_index = line.index(keyword)-1
+                if last_index >= 0
+                  last_char = line[last_index]
+                end
+                next_char = '.'
+                next_index = line.index(keyword)+keyword.size
+                if next_index < line.size
+                  next_char = line[next_index]
+                end
+                if !(((next_char<='z'&&next_char>='a')||(next_char<='Z'&&next_char>='A')||(next_char<='9'&&next_char>='0')||next_char=='_')||((last_char<='z'&&last_char>='a')||(last_char<='Z'&&last_char>='A')||(last_char<='9'&&last_char>='0')||last_char=='_'))
+                  if keyword.include?(".h") && line.include?("import") && line.include?("/"+keyword+">")
+                    dependence_library_name = line[line.index("<")+1...line.index("/"+keyword+">")]
+                    if dependence_library_name == library_name
+                      tip = " [file]:"+File.basename(file_path)+" [line]: "+line.strip+" [keyword]: "+keyword
+                      is_dependence = true
+                      break
+                    end
+                  else
+                    tip = " [file]:"+File.basename(file_path)+" [line]: "+line.strip+" [keyword]: "+keyword
+                    is_dependence = true
+                    break
+                  end
+                end
+              end
+            end
+            if is_dependence
+              @spec_library[@spec_library.size] = library_name+tip
+              library_keywords_hash.delete(library_name)
+            end
+          }
+
+        }
+      end
+    end
+
+  end
+end

data/lib/big_keeper/model/operate_type.rb

@@ -0,0 +1,27 @@
+module BigKeeper
+  module OperateType
+    START = 1
+    UPDATE = 2
+    SWITCH = 3
+
+    def self.name(type)
+      if START == type
+        "start"
+      elsif UPDATE == type
+        "update"
+      elsif SWITCH == type
+        "switch"
+      else
+        name
+      end
+    end
+  end
+
+  module ModuleOperateType
+    ADD = 1
+    DELETE = 2
+    FINISH = 3
+    PUBLISH = 4
+    RELEASE = 5
+  end
+end

data/lib/big_keeper/model/podfile_model.rb

@@ -0,0 +1,33 @@
+
+module BigKeeper
+
+class PodfileModel
+  attr_accessor :name, :git, :path, :configurations, :branch,:tag, :comment
+  def initialize(sentence)
+    if sentence.include?('#')
+      list = sentence.split('#')
+      @comment = list[1]
+      sentence = list[0]
+    end
+
+    sentence_slip_list = sentence.split(',')
+    return if sentence_slip_list.size.zero?
+    for piece in sentence_slip_list do
+        if /:git =>/ =~ piece
+          @git = $~.post_match.strip
+        elsif /:path =>/ =~ piece
+          @path = $~.post_match.strip
+        elsif /:configurations =>/ =~ piece
+          @configurations = $~.post_match.strip
+        elsif /:branch =>/ =~ piece
+          @branch = $~.post_match.strip
+        elsif /:tag =>/ =~ piece
+          @tag = $~.post_match.strip
+        elsif /pod /=~ piece
+          @name = $~.post_match.delete("'\n ")
+        end
+      #  p %Q{model name:#{@name},git:#{@git},path:#{@path},config:#{@configurations},branch:#{@branch},tag:#{@tag},comment:#{@comment}}
+    end
+  end
+end
+end

data/lib/big_keeper/service/git_service.rb

@@ -0,0 +1,261 @@
+require 'big_keeper/util/git_operator'
+require 'big_keeper/util/gitflow_operator'
+require 'big_keeper/model/gitflow_type'
+require 'big_keeper/model/operate_type'
+require 'big_keeper/util/logger'
+
+module BigKeeper
+  # Operator for got
+  class GitService
+
+    def startHome(path, name, type)
+      p "--------------------11.1.startHome"
+      git = GitOperator.new
+      branch_name = "#{GitflowType.name(type)}/#{name}"
+      p "--------------------11.2branch_name：#{branch_name}"
+      if !git.has_remote_branch(path, branch_name) && !git.has_local_branch(path, branch_name)
+        p "------------------------------11.2.1如果远程和本地没有#{branch_name}分支"
+        verify_special_branch(path, 'master')
+
+
+        #verify_special_branch(path, 'develop')
+
+        #GitflowOperator.new.verify_git_flow(path)
+
+        #GitflowOperator.new.start(path, name, type)
+        #
+        Dir.chdir(path) do
+          p "------------------------------11.2.2git checkout -b #{branch_name}"
+          `git checkout -b #{branch_name}`
+        end
+        git.push_to_remote(path, branch_name)
+      else
+        verify_checkout(path, branch_name)
+
+        if !git.has_remote_branch(path, branch_name)
+          p "------------------------------11.3.1如果远程没有 #{branch_name}"
+          git.push_to_remote(path, branch_name)
+        end
+      end
+    end
+
+
+    def start(path, name, type)
+      git = GitOperator.new
+
+      branch_name = "#{GitflowType.name(type)}/#{name}"
+      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')
+
+        #GitflowOperator.new.verify_git_flow(path)
+
+        #GitflowOperator.new.start(path, name, type)
+
+        verify_checkout(path, branch_name)
+        git.push_to_remote(path, branch_name)
+      else
+        verify_checkout(path, branch_name)
+
+        if !git.has_remote_branch(path, branch_name)
+          git.push_to_remote(path, branch_name)
+        end
+      end
+    end
+
+    def verify_checkout(path, branch_name)
+      p "++++++++++verify_checkout：#{path} #{branch_name}"
+      Dir.chdir(path) do
+        p "++++++++++cd：#{path}"
+        cmd = "git checkout -b #{branch_name}"
+        if GitOperator.new.has_branch(path, branch_name)
+          p "++++++++++有#{branch_name}"
+          cmd = "git checkout #{branch_name}"
+        end
+        p "++++++++++cmd：#{cmd}"
+        IO.popen(cmd) do |io|
+          io.each do |line|
+            Logger.error("Checkout #{branch_name} failed.") if line.include? 'error'
+          end
+        end
+      end
+    end
+
+    def verify_checkout_pull(path, branch_name)
+      GitService.new.verify_checkout(path, branch_name)
+      GitService.new.pull(path, branch_name)
+    end
+
+    def verify_special_branch(path, name)
+      git = GitOperator.new
+      p "----------检查#{name}分支"
+      if git.has_remote_branch(path, name)
+        p "--------------------有远程#{name}分支"
+        if git.has_local_branch(path, name)
+          p "------------------------------有本地#{name}分支"
+          if git.has_commits(path, name)
+            p "----------------------------------------有commits"
+            Logger.error(%Q('#{name}' has unpushed commits, you should fix it manually...))
+          end
+          p "------------------------------git pull"
+          git.checkout(path, name)
+          pull(path, name)
+        else
+          p "------------------------------没有本地#{name}分支"
+          git.checkout(path, name)
+        end
+      else
+        p "--------------------没有远程#{name}分支"
+        verify_checkout(path, name)
+        git.push_to_remote(path, name)
+      end
+    end
+
+    def verify_home_branch(path, branch_name, type)
+
+      p "--------------------7.1.从远程同步本地分支"
+      Logger.highlight('Sync local branchs from remote, waiting...')
+      git = GitOperator.new
+      p "--------------------7.2.git fetch origin"
+      git.fetch(path)
+
+      if OperateType::START == type
+        if git.current_branch(path) == branch_name
+          Logger.error(%(Current branch is '#{branch_name}' already. Use 'update' please))
+        end
+        if git.has_branch(path, branch_name)
+          Logger.error(%(Branch '#{branch_name}' already exists. Use 'switch' please))
+        end
+      elsif OperateType::SWITCH == type
+        if !git.has_branch(path, branch_name)
+          Logger.error(%(Can't find a branch named '#{branch_name}'. Use 'start' please))
+        end
+        if git.current_branch(path) == branch_name
+          Logger.error(%(Current branch is '#{branch_name}' already. Use 'update' please))
+        end
+      elsif OperateType::UPDATE == type
+        if !git.has_branch(path, branch_name)
+          Logger.error(%(Can't find a branch named '#{branch_name}'. Use 'start' please))
+        end
+        if git.current_branch(path) != branch_name
+          Logger.error(%(Current branch is not '#{branch_name}'. Use 'switch' please))
+        end
+      else
+        Logger.error(%(Not a valid command for '#{branch_name}'.))
+      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
+        IO.popen('git branch -r') do | io |
+          io.each do | line |
+            branchs << line.gsub(/\s/, '') if line =~ /[\s\S]*#{GitflowType.name(type)}*/
+          end
+        end
+      end
+      branchs
+    end
+
+    def pull(path, branch_name)
+      git = GitOperator.new
+      current_branch_name = git.current_branch(path)
+
+      p "----------current_branch_name：#{current_branch_name}"
+      p "----------branch_name：#{branch_name}"
+      if current_branch_name == branch_name
+        git.pull(path)
+      else
+        git.checkout(path, branch_name)
+        git.pull(path)
+        git.checkout(path, current_branch_name)
+      end
+    end
+
+    def verify_del(path, branch_name, name, type)
+      git = GitOperator.new
+
+      if git.has_local_branch(path, branch_name)
+        Logger.highlight("Delete local branch '#{branch_name}' for '#{name}'...")
+
+        if git.current_branch(path) == branch_name
+          git.discard(path)
+          git.checkout(path, GitflowType.base_branch(type))
+        end
+        git.del_local(path, branch_name)
+      end
+
+      if git.has_remote_branch(path, branch_name)
+        Logger.highlight("Delete remote branch '#{branch_name}' for '#{name}'...")
+        git.del_remote(path, branch_name)
+      end
+    end
+
+    def verify_push(path, comment, branch_name, name)
+      git = GitOperator.new
+      if git.has_changes(path) || git.has_commits(path, branch_name)
+
+        git.commit(path, comment) if git.has_changes(path)
+
+        if git.has_remote_branch(path, branch_name)
+          Dir.chdir(path) do
+            `git push`
+          end
+        else
+          git.push_to_remote(path, branch_name)
+        end
+
+        GitOperator.new.check_push_success(path, branch_name, "origin/#{branch_name}")
+      else
+        Logger.default("Nothing to push for '#{name}'.")
+      end
+    end
+
+    def verify_rebase(path, branch_name, name)
+
+      # pull rebased branch
+      pull(path, branch_name)
+
+      Dir.chdir(path) do
+        IO.popen("git rebase #{branch_name} --ignore-whitespace") do |io|
+          unless io.gets
+            Logger.error("#{name} is already in a rebase-apply, Please:\n"\
+                         "  1.Resolve it;\n"\
+                         "  2.Commit the changes;\n"\
+                         "  3.Push to remote;\n"\
+                         "  4.Create a MR;\n"\
+                         "  5.Run 'finish' again.")
+          end
+          io.each do |line|
+            next unless line.include? 'Merge conflict'
+            Logger.error("Merge conflict in #{name}, Please:\n"\
+                         "  1.Resolve it;\n"\
+                         "  2.Commit the changes;\n"\
+                         "  3.Push to remote;\n"\
+                         "  4.Create a MR;\n"\
+                         "  5.Run 'finish' again.")
+          end
+        end
+        if GitOperator.new.current_branch(path) != 'develop' && GitOperator.new.current_branch(path) != 'master'
+          `git push -f`
+        else
+          Logger.error("You should not push 'master' or 'develop'")
+        end
+      end
+    end
+  end
+end

data/lib/big_keeper/service/module_service.rb

@@ -0,0 +1,161 @@
+require 'big_keeper/service/git_service'
+
+require 'big_keeper/util/logger'
+require 'big_keeper/util/cache_operator'
+
+module BigKeeper
+  # Operator for got
+  class ModuleService
+
+    def verify_module(path, user, module_name, home_branch_name, type)
+      name = home_branch_name.gsub(/#{GitflowType.name(type)}\//, '')
+      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
+
+      current_branch_name = git.current_branch(module_full_path)
+      if current_branch_name != home_branch_name
+        # stash current branch
+        StashService.new.stash(module_full_path, current_branch_name, module_name)
+
+        GitService.new.start(module_full_path, name, type)
+
+        StashService.new.pop_stash(module_full_path, home_branch_name, module_name)
+      end
+
+      StashService.new.pop_stash(module_full_path, home_branch_name, module_name)
+    end
+
+    def push(path, user, module_name, home_branch_name, type, comment)
+      Logger.highlight("Push 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, comment, home_branch_name, module_name)
+    end
+
+    def rebase(path, user, module_name, home_branch_name, type)
+      Logger.highlight("Rebase '#{GitflowType.base_branch(type)}' "\
+        "to 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)
+
+      Logger.error("You have some changes in branch "\
+        "'#{home_branch_name}' for module '#{module_name}'. "\
+        "Use 'push' first please") if GitOperator.new.has_changes(module_full_path)
+
+      GitService.new.verify_rebase(module_full_path, GitflowType.base_branch(type), module_name)
+    end
+
+    def pull(path, user, module_name, home_branch_name, type)
+      Logger.highlight("Pull 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)
+      GitOperator.new.pull(module_full_path)
+    end
+
+    def switch_to(path, user, module_name, home_branch_name, type)
+      Logger.highlight("Switch to branch '#{home_branch_name}' for module '#{module_name}'...")
+
+      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}'...")
+
+      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)
+
+      `open #{BigkeeperParser.module_pulls(module_name)}`
+
+      ModuleCacheOperator.new(path).del_git_module(module_name)
+    end
+
+    def finish(path, user, module_name, home_branch_name, type)
+      Logger.highlight("Finish 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::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)
+
+      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)
+
+      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
+
+    def del(path, user, module_name, name, type)
+      home_branch_name = "#{GitflowType.name(type)}/#{name}"
+
+      Logger.highlight("Delete branch '#{home_branch_name}' for module '#{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))
+
+      ModuleCacheOperator.new(path).del_path_module(module_name)
+    end
+
+    def module_info(module_path, home_branch_name, user, type, module_name, version)
+      result_dic = {}
+      matched_branches = []
+      branches = GitService.new.branchs_with_type(module_path, type)
+      if version == 'all versions'
+        matched_branches = branches
+      else
+        branches.each do | branch |
+          matched_branches << branch if branch.include?(version)
+        end
+      end
+      result_dic[:module_name] = module_name
+      result_dic[:current_branch] = GitOperator.new.current_branch(module_path)
+      result_dic[:branches] = matched_branches
+      result_dic
+    end
+
+    private :verify_module
+  end
+end