root/lang/ruby/reposh/trunk/reposh.rb @ 6276

#
# reposh.rb - Reposh - Simple VCS Manager Shell
# usage:
#   read bottom of this file
#
require 'readline'
require 'yaml'
require 'optparse'

class Hash
  def recursive_merge(other)
    self.merge(other) do |key, my_val, other_val|
      # for values of a same key
      if my_val.is_a? Hash and other_val.is_a? Hash
        my_val.recursive_merge(other_val) # XXX: hang-ups for cyclic hash?
      else
        other_val
      end
    end
  end
end

class Reposh
  VERSION = "0.1.3"
  CONF_DEFAULT = { 
    "global" => {
      "editing_mode" => nil,
    },
    "system" => {
      "default" => {
        "binpath" => nil,
        "prompt" => "> ",
        "default_cmd" => "status",
      },
      "darcs" => {
        "default_cmd" => "whatsnew --summary",
      }
    }
  }

  def initialize
  end

  def run
    parse_option(ARGV)
    @conf_path ||= File.join(ENV["HOME"], ".reposh.yaml")
    @system_name ||= guess_system

    @conf = load_config(@conf_path)
    @editing_mode = @conf["global"]["editing_mode"]
    @binpath     = get_conf(@system_name, "binpath") || @system_name
    @prompt      = get_conf(@system_name, "prompt")
    @default_cmd = get_conf(@system_name, "default_cmd")
    run_loop
  end

  def parse_option(args)
    o = OptionParser.new{|opt|
      opt.on("-c confpath",
             "path to .reposh.yaml"){|path|
        @confpath = path
      }
      opt.on("-s system",
             "vcs command name (eg. svn, svk, hg)"){|sys|
        @system_name = sys
      }
      opt.on("-h", "--help",
             "show this message"){
        puts opt
        exit
      }
      opt.on("-v", "--version",
             "show version information"){
        puts VERSION
        exit
      }
    }
    o.parse(args)
  end

  def load_config(path)
    if File.exist?(path)
      config_hash = YAML.load(File.read(path))
      CONF_DEFAULT.recursive_merge(config_hash)
    else
      CONF_DEFAULT
    end
  end

  def guess_system
    case 
    when File.directory?(".hg")
      "hg"
    when File.directory?("_darcs")
      "darcs"
    when File.directory?(".svn")
      "svn"
    else
      "svk"
    end
  end
  
  def get_conf(system, prop)
    if @conf["system"][system] 
      @conf["system"][system][prop]
    else
      @conf["system"]["default"][prop] 
    end
  end

  def run_loop
    if @editing_mode == "vi"
      Readline.vi_editing_mode
    end

    puts "Welcome to reposh #{VERSION} (mode: #{@system_name})"
    loop do
      cmd = Readline.readline(@prompt, true)
      cmd = @default_cmd if cmd == ""

      case cmd
      when "%reload"
        load __FILE__
      when "%env"
        require 'pp'
        pp ENV
      when "%version"
        puts VERSION
      when nil, "exit", "quit"
        puts ""
        exit
      when /^:(.*)/
        puts $1
        execute $1
      else
        execute "#{@binpath} #{cmd}"
      end
    end
  end

  def execute(cmd)
    result = system(cmd)
    if (not result) and ($?.nil? or $?.exitstatus == 127)
      puts "error: failed to exec '#{cmd}'"
    end
  end
end

if $0==__FILE__
  Reposh.new.run
end

=begin
== Reposh - what's this?
Without reposh, you type like this:
  $ svk di
  $ svk ci
  $ svk st
  $ ls
but this is not DRY :)

With reposh, you can omit typing all 'svk's:
  $ reposh
  Welcome to reposh x.y.z (mode: svk)
  > di
  > ci
  >          # just push [Enter] for 'svk status'
  > :ls      # start with ':' to run shell commands

== How to use
(1) write /home/(your name)/.reposh.yaml
(2) cd to your working directory
(3) reposh.rb [Enter]

== Options
see reposh.rb --help

== Commands
* exit, quit, ^D(^Z)
  * Quit reposh
* :ls ~/
  * Run "ls ~/" by shell
* [Enter]
  * Equals to "status" (you can change this by .reposh.yaml) 
* %reload
  * Reload reposh.rb (for reposh developper)
  * Some more commands starts with % are supported: see source

All other commands are passed to vcs system.

== Configuration
see sample.reposh.yaml

=end