gistore 1.0.0.rc4

data/exe/gistore

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+std_trap = trap("INT") { exit! 130 } # no backtrace thanks
+
+require 'gistore/runner'
+require 'gistore/utils'
+
+abort "Please install git first" unless git_cmd
+if Gistore.git_version_compare('1.6.0') < 0
+  abort "Git lower than 1.6.0 has not been tested. Please upgrade your git."
+end
+
+$gistore_runner = true
+Gistore::Runner.start

data/lib/gistore.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+std_trap = trap("INT") { exit! 130 } # no backtrace thanks
+
+require 'pathname'
+LIBRARY_PATH = Pathname.new(__FILE__).realpath.dirname.to_s
+$:.unshift(LIBRARY_PATH + '/gistore/vendor')
+$:.unshift(LIBRARY_PATH)
+
+require 'gistore/runner'
+require 'gistore/utils'
+
+abort "Please install git first" unless git_cmd
+if Gistore.git_version_compare('1.6.0') < 0
+  abort "Git lower than 1.6.0 has not been tested. Please upgrade your git."
+end
+
+$gistore_runner = true
+Gistore::Runner.start

data/lib/gistore/cmd/add.rb

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

data/lib/gistore/cmd/checkout.rb

@@ -0,0 +1,49 @@
+module Gistore
+  class Runner
+    desc "checkout [--rev <rev>]",
+         "Checkout entries to <path>"
+    option :rev, :aliases => [:r], :desc => "Revision to checkout", :banner => "<rev>"
+    option :to, :required => true, :banner => "<path>", :desc => "a empty directory to save checkout items"
+    def checkout(*args)
+      parse_common_options_and_repo
+      work_tree = options[:to]
+      if File.exist? work_tree
+        if not File.directory? work_tree
+          Tty.die "\"#{work_tree}\" is not a valid directory."
+        elsif File.file? File.join(work_tree, ".git")
+          gitfile = File.open(File.join(work_tree, ".git")) {|io| io.read}.strip
+          if gitfile != "gitdir: #{gistore.repo_path}"
+            Tty.die "\"#{work_tree}\" not a checkout from #{gistore.repo_path}"
+          end
+        elsif Dir.entries(work_tree).size != 2
+          Tty.die "\"#{work_tree}\" is not a blank directory."
+        end
+      else
+        require 'fileutils'
+        FileUtils.mkdir_p work_tree
+        File.open(File.join(work_tree, '.git'), 'w') do |io|
+          io.puts "gitdir: #{gistore.repo_path}"
+        end
+      end
+      if git_version_compare('1.7.7.1') >= 0
+        args = args.empty? ? ["."]: args.dup
+        args << {:work_tree => work_tree}
+        args.shift if args.first == '--'
+        cmds = [git_cmd,
+                "checkout",
+                options[:rev] || 'HEAD',
+                "--",
+                *args]
+        gistore.safe_system(*cmds)
+      else
+        gistore.setup_environment
+        Dir.chdir(work_tree) do
+          `#{git_cmd} archive --format=tar #{options[:rev] || 'HEAD'} #{args.map{|e| e.to_s.gsub " ", "\\ "} * " "} | tar xf -`
+        end
+      end 
+
+    rescue Exception => e
+      Tty.die "#{e.message}"
+    end
+  end
+end

data/lib/gistore/cmd/commit.rb

