rib 0.1.0 → 0.9.0

data/lib/rib/more/color.rb

@@ -5,6 +5,8 @@ module Rib::Color
   include Rib::Plugin
   Shell.use(self)
 
+  # --------------- Rib API ---------------
+
   def before_loop
     config[:color] ||= {
       Numeric    => :red    ,
@@ -26,73 +28,72 @@ module Rib::Color
     config[:result_prompt] + format_color(result)
   end
 
-  private
-  def colors
-    config[:color]
-  end
+  # --------------- Plugin API ---------------
+
+  def colors; config[:color]; end
 
   def format_color result, display=result.inspect
     case result
-      when String ; P.send(colors[String ]){ display }
-      when Numeric; P.send(colors[Numeric]){ display }
-      when Symbol ; P.send(colors[Symbol ]){ display }
+      when String ; send(colors[String ]){ display }
+      when Numeric; send(colors[Numeric]){ display }
+      when Symbol ; send(colors[Symbol ]){ display }
 
-      when Array  ; P.send(colors[Array  ]){ '['     }   +
+      when Array  ; send(colors[Array  ]){ '['     }   +
                       result.map{ |e   | format_color(e) }.
-               join(P.send(colors[Array  ]){ ', '    })  +
-                    P.send(colors[Array  ]){ ']'     }
+               join(send(colors[Array  ]){ ', '    })  +
+                    send(colors[Array  ]){ ']'     }
 
-      when Hash   ; P.send(colors[Hash   ]){ '{'     }   +
+      when Hash   ; send(colors[Hash   ]){ '{'     }   +
                       result.map{ |k, v| format_color(k) +
-                    P.send(colors[Hash   ]){ '=>'    }   +
+                    send(colors[Hash   ]){ '=>'    }   +
                                          format_color(v) }.
-               join(P.send(colors[Hash   ]){ ', '    }) +
-                    P.send(colors[Hash   ]){ '}'     }
+               join(send(colors[Hash   ]){ ', '    }) +
+                    send(colors[Hash   ]){ '}'     }
 
-      else        ; if color = P.find_color(colors, result)
-                    P.send(color){ display }
+      else        ; if color = find_color(colors, result)
+                    send(color){ display }
                     else
-                    P.send(colors[Object      ]){ display }
+                    send(colors[Object      ]){ display }
                     end
     end
   end
 
-  def get_error e, backtrace=e.backtrace
+  # override StripBacktrace#get_error
+  def get_error err, backtrace=err.backtrace
     return super if Color.disabled?
-    [format_color(e, "#{e.class.to_s}: #{e.message}"),
+    [format_color(err, "#{err.class.to_s}: #{err.message}"),
      backtrace.map{ |b|
        path, rest = ::File.split(b)
        name, msgs = rest.split(':', 2)
-       msg = msgs.sub(/(\d+):/){P.red{$1}+':'}.sub(/`.+?'/){P.green{$&}}
+       msg = msgs.sub(/(\d+):/){red{$1}+':'}.sub(/`.+?'/){green{$&}}
 
-       "#{path+'/'}#{P.yellow{name}}:#{msg}"
+       "#{path+'/'}#{yellow{name}}:#{msg}"
      }]
   end
 
-  module Imp
-    def find_color colors, value
-      (colors.sort{ |(k1, v1), (k2, v2)|
-        # Class <=> Class
-        if    k1 < k2 then -1
-        elsif k1 > k2 then  1
-        else                0
-        end}.find{ |(klass, _)| value.kind_of?(klass) } || []).last
-    end
 
-    def color rgb
-      "\x1b[#{rgb}m" + (block_given? ? "#{yield}#{reset}" : '')
-    end
 
-    def   black &block; color(30, &block); end
-    def     red &block; color(31, &block); end
-    def   green &block; color(32, &block); end
-    def  yellow &block; color(33, &block); end
-    def    blue &block; color(34, &block); end
-    def magenta &block; color(35, &block); end
-    def    cyan &block; color(36, &block); end
-    def   white &block; color(37, &block); end
-    def   reset &block; color('', &block); end
+  module_function
+  def find_color colors, value
+    (colors.sort{ |(k1, v1), (k2, v2)|
+      # Class <=> Class
+      if    k1 < k2 then -1
+      elsif k1 > k2 then  1
+      else                0
+      end}.find{ |(klass, _)| value.kind_of?(klass) } || []).last
+  end
+
+  def color rgb
+    "\x1b[#{rgb}m" + (block_given? ? "#{yield}#{reset}" : '')
   end
 
-  Plugin.extend(Imp)
+  def   black &block; color(30, &block); end
+  def     red &block; color(31, &block); end
+  def   green &block; color(32, &block); end
+  def  yellow &block; color(33, &block); end
+  def    blue &block; color(34, &block); end
+  def magenta &block; color(35, &block); end
+  def    cyan &block; color(36, &block); end
+  def   white &block; color(37, &block); end
+  def   reset &block; color('', &block); end
 end

data/lib/rib/{zore → more}/edit.rb

@@ -6,14 +6,14 @@ module Rib::Edit
   include Rib::Plugin
   Shell.use(self)
 
-  module EditImp
+  module Imp
     def edit
       return if Rib::Edit.disabled?
       file = Tempfile.new(['rib.edit', '.rb'])
       file.puts(Rib.vars[:edit])
       file.close
 
-      system("$EDITOR #{file.path}")
+      system("#{ENV['EDITOR']} #{file.path}")
 
       if (shell = Rib.shell).running?
         shell.send(:multiline_buffer).pop
@@ -29,5 +29,5 @@ module Rib::Edit
     end
   end
 
-  Rib.extend(EditImp)
+  Rib.extend(Imp)
 end

data/lib/rib/more/multiline_history.rb

@@ -1,23 +1,24 @@
 
-require 'rib/more/multiline' # dependency
+require 'rib/core/history'   # dependency
+require 'rib/core/multiline' # dependency
 
 module Rib::MultilineHistory
   include Rib::Plugin
   Shell.use(self)
 
+  # --------------- Rib API ---------------
+
+  def before_loop
+    @multiline_trash = 0
+    super
+  end
+
   def loop_eval input
     return super if MultilineHistory.disabled?
-    value = super
-  rescue Exception
-    # might be multiline editing, ignore
-    raise
-  else
-    if multiline_buffer.size > 1
-      # so multiline editing is considering done here
-      (multiline_buffer.size + (@multiline_trash || 0)).times{ history.pop }
-      history << "\n" + multiline_buffer.join("\n")
-    end
-    value
+    super
+  ensure
+    # SyntaxError might mean we're multiline editing
+    handle_multiline unless multiline?($!)
   end
 
   def handle_interrupt
@@ -28,4 +29,15 @@ module Rib::MultilineHistory
     end
     super
   end
+
+
+
+  private
+  def handle_multiline
+    if multiline_buffer.size > 1
+      # so multiline editing is considering done here
+      (multiline_buffer.size + @multiline_trash).times{ history.pop }
+      history << "\n" + multiline_buffer.join("\n")
+    end
+  end
 end

data/lib/rib/more/multiline_history_file.rb

@@ -5,17 +5,21 @@ module Rib::MultilineHistoryFile
   include Rib::Plugin
   Shell.use(self)
 
+  # --------------- Rib API ---------------
+
   def before_loop
     return super if MultilineHistoryFile.disabled?
     config[:multiline_history_file_token] ||= ' '
     super
   end
 
+  # --------------- Plugin API ---------------
+
   def read_history
     return super if MultilineHistoryFile.disabled?
     buffer = []
-    File.exist?(history_file) && history.empty? &&
-      IO.readlines(history_file).each{ |line|
+    File.exist?(history_file_path) && history.empty? &&
+      IO.readlines(history_file_path).each{ |line|
         if line.end_with?(
              "#{config[:multiline_history_file_token]}\n")
           buffer << line[0...
@@ -29,7 +33,7 @@ module Rib::MultilineHistoryFile
 
   def write_history
     return super if MultilineHistoryFile.disabled?
-    @history = history.to_a.map{ |line|
+    config[:history] = history.to_a.map{ |line|
       line.gsub("\n", "#{config[:multiline_history_file_token]}\n")
     }
     super

data/lib/rib/plugin.rb

@@ -1,8 +1,6 @@
 
 module Rib; end
 module Rib::Plugin
-  Rib::P = self
-
   def self.included mod
     mod.send(:include, Rib)
 
@@ -28,8 +26,8 @@ module Rib::Plugin
       end
     end
 
-    snake_name = mod.name[/::\w+$/].tr(':', ''). # remove namespaces
-                     gsub(/([A-Z][a-z]*)/, '\\1_').downcase[0..-2]
+    snake_name = mod.name.sub(/(\w+::)+?(\w+)$/, '\2').
+      gsub(/([A-Z][a-z]*)/, '\\1_').downcase[0..-2]
 
     code = (%w[enable disable].map{ |meth|
       <<-RUBY

data/lib/rib/runner.rb

@@ -3,54 +3,66 @@ require 'rib'
 
 module Rib::Runner
   module_function
-  def name
-    File.basename($PROGRAM_NAME)
-  end
-
   def options
-    { # Ruby OPTIONS
-     '-e, --eval LINE'       =>
-       'Evaluate a LINE of code'                                      ,
+    @options ||=
+    [['ruby options:'    , ''                                        ],
+     ['-e, --eval LINE'                                               ,
+      'Evaluate a LINE of code'                                      ],
+
+     ['-d, --debug'                                                   ,
+      'Set debugging flags (set $DEBUG to true)'                     ],
 
-     '-d, --debug'           =>
-       'Set debugging flags (set $DEBUG to true)'                     ,
+     ['-w, --warn'                                                    ,
+       'Turn warnings on for your script (set $-w to true)'          ],
 
-     '-w, --warn'            =>
-       'Turn warnings on for your script (set $-w to true)'           ,
+     ['-I, --include PATH'                                            ,
+       'Specify $LOAD_PATH (may be used more than once)'             ],
 
-     '-I, --include PATH'    =>
-       'Specify $LOAD_PATH (may be used more than once)'              ,
+     ['-r, --require LIBRARY'                                         ,
+       'Require the library, before executing your script'           ],
 
-     '-r, --require LIBRARY' =>
-       'Require the library, before executing your script'            ,
+     ['rib options:'     , ''                                        ],
+     ['-c, --config FILE', 'Load config from FILE'                   ],
+     ['-n, --no-config'  , 'Suppress loading ~/.config/rib/config.rb'],
+     ['-h, --help'       , 'Print this message'                      ],
+     ['-v, --version'    , 'Print the version'                       ]] +
 
-      # Rib OPTIONS
-     '-c, --config FILE' => 'Load config from FILE'                   ,
-     '-n, --no-config'   => 'Suppress loading ~/.config/rib/config.rb',
-     '-h, --help'        => 'Print this message'                      ,
-     '-v, --version'     => 'Print the version'                       }
+    [['rib commands:'    , '']] + commands
   end
 
-  def run argv=ARGV
-    if command = argv.find{ |a| a =~ /^[^-]/ }
-      argv.delete(command)
-      plugin = "rib-#{command}"
-      path   = `which #{plugin}`.strip
-      if path == ''
-        puts("Can't find `#{plugin}' in $PATH.\n"           \
-             "Please make sure `#{plugin}' is installed.\n" \
-             "e.g. run `gem install #{plugin}`")
-      else
-        load(path)
-      end
-    else
-      start(*argv)
-    end
+  def commands
+     @commands ||=
+      command_names.map{ |n| [n, command_descriptions[n] || ' '] }
+  end
+
+  def command_names
+    @command_names ||=
+    Gem.path.map{ |path|
+      Dir["#{path}/bin/*"].map{ |f|
+        (File.executable?(f) && File.basename(f) =~ /^rib\-(\w+)$/ && $1) ||
+         nil    # a trick to make false to be nil and then
+      }.compact # this compact could eliminate them
+    }.flatten
   end
 
-  def start *argv
-    unused = parse(argv.dup)
-    warn "#{name}: Unused arguments: #{unused.inspect}" unless unused.empty?
+  def command_descriptions
+    @command_descriptions ||=
+    {'all'    => 'Load all recommended plugins'                ,
+     'min'    => 'Run the minimum essence'                     ,
+     'auto'   => 'Run as Rails or Ramaze console (auto-detect)',
+     'rails'  => 'Run as Rails console'                        ,
+     'ramaze' => 'Run as Ramaze console'                       }
+  end
+
+  def run argv=ARGV
+    (@running_commands ||= []) << Rib.config[:name]
+    unused = parse(argv)
+    # if it's running a Rib command, the loop would be inside Rib itself
+    # so here we only parse args for the command
+    return if @running_commands.pop != 'rib'
+    # by comming to this line, it means now we're running Rib main loop,
+    # not any other Rib command
+    Rib.warn("Unused arguments: #{unused.inspect}") unless unused.empty?
     Rib.shell.loop
   end
 
@@ -58,23 +70,23 @@ module Rib::Runner
     unused = []
     until argv.empty?
       case arg = argv.shift
-      when /-e=?(.*)/, /--eval=?(.*)/
-        eval($1 || argv.shift, __FILE__, __LINE__)
+      when /-e=?(.+)?/, /--eval=?(.+)?/
+        eval($1 || argv.shift, binding, __FILE__, __LINE__)
 
       when '-d', '--debug'
         $DEBUG = true
 
       when '-w', '--warn'
-        $-w = true
+        $-w, $VERBOSE = true, true
 
-      when /-I=?(.*)/, /--include=?(.*)/
+      when /-I=?(.+)?/, /--include=?(.+)?/
         paths = ($1 || argv.shift).split(':')
         $LOAD_PATH.unshift(*paths)
 
-      when /-r=?(.*)/, /--require=?(.*)/
+      when /-r=?(.+)?/, /--require=?(.+)?/
         require($1 || argv.shift)
 
-      when /-c=?(.*)/, /--config=?(.*)/
+      when /-c=?(.+)?/, /--config=?(.+)?/
         Rib.config[:config] = $1 || argv.shift
 
       when '-n', '--no-config'
@@ -89,6 +101,9 @@ module Rib::Runner
         puts(Rib::VERSION)
         exit
 
+      when /^[^-]/
+        load_command(arg)
+
       else
         unused << arg
       end
@@ -97,10 +112,30 @@ module Rib::Runner
   end
 
   def help
-    maxn = options.keys  .map(&:size).max
-    maxd = options.values.map(&:size).max
-    "Usage: #{name} [Ruby OPTIONS] [Rib COMMAND] [Rib OPTIONS]\n" +
-    options.map{ |name, desc|
-      sprintf("  %-*s  %-*s", maxn, name, maxd, desc) }.join("\n")
+    maxn = options.transpose.first.map(&:size).max
+    maxd = options.transpose.last .map(&:size).max
+    "Usage: #{Rib.config[:name]}"                    \
+    " [ruby OPTIONS] [rib OPTIONS] [rib COMMANDS]\n" +
+    options.map{ |(name, desc)|
+      if desc.empty?
+        name
+      else
+        sprintf("  %-*s  %-*s", maxn, name, maxd, desc)
+      end
+    }.join("\n")
+  end
+
+  def load_command command
+    bin  = "rib-#{command}"
+    path = `which #{bin}`.strip
+    if path == ''
+      Rib.warn(
+        "Can't find #{bin} in $PATH. Please make sure it is installed,",
+        "or is there any typo? You can try this to install it:\n"         ,
+        "    gem install #{bin}")
+    else
+      Rib.config[:name] = bin
+      load(path)
+    end
   end
 end

data/lib/rib/shell.rb

@@ -13,13 +13,13 @@ class Rib::Shell
   attr_reader :config
   def initialize(config={})
     self.config = {
-      :name          => 'rib'                    ,
       :result_prompt => '=> '                    ,
       :prompt        => '>> '                    ,
       :binding       => TOPLEVEL_BINDING         ,
       :exit          => [nil, 'exit', 'quit']    ,
       :line          => 1
     }.merge(config)
+    @running = false
   end
 
   # Loops shell until user exits
@@ -28,6 +28,9 @@ class Rib::Shell
     @running = true
     in_loop
     self
+  rescue Exception => e
+    Rib.warn("Error while running loop:\n  #{format_error(e)}")
+    raise
   ensure
     @running = false
     after_loop
@@ -39,5 +42,4 @@ class Rib::Shell
 
   protected
   attr_writer :config
-  attr_accessor :error_raised
 end