shkeeper 1.0.0

data/lib/big_keeper/service/stash_service.rb

@@ -0,0 +1,58 @@
+require 'big_stash/stash_operator'
+require 'big_keeper/util/bigkeeper_parser'
+require 'big_keeper/util/git_operator'
+require 'big_keeper/util/logger'
+
+module BigKeeper
+  # Operator for got
+  class StashService
+    def pop_stash(path, branch_name, name)
+      # pop stash
+      if BigStash::StashOperator.new(path).stash_for_name(branch_name)
+        Logger.highlight(%Q(Branch '#{branch_name}' of '#{name}' has stash , start to pop...))
+        BigStash::StashOperator.new(path).pop_stash(branch_name)
+      end
+    end
+
+    def stash(path, branch_name, name)
+      # stash
+      if GitOperator.new.has_changes(path)
+        Logger.highlight(%Q(Branch '#{branch_name}' of '#{name}' needs stash , start to stash...))
+        BigStash::StashOperator.new(path).stash(branch_name)
+      end
+    end
+
+    def stash_all(path, new_branch_name, user, modules,version)
+      # Stash modules
+      Logger.highlight('Stash for current workspace...')
+      p "--------------------9.1.Stash modules----------"
+      modules.each do |module_name|
+        module_path = BigkeeperParser.module_full_path(path, user, module_name)
+        branch_name = GitOperator.new.current_branch(module_path)
+
+        p "------------------------------module_path：#{module_path}"
+        p "------------------------------branch_name：#{branch_name}"
+        p "------------------------------new_branch_name：#{new_branch_name}"
+        if branch_name != new_branch_name
+          stash(module_path, branch_name, module_name)
+        end
+      end
+      p "--------------------end Stash modules----------"
+      # Stash home
+      branch_name = GitOperator.new.current_branch(path)
+      p "--------------------9.2.Stash home----------"
+
+
+      home_branch_name = "release/#{version}"
+
+      p "------------------------------branch_name：#{branch_name}"
+      p "------------------------------home_branch_name：#{home_branch_name}"
+
+      if branch_name != home_branch_name
+        stash(path, branch_name, 'Home')
+      end
+
+      p "--------------------end Stash home----------"
+    end
+  end
+end

data/lib/big_keeper/util/bigkeeper_parser.rb