@@ -0,0 +1,171 @@
+require 'gistore/error'
+
+module Gistore
+  class Runner
+    map ["ci", "backup"] => :commit
+    desc "commit [-m <message>]", "Start commit changes (i.e. backup)"
+    option :message, :aliases => :m, :desc => "commit log"
+    def commit(*args)
+      parse_common_options_and_repo
+
+      # Check if backup needs rotate
+      gistore.backup_rotate
+
+      # Compare with last backup, and remove unwanted from cache
+      latest_backups = gistore.get_backups
+      last_backups = gistore.get_last_backups
+      if last_backups
+        last_backups.each do |entry|
+          if entry and not latest_backups.include? entry
+            cmds = [git_cmd,
+                    "rm",
+                    "--cached",
+                    "-r",
+                    "-f",
+                    "--ignore-unmatch",
+                    "--quiet",
+                    "--",
+                    entry.sub(/^\/+/, '')]
+            cmds << {:check_return => false, :without_work_tree => true}
+            gistore.shellout(*cmds)
+          end
+        end
+      end
+
+      # Add/remove files...
+      latest_backups.each do |entry|
+        # entry may be ignored by ".gitignore" under parent dirs.
+        gistore.shellout git_cmd, "add", "-f", entry.sub(/^\/+/, '')
+      end
+
+      cmds = [git_cmd, "add", "-A"]
+      cmds << ":/" if git_version_compare('1.7.6') >= 0
+      gistore.shellout *cmds
+
+      # Read status
+      git_status = []
+      gistore.shellout git_cmd, "status", "--porcelain" do |stdout|
+        stdout.readlines.each do |line|
+          line.strip!
+          git_status << line unless line.empty?
+        end
+      end
+
+      # Add contents of a submodule, not add as a submodule
+      submodules = gistore.remove_submodules
+      until submodules.empty? do
+          Tty.debug "Re-add files in submodules: #{submodules.join(', ')}"
+          submodules.each do |submod|
+              git_status += gistore.add_submodule(submod)
+          end
+          # new add directories may contain other submodule.
+          submodules = gistore.remove_submodules
+      end
+
+      # Format commit messages
+      message = ""
+      message << options[:message].strip if options[:message]
+      message << "\n\n" unless message.empty?
+      message << commit_summary(git_status)
+      msgfile = File.join(gistore.repo_path, "COMMIT_EDITMSG")
+      open(msgfile, "w") do |io|
+        io.puts message  
+      end
+
+      # Start to commit
+      committed = nil
+      output = ""
+      begin
+        gistore.shellout(git_cmd, "commit", "-s", "--quiet", "-F", msgfile,
+                         :without_locale => true,
+                         :check_return => true) do |stdout|
+          output = stdout.read
+        end
+        committed = true
+      rescue CommandReturnError
+        if output and
+           (output =~ /no changes added to commit/ or
+            output =~ /nothing to commit/ or
+            output =~ /nothing added to commit/)
+          committed = false
+        else
+          raise "Failed to execute git-commit:\n\n#{output.to_s}"
+        end
+      end
+
+      # Save backups
+      gistore.update_gistore_config(:backups => latest_backups)
+      gistore.save_gistore_config
+
+      display_name = gistore.task_name ?
+                     "#{gistore.task_name} (#{gistore.repo_path})" :
+                     "#{gistore.repo_path}"
+
+      if committed
+        Tty.info "Successfully backup repo: #{display_name}"
+        # Run git-gc
+        gistore.git_gc
+      else
+        Tty.info "Nothing changed for repo: #{display_name}"
+      end
+
+    rescue Exception => e
+      Tty.die "#{e.message}"
+    end
+
+    map ["ci_all", "ci-all", "backup_all", "backup-all"] => :commit_all
+    desc "commit-all [-m <message>]", "Start backup (commit) all tasks", :hide => true
+    option :message, :aliases => :m, :desc => "commit log"
+    def commit_all
+      messages = []
+      Gistore::get_gistore_tasks.each do |task, path|
+        cmds = ["commit", "--repo", path]
+        if options[:message]
+          cmds << "-m"
+          cmds << options[:message]
+        end
+        # invoke run only once? -- invoke :commit, args, opts
+        begin
+          Gistore::Runner.start(cmds)
+        rescue Exception => e
+          messages << "Failed to execute #{cmds}."
+          messages << "Error_msg: #{e.message}"
+        end
+      end
+      unless messages.empty?
+        Tty.die "At lease one task backup failed.\n#{messages * "\n"}"
+      end
+    end
+
+  private
+    def commit_summary(git_status)
+      sample = 2
+      statistics = {}
+      output = []
+      git_status.each do |line|
+        k,v = line.split(" ", 2)
+        statistics[k] ||= []
+        statistics[k] << v
+      end
+  
+      total = git_status.size
+      detail = statistics.to_a.map{|h| "#{h[0]}: #{h[1].size}"}.sort.join(", ")
+      output << "Backup #{total} item#{total > 1 ? "s" : ""} (#{detail})"
+      output << ""
+      statistics.keys.sort.each do |k|
+        buffer = []
+        if statistics[k].size > sample
+          step = statistics[k].size / sample
+          (0...sample).each do |i|
+            buffer << statistics[k][step * i]
+          end
+          buffer << "...#{statistics[k].size - sample} more..."
+        else
+          buffer = statistics[k]
+        end
+        output << "  #{k} => #{buffer.join(", ")}"
+      end
+      output.join("\n")
+    end
+  end
+end

data/lib/gistore/cmd/config.rb

@@ -0,0 +1,23 @@
+module Gistore
+  class Runner
+    map "config" => :cmd_config
+    desc "config name value", "Read or update gistore config or git config"
+    option :plan, :desc => "builtin plan: no-gc, no-compress, or normal (default)"
+    def cmd_config(*args)
+      parse_common_options_and_repo
+      if options[:plan]
+        return gistore.git_config('--plan', options[:plan])
+      end
+
+      args << {:check_return => true}
+      unless gistore.git_config(*args)
+        exit 1
+      end
+    rescue SystemExit
+      exit 1
+    rescue Exception => e
+      Tty.die "#{e.message}"
+    end
+  end
+end
+

data/lib/gistore/cmd/export-to-backups.rb

