gistore 1.0.0.rc4

data/lib/gistore/cmd/restore-from-backups.rb

@@ -0,0 +1,91 @@
+module Gistore
+  class Runner
+    desc "restore-from-backups", "Export to a series of full/increment backups"
+    option :from, :required => true, :desc => "path of backup packs", :banner => "<from>"
+    option :to, :required => true, :desc => "path of repo.git to restore to", :banner => "<repo.git>"
+    def restore_from_backups
+      parse_common_options
+      from = options[:from]
+      repo_name = options[:to]
+      backups = []
+      if not File.exist? from
+        raise "Path \"#{from}\" does not exist."
+      elsif File.directory? from
+        backups = Dir.glob("#{from}/*.pack")
+      elsif from.end_with? ".pack"
+        backups << from
+      end
+
+      if not backups or backups.empty?
+        raise "Can not find valid pack file(s) from \"#{from}\""
+      else
+        backups = backups.map {|p| File.expand_path(p.strip)}
+      end
+
+      if not File.exist? repo_name
+        Repo.init repo_name
+      elsif not Gistore.is_git_repo? repo_name
+        raise "Path \"#{repo_name}\" is not a valid repo, create one using \"gistore init\""
+      end
+
+      self.gistore = Repo.new(repo_name)
+      output = ""
+      backups.each do |pack|
+        begin
+          gistore.shellpipe(git_cmd, "unpack-objects", "-q",
+                            :work_tree => gistore.repo_path,
+                            :check_return => true
+                           ) do |stdin, stdout, stderr|
+            File.open(pack, "r") do |io|
+              stdin.write io.read
+            end
+            stdin.close
+            output << stdout.read
+            output << "\n" unless output.empty?
+            output << stderr.read
+          end
+        rescue
+          Tty.warning "failed to unpack #{pack}"
+        end
+      end
+
+      danglings = []
+      cmds = [git_cmd, "fsck"]
+      cmds << "--dangling" if Gistore.git_version_compare('1.7.10') >= 0
+      gistore.shellout(*cmds) do |stdout|
+        stdout.readlines.each do |line|
+          if line =~ /^dangling commit (.*)/
+            danglings << $1.strip
+          end
+        end
+      end
+
+      unless danglings.empty?
+        begin
+          gistore.shellout(git_cmd, "rev-parse", "master", :check_return => true)
+        rescue
+          if danglings.size == 1
+            gistore.shellout(git_cmd, "update-ref", "refs/heads/master", danglings[0])
+          else
+            show_dangling_commits danglings
+          end
+        else
+          show_dangling_commits danglings
+        end
+      end
+    rescue Exception => e
+      Tty.error "Failed to restore-from-backups.\n#{output}"
+      Tty.die "#{e.message}"
+    end
+
+  private
+
+    def show_dangling_commits(danglings)
+      puts "Found dangling commits after restore backups:"
+      puts "\n"
+      puts Tty.show_columns danglings
+      puts "\n"
+      puts "You may like to update master branch with it(them) by hands."
+    end
+  end
+end

data/lib/gistore/cmd/rm.rb

@@ -0,0 +1,15 @@
+module Gistore
+  class Runner
+    desc "rm <path> ...", "Remove entry from backup list"
+    def rm(*args)
+      parse_common_options_and_repo
+      raise "nothing to remove." if args.empty?
+      args.each do |entry|
+        gistore.remove_entry entry
+      end
+      gistore.save_gistore_backups
+    rescue Exception => e
+      Tty.die "#{e.message}"
+    end
+  end
+end

data/lib/gistore/cmd/safe-commands.rb

