rib 0.0.1 → 0.1.0

data/lib/rib/more/multiline_history.rb

@@ -0,0 +1,31 @@
+
+require 'rib/more/multiline' # dependency
+
+module Rib::MultilineHistory
+  include Rib::Plugin
+  Shell.use(self)
+
+  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
+  end
+
+  def handle_interrupt
+    return super if MultilineHistory.disabled?
+    if multiline_buffer.size > 1
+      @multiline_trash ||= 0
+      @multiline_trash  += 1
+    end
+    super
+  end
+end

data/lib/rib/more/multiline_history_file.rb

@@ -0,0 +1,37 @@
+
+require 'rib/more/multiline_history'
+
+module Rib::MultilineHistoryFile
+  include Rib::Plugin
+  Shell.use(self)
+
+  def before_loop
+    return super if MultilineHistoryFile.disabled?
+    config[:multiline_history_file_token] ||= ' '
+    super
+  end
+
+  def read_history
+    return super if MultilineHistoryFile.disabled?
+    buffer = []
+    File.exist?(history_file) && history.empty? &&
+      IO.readlines(history_file).each{ |line|
+        if line.end_with?(
+             "#{config[:multiline_history_file_token]}\n")
+          buffer << line[0...
+               -config[:multiline_history_file_token].size-1] + "\n"
+        else
+          history << (buffer.join + line).chomp
+          buffer = []
+        end
+      }
+  end
+
+  def write_history
+    return super if MultilineHistoryFile.disabled?
+    @history = history.to_a.map{ |line|
+      line.gsub("\n", "#{config[:multiline_history_file_token]}\n")
+    }
+    super
+  end
+end

data/lib/rib/more/squeeze_history.rb

@@ -0,0 +1,37 @@
+
+require 'rib/core/history_file'
+
+module Rib::SqueezeHistory
+  include Rib::Plugin
+  Shell.use(self)
+
+  # squeeze history on memory too
+  def eval_input input
+    return super if SqueezeHistory.disabled?
+    history.pop if input.strip == '' ||
+                  (history.size > 1 && input == history.to_a[-2])
+                  # EditLine is really broken, to_a is needed for it
+    super
+  end
+
+  # write squeezed history
+  def write_history
+    return super if SqueezeHistory.disabled?
+    @history = P.squeeze_history(history)
+    super
+  end
+
+  module Imp
+    def squeeze_history history
+      history.to_a.inject([]){ |result, item|
+        if result.last == item || item.strip == ''
+          result
+        else
+          result << item
+        end
+      }
+    end
+  end
+
+  Plugin.extend(Imp)
+end

data/lib/rib/more/strip_backtrace.rb

