kookeeper 3.0.1 → 3.0.4

data/lib/big_keeper/service/stash_service.rb

@@ -0,0 +1,45 @@
+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)
+      # Stash modules
+      Logger.highlight('Stash for current workspace...')
+
+      modules.each do |module_name|
+        module_path = BigkeeperParser.module_full_path(path, user, module_name)
+        branch_name = GitOperator.new.current_branch(module_path)
+
+        if branch_name != new_branch_name
+          stash(module_path, branch_name, module_name)
+        end
+      end
+
+      # Stash home
+      branch_name = GitOperator.new.current_branch(path)
+      if branch_name != new_branch_name
+        stash(path, branch_name, 'Home')
+      end
+    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,116 @@
+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" => []}}
+      end
+    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
+      @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_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
+      @modules = {"git" => {"all" => [], "current" => []}, "path" => {"all" => [], "add" => [], "del" => [], "current" => []}}
+      cache_modules
+    end
+
+    def cache_modules
+      file = File.new("#{@cache_path}/module.cache", 'w')
+      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

data/lib/big_keeper/util/git_operator.rb

@@ -0,0 +1,221 @@
+require 'big_keeper/util/logger'
+
+module BigKeeper
+  # Operator for got
+  class GitOperator
+    def current_branch(path)
+      Dir.chdir(path) do
+        `git rev-parse --abbrev-ref HEAD`.chop
+      end
+    end
+
+    def has_remote_branch(path, branch_name)
+      has_branch = false
+      IO.popen("cd '#{path}'; git branch -r") do |io|
+        io.each do |line|
+          has_branch = true if line.include? branch_name
+        end
+      end
+      has_branch
+    end
+
+    def has_local_branch(path, branch_name)
+      has_branch = false
+      IO.popen("cd '#{path}'; git branch") do |io|
+        io.each do |line|
+          has_branch = true if line.include? branch_name
+        end
+      end
+      has_branch
+    end
+
+    def has_branch(path, branch_name)
+      has_branch = false
+      IO.popen("cd '#{path}'; git branch -a") do |io|
+        io.each do |line|
+          has_branch = true if line.include? branch_name
+        end
+      end
+      has_branch
+    end
+
+    def checkout(path, branch_name)
+      Dir.chdir(path) do
+        IO.popen("git checkout #{branch_name}") do |io|
+          io.each do |line|
+            Logger.error("Checkout #{branch_name} failed.") if line.include? 'error'
+          end
+        end
+      end
+    end
+
+    def fetch(path)
+      Dir.chdir(path) do
+        `git fetch origin`
+      end
+    end
+
+    def rebase(path, branch_name)
+      Dir.chdir(path) do
+        `git rebase origin/#{branch_name}`
+      end
+    end
+
+    def clone(path, git_base)
+      Dir.chdir(path) do
+        `git clone #{git_base}`
+      end
+    end
+
+    def commit(path, message)
+      Dir.chdir(path) do
+        `git add .`
+        `git commit -m "#{Logger.formatter_output(message)}"`
+      end
+    end
+
+    def push_to_remote(path, branch_name)
+      Dir.chdir(path) do
+        `git push -u origin #{branch_name}`
+      end
+      GitOperator.new.check_push_success(path, branch_name, "origin/#{branch_name}")
+    end
+
+    def pull(path)
+      Dir.chdir(path) do
+        `git pull`
+      end
+    end
+
+    def has_commits(path, branch_name)
+      has_commits = false
+      IO.popen("cd '#{path}'; git log --branches --not --remotes") do |io|
+        io.each do |line|
+          has_commits = true if line.include? "(#{branch_name})"
+        end
+      end
+      has_commits
+    end
+
+    def has_changes(path)
+      has_changes = true
+      clear_flag = 'nothing to commit, working tree clean'
+      IO.popen("cd '#{path}'; git status") do |io|
+        io.each do |line|
+          has_changes = false if line.include? clear_flag
+        end
+      end
+      has_changes
+    end
+
+    def discard(path)
+      Dir.chdir(path) do
+        `git checkout . && git clean -xdf`
+      end
+    end
+
+    def del_local(path, branch_name)
+      Dir.chdir(path) do
+        `git branch -D #{branch_name}`
+      end
+    end
+
+    def del_remote(path, branch_name)
+      Dir.chdir(path) do
+        `git push origin --delete #{branch_name}`
+      end
+    end
+
+    def user
+      `git config user.name`.chop
+    end
+
+    def tag(path, version)
+      tags = Array.new
+      IO.popen("cd '#{path}'; git tag") do |io|
+        io.each do |line|
+          tags << line
+        end
+      end
+      unless tags.include? "#{version}\n"
+        Dir.chdir(path) do
+          `git tag -a #{version} -m "release: V #{version}" master;`
+          `git push --tags`
+        end
+        return
+      end
+      Logger.highlight("tag already exists in the remote, skip this step")
+    end
+
+    def tag_list(path)
+      tag_list = Array.new
+      IO.popen("cd '#{path}'; git tag -l") do |io|
+        io.each do |line|
+          unless line=~(/[a-zA-Z]/)
+            tag_list << line
+          end
+        end
+      end
+      tag_list
+    end
+
+    def check_merge(path, condition)
+      unmerged_branch = Array.new
+      IO.popen("cd '#{path}'; git branch --no-merged") do |io|
+        io.each do |line|
+          unmerged_branch.push(line) if line.include? "#{condition}"
+        end
+      end
+      if (unmerged_branch.size > 0)
+        unmerged_branch.map { |item|
+            Logger.default(item)
+        }
+        Logger.error("Still has unmerged feature branch, please check")
+      end
+    end
+
+    def check_diff(path, branch, compare_branch)
+      compare_branch_commits = Array.new
+      IO.popen("cd '#{path}'; git log --left-right #{branch}...#{compare_branch} --pretty=oneline") do |io|
+        io.each do |line|
+          compare_branch_commits.push(line) if (line.include? '>') && (line.include? "Merge branch #{branch} into #{compare_branch}")
+        end
+      end
+      if compare_branch_commits.size > 0
+        compare_branch_commits.map { |item|
+            Logger.default(item)
+        }
+        Logger.error("#{compare_branch} branch has commit doesn't committed in #{branch}, please check")
+      else
+        Logger.highlight("#{compare_branch} branch doesn't have commit before #{branch}")
+      end
+    end
+
+    def merge(path, branch_name)
+      IO.popen("cd '#{path}'; git merge #{branch_name}") do |line|
+        Logger.error("Merge conflict in #{branch_name}") if line.include? 'Merge conflict'
+      end
+    end
+
+    def check_push_success(path, branch, compare_branch)
+      compare_branch_commits = Array.new
+      IO.popen("cd '#{path}'; git log --left-right #{branch}...#{compare_branch} --pretty=oneline") do |io|
+        io.each do |line|
+          compare_branch_commits.push(line) if (line.include? '>') || (line.include? 'fatal')
+        end
+      end
+      if compare_branch_commits.size > 0
+        compare_branch_commits.map { |item|
+            Logger.default(item)
+        }
+        Logger.error("#{branch} branch push unsuccess, please check")
+      else
+        Logger.highlight("#{branch} branch push success")
+      end
+    end
+
+  end
+
+  # p GitOperator.new.user
+  # BigStash::StashOperator.new("/Users/mmoaay/Documents/eleme/BigKeeperMain").list
+end