@@ -0,0 +1,53 @@
+module Gistore
+  SAFE_GIT_COMMANDS = %w(
+        annotate        blame           branch          cat-file        check-ignore
+        count-objects   describe        diff            fsck            grep
+        log             lost-found      ls-files        ls-tree         name-rev
+        prune           reflog          rev-list        rev-parse       shortlog
+        show            show-ref        status          tag             whatchanged)
+
+  class Runner
+    desc "repo <repo> git-command ...", "Delegate to safe git commands (log, ls-tree, ...)"
+    option :without_grafts, :type => :boolean, :desc => "not check info/grafts"
+    option :without_work_tree, :type => :boolean, :desc => "not change work tree"
+    option :without_locale, :type => :boolean, :desc => "use locale C"
+    def repo (name, cmd=nil, *args, &block)
+      parse_common_options
+      if options[:repo]
+        args ||= []
+        args.unshift cmd if cmd
+        name, cmd = options[:repo], name
+      end
+      cmd = args.shift if cmd == "git"
+      if Gistore::SAFE_GIT_COMMANDS.include? cmd
+        opts = options.dup
+        opts.delete("repo")
+        args << opts
+        gistore = Repo.new(name || ".")
+        gistore.safe_system(git_cmd, cmd, *args)
+      elsif self.respond_to? cmd
+        # Because command may have specific options mixed in args,
+        # can not move options from args easily. So we not call
+        # invoke here, but call Gistore::Runner.start.
+        Gistore::Runner.start([cmd, "--repo", name, *args])
+      else
+        raise "Command \"#{cmd}\" is not allowed.\n"
+      end
+    rescue Exception => e
+      Tty.die "#{e.message}"
+    end
+
+    desc "log args...", "Show gistore backup logs (delegater for git log)"
+    option :without_grafts, :type => :boolean, :desc => "not check info/grafts"
+    option :without_work_tree, :type => :boolean, :desc => "not change work tree"
+    option :without_locale, :type => :boolean, :desc => "use locale C"
+    def log(*args)
+      if options[:repo]
+        repo('log', *args)
+      else
+        name = args.shift || "."
+        repo(name, 'log', *args)
+      end
+    end
+  end
+end

data/lib/gistore/cmd/status.rb

@@ -0,0 +1,40 @@
+module Gistore
+  class Runner
+    map "st" => :status
+    desc "status", "Show backup entries list and run git status"
+    option :config, :type => :boolean, :desc => "Show gistore configurations"
+    option :backup, :type => :boolean,
+                    :aliases => [:entries, :entry, :backups],
+                    :desc => "Show backup list"
+    option :git, :type => :boolean, :desc => "Show git status"
+    def status(*args)
+      parse_common_options_and_repo
+      all = (not options.include? "config" and
+             not  options.include? "backup" and
+             not  options.include? "git")
+
+      if all or options[:config]
+        puts "Task name     : #{gistore.task_name || "-"}"
+        puts "Gistore       : #{gistore.repo_path}"
+        puts "Configurations:"
+        puts Tty.show_columns gistore.gistore_config.to_a.map {|h| "#{h[0]}: #{h[1].inspect}"}
+        puts
+      end
+
+      if all
+        puts "Backup entries:"
+        puts Tty.show_columns gistore.gistore_backups
+        puts
+      elsif options[:backup]
+        puts gistore.gistore_backups.join("\n")
+      end
+
+      if all or options[:git]
+        puts "#{'-' * 30} Git status #{'-' * 30}" if all
+        gistore.safe_system(git_cmd, "status", *args)
+      end
+    rescue Exception => e
+      Tty.die "#{e.message}"
+    end
+  end
+end

data/lib/gistore/cmd/task.rb