@@ -0,0 +1,43 @@
+
+require 'rib'
+
+module Rib::StripBacktrace
+  include Rib::Plugin
+  Shell.use(self)
+
+  # strip backtrace until ripl
+  def format_error e
+    return super if StripBacktrace.disabled?
+    message, backtrace = get_error(e, P.strip_backtrace(e, config[:name]))
+    "#{message}\n  #{backtrace.join("\n  ")}"
+  end
+
+  def get_error e, backtrace=e.backtrace
+    return super if StripBacktrace.disabled?
+    ["#{e.class}: #{e.message}", backtrace]
+  end
+
+  private
+  module Imp
+    def strip_backtrace e, name
+      home(cwd(snip(e, name)))
+    end
+
+    def home b
+      b.map{ |p| p.sub(ENV['HOME'], '~') }
+    end
+
+    def cwd b
+      b.map{ |p| p.sub(Dir.pwd, '.') }
+    end
+
+    def snip e, name
+      return [] if e.kind_of?(SyntaxError)
+      e.backtrace[
+        0..
+        e.backtrace.rindex{ |l| l =~ /\(#{name}\):\d+:in `.+?'/ } || -1]
+    end
+  end
+
+  Plugin.extend(Imp)
+end

data/lib/rib/plugin.rb

@@ -0,0 +1,56 @@
+
+module Rib; end
+module Rib::Plugin
+  Rib::P = self
+
+  def self.included mod
+    mod.send(:include, Rib)
+
+    class << mod
+      attr_accessor :disabled
+
+      def enable
+        self.disabled = false
+        if block_given? then yield else enabled? end
+      end
+
+      def disable
+        self.disabled = true
+        if block_given? then yield else enabled? end
+      end
+
+      def enabled?
+        !disabled
+      end
+
+      def disabled?
+        !!disabled
+      end
+    end
+
+    snake_name = mod.name[/::\w+$/].tr(':', ''). # remove namespaces
+                     gsub(/([A-Z][a-z]*)/, '\\1_').downcase[0..-2]
+
+    code = (%w[enable disable].map{ |meth|
+      <<-RUBY
+        def #{meth}_#{snake_name} &block
+          #{mod.name}.#{meth}(&block)
+        end
+      RUBY
+    } + %w[enabled? disabled?].map{ |meth|
+      <<-RUBY
+        def #{snake_name}_#{meth} &block
+          #{mod.name}.#{meth}(&block)
+        end
+      RUBY
+    }).join("\n")
+
+    meta_rib = if respond_to?(:singleton_class)
+                 Rib.singleton_class
+               else
+                 class << Rib; self; end
+               end
+
+    meta_rib.module_eval(code, __FILE__, __LINE__)
+  end
+end

data/lib/rib/runner.rb

@@ -0,0 +1,106 @@
+
+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'                                      ,
+
+     '-d, --debug'           =>
+       'Set debugging flags (set $DEBUG 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)'              ,
+
+     '-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'                       }
+  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
+  end
+
+  def start *argv
+    unused = parse(argv.dup)
+    warn "#{name}: Unused arguments: #{unused.inspect}" unless unused.empty?
+    Rib.shell.loop
+  end
+
+  def parse argv
+    unused = []
+    until argv.empty?
+      case arg = argv.shift
+      when /-e=?(.*)/, /--eval=?(.*)/
+        eval($1 || argv.shift, __FILE__, __LINE__)
+
+      when '-d', '--debug'
+        $DEBUG = true
+
+      when '-w', '--warn'
+        $-w = true
+
+      when /-I=?(.*)/, /--include=?(.*)/
+        paths = ($1 || argv.shift).split(':')
+        $LOAD_PATH.unshift(*paths)
+
+      when /-r=?(.*)/, /--require=?(.*)/
+        require($1 || argv.shift)
+
+      when /-c=?(.*)/, /--config=?(.*)/
+        Rib.config[:config] = $1 || argv.shift
+
+      when '-n', '--no-config'
+        Rib.config.delete(:config)
+
+      when '-h', '--help'
+        puts(help)
+        exit
+
+      when '-v', '--version'
+        require 'rib/version'
+        puts(Rib::VERSION)
+        exit
+
+      else
+        unused << arg
+      end
+    end
+    unused
+  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")
+  end
+end

data/lib/rib/shell.rb

@@ -0,0 +1,43 @@
+
+require 'rib/plugin'
+require 'rib/api'
+
+class Rib::Shell
+  include Rib::API
+  trap('INT'){ raise Interrupt }
+
+  def self.use mod
+    include mod
+  end
+
+  attr_reader :config
+  def initialize(config={})
+    self.config = {
+      :name          => 'rib'                    ,
+      :result_prompt => '=> '                    ,
+      :prompt        => '>> '                    ,
+      :binding       => TOPLEVEL_BINDING         ,
+      :exit          => [nil, 'exit', 'quit']    ,
+      :line          => 1
+    }.merge(config)
+  end
+
+  # Loops shell until user exits
+  def loop
+    before_loop
+    @running = true
+    in_loop
+    self
+  ensure
+    @running = false
+    after_loop
+  end
+
+  def running?
+    !!@running
+  end
+
+  protected
+  attr_writer :config
+  attr_accessor :error_raised
+end

data/lib/rib/test.rb

@@ -0,0 +1,25 @@
+
+require 'bacon'
+require 'rr'
+require 'fileutils'
+Bacon.summary_on_exit
+include RR::Adapters::RRMethods
+
+require 'rib'
+
+shared :rib do
+  before do
+    Rib.disable_plugins
+  end
+
+  after do
+    RR.verify
+    Rib.enable_plugins
+  end
+end
+
+module Kernel
+  def eq? rhs
+    self == rhs
+  end
+end

data/lib/rib/version.rb

@@ -0,0 +1,4 @@
+
+module Rib
+  VERSION = '0.1.0'
+end

data/lib/rib/zore.rb

@@ -0,0 +1,3 @@
+
+require 'rib/zore/anchor'
+require 'rib/zore/edit'

data/lib/rib/zore/anchor.rb

@@ -0,0 +1,69 @@
+
+require 'rib'
+
+module Rib::Anchor
+  include Rib::Plugin
+  Shell.use(self)
+
+  def loop_eval(str)
+    case obj_or_binding = (Rib.vars[:anchor] ||= []).last
+      when NilClass
+        super
+
+      when Binding
+        @binding = obj_or_binding
+        super
+
+      else
+        obj_or_binding.instance_eval(str, "(#{config[:name]})", config[:line])
+    end
+  end
+
+  def prompt
+    if Rib.const_defined?(:Color) && kind_of?(Rib::Color) &&
+       obj_or_binding = (Rib.vars[:anchor] ||= []).last
+
+      super.sub(config[:name], format_color(obj_or_binding, config[:name]))
+    else
+      super
+    end
+  end
+
+  # if the object is the same, then we're exiting from an anchor,
+  # so don't print anything.
+  def print_result result
+    super unless !result.nil? &&
+                 result.object_id == Rib.vars[:anchor_last].object_id
+  end
+
+  module Imp
+    def short_inspect obj_or_binding
+      obj_or_binding.inspect[0..9]
+    end
+  end
+
+  module AnchorImp
+    def anchor obj_or_binding
+      return if Rib::Anchor.disabled?
+
+      (Rib.vars[:anchor] ||= []) << obj_or_binding
+      name = Rib::P.short_inspect(obj_or_binding)
+
+      Rib.shells <<
+        Rib::Shell.new(Rib.config.merge(
+          :name   => name,
+          :prompt => "#{name}(#{Rib.vars[:anchor].size})" +
+                     (Rib.config[:prompt] || '>> ')))
+
+      Rib.shell.loop
+
+    ensure
+      # stores to check if we're exiting from an anchor
+      Rib.vars[:anchor_last] = Rib.vars[:anchor].pop
+      Rib.shells.pop
+    end
+  end
+
+  Plugin.extend(Imp)
+  Rib   .extend(AnchorImp)
+end