rib 0.0.1 → 0.1.0

data/lib/rib/all.rb

@@ -0,0 +1,4 @@
+
+require 'rib/core'
+require 'rib/more'
+require 'rib/zore'

data/lib/rib/api.rb

@@ -0,0 +1,105 @@
+
+module Rib; end
+module Rib::API
+  def before_loop
+    read_history
+    self
+  end
+
+  def in_loop
+    input = catch(:rib_exit){ loop_once while true }
+    puts if input == nil
+  end
+
+  # Runs through one loop iteration: gets input, evals and prints result
+  def loop_once
+    self.error_raised = nil
+    input = get_input
+    throw(:rib_exit, input) if config[:exit].include?(input)
+    if input.strip == ''
+      eval_input(input)
+    else
+      print_result(eval_input(input))
+    end
+  rescue Interrupt
+    handle_interrupt
+  end
+
+  # Handles interrupt (Control-C) by printing a newline
+  def handle_interrupt() puts end
+
+  # Sets @result to result of evaling input and print unexpected errors
+  def eval_input(input)
+    loop_eval(input)
+  rescue Exception => e
+    self.error_raised = true
+    print_eval_error(e)
+  ensure
+    config[:line] += 1
+  end
+
+  # When extending this method, ensure your plugin disables readline:
+  # Readline.config[:readline] = false.
+  # @return [String, nil] Prints #prompt and returns input given by user
+  def get_input
+    print(prompt)
+    if input = $stdin.gets
+      input.chomp
+    else
+      nil
+    end
+  end
+
+  # @return [String]
+  def prompt
+    config[:prompt]
+  end
+
+  def read_history
+  end
+
+  def write_history
+  end
+
+  def history
+    @history ||= []
+  end
+
+  # Evals user input using @binding, @name and @line
+  def loop_eval(input)
+    config[:binding].eval(input, "(#{config[:name]})", config[:line])
+  end
+
+  # Prints error formatted by #format_error to STDERR. Could be extended to
+  # handle certain exceptions.
+  # @param [Exception]
+  def print_eval_error(err)
+    warn format_error(err)
+  end
+
+  # Prints result using #format_result
+  def print_result(result)
+    puts(format_result(result)) unless error_raised
+  rescue StandardError, SyntaxError => e
+    warn "#{config[:name]}: Error while printing result:\n" \
+         "#{format_error(e)}"
+  end
+
+  # Formats errors raised by eval of user input
+  # @param [Exception]
+  # @return [String]
+  def format_error(e)
+    "#{e.class}: #{e.message}\n    #{e.backtrace.join("\n    ")}"
+  end
+
+  # @return [String] Formats result using result_prompt
+  def format_result(result)
+    config[:result_prompt] + result.inspect
+  end
+
+  # Called after shell finishes looping.
+  def after_loop
+    write_history
+    self
+  end
+end

data/lib/rib/core.rb

@@ -0,0 +1,5 @@
+
+require 'rib/core/completion'
+require 'rib/core/history_file'
+require 'rib/core/readline'
+require 'rib/core/underscore'

data/lib/rib/core/completion.rb

@@ -0,0 +1,22 @@
+
+require 'rib'
+require 'bond'
+
+module Rib::Completion
+  include Rib::Plugin
+  Shell.use(self)
+
+  def before_loop
+    return super if Completion.disabled?
+     config[:completion]                ||= {}
+     config[:completion][:eval_binding] ||= lambda{ config[:binding] }
+    (config[:completion][:gems]         ||= []).concat(ripl_plugins)
+    Bond.start(config[:completion])
+    super
+  end
+
+  private
+  def ripl_plugins
+    $LOADED_FEATURES.map{ |e| e[/ripl\/[^\/]+$/] }.compact
+  end
+end

data/lib/rib/core/history_file.rb

@@ -0,0 +1,38 @@
+
+require 'rib'
+require 'fileutils'
+
+module Rib::HistoryFile
+  include Rib::Plugin
+  Shell.use(self)
+
+  def before_loop
+    return super if HistoryFile.disabled?
+    config[:history_file] ||= '~/.config/rib/history.rb'
+    config[:history_size] ||= 500
+    FileUtils.mkdir_p(File.dirname(history_file))
+    super
+  end
+
+  def get_input
+    return super if HistoryFile.disabled?
+    (history << super).last
+  end
+
+  def read_history
+    return super if HistoryFile.disabled?
+    File.exist?(history_file) && history.empty? &&
+      File.readlines(history_file).each{ |e| history << e.chomp }
+  end
+
+  def write_history
+    return super if HistoryFile.disabled?
+    File.open(history_file, 'w'){ |f|
+      f.puts(history.to_a.last(config[:history_size]).join("\n")) }
+  end
+
+  private
+  def history_file
+    @history_file ||= File.expand_path(config[:history_file])
+  end
+end

data/lib/rib/core/readline.rb

@@ -0,0 +1,19 @@
+
+require 'rib'
+require 'readline'
+
+module Rib::Readline
+  include Rib::Plugin
+  Shell.use(self)
+
+  def before_loop
+    return super if Readline.disabled?
+    @history = ::Readline::HISTORY
+    super
+  end
+
+  def get_input
+    return super if Readline.disabled?
+    ::Readline.readline(prompt, true)
+  end
+end

data/lib/rib/core/underscore.rb