@@ -0,0 +1,85 @@
+module Gistore
+  class Task < Thor; end
+
+  class Runner
+    desc "task SUBCOMMAND ...ARGS", "manage set of tracked repositories"
+    subcommand "task", Gistore::Task
+  end
+
+  class Task < Thor
+    # Use command name "gistore" in help instead of "gistore.rb"
+    def self.basename; "gistore"; end
+
+    # Show in help screen
+    package_name "Gistore"
+
+    desc "add <task> [<repo>]", "Register repo as a task"
+    option :system, :type => :boolean
+    def add(task, path=nil)
+      parse_common_options
+      path ||= "."
+      cmds = [git_cmd, "config"]
+      unless ENV["GISTORE_TEST_GIT_CONFIG"]
+        ENV.delete "GIT_CONFIG"
+        if options[:system]
+          cmds << "--system"
+        else
+          cmds << "--global"
+        end
+      end
+      cmds << "gistore.task.#{task}"
+      cmds << File.expand_path(path)
+      system(*cmds)
+    rescue Exception => e
+      Tty.die "#{e.message}"
+    end
+
+    desc "rm <task>", "Remove register of task"
+    option :system, :type => :boolean
+    def rm(task)
+      parse_common_options
+      cmds = [git_cmd, "config", "--unset"]
+      unless ENV["GISTORE_TEST_GIT_CONFIG"]
+        ENV.delete "GIT_CONFIG"
+        if options[:system]
+          cmds << "--system"
+        else
+          cmds << "--global"
+        end
+      end
+      cmds << "gistore.task.#{task}"
+      Kernel::system(*cmds)
+    rescue Exception => e
+      Tty.die "#{e.message}"
+    end
+    
+    desc "list", "Display task list"
+    option :system, :type => :boolean
+    option :global, :type => :boolean
+    def list(name=nil)
+      parse_common_options
+      if name
+        invoke "gistore:runner:status", [], :repo => name
+      else
+        puts "System level Tasks"
+        tasks = Gistore::get_gistore_tasks(:system => true)
+        puts Tty.show_columns tasks.to_a.map {|h| "#{h[0]} => #{h[1]}"}
+        puts
+        puts "User level Tasks"
+        tasks = Gistore::get_gistore_tasks(:global => true)
+        puts Tty.show_columns tasks.to_a.map {|h| "#{h[0]} => #{h[1]}"}
+      end
+    end
+
+    private
+
+    def parse_common_options
+      if options[:verbose]
+        Tty.options[:verbose] = true
+      elsif options[:quiet]
+        Tty.options[:quiet] = true
+      end
+    end
+
+  end
+end

data/lib/gistore/cmd/version.rb

@@ -0,0 +1,27 @@
+require 'gistore/version'
+
+module Gistore
+  class Runner
+    map ["--version", "-v"] => :version
+    desc "version", "Show Gistore version and/or repository format version", :hide => true
+    def version(*args)
+      parse_common_options
+      v = Gistore::VERSION
+      Dir.chdir(GISTORE_REPOSITORY) do
+        if Gistore.is_git_repo? ".git"
+          Gistore.shellout(git_cmd, "describe", "--always", "--dirty") do |stdout|
+            v = stdout.read.strip
+            v.sub!(/^v/, '')
+            v << " (#{Gistore::VERSION})" if v != Gistore::VERSION
+          end
+        end
+      end
+      puts "Gistore version #{v}"
+
+      gistore = Repo.new(options[:repo]) rescue nil if options[:repo]
+      if gistore
+        puts "Repository format #{gistore.repo_version}"
+      end
+    end
+  end
+end

data/lib/gistore/config.rb

@@ -0,0 +1,13 @@
+module Gistore
+
+  DEFAULT_GISTORE_CONFIG = {"backups" => [],
+                            "plan" => nil,
+                            "increment_backup_number" => 30,
+                            "full_backup_number" => 12,
+                            "user_name" => nil,
+                            "user_email" => nil
+                           }
+  GISTORE_REPOSITORY_URL = "git://github.com/jiangxin/gistore"
+  GISTORE_REPOSITORY = File.dirname(File.dirname(File.dirname(__FILE__)))
+
+end

data/lib/gistore/config/gistore.yml

@@ -0,0 +1 @@
+---

data/lib/gistore/error.rb

@@ -0,0 +1,6 @@
+module Gistore
+  class CommandReturnError < StandardError; end
+  class CommandExceptionError < StandardError; end
+  class InvalidRepoError < StandardError; end
+  class CommandExit < StandardError; end
+end

data/lib/gistore/repo.rb