@@ -0,0 +1,244 @@
+require 'big_keeper/util/logger'
+require 'big_keeper/util/file_operator'
+
+# Bigkeeper module
+module BigKeeper
+  def self.version(name)
+    BigkeeperParser.parse_version(name)
+  end
+
+  def self.user(name)
+    BigkeeperParser.parse_user(name)
+    yield if block_given?
+  end
+
+  def self.home(name, params)
+    BigkeeperParser.parse_home(name, params)
+  end
+
+  def self.mod(name, params)
+    BigkeeperParser.parse_mod(name, params)
+  end
+
+  def self.modules
+    BigkeeperParser.parse_modules
+    yield if block_given?
+  end
+
+  def self.source(name)
+    BigkeeperParser.parse_source(name)
+    yield if block_given?
+  end
+
+  def self.configs
+    BigkeeperParser.parse_configs
+    yield if block_given?
+  end
+
+  def self.param(key, value)
+    BigkeeperParser.parse_param(key, value)
+    yield if block_given?
+  end
+
+  # Bigkeeper file parser
+  class BigkeeperParser
+    @@config = {}
+    @@current_user = ''
+
+    def self.parse(bigkeeper)
+      if @@config.empty?
+
+        Logger.error("Can't find a Bigkeeper file in current directory.") if !FileOperator.definitely_exists?(bigkeeper)
+
+        content = File.read bigkeeper
+        content.gsub!(/version\s/, 'BigKeeper::version ')
+        content.gsub!(/user\s/, 'BigKeeper::user ')
+        content.gsub!(/home\s/, 'BigKeeper::home ')
+        content.gsub!(/source\s/, 'BigKeeper::source ')
+        content.gsub!(/mod\s/, 'BigKeeper::mod ')
+        content.gsub!(/modules\s/, 'BigKeeper::modules ')
+        content.gsub!(/configs\s/, 'BigKeeper::configs ')
+        content.gsub!(/param\s/, 'BigKeeper::param ')
+        eval content
+      end
+    end
+
+    def self.parse_source(name)
+      @@config.delete("tmp_spec")
+      source_split = name.split(",") unless name.split(",").length != 2
+      if source_split != nil
+        sources = Hash["#{source_split[1].lstrip}" => "#{source_split[0]}"]
+        @@config[:source] = sources
+        @@config[:tmp_spec] = source_split[1].lstrip
+      end
+    end
+
+    def self.parse_version(name)
+      @@config[:version] = name
+    end
+
+    def self.parse_user(name)
+      @@current_user = name
+      users = @@config[:users]
+      users = {} if users.nil?
+      users[name] = {}
+      @@config[:users] = users
+    end
+
+    def self.parse_home(name, params)
+      @@config[:home] = params
+      @@config[:name] = name
+    end
+
+    def self.parse_mod(name, params)
+      if params[:path]
+        parse_user_mod(name, params)
+      elsif params[:git]
+        parse_modules_mod(name, params)
+      else
+        Logger.error(%(There should be ':path =>' or ':git =>' ':alias =>' for mod #{name}))
+      end
+    end
+
+    def self.parse_user_mod(name, params)
+      users = @@config[:users]
+      user = users[@@current_user]
+      mods = user[:mods]
+      mods = {} if mods.nil?
+      mods[name] = params
+      user[:mods] = mods
+      @@config[:users] = users
+    end
+
+    def self.parse_modules_mod(name, params)
+      if @@config[:source] != nil
+          params[:spec] = "#{@@config[:tmp_spec]}"
+      end
+      modules = @@config[:modules]
+      modules[name] = params
+      @@config[:modules] = modules
+    end
+
+    def self.parse_modules
+      modules = @@config[:modules]
+      modules = {} if modules.nil?
+      @@config[:modules] = modules
+    end
+
+    def self.parse_configs
+      @@config[:configs] = {}
+    end
+
+    def self.parse_param(key, value)
+      @@config[:configs] = @@config[:configs].merge(key => value)
+    end
+
+    def self.version
+      @@config[:version]
+    end
+
+    def self.home_name
+      @@config[:name]
+    end
+
+    def self.home_git()
+      @@config[:home][:git]
+    end
+
+    def self.home_modules_workspace()
+      if @@config[:home][:modules_workspace]
+        home_modules_workspace = @@config[:home][:modules_workspace]
+        if home_modules_workspace.rindex('/') != home_modules_workspace.length - 1
+          home_modules_workspace = home_modules_workspace + '/'
+        end
+
+        home_modules_workspace
+      else
+        '../'
+      end
+    end
+
+    def self.home_pulls()
+      @@config[:home][:pulls]
+    end
+
+    def self.source_spec_path(module_name)
+      spec = @@config[:modules][module_name][:spec]
+      @@config[:source][spec]
+    end
+
+    def self.source_spec_name(module_name)
+      spec = @@config[:modules][module_name][:spec]
+    end
+
+    def self.sources
+      @@config[:source].keys
+    end
+
+    def self.global_configs(key)
+      if @@config[:configs] == nil
+        return
+      end
+      @@config[:configs][key]
+    end
+
+    def self.module_full_path(home_path, user_name, module_name)
+      if @@config[:users] \
+        && @@config[:users][user_name] \
+        && @@config[:users][user_name][:mods] \
+        && @@config[:users][user_name][:mods][module_name] \
+        && @@config[:users][user_name][:mods][module_name][:path]
+        File.expand_path(@@config[:users][user_name][:mods][module_name][:path])
+      else
+        if @@config[:modules][module_name][:alias]
+          File.expand_path("#{home_path}/#{home_modules_workspace}/#{@@config[:modules][module_name][:alias]}")
+        else
+          File.expand_path("#{home_path}/#{home_modules_workspace}/#{module_name}")
+        end
+      end
+    end
+
+    def self.module_path(user_name, module_name)
+      if @@config[:users] \
+        && @@config[:users][user_name] \
+        && @@config[:users][user_name][:mods] \
+        && @@config[:users][user_name][:mods][module_name] \
+        && @@config[:users][user_name][:mods][module_name][:path]
+        File.expand_path(@@config[:users][user_name][:mods][module_name][:path])
+      else
+        p @@config[:modules][module_name]
+        if @@config[:modules][module_name][:alias]
+          "#{home_modules_workspace}#{@@config[:modules][module_name][:alias]}"
+        else
+          "#{home_modules_workspace}#{module_name}"
+        end
+      end
+    end
+
+    def self.module_git(module_name)
+      @@config[:modules][module_name][:git]
+    end
+
+    def self.module_pulls(module_name)
+      @@config[:modules][module_name][:pulls]
+    end
+
+    def self.verify_modules(modules)
+      modules = [] unless modules
+      modules = modules.uniq
+      modules.each do |item|
+        Logger.error("Can not find module #{item} in Bigkeeper file") unless @@config[:modules][item]
+      end
+      modules
+    end
+
+    def self.module_names
+      @@config[:modules].keys
+    end
+
+    def self.config
+      @@config
+    end
+  end
+
+end

data/lib/big_keeper/util/cache_operator.rb

@@ -0,0 +1,149 @@
+require 'fileutils'
+require 'json'
+
+module BigKeeper
+  class CacheOperator
+    def initialize(path)
+      @path = File.expand_path(path)
+      @cache_path = File.expand_path("#{path}/.bigkeeper")
+    end
+
+    def save(file)
+      dest_path = File.dirname("#{@cache_path}/#{file}")
+      FileUtils.mkdir_p(dest_path) unless File.exist?(dest_path)
+      FileUtils.cp("#{@path}/#{file}", "#{@cache_path}/#{file}");
+    end
+
+    def load(file)
+      FileUtils.cp("#{@cache_path}/#{file}", "#{@path}/#{file}");
+    end
+
+    def clean
+      FileUtils.rm_r(@cache_path)
+    end
+  end
+
+  class ModuleCacheOperator
+    def initialize(path)
+      @cache_path = File.expand_path("#{path}/.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')
+        @modules = JSON.load(file.read())
+        file.close
+      else
+        @modules = {"git" => {"all" => [], "current" => []}, "path" => {"all" => [], "add" => [], "del" => [], "current" => []},"branch_name" => ""}
+      end
+    end
+
+    def branch_name
+      @modules["branch_name"]
+    end
+
+    def all_path_modules
+      @modules["path"]["all"]
+    end
+
+    def add_path_modules
+      @modules["path"]["add"]
+    end
+
+    def del_path_modules
+      @modules["path"]["del"]
+    end
+
+    def current_path_modules_path(path)
+      BigkeeperParser.parse("#{path}/Bigkeeper")
+      # Get modules' name
+      module_list = BigkeeperParser.module_names
+      detector = PodfileDetector.new(path, module_list)
+      # Get unlocked third party pods list
+      current_module_list = detector.get_current_module_list
+      current_module_list
+      #@modules["path"]["current"]
+    end
+
+    def current_path_modules
+      # BigkeeperParser.parse("#{@path}/Bigkeeper")
+      # # Get modules' name
+      # module_list = BigkeeperParser.module_names
+      # detector = PodfileDetector.new(@path, module_list)
+      # # Get unlocked third party pods list
+      # current_module_list = detector.get_current_module_list
+      # current_module_list
+      # #@modules["path"]["current"]
+      # #
+      @modules["path"]["current"]
+    end
+
+    def remain_path_modules
+      @modules["path"]["all"] - @modules["path"]["current"]
+    end
+
+    def all_git_modules
+      @modules["git"]["all"]
+    end
+
+    def current_git_modules
+      @modules["git"]["current"]
+    end
+
+    def remain_git_modules
+      @modules["git"]["all"] - @modules["git"]["current"]
+    end
+
+
+    def cache_branch_name(branch_name)
+      @modules["branch_name"] = branch_name
+      cache_modules
+    end
+
+
+    def cache_path_modules(modules, add_modules, del_modules)
+      @modules["path"]["all"] = modules.uniq
+      @modules["path"]["add"] = add_modules.uniq
+      @modules["path"]["del"] = del_modules.uniq
+      cache_modules
+    end
+
+    def cache_git_modules(modules)
+      @modules["git"]["all"] = modules.uniq
+      cache_modules
+    end
+
+    def add_git_module(module_name)
+      @modules["git"]["current"] << module_name unless @modules["git"]["current"].include?(module_name)
+      cache_modules
+    end
+
+    def del_git_module(module_name)
+      @modules["git"]["current"].delete(module_name) if @modules["git"]["current"].include?(module_name)
+      cache_modules
+    end
+
+    def add_path_module(module_name)
+      @modules["path"]["current"] << module_name unless @modules["path"]["current"].include?(module_name)
+      cache_modules
+    end
+
+    def del_path_module(module_name)
+      @modules["path"]["current"].delete(module_name) if @modules["path"]["current"].include?(module_name)
+      cache_modules
+    end
+
+    def clean_modules
+      branch_name = @modules["branch_name"]
+      @modules = {"git" => {"all" => [], "current" => []}, "path" => {"all" => [], "add" => [], "del" => [], "current" => []},"branch_name" => branch_name}
+      cache_modules
+    end
+
+    def cache_modules
+      file = File.new("#{@cache_path}/module.cache", 'w')
+      p "module缓存地址：#{@cache_path}/module.cache"
+      file << @modules.to_json
+      file.close
+    end
+  end
+end

data/lib/big_keeper/util/code_operator.rb

@@ -0,0 +1,37 @@
+module BigKeeper
+
+  class OCCodeOperator
+  end
+
+  class << OCCodeOperator
+
+    def in_note_code(line_hash)
+      line = line_hash["line"]
+      in_note = line_hash["in_note"]
+      line = line.strip
+      if in_note
+        line_hash["line"]=""
+        if (line.include?("*/"))
+          line_hash["in_note"] = false
+        end
+        return
+      end
+      if line[0,2] == "//" || line[0,7] == "#pragma"
+        line_hash["line"]=""
+        return
+      end
+      if line.include?("/*")
+        line_hash["in_note"] = true
+        before_line = line[line.index("/*")+1...line.size]
+        if before_line.include?("*/")
+          line_hash["in_note"] = false
+        end
+        line_hash["line"] = line[0,line.index("/*")]
+        return
+      end
+
+    end
+
+  end
+
+end

data/lib/big_keeper/util/file_operator.rb

@@ -0,0 +1,33 @@
+module BigKeeper
+  # Operator for got
+  class FileOperator
+    def self.definitely_exists? path
+      folder = File.dirname path
+      filename = File.basename path
+      # Unlike Ruby IO, ls, and find -f, this technique will fail to locate the file if the case is wrong:
+      not %x( find "#{folder}" -name "#{filename}" ).empty?
+    end
+
+    def find_all(path, name)
+      Dir.glob("#{path}/*/#{name}")
+    end
+
+    def current_username
+      current_name = `whoami`
+      current_name.chomp
+    end
+
+  end
+
+  class << FileOperator
+    def find_all_header_file(path)
+      return Dir.glob("#{path}/**/*.h")
+    end
+    def find_all_code_file(path)
+      header_file_list = Dir.glob("#{path}/**/*.[h]")
+      m_file_list = Dir.glob("#{path}/**/*.[m]")
+      return header_file_list+m_file_list
+    end
+  end
+  
+end