Changeset 6299

Timestamp:

02/06/08 22:22:00 (5 years ago)

Author:

yhara

Message:

lang/ruby/reposh: new: custom command (ver 0.1.4)

Location:

lang/ruby/reposh/trunk

Files:

• reposh.rb (modified) (5 diffs)
• sample.reposh.yaml (modified) (1 diff)
• spec_reposh.rb (modified) (2 diffs)

lang/ruby/reposh/trunk/reposh.rb

@@ -22 +22 @@
 
 class Reposh
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
   CONF_DEFAULT = { 
     "global" => {
       "editing_mode" => nil,
+      "custom_commands" => [],
     },
     "system" => {
@@ -39 +40 @@
   }
 
-  def initialize
-  end
-
   def run
     parse_option(ARGV)
@@ -49 +47 @@
     @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")
+    binpath      = get_conf(@system_name, "binpath") || @system_name
+    default_cmd  = get_conf(@system_name, "default_cmd")
+
+    @commands = Commands.new(binpath, default_cmd)
+    @commands.register_custom_commands(@conf["global"]["custom_commands"])
+
     run_loop
   end
@@ -102 +104 @@
   
   def get_conf(system, prop)
-    if @conf["system"][system] 
-      @conf["system"][system][prop]
-    else
-      @conf["system"]["default"][prop] 
-    end
+    (@conf["system"][system] and @conf["system"][system][prop]) or @conf["system"]["default"][prop] 
   end
 
@@ -117 +115 @@
     loop do
       cmd = Readline.readline(@prompt, true)
-      cmd = @default_cmd if cmd == ""
-
-      case cmd
-      when "%reload"
-        load __FILE__
-      when "%env"
+      @commands.dispatch(cmd, @system_name)
+    end
+  end
+
+  class Commands
+    def initialize(binpath, default_cmd)
+      @binpath, @default_cmd = binpath, default_cmd
+      @commands = []
+      register_builtin_commands
+    end
+
+    def register_builtin_commands
+      # default command
+      register(/.*/){|match|
+        cmd = (match[0] == "") ? @default_cmd : match[0]
+        execute "#{@binpath} #{cmd}"
+      }
+
+      # system commands
+      register("%reload"){ 
+        load __FILE__ 
+      }
+      register("%env"){
         require 'pp'
         pp ENV
-      when "%version"
-        puts VERSION
-      when nil, "exit", "quit"
+      }
+      register("%version"){
+        puts VERSION 
+      }
+      register(/\A%ruby (.*)/){|match|
+        puts "reposh: result is " + eval(match[1]).inspect
+      }
+      @trace_mode = false
+      register("%trace"){
+        @trace_mode = (not @trace_mode)
+        puts "set trace_mode to #{@trace_mode}"
+      }
+
+      # exit commands
+      exit_task = lambda{
         puts ""
         exit
-      when /^:(.*)/
-        puts $1
-        execute $1
+      }
+      register(nil,    &exit_task)
+      register("exit", &exit_task)
+      register("quit", &exit_task)
+
+      # shell execution command
+      register(/^:(.*)/){|match|
+        execute match[1]
+      }
+    end
+
+    def register_custom_commands(commands)
+      commands.each do |hash|
+        if hash["for"] 
+          systems = hash["for"].split(/,/).map{|s| s.strip}
+        else
+          systems = nil
+        end
+        register(Regexp.new(hash["pattern"]), systems){|match|
+          cmd = hash["rule"].
+                  gsub(/\{system\}/, @binpath).
+                  gsub(/\{\$(\d+)\}/){ match[$1.to_i] }
+          puts cmd
+          execute cmd
+        }
+      end
+    end
+
+    def register(pattern, systems = nil, &task)
+      @commands.unshift [pattern, systems, task]
+    end
+
+    def dispatch(cmd, sys)
+      @commands.each do |pattern, systems, task|
+        next if systems && !systems.include?(sys)
+
+        if (match = match?(pattern, cmd))
+          return task.call(match)
+        end
+      end
+      raise "must not happen"
+    end
+
+    def match?(pat, value)
+      case pat
+      when Regexp
+        pat.match(value)
+      when nil
+        value == nil
       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
+        pat.strip == value
+      end
+    end
+
+    def execute(cmd)
+      puts cmd if @trace_mode
+      result = system(cmd)
+      if result == false 
+        case
+        when $?.nil? 
+          puts "reposh: unknown error ($? is nil)"
+        when [0, 127].include?($?.exitstatus)
+          puts "reposh: failed to exec '#{cmd}': status #{$?.exitstatus}"
+        end
+      end
+    end
+
+  end
+
 end
 

lang/ruby/reposh/trunk/sample.reposh.yaml

@@ -1 @@
-# vcs independent settings
 global:
   editing_mode: vi  # default is: emacs
+  custom_commands:
+    # > ignore_of lib  =>  svn propedit svn:ignore lib
+    - pattern: \Aignore_of (.*)
+      rule: "{system} propedit svn:ignore {$1}"
+      for: svn, svk
+    # > ignore lib/*.o  =>  svn propset svn:ignore *.o lib
+    - pattern: \Aignore (.*)[\\/]([^\\/]+)
+      rule: "{system} propset svn:ignore {$2} {$1}"
+      for: svn, svk
 
 # settings for each vcs

lang/ruby/reposh/trunk/spec_reposh.rb

@@ +1 @@
+require 'rubygems'
+require 'kagemusha'
 require 'reposh'
 
 describe "Hash#recursive_merge" do
-  before(:all) do
+  before :all do
     @reposh = Reposh.new
   end
@@ -33 +35 @@
   end
 end
+
+describe "Reposh::Commands" do
+  before :each do
+    @commands = Reposh::Commands.new("svn")
+  end
+
+  it "should judge whether a command matches a pattern" do
+    @commands.match?("exit", "exit").should == true
+    match = @commands.match?(/:(.*)/, ":rake aaa")
+    match.should be_an_instance_of(MatchData)
+    match[1].should == "rake aaa"
+  end
+
+  it "should register a command and dispatch" do
+    @commands.register(/foo (.*) (\d+)/){|match|
+      match[1].should == "bar"
+      match[2].should == "1192"
+    }
+    @commands.dispatch("foo bar 1192", "svk")
+  end
+
+  it "should dispatch only for wanted systems" do
+    @commands.register("foo"){ :no_match }
+    @commands.register("foo", ["svn", "svk"]){ :match }
+
+    @commands.dispatch("foo", "svn").should == :match
+    @commands.dispatch("foo", "svk").should == :match
+    @commands.dispatch("foo", "hg").should == :no_match
+  end
+
+  it "should register custom commands" do 
+    my_execute = Kagemusha.new(Reposh::Commands).def(:execute){|x| x}
+
+    @commands.register_custom_commands([
+      { "pattern" => "ignore (\\S+)",
+        "rule"    => "{system} propset svn:ignore . {$1}",
+        "for"     => "svn, svk" }
+    ])
+    my_execute.swap{
+      result = @commands.dispatch("ignore *.swp", "svn")
+      result.should == "svn propset svn:ignore . *.swp"
+    }
+  end
+
+end