@@ -0,0 +1,79 @@
+module Gistore
+  class Runner
+    desc "export-to-backups", "Export to a series of full/increment backups"
+    option :to, :required => true, :banner => "<dir>", :desc => "path to save full/increment backups"
+    def export_to_backups
+      parse_common_options_and_repo
+      work_tree = options[:to]
+      if File.exist? work_tree
+        if not File.directory? work_tree
+          raise "\"#{work_tree}\" is not a valid directory."
+        elsif Dir.entries(work_tree).size != 2
+          Tty.warning "\"#{work_tree}\" is not a blank directory."
+        end
+      else
+        require 'fileutils'
+        FileUtils.mkdir_p work_tree
+      end
+
+      commits = []
+      gistore.shellout(git_cmd, "rev-list", "master",
+                       :without_grafts => true) do |stdout|
+        commits = stdout.readlines
+      end
+
+      export_commits(commits, work_tree)
+    rescue Exception => e
+      Tty.die "#{e.message}"
+    end
+
+  private
+
+    def export_commits(commits, work_tree)
+      left = right = nil
+      n = 1
+      until commits.empty?
+        right=commits.pop.strip
+        export_one_commit(n, left, right, work_tree)
+        left = right
+        n += 1
+      end
+    end
+
+    def export_one_commit(n, left, right, work_tree)
+      time = nil
+      gistore.shellout(git_cmd, "cat-file", "commit", right) do |stdout|
+        stdout.readlines.each do |line|
+          if line =~ /^committer .* ([0-9]+)( [+-][0-9]*)?$/
+            time = Time.at($1.to_i).strftime("%Y%m%d-%H%M%S")
+            break
+          end
+        end
+      end
+
+      prefix = "%03d-" % n
+      prefix << (left ? "incremental" : "full-backup")
+      prefix << "-#{time}" if time
+      prefix << "-g#{right[0...7]}"
+
+      if not Dir.glob("#{work_tree}/#{prefix}*.pack").empty?
+        Tty.info "already export commit #{right}"
+        return
+      end
+
+      if left
+        input_rev = "#{left}..#{right}"
+      else
+        input_rev = right
+      end
+
+      gistore.shellpipe(git_cmd, "pack-objects", "--revs", prefix,
+                        :without_grafts => true,
+                        :work_tree => work_tree) do |stdin, stdout, stderr|
+        stdin.write input_rev
+        stdin.close_write
+      end
+      Tty.info "export #{n}: #{prefix}"
+    end
+  end
+end

data/lib/gistore/cmd/gc.rb

@@ -0,0 +1,15 @@
+module Gistore
+  class Runner
+    desc "gc [--force]", "Run git-gc if gc.auto != 0"
+    option :force, :type => :boolean, :aliases => [:f], :desc => "run git-gc without --auto option"
+    def gc(*args)
+      parse_common_options_and_repo
+      opts = options.dup
+      opts.delete :repo
+      args << opts
+      gistore.git_gc(*args)
+    rescue Exception => e
+      Tty.die "#{e.message}"
+    end
+  end
+end

data/lib/gistore/cmd/git-version.rb

@@ -0,0 +1,14 @@
+require 'gistore/utils'
+
+module Gistore
+  class Runner
+    desc "check-git-version", "Check git version", :hide => true
+    def check_git_version(v1, v2=nil)
+      if v2
+        puts Gistore.git_version_compare(v1, v2)
+      else
+        puts Gistore.git_version_compare(v1)
+      end
+    end
+  end
+end

data/lib/gistore/cmd/init.rb

@@ -0,0 +1,36 @@
+require 'gistore/repo'
+require 'gistore/utils'
+require 'gistore/version'
+
+module Gistore
+  class Runner
+    desc "init", "Initialize gistore repository"
+    long_desc <<-LONGDESC
+      `gistore init [--repo] <repo>` will create a gistore backup repo.
+
+      The created <repo> is a bare git repository, and when excute backup and/or
+      other commands on <repo>, GIT_WORK_TREE will be set as '/', and GIT_DIR
+      will be set as <repo> automatically.
+
+      This bare repo has been set with default settings which are suitable for
+      backup for text files. But if most of the backups are binaries, you may
+      like to set <repo> with custom settings. You can give specific plan for
+      <repo> when initializing, like:
+
+      > $ gistore init --plan <no-gc|no-compress|normal> <repo>
+
+      Or run `gistore config` command latter, like
+
+      > $ gistore config --repo <repo> --plan no-compress
+      \x5> $ gistore config --repo <repo> --plan no-gc
+    LONGDESC
+    option :plan, :required => false, :type => :string,
+           :desc => "no-gc, no-compress, or normal (default)"
+    def init(name=nil)
+      parse_common_options
+      Repo.init(options[:repo] || name || ".", options)
+    rescue Exception => e
+      Tty.die "#{e.message}"
+    end
+  end
+end