rib 0.1.0 → 0.9.0

data/Rakefile

@@ -10,10 +10,12 @@ task 'gem:spec' do
     require 'rib/version'
     s.name        = 'rib'
     s.version     = Rib::VERSION
-    s.executables = [s.name]
 
-    %w[bond]    .each{ |g| s.add_runtime_dependency(g) }
-    %w[bacon rr].each{ |g| s.add_development_dependency(g) }
+    %w[].each{ |g| s.add_runtime_dependency(g) }
+    %w[bond
+       hirb
+       bacon
+       rr]  .each{ |g| s.add_development_dependency(g) }
   end
 
   Gemgem.write

data/TODO.md

@@ -0,0 +1,6 @@
+# Rib TODO
+
+* Runner tests
+* Documentation
+* Fix Rubinius weird Runtime BOOM error
+* Implement exception_spy

data/bin/rib-all

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'rib/runner'
+require 'rib/all'
+Rib::Runner.run(ARGV)

data/bin/rib-auto

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require 'rib/runner'
+# create the shell before app to prvent your bundler (if any) kicks in
+Rib.shell
+require 'rib/app/auto'
+# load the app
+Rib::Auto.load
+Rib::Runner.run(ARGV)

data/bin/rib-min

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'rib/runner'
+Rib.shells << Rib::Shell.new(Rib.config)
+Rib::Runner.run(ARGV)

data/bin/rib-rails

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require 'rib/runner'
+# create the shell before app to prvent your bundler (if any) kicks in
+Rib.shell
+require 'rib/app/rails'
+# load the app
+Rib::Rails.load
+Rib::Runner.run(ARGV)

data/bin/rib-ramaze

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require 'rib/runner'
+# create the shell before app to prvent your bundler (if any) kicks in
+Rib.shell
+require 'rib/app/ramaze'
+# load the app
+Rib::Ramaze.load
+Rib::Runner.run(ARGV)

data/lib/rib.rb

@@ -3,40 +3,104 @@ require 'rib/shell'
 
 module Rib
   module_function
+  # All default Rib configs, would be passed to Shell.new in Rib.shell,
+  # but calling Shell.new directly won't bring this in.
   def config
-    @config ||= {:config => '~/.config/rib/config.rb'}
+    @config ||= {:config => '~/.config/rib/config.rb', :name => 'rib'}
   end
 
+  # All shells in the memory
   def shells
     @shells ||= []
   end
 
+  # All shared variables for all shells
   def vars
     @vars   ||= {}
   end
 
+  # Convenient shell accessor, which would just give you current last shell
+  # or create one and load ~/.config/rib/config.rb if non has existed. If you
+  # need a clean shell which does not load rc file, use Shell.new instead.
   def shell
     shells.last || begin
-      require_rc
+      if config_path
+        require_config
+      else # for those who don't have a config, we use core plugins
+        require 'rib/core'
+      end
       (shells << Shell.new(config)).last
     end
   end
 
+  # All plugins which have been loaded into the memory regardless
+  # it's enabled or not.
   def plugins
     Shell.ancestors[1..-1].select{ |a| a < Plugin }
   end
 
+  # Convenient way to disable all plugins in the memory.
+  # This could also take a list of plugins and disable them.
   def disable_plugins plugs=plugins
     plugs.each(&:disable)
   end
 
+  # Convenient way to enable all plugins in the memory.
+  # This could also take a list of plugins and enable them.
   def enable_plugins plugs=plugins
     plugs.each(&:enable)
   end
 
-  def require_rc
-    config[:config] &&
-      File.exist?(rc = File.expand_path(config[:config])) &&
-      require(rc)
+  # Load (actually require) ~/.config/rib/config.rb if exists.
+  # This might emit warnings if there's some error while loading it.
+  def require_config
+    config_path && require(config_path)
+  rescue Exception => e
+    Rib.warn("Error loading #{config[:config]}\n" \
+             "  #{Rib::API.format_error(e)}")
+  end
+
+  # The config path where Rib tries to load upon Rib.shell
+  def config_path
+    return nil unless config[:config]
+    path = File.expand_path(config[:config])
+    if File.exist?(path)
+      path
+    else
+      nil
+    end
+  end
+
+  # Say (print to $stdout, with colors in the future, maybe)
+  # something by the name of Rib
+  def say *words
+    $stdout.puts(Rib.prepare(words))
+  end
+
+  # Warn (print to $stderr, with colors in the future, maybe)
+  # something by the name of Rib
+  def warn *words
+    $stderr.puts(Rib.prepare(words))
+  end
+
+  # Warn (print to $stderr, with colors in the future, maybe)
+  # something by the name of Rib and then exit(1)
+  def abort *words
+    warn(words)
+    exit(1)
+  end
+
+  def silence
+    w, v = $-w, $VERBOSE
+    $-w, $VERBOSE = false, false
+    yield
+  ensure
+    $-w, $VERBOSE = w, v
+  end
+
+  private
+  def self.prepare words
+    name = config[:name]
+    "#{name}: #{words.join("\n#{' '*(name.size+2)}")}"
   end
 end

data/lib/rib/all.rb

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

data/lib/rib/api.rb

@@ -1,46 +1,57 @@
 
 module Rib; end
 module Rib::API
+  extend self
+
+  # Called before shell starts looping
   def before_loop
