kookeeper 1.0.0

data/lib/big_keeper/dependency/dep_gradle_operator.rb

@@ -0,0 +1,74 @@
+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'
+
+module BigKeeper
+  # Operator for podfile
+  class DepGradleOperator < DepOperator
+
+    BUILD_GRADLE = "app/build.gradle"
+    SETTINGS_GRADLE = "settings.gradle"
+
+    def backup
+    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
+    end
+
+    def update_module_config(module_name, module_operate_type)
+      if ModuleOperateType::ADD == module_operate_type
+        GradleModuleOperator.new(@path, @user, module_name).update_module(ModuleOperateType::ADD)
+      elsif ModuleOperateType::DELETE == module_operate_type
+        GradleModuleOperator.new(@path, @user, module_name).recover()
+      elsif ModuleOperateType::FINISH == module_operate_type
+        GradleModuleOperator.new(@path, @user, module_name).update_module(ModuleOperateType::FINISH)
+      elsif ModuleOperateType::PUBLISH == module_operate_type
+        GradleModuleOperator.new(@path, @user, module_name).recover()
+      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)
+    end
+
+    def release_home_finish(modules, version)
+      version_config_file = "#{@path}/doc/config/version-config.gradle"
+      VersionConfigOperator.change_version(version_config_file, modules, version)
+    end
+
+    def open
+    end
+  end
+end

data/lib/big_keeper/dependency/dep_operator.rb

@@ -0,0 +1,48 @@
+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 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)
+      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,130 @@
+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', :encoding => 'UTF-8')
+
+      begin
+        File.open(file, 'r', :encoding => 'UTF-8') 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(modules, type, 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}((\/[_a-zA-Z0-9]+)?)('|")([\s\S]*)/){
+        if ModuleOperateType::ADD == module_operate_type
+          module_path = BigkeeperParser.module_path(@user, module_name)
+          "#{$1}pod '#{module_name}#{$4}', :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)
+          "#{$1}pod '#{module_name}#{$4}', :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}'"
+        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}'"
+          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}'"
+          end
+        else
+          line
+        end
+      }
+    end
+
+    def origin_config_of_module(module_name)
+      origin_config = ''
+
+      File.open("#{@path}/.bigkeeper/Podfile", 'r', :encoding => 'UTF-8') 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

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,30 @@
+module BigKeeper
+  module OperateType
+    START = 1
+    UPDATE = 2
+    SWITCH = 3
+    FINISH = 4
+    PUBLISH = 5
+    RELEASE = 6
+
+    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