@@ -0,0 +1,53 @@
+
+require 'rib'
+
+module Rib::Underscore
+  include Rib::Plugin
+  Shell.use(self)
+
+  IVAR = {:_  => :@__rib_result__,
+          :__ => :@__rib_exception__}
+
+  def before_loop
+    return super if Underscore.disabled?
+    eliminate_warnings
+    inject_inspecter
+    super
+  end
+
+  def loop_eval input
+    return super if Underscore.disabled?
+    bound_object.instance_variable_set(:@__rib_result__, super)
+  end
+
+  def print_eval_error e
+    return super if Underscore.disabled?
+    bound_object.instance_variable_set(:@__rib_exception__, e)
+    super
+  end
+
+  private
+  def eliminate_warnings
+    IVAR.values.each{ |ivar| bound_object.instance_variable_set(ivar, nil) }
+  end
+
+  def inject_inspecter
+    IVAR.each{ |k, v|
+      bound_singleton.send(:define_method, k){
+        instance_variable_get(v)
+      } unless bound_object.respond_to?(k) # only inject for innocences
+    }
+  end
+
+  def bound_singleton
+    if respond_to?(:singleton_class)
+      bound_object.singleton_class
+    else
+      class << bound_object; self; end
+    end
+  end
+
+  def bound_object
+    config[:binding].eval('self')
+  end
+end

data/lib/rib/debug.rb

@@ -0,0 +1,3 @@
+
+require 'rib/zore/anchor'
+Rib::Anchor.disable

data/lib/rib/more.rb

@@ -0,0 +1,12 @@
+
+# upon session ends
+require 'rib/more/squeeze_history'
+require 'rib/more/multiline_history_file'
+
+# upon formatting output
+require 'rib/more/strip_backtrace'
+require 'rib/more/color'
+
+# upon input
+require 'rib/more/multiline'
+require 'rib/more/multiline_history'

data/lib/rib/more/color.rb

@@ -0,0 +1,98 @@
+
+require 'rib'
+
+module Rib::Color
+  include Rib::Plugin
+  Shell.use(self)
+
+  def before_loop
+    config[:color] ||= {
+      Numeric    => :red    ,
+      String     => :green  ,
+      Symbol     => :cyan   ,
+      Array      => :blue   ,
+      Hash       => :blue   ,
+      NilClass   => :magenta,
+      TrueClass  => :magenta,
+      FalseClass => :magenta,
+      Exception  => :magenta,
+      Object     => :yellow
+    }
+    super
+  end
+
+  def format_result result
+    return super if Color.disabled?
+    config[:result_prompt] + format_color(result)
+  end
+
+  private
+  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 Array  ; P.send(colors[Array  ]){ '['     }   +
+                      result.map{ |e   | format_color(e) }.
+               join(P.send(colors[Array  ]){ ', '    })  +
+                    P.send(colors[Array  ]){ ']'     }
+
+      when Hash   ; P.send(colors[Hash   ]){ '{'     }   +
+                      result.map{ |k, v| format_color(k) +
+                    P.send(colors[Hash   ]){ '=>'    }   +
+                                         format_color(v) }.
+               join(P.send(colors[Hash   ]){ ', '    }) +
+                    P.send(colors[Hash   ]){ '}'     }
+
+      else        ; if color = P.find_color(colors, result)
+                    P.send(color){ display }
+                    else
+                    P.send(colors[Object      ]){ display }
+                    end
+    end
+  end
+
+  def get_error e, backtrace=e.backtrace
+    return super if Color.disabled?
+    [format_color(e, "#{e.class.to_s}: #{e.message}"),
+     backtrace.map{ |b|
+       path, rest = ::File.split(b)
+       name, msgs = rest.split(':', 2)
+       msg = msgs.sub(/(\d+):/){P.red{$1}+':'}.sub(/`.+?'/){P.green{$&}}
+
+       "#{path+'/'}#{P.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
+  end
+
+  Plugin.extend(Imp)
+end

data/lib/rib/more/multiline.rb

@@ -0,0 +1,77 @@
+
+require 'rib'
+
+# from https://github.com/janlelis/ripl-multi_line
+module Rib::Multiline
+  include Rib::Plugin
+  Shell.use(self)
+
+  # test those:
+  # ruby -e '"'
+  # ruby -e '{'
+  # ruby -e '['
+  # ruby -e '('
+  # ruby -e '/'
+  # ruby -e 'class C'
+  # ruby -e 'def f'
+  # ruby -e 'begin'
+  ERROR_REGEXP = Regexp.new(
+    [ # string or regexp
+      "unterminated \\w+ meets end of file",
+      # mri and rubinius
+      "syntax error, unexpected \\$end",
+      # rubinius
+      "expecting '.+'( or '.+')*",
+      # jruby
+      "syntax error, unexpected end-of-file",
+    ].join('|'))
+
+  def prompt
+    return super if Multiline.disabled?
+    if multiline_buffer.empty?
+      super
+    else
+      "#{' '*(config[:prompt].size-2)}| "
+    end
+  end
+
+  def loop_once
+    return super if Multiline.disabled?
+    catch(:multiline_cont) do
+      super
+      multiline_buffer.clear
+    end
+  end
+
+  def loop_eval(input)
+    return super if Multiline.disabled?
+    multiline_buffer << input
+    super(multiline_buffer.join("\n"))
+  end
+
+  def print_eval_error(e)
+    return super if Multiline.disabled?
+    if e.is_a?(SyntaxError) && e.message =~ ERROR_REGEXP
+      throw :multiline_cont
+    else
+      super
+    end
+  end
+
+  def handle_interrupt
+    return super if Multiline.disabled?
+    if multiline_buffer.empty?
+      super
+    else
+      line = multiline_buffer.pop
+      print "[removed this line: #{line}]"
+      super
+      throw :multiline_cont
+    end
+  end
+
+  private
+  def multiline_buffer
+    @multiline_buffer ||= []
+  end
+end