-    read_history
     self
   end
 
+  # Called after shell finishes looping
+  def after_loop
+    self
+  end
+
+  # Handle interrupt (control-c)
+  def handle_interrupt; puts                ; end
+  # The prompt string of this shell
+  def prompt       ; config[:prompt]        ; end
+  # The result prompt string of this shell
+  def result_prompt; config[:result_prompt] ; end
+  # The name of this shell
+  def name         ; config[:name]          ; end
+  # The binding for evaluation
+  def eval_binding ; config[:binding]       ; end
+  # The line number for next evaluation
+  def line         ; config[:line]          ; end
+
+  # Main loop
   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
+  # Loop iteration: REPL
   def loop_once
-    self.error_raised = nil
-    input = get_input
+    input, result, err = get_input, nil, nil
     throw(:rib_exit, input) if config[:exit].include?(input)
-    if input.strip == ''
-      eval_input(input)
-    else
-      print_result(eval_input(input))
+    catch(:rib_skip) do
+      result, err = eval_input(input)
+      if err
+        print_eval_error(err)
+      elsif input.strip != ''
+        print_result(result)
+      else
+        # print nothing for blank input
+      end
     end
+    [result, err]
   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
+  # Get user input. This is most likely overrided in Readline plugin
   def get_input
     print(prompt)
     if input = $stdin.gets
@@ -50,56 +61,41 @@ module Rib::API
     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])
+  # Evaluate the input using #loop_eval and handle it
+  def eval_input input
+    [loop_eval(input), nil]
+  rescue Exception => e
+    [nil, e]
+  ensure
+    config[:line] += 1
   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)
+  # Evaluate user input with #eval_binding, name and line
+  def loop_eval input
+    eval_binding.eval(input, "(#{name})", line)
   end
 
-  # Prints result using #format_result
-  def print_result(result)
-    puts(format_result(result)) unless error_raised
+  # Print result using #format_result
+  def print_result result
+    puts(format_result(result))
   rescue StandardError, SyntaxError => e
-    warn "#{config[:name]}: Error while printing result:\n" \
-         "#{format_error(e)}"
+    Rib.warn("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    ")}"
+  # Print evaluated error using #format_error
+  def print_eval_error err
+    puts(format_error(err))
+  rescue StandardError, SyntaxError => e
+    Rib.warn("Error while printing error:\n  #{format_error(e)}")
   end
 
-  # @return [String] Formats result using result_prompt
-  def format_result(result)
-    config[:result_prompt] + result.inspect
+  # Format result using #result_prompt
+  def format_result result
+    result_prompt + result.inspect
   end
 
-  # Called after shell finishes looping.
-  def after_loop
-    write_history
-    self
+  # Format error raised in #loop_eval
+  def format_error err
+    "#{err.class}: #{err.message}\n    #{err.backtrace.join("\n    ")}"
   end
 end

data/lib/rib/app/auto.rb

@@ -0,0 +1,25 @@
+
+module Rib; end
+module Rib::Auto
+  module_function
+  def load
+    app, name = %w[ramaze rails].find{ |name|
+      require "rib/app/#{name}"
+      app = Rib.const_get(name.capitalize)
+      if app.send("#{name}?")
+        break app, name
+      end
+    }
+
+    if app
+      Rib.say("Found #{name.capitalize}, loading it...")
+      begin
+        app.load
+      rescue LoadError => e
+        Rib.warn("Is this a #{app} app?\n  #{e}")
+      end
+    else
+      Rib.warn("No app found")
+    end
+  end
+end

data/lib/rib/app/rails.rb

@@ -0,0 +1,41 @@
+
+module Rib; end
+module Rib::Rails
+  module_function
+  def load
+    load_rails
+  rescue LoadError => e
+    Rib.abort("Is this a Rails app?\n  #{e}")
+  end
+
+  def load_rails
+    require './config/boot'
+
+    if File.exist?('./config/application.rb')
+      Rib::Rails.load_rails3
+    else
+      Rib::Rails.load_rails2
+    end
+
+    puts("Loading #{::Rails.env} environment (Rails #{::Rails.version})")
+  end
+
+  def load_rails2
+    ['./config/environment',
+     'console_app'         ,
+     'console_with_helpers'].each{ |f| require f }
+  end
+
+  def load_rails3
+    ['./config/application',
+     'rails/console/app'   ,
+     'rails/console/helpers'].each{ |f| require f }
+
+    ::Rails.application.require_environment!
+  end
+
+  def rails?
+    File.exist?('./config/boot.rb')    &&
+    File.exist?('./config/environment.rb')
+  end
+end

data/lib/rib/app/ramaze.rb

@@ -0,0 +1,25 @@
+
+module Rib; end
+module Rib::Ramaze
+  module_function
+  def load
+    load_ramaze
+  rescue LoadError => e
+    Rib.abort("Is this a Ramaze app?\n  #{e}")
+  end
+
+  def load_ramaze
+    # try to produce consistent error message, and yet lazy loading ramaze
+    require './start' unless ramaze?
+
+    require 'ramaze'
+    ::Ramaze.options.started = true
+
+    require './start'
+    at_exit{ puts('Ramazement has ended, go in peace.') }
+  end
+
+  def ramaze?
+    File.exist?('./start.rb')
+  end
+end