@@ -0,0 +1,683 @@
+require 'yaml'
+require 'fileutils'
+require 'gistore/utils'
+require 'gistore/error'
+require 'gistore/config'
+
+module Gistore
+
+  class Repo
+    attr_reader :task_name, :repo_path, :gistore_config, :gistore_backups
+
+    class <<self
+      def init(name, options = {})
+        if File.directory? name and Dir.entries(name).size != 2
+          raise "Non-empty directory '#{name}' is already exist."
+        else
+          FileUtils.mkdir_p name
+        end
+
+        # git initial --bare #{name}
+        ENV['GIT_TEMPLATE_DIR'] = File.join(File.dirname(__FILE__), 'templates')
+        # git-init can not take path as argument for git < v1.6.5
+        Dir.chdir(name) do
+          Gistore::shellout git_cmd, 'init',  '--bare', :without_work_tree => true
+        end
+
+        gistore = Repo.new(name)
+
+        # Save repo version to "info/VERSION"
+        gistore.repo_version = Gistore::REPO_VERSION
+
+        # Set git config
+        gistore.git_config('--plan', options[:plan] || 'normal')
+
+        # Set gistore config
+        gistore.update_gistore_config("increment_backup_number" => 30,
+                                      "full_backup_number" => 12)
+        gistore.save_gistore_config
+      end
+    end
+
+    def initialize(name)
+      # Setup taskname
+      gistore_tasks = Gistore::get_gistore_tasks
+      if File.exist? name and
+         File.exist? name and
+         File.directory? name
+        @repo_path = realpath(name)
+        gistore_tasks.each do |t, p|
+          if realpath(p) == @repo_path
+            @task_name = t
+            break
+          end
+        end
+      elsif gistore_tasks.include? name and
+            File.exist? gistore_tasks[name] and
+            File.directory? gistore_tasks[name]
+        @repo_path = realpath gistore_tasks[name]
+        @task_name = name
+      else
+        raise InvalidRepoError.new("Can not find repo at \"#{name}\"")
+      end
+
+      raise InvalidRepoError.new("Not a valid git repo: #{@repo_path}") unless is_git_repo?
+
+      @gistore_config_file = "#{@repo_path}/info/gistore_config.yml"
+      @gistore_backups_file = "#{@repo_path}/info/gistore_backups.yml"
+      @gistore_exclude_file = "#{@repo_path}/info/exclude"
+      @gistore_version_file = "#{@repo_path}/info/VERSION"
+      @work_tree = "/"
+
+      parse_gistore_config
+
+      # Generate new info/exclude file
+      update_info
+    end
+
+    def normalize_entry(entry)
+      unless entry.start_with? '/'
+        Tty.error "entry not start with '/'"
+        return nil
+      end
+      # Note: not support UNC names
+      result = entry.gsub(/\/\/+/, '/')
+      if ['/'].include? result
+        Tty.error "root entry ignored!"
+        return nil
+      end
+      result
+    end
+
+    def validate_entry(entry)
+      return false unless entry
+      entry_path = realpath(entry)
+      if repo_path == entry_path or repo_path =~ /^#{entry_path}\//
+        Tty.warning "gistore repo is a subdir of entry: #{entry_path}"
+        return false
+      elsif entry_path =~ /^#{repo_path}\//
+        Tty.warning "entry is a subdir of gistore repo: #{repo_path}"
+        return false
+      else
+        return true
+      end
+    end
+
+    def add_entry(entry)
+      if entry
+        entry = File.expand_path(entry)
+        entry = normalize_entry(entry)
+      end
+      if not entry
+        Tty.warning "entry is nil"
+      elsif not validate_entry(entry)
+        Tty.warning "entry (#{entry}) is not valid."
+      elsif @gistore_backups.include? entry
+        Tty.warning "entry (#{entry}) is already added."
+      else
+        Tty.info "add entry: #{entry}."
+        @gistore_backups << entry
+        entry
+      end
+    end
+
+    def remove_entry(entry)
+      if not entry
+        Tty.warning "entry is nil"
+      else
+        unless @gistore_backups.include? entry
+          entry = File.expand_path(entry)
+          entry = normalize_entry(entry)
+        end
+        if @gistore_backups.delete entry
+          Tty.info "remove entry: #{entry}."
+        else
+          Tty.warning "entry (#{entry}) not in backup list, nothing removed."
+        end
+      end
+    end
+
+    def save_gistore_backups
+      backups = []
+      @gistore_backups.sort.each do |entry|
+        next if not validate_entry(entry)
+        if backups[-1] and entry.start_with? backups[-1]
+          if (entry.end_with? '/' or
+              backups[-1].size == entry.size or
+              entry.charat(backups[-1].size) == '/')
+            Tty.warning "remove \"#{entry}\", for it has been added as \"#{backups[-1]}\""
+            next
+          end
+        end
+        backups << entry
+      end
+      @gistore_backups = backups
+      f = File.new("#{@gistore_backups_file}.lock", 'w')
+      f.write(@gistore_backups.to_yaml)
+      f.close
+      File.rename("#{@gistore_backups_file}.lock", @gistore_backups_file)
+    end
+
+    def save_gistore_config
+      File.open("#{@gistore_config_file}.lock", 'w') do |io|
+        io.write(@gistore_config.to_yaml)
+      end
+      File.rename("#{@gistore_config_file}.lock", @gistore_config_file)
+    end
+
+    def update_gistore_config(options={})
+      options.each do |k, v|
+        @gistore_config[k.to_s] = v
+      end
+    end
+
+    def git_config(*args)
+      if Hash === args.last
+        options = args.pop.dup
+      else
+        options = {}
+      end
+      if args.size == 2 and (args[0] == '--plan' or args[0] == "plan")
+        git_config('core.quotepath', false)
+        git_config('core.autocrlf', false)
+        git_config('core.logAllRefUpdates', true)
+        git_config('core.sharedRepository', 'group')
+        git_config('core.bigFileThreshold', '2m')
+
+        case args[1]
+        when /no[-_]?gc/
+          git_config('gc.auto', 0)
+          git_config('core.compression', 0)
+          git_config('core.loosecompression', 0)
+          update_gistore_config("plan" => "no-gc")
+        when /no[-_]?compress/
+          git_config('--unset', 'gc.auto')
+          git_config('core.compression', 0)
+          git_config('core.loosecompression', 0)
+          update_gistore_config("plan" => "no-compress")
+        else
+          git_config('--unset', 'gc.auto')
+          git_config('--unset', 'core.compression')
+          git_config('--unset', 'core.loosecompression')
+          update_gistore_config("plan" => "normal")
+        end
+        save_gistore_config
+      else
+        k, v = args
+        if args.size == 0
+          puts Tty.show_columns gistore_config.to_a.map {|h| "#{h[0]} : #{h[1].inspect}"}
+        elsif args.size <= 2 and gistore_config.include? k
+          if args.size == 1
+            puts gistore_config[k]
+          elsif args.size == 2
+            update_gistore_config(k => v)
+            save_gistore_config
+          end
+        else
+          # Unset non-exist variable return error 5.
+          system(git_cmd, 'config', *args)
+        end
+      end
+    end
+
+    def generate_git_exclude
+      return if uptodate? @gistore_exclude_file, @gistore_backups_file
+      generate_git_exclude!
+    end
+
+    def generate_git_exclude!
+      backups = get_backups
+      hierarchies = []
+      excludes = []
+
+      backups.each do |entry|
+        excludes << entry
+        entries = entry.split(/\/+/)[1..-1].inject([]){|sum, e| sum << [sum[-1], e].join('/')}
+        entries.each do |e|
+          unless hierarchies.include? e
+            hierarchies << e
+          end
+        end
+      end
+      File.open(@gistore_exclude_file, "w") do |f|
+        f.puts "*"
+        # No trailing "/", because entry maybe a symlink
+        hierarchies.each do |entry|
+          f.puts "!#{entry}"
+        end
+        # Two trailing "**" will backup all files include files under subdir.
+        excludes.each do |entry|
+          if Gistore.git_version_compare('1.8.2') >= 0
+            f.puts "!#{entry}/**"
+          else
+            f.puts "!#{entry}/*"
+          end
+        end
+      end
+    end
+
+    def get_backups
+      backups = []
+      @gistore_backups.each do |entry|
+        entry = normalize_entry(entry)
+        next unless entry
+        next unless validate_entry(entry)
+        backups << entry
+        if File.exist?(entry)
+          entry_real = realpath(entry)
+          backups << entry_real if entry != entry_real
+        end
+      end
+      backups
+    end
+
+    def get_last_backups
+      gistore_config["backups"]
+    end
+
+    def update_info
+      # Because real directories pointed by entries may change,
+      # always generate info/exclude,
+      generate_git_exclude!
+    end
+
+    def setup_environment(options={})
+      if options[:without_work_tree]
+        ENV.delete 'GIT_WORK_TREE'
+      else
+        ENV['GIT_WORK_TREE'] = "."
+      end
+      if options[:without_grafts]
+        ENV['GIT_GRAFT_FILE'] = "/dev/null"
+      else
+        ENV.delete 'GIT_GRAFT_FILE'
+      end
+      if options[:without_locale]
+        ENV['LC_ALL'] = 'C'
+      else
+        ENV.delete 'LC_ALL'
+      end
+      unless options[:with_git_config]
+        ENV.delete 'GIT_CONFIG'
+      end
+      unless options[:without_gitdir]
+        ENV['GIT_DIR'] = repo_path
+      end
+      ENV.delete 'HOME'
+      ENV.delete 'XDG_CONFIG_HOME'
+      ENV['GIT_CONFIG_NOSYSTEM'] = '1'
+      ENV['GIT_AUTHOR_NAME'] = get_login
+      ENV['GIT_AUTHOR_EMAIL'] = get_email
+      ENV['GIT_COMMITTER_NAME'] = get_login
+      ENV['GIT_COMMITTER_EMAIL'] = get_email
+    end
+
+    # block has only 1 arg: stdout
+    def shellout(*args, &block)
+      if Hash === args.last
+        options = args.last.dup
+      else
+        options = {}
+      end
+      setup_environment(options)
+      if options[:without_work_tree]
+        Gistore::shellout(*args, &block)
+      else
+        Dir.chdir(options[:work_tree] || @work_tree) do
+          Gistore::shellout(*args, &block)
+        end
+      end
+    end
+
+    # block has 3 args: stdin, stdout, stderr
+    def shellpipe(*args, &block)
+      if Hash === args.last
+        options = args.last.dup
+      else
+        options = {}
+      end
+      setup_environment(options)
+      if options[:without_work_tree]
+        Gistore::shellpipe(*args, &block)
+      else
+        Dir.chdir(options[:work_tree] || @work_tree) do
+          Gistore::shellpipe(*args, &block)
+        end
+      end
+    end
+
+    def system(*args, &block)
+      if Hash === args.last
+        options = args.pop.dup
+      else
+        options = {}
+      end
+      setup_environment(options)
+      if options[:without_work_tree]
+        Gistore::system(*args, &block)
+      else
+        Dir.chdir(options[:work_tree] || @work_tree) do
+          Gistore::system(*args, &block)
+        end
+      end
+    end
+
+    # Same like system but with exceptions
+    def safe_system(*args, &block)
+      if Hash === args.last
+        options = args.pop.dup
+      else
+        options = {}
+      end
+      setup_environment(options)
+      if options[:without_work_tree]
+        Gistore::safe_system(*args, &block)
+      else
+        Dir.chdir(options[:work_tree] || @work_tree) do
+          Gistore::safe_system(*args, &block)
+        end
+      end
+    end
+
+    def quiet_system(*args, &block)
+      if Hash === args.last
+        options = args.pop.dup
+      else
+        options = {}
+      end
+      setup_environment(options)
+      if options[:without_work_tree]
+        Gistore::quiet_system(*args, &block)
+      else
+        Dir.chdir(options[:work_tree] || @work_tree) do
+          Gistore::quiet_system(*args, &block)
+        end
+      end
+    end
+
+    def repo_version
+      File.open(@gistore_version_file, "r") do |io|
+        io.read.to_s.strip
+      end
+    end
+
+    def repo_version=(ver)
+      File.open(@gistore_version_file, "w") do |io|
+        io.puts ver
+      end
+    end
+
+    def remove_submodules
+      submodules = []
+      shellpipe(git_cmd, "submodule", "status",
+                :without_locale => true,
+                :check_return => false) do |ignore, stdout, stderr|
+        stdout.readlines.each do |line|
+          line.strip!
+          if line =~ /.\w{40} (\w*) (.*)?/
+            submodules << Regexp.last_match(1)
+          end
+        end
+        stderr.readlines.each do |line|
+          line.strip!
+          if line =~ /No submodule mapping found in .gitmodules for path '(.*)'/
+            submodules << Regexp.last_match(1)
+          end
+        end
+      end
+      if submodules.empty?
+        []
+      else
+        Tty.debug "Remove submodules: #{submodules.join(", ")}"
+        system(git_cmd, "rm", "-f", "--cached", "-q", *submodules)
+        submodules
+      end
+    end
+
+    # add submodule as normal directory
+    def add_submodule(submodule, status=[])
+      # add tmp file in submodule
+      tmpfile = File.join(submodule, '.gistore-submodule')
+      File.open(File.join(@work_tree, tmpfile), 'w') {}
+
+      # git add tmp file in submodule
+      shellout(git_cmd, "add", "-f", tmpfile)
+
+      # git add whole submodule dir (-f to bypass .gitignore in parent dir)
+      shellout(git_cmd, "add", "-f", submodule)
+
+      # git rm -f tmp file in submodule
+      shellout(git_cmd, "rm", "-f", tmpfile)
+
+      # Read status
+      shellout git_cmd, "status", "--porcelain", "--", submodule do |stdout|
+        stdout.readlines.each do |line|
+          line.strip!
+          status << line unless line.empty?
+        end
+      end
+      status
+    end
+
+    def backup_rotate
+      increment_backup_number = gistore_config["increment_backup_number"].to_i
+      full_backup_number = gistore_config["full_backup_number"].to_i
+      return if full_backup_number == 0 and increment_backup_number == 0
+      increment_backup_number = 30 if increment_backup_number < 1
+      full_backup_number = 6 if full_backup_number < 1
+
+      count = shellout(git_cmd, "rev-list", "master",
+                       :without_grafts => true,
+                       :check_return => false){|stdout| stdout.readlines.size}.to_i
+      if count <= increment_backup_number
+          Tty.debug "no backup rotate needed. #{count} <= #{increment_backup_number}"
+          return
+      else
+          Tty.debug "start to rotate branch, because #{count} > #{increment_backup_number}"
+      end
+
+      # list branches with prefix: gistore/
+      branches = []
+      cmds  = [git_cmd, "branch"]
+      cmds += ["--list", "gistore/*"] if Gistore.git_version_compare('1.7.8') >= 0
+      shellout *cmds do |stdout|
+        stdout.readlines.each do |line|
+          line.strip!
+          branches << line if line =~ /^gistore\//
+        end
+      end
+      branches.sort!
+
+      # Remove unwanted branches
+      if branches.size >= full_backup_number and full_backup_number > 0
+        until branches.size <= full_backup_number
+          right = branches.pop
+          shellout git_cmd, "branch", "-D", right
+          Tty.debug "deleted unwanted branch - #{right}"
+        end
+      end
+
+      # Add new branch to branches
+      if branches.size < full_backup_number
+        if branches.empty?
+          branches << "gistore/1"
+        else
+          branches << branches[-1].succ
+        end
+      end
+
+      # Rotate branches
+      branches_dup = branches.dup
+      right = nil
+      until branches_dup.empty? do
+        left = branches_dup.pop
+        if left and right
+          # shellout git_cmd, "update-ref", "refs/heads/#{right}", "refs/heads/#{left}"
+          shellout git_cmd, "branch", "-f", right, left
+          Tty.debug "update branch #{right} (value from #{left})"
+        end
+        right = left
+      end
+
+      # Save master to gistore/1
+      old_branch = "master"
+      new_branch = branches[0] || "gistore/1"
+      shellout git_cmd, "branch", "-f", new_branch, old_branch
+      Tty.debug "update branch #{new_branch} (from master)"
+
+      # Run: git cat-file commit master | \
+      #          sed  '/^parent/ d'     | \
+      #          git hash-object -t commit -w --stdin
+      cobj = ""
+      shellout git_cmd, "cat-file", "commit", "master" do |stdout|
+        end_of_header = false
+        stdout.readlines.each do |line|
+          if line !~ /^parent [0-9a-f]{40}\s*$/ or end_of_header
+            cobj << line
+          end
+          if line == "\n" and not end_of_header
+            cobj << <<-EDIT_COMMIT_LOG
+Full backup of #{task_name || File.basename(repo_path)}
+
+#{Tty.show_columns gistore_backups}
+
+** Copy from this commit **
+
+            EDIT_COMMIT_LOG
+            end_of_header = true
+          end
+        end
+      end
+
+      object_id = shellpipe(git_cmd, "hash-object",
+                            "-t", "commit",
+                            "-w", "--stdin") do |stdin, stdout, stderr|
+                    stdin.puts cobj
+                    stdin.close
+                    stdout.read
+                  end.to_s.strip
+
+      raise "Bad object_id created by 'git hash-object'" if object_id !~ /^[0-9a-f]{40}$/
+      shellout git_cmd, "update-ref", "refs/heads/master", object_id
+      Tty.debug "update master with #{object_id}"
+
+      # create file .git/info/grafts.
+      #   parent of object_id -> gistore/N^
+      #   paretn of gistore/N last commit -> gistore/(N-1)^
+      grafts_file = File.join(repo_path, "info", "grafts")
+      grafts = [object_id]
+
+      branches.each do |branch|
+        shellout(git_cmd, "rev-list", "refs/heads/#{branch}",
+                 :without_grafts => true) do |stdout|
+          lines = stdout.readlines
+          # lines[0] and object_id points to same tree.
+          new = lines.size > 1 ? lines[1] : lines[0]
+          old = lines[-1]
+          grafts << new.strip
+          grafts << old.strip
+        end
+      end
+      File.open(grafts_file, "w") do |io|
+        until grafts.empty?
+          left = grafts.shift
+          right = grafts.shift
+          if left and right
+            io.puts "#{left} #{right}"
+          end
+        end
+      end
+    end
+
+    def git_gc(*args)
+      if Hash === args.last
+        options = args.pop.dup
+      else
+        options = {}
+      end
+      gc_enabled = true
+      shellout git_cmd, "config", "gc.auto" do |stdout|
+        if stdout.read.strip == "0"
+          gc_enabled = false
+        end
+      end
+      if gc_enabled
+        if options[:force]
+          safe_system git_cmd, "reflog", "expire", "--expire=now", "--all", :without_work_tree => true
+          safe_system git_cmd, "prune", "--expire=now", :without_work_tree => true
+          args.delete "--auto" if args.include? "--auto"
+          args << {:without_work_tree => true}
+          safe_system git_cmd, "gc", *args
+        else
+          args.unshift "--auto" unless args.include? "--auto"
+          args << {:without_work_tree => true}
+          safe_system git_cmd, "gc", *args
+        end
+      else
+        Tty.warning "GC is disabled."
+      end
+    end
+
+  private
+    def is_git_repo?
+      Gistore.is_git_repo? repo_path
+    end
+
+    def load_default_config
+      @gistore_config = DEFAULT_GISTORE_CONFIG
+      gistore_default_config_file = File.join(File.dirname(__FILE__),
+                                              "config/gistore.yml")
+      @gistore_config.merge!(YAML::load_file(gistore_default_config_file) || {})
+      @gistore_backups = []
+    end
+
+    def parse_gistore_config
+      load_default_config
+      if File.exist? @gistore_config_file
+        @gistore_config.merge!(YAML::load_file(@gistore_config_file))
+      end
+      if File.exist? @gistore_backups_file
+        @gistore_backups = YAML::load_file(@gistore_backups_file)
+      end
+    end
+
+    def realpath(entry)
+      if File.exist? entry
+        if File.respond_to? :realpath
+          File.realpath(entry)
+        else
+          # ruby 1.8
+          require 'pathname'
+          Pathname.new(entry).realpath.to_s
+        end
+      else
+        File.expand_path(entry)
+      end
+    end
+
+    def uptodate?(file, *depends)
+      if File.exist?(file) and FileUtils::uptodate?(file, depends)
+        true
+      else
+        false
+      end
+    end
+
+    def get_login
+      username = gistore_config["username"]
+      username = `#{git_cmd} config user.name`.strip if username.nil? or username.empty?
+      if username.nil? or username.empty?
+        require 'etc'
+        username = Etc::getlogin
+      end
+      username
+    end
+
+    def get_email
+      useremail = gistore_config["useremail"]
+      useremail = `#{git_cmd} config user.email`.strip if useremail.nil? or useremail.empty?
+      useremail = "none" if useremail.nil? or useremail.empty?
+      useremail
+    end
+  end
+end