irbtools 1.7.1 → 2.0.0

data/lib/irbtools.rb

@@ -1,118 +1,66 @@
-# encoding: utf-8
-
-if defined?(IRB) || defined?(Ripl)
-  # # # # #
-  # require 'irbtools' in your .irbrc
-  # see the README file for more information
-  require_relative 'irbtools/configure' unless defined? Irbtools
-
-  # # # # #
-  # load extension packages
-  Irbtools.packages.each{ |pkg|
-    begin
-      require "irbtools/#{pkg}"
-
-    rescue LoadError => err
-      warn "Couldn't load the extension package '#{pkg}' #{err.class}\n* " +
-            err.message + "\n* " + err.backtrace[0] + "\n"
-    end
-  }
-
-  # # # # #
-  # loading helper proc
-  load_libraries_proc = proc{ |libs|
-    remember_verbose_and_debug = $VERBOSE, $DEBUG
-    $VERBOSE = $DEBUG = false
-
-    libs.each{ |lib|
-      begin
-        require lib.to_s
-        Irbtools.send :library_loaded, lib
-      rescue Exception => err
-        warn "Couldn't load the irb library '#{lib}': #{err.class}\n* " +
-             err.message + "\n* " + err.backtrace[0] + "\n"
-      end
-    }
-    $VERBOSE, $DEBUG = remember_verbose_and_debug
-  }
-
-  # # # # #
-  # load: start
-  load_libraries_proc[ Irbtools.libraries[:start] ]
-
-  # # # # #
-  # load: autoload
-  Irbtools.libraries[:autoload].each{ |constant, lib_name, gem_name|
-    gem gem_name
-    autoload constant, lib_name
-    Irbtools.send :library_loaded, lib_name
-  }
-
-  # # # # #
-  # irb options
-  unless defined?(Ripl) && Ripl.respond_to?(:started?) && Ripl.started?
-    IRB.conf[:AUTO_INDENT]  = true                 # simple auto indent
-    IRB.conf[:EVAL_HISTORY] = 42424242424242424242 # creates the special __ variable
-    IRB.conf[:SAVE_HISTORY] = 2000                 # how many lines will go to ~/.irb_history
-
-    # prompt
-    (IRB.conf[:PROMPT] ||= {} ).merge!( {:IRBTOOLS => {
-      :PROMPT_I => ">> ",    # normal
-      :PROMPT_N => "|  ",    # indenting
-      :PROMPT_C => " > ",    # continuing a statement
-      :PROMPT_S => "%l> ",   # continuing a string
-      :RETURN   => "=> %s \n",
-      :AUTO_INDENT => true,
-    }})
-
-    IRB.conf[:PROMPT_MODE] = :IRBTOOLS
+require_relative 'irbtools/configure'
+
+# # # # #
+# Load irbtools extension packages
+Irbtools.load_packages
+
+# # # # #
+# Load: start
+Irbtools.load_libraries(Irbtools.libraries[:start])
+
+# # # # #
+# Load: autoload
+Irbtools.libraries[:autoload].each{ |constant, lib_name, gem_name|
+  gem(gem_name)
+  autoload(constant, lib_name)
+  Irbtools.library_loaded(lib_name)
+}
+
+# # # # #
+# Misc: Apply IRB options
+Irbtools.configure_irb!
+
+# # # # #
+# Load: sub-session / after_rc
+if Irbtools.ripl?
+  if defined? Ripl::AfterRc
+    Irbtools.libraries[:sub_session].each{ |r| Ripl.after_rcs << r }
+  elsif !Irbtools.libraries[:sub_session].empty?
+    warn "Couldn't load libraries in Irbtools.libraries[:sub_session]. Please install ripl-after_rc to use this feature in Ripl!"
   end
+else
+  original_irbrc_proc = IRB.conf[:IRB_RC]
+  IRB.conf[:IRB_RC] = proc{
+    Irbtools.load_libraries(Irbtools.libraries[:sub_session])
+    original_irbrc_proc.call if original_irbrc_proc
+  }
+end
 
-  # # # # #
-  # misc: add current directory to the load path
-  $: << '.'  if RUBY_VERSION >= '1.9.2'
-
-  # # # # #
-  # load: sub-session / after_rc
-  if defined?(Ripl) && Ripl.respond_to?(:started?) && Ripl.started?
-    if defined? Ripl::AfterRc
-      Irbtools.libraries[:sub_session].each{ |r| Ripl.after_rcs << r }
-    elsif !Irbtools.libraries[:sub_session].empty?
-      warn "Couldn't load libraries in Irbtools.libraries[:sub_session]. Please install ripl-after_rc to use this feature in Ripl!"
-    end
-  else
-    original_irbrc_proc = IRB.conf[:IRB_RC]
-    IRB.conf[:IRB_RC] = proc{
-      load_libraries_proc[ Irbtools.libraries[:sub_session] ]
-      original_irbrc_proc[ ]  if original_irbrc_proc
-    }
+# # # # #
+# Load: threads
+threads = []
+Irbtools.libraries[:thread].each{ |_,libs|
+  threads << Thread.new do
+    Irbtools.load_libraries(libs)
   end
+}
 
-  # # # # #
-  # load: threads
-  Irbtools.libraries[:thread].each{ |_,libs|
-    Thread.new do
-      load_libraries_proc[ libs ]
-    end
-  }
-
-  # # # # #
-  # load: late
-  load_libraries_proc[ Irbtools.libraries[:late] ]
+threads.map(&:join)
 
-  # # # # #
-  # load: late_threads
-  Irbtools.libraries[:late_thread].each{ |_,libs|
-    Thread.new do
-      load_libraries_proc[ libs ]
-    end
-  }
+# # # # #
+# Load: late
+Irbtools.load_libraries(Irbtools.libraries[:late])
 
-  # # # # #
-  # done :)
-  if msg = Irbtools.welcome_message
-    puts msg
+# # # # #
+# Load: late_threads
+Irbtools.libraries[:late_thread].each{ |_,libs|
+  Thread.new do
+    Irbtools.load_libraries(libs)
   end
-end
+}
 
-# J-_-L
+# # # # #
+# Done
+if msg = Irbtools.welcome_message
+  puts msg
+end

data/lib/irbtools/binding.rb

@@ -0,0 +1,19 @@
+require 'binding.repl'
+BindingRepl.auto = %w[irb ripl ir rib pry]
+
+class Binding
+  alias irb repl!
+end
+
+begin
+  require 'binding_of_caller'
+rescue LoadError
+end
+
+if defined? BindingOfCaller
+  require 'debugging/repl'
+
+  module Debugging
+    alias irb repl
+  end
+end

data/lib/irbtools/configure.rb

@@ -1,137 +1,4 @@
-# encoding: utf-8
-
-# # # # #
-# require 'irbtools' in your .irbrc
-# but you could also require 'irbtools/configure' and then call Irbtools.init to modify the loaded libraries
-# see the README file for more information
-
-# # # # #
-# define module methods
-module Irbtools
-  VERSION = "1.7.1"
-
-  @libraries       = { :start => [], :sub_session => [], :autoload => [], :thread => {}, :late => [], :late_thread => {} }
-  @lib_hooks       = Hash.new{|h,k| h[k] = [] }
-  @packages        = []
-  @shell_name      = File.split($0)[-1].upcase
-  @welcome_message = "Welcome to #{ @shell_name }. You are using #{ RUBY_DESCRIPTION }. Have fun ;)"
-  @minimal         ||= false
-
-  class << self
-    # message to display when starting. Set to nil to disable
-    attr_accessor :welcome_message
-
-    # shell name (usually irb), retrieved from $0
-    attr_reader :shell_name
-
-    # set this to true before loading this file to deactivate loading of default libraries
-    attr_accessor :minimal
-
-    # a hash of arrays of libraries that get loaded
-    # keys determine if lib is required, required on sub-session or autoloaded
-    attr_accessor :libraries
-    alias libs libraries
-    alias libs= libraries=
-    alias gems libraries
-    alias gems= libraries=
-
-    # an array of extension packages that get loaded (e.g. irbtools-more)
-    attr_accessor :packages
-
-    # add a library. the block gets executed, when the library was loaded.
-    # if the second param is true, it's hooked in into IRB.conf[:IRB_RC] instead of the start.
-    def add_library(lib, options = {}, &block)
-      lib = lib.to_s
-
-      if constant = options[:autoload]
-        lib_path = File.split( lib ); lib_path.delete('.')
-        gem_name = lib_path[0] # assume that first dir in load dir is the gem name
-        if constant.is_a?(Array)
-          constant.each{ |single_constant|
-            @libraries[:autoload] << [single_constant, lib, gem_name]
-          }
-        else
-          @libraries[:autoload] << [constant, lib, gem_name]
-        end
-      elsif options[:after_rc]
-        @libraries[:after_rc] << lib
-      elsif which = options[:thread]
-        @libraries[:thread][which] ||= []
-        @libraries[:thread][which] << lib
-      elsif options[:late]
-        @libraries[:late] << lib
-      elsif which = options[:late_thread]
-        @libraries[:late_thread][which] ||= []
-        @libraries[:late_thread][which] << lib
-      else
-        @libraries[:start] << lib
-      end
-
-      add_library_callback(lib, &block) if block_given?
-    end
-    alias add_lib add_library
-    alias add_gem add_library
-
-    # add a callback that gets (usually) executed after loading the library
-    def add_library_callback(lib, &block)
-      lib = lib.to_s
-      @lib_hooks[lib] << block
-    end
-    alias add_lib_callback add_library_callback
-    alias add_gem_callback add_library_callback
-
-    # replace all callbacks with the new one given in the block
-    # a callback that gets (usually) executed after loading the library
-    def replace_library_callback(lib, &block)
-      lib = lib.to_s
-      @lib_hooks[lib].clear
-      @lib_hooks[lib] << block
-    end
-    alias replace_lib_callback replace_library_callback
-    alias replace_gem_callback replace_library_callback
-
-    # don't load a specific library
-    def remove_library(lib)
-      lib = lib.to_s
-
-      @libraries[:start].delete lib
-      @libraries[:sub_session].delete lib
-      @libraries[:autoload].reject!{|_,e,| e == lib }
-      @libraries[:thread].each{ |_,libs| libs.delete lib }
-      @libraries[:late].delete lib
-      @libraries[:late_thread].each{ |_,libs| libs.delete lib }
-
-      @lib_hooks.delete lib
-    end
-    alias remove_lib remove_library
-    alias remove_gem remove_library
-
-    # add extensions packages
-    def add_package(pkg)
-      @packages << pkg.to_s
-    end
-
-    # remove extension package
-    def remove_package(pkg)
-      @packages.delete pkg.to_s
-    end
-
-    def library_loaded(lib) #:nodoc:
-      @lib_hooks[lib.to_s].each{ |hook| hook.call }
-    end
-    private :library_loaded
-
-    # loads all the stuff ;)
-    def init
-      require File.expand_path( '../irbtools.rb', File.dirname(__FILE__) )
-    end
-    alias start init
-  end
-end
-
-# # # # #
-# libraries
-require File.expand_path( 'libraries.rb', File.dirname(__FILE__) ) unless Irbtools.minimal
-
-# J-_-L
+require_relative 'version'
 
+require_relative 'implementation'
+require_relative 'libraries' unless Irbtools.minimal

data/lib/irbtools/hirb.rb

@@ -0,0 +1,46 @@
+Irbtools.add_library :hirb, thread: :paint do
+  Hirb::View.enable output: { "Object" => { ancestor: true, options: { unicode: true }}},
+                    pager_command: 'less -R'
+  extend Hirb::Console
+
+  def page(what, options = {})
+    Hirb::Pager.command_pager(what, options = {})
+  end
+
+  # page wirb output hacks
+  class Hirb::Pager
+    alias original_activated_by? activated_by?
+    def activated_by?(string_to_page, inspect_mode=false)
+      original_activated_by?(Paint.unpaint(string_to_page || ''), inspect_mode)
+    end
+  end
+
+  class << Hirb::View
+    def view_or_page_output(val)
+      if defined?(val.inspect)
+        unless view_output(val)
+          if defined?(Wirb) && Wirb.running?
+            page_output Wirb.colorize_result_with_timeout(val.inspect), true
+          else
+            page_output val.inspect, true
+          end
+        end
+      end
+    end
+  end
+
+  # colorful border
+  table_color = :yellow
+  Hirb::Helpers::UnicodeTable::CHARS.each do |place, group|
+    Hirb::Helpers::UnicodeTable::CHARS[place] =
+    group.each do |name, part|
+      if part.kind_of? String
+        Hirb::Helpers::UnicodeTable::CHARS[place][name] = Paint[part, *table_color]
+      elsif part.kind_of? Hash
+        part.each do |special, char|
+          Hirb::Helpers::UnicodeTable::CHARS[place][name][special] = Paint[char, *table_color]
+        end
+      end
+    end
+  end
+end

data/lib/irbtools/implementation.rb

@@ -0,0 +1,156 @@
+module Irbtools
+  @libraries       = { :start => [], :sub_session => [], :autoload => [], :thread => {}, :late => [], :late_thread => {} }
+  @lib_hooks       = Hash.new{|h,k| h[k] = [] }
+  @packages        = []
+  @shell_name      = File.split($0)[-1].upcase
+  @welcome_message = "Welcome to #{ @shell_name }. You are using #{ RUBY_DESCRIPTION }. Have fun ;)"
+  @minimal         ||= false
+
+  class << self
+    # message to display when starting. Set to nil to disable
+    attr_accessor :welcome_message
+
+    # shell name (usually irb), retrieved from $0
+    attr_reader :shell_name
+
+    # set this to true before loading this file to deactivate loading of default libraries
+    attr_accessor :minimal
+
+    # a hash of arrays of libraries that get loaded
+    # keys determine if lib is required, required on sub-session or autoloaded
+    attr_accessor :libraries
+
+    # an array of extension packages that get loaded (e.g. irbtools-more)
+    attr_accessor :packages
+
+    # add a library. the block gets executed, when the library was loaded.
+    # if the second param is true, it's hooked in into IRB.conf[:IRB_RC] instead of the start.
+    def add_library(lib, options = {}, &block)
+      lib = lib.to_s
+
+      if constant = options[:autoload]
+        lib_path = File.split( lib ); lib_path.delete('.')
+        gem_name = lib_path[0] # assume that first dir in load dir is the gem name
+        if constant.is_a?(Array)
+          constant.each{ |single_constant|
+            @libraries[:autoload] << [single_constant, lib, gem_name]
+          }
+        else
+          @libraries[:autoload] << [constant, lib, gem_name]
+        end
+      elsif options[:after_rc]
+        @libraries[:after_rc] << lib
+      elsif which = options[:thread]
+        @libraries[:thread][which] ||= []
+        @libraries[:thread][which] << lib
+      elsif options[:late]
+        @libraries[:late] << lib
+      elsif which = options[:late_thread]
+        @libraries[:late_thread][which] ||= []
+        @libraries[:late_thread][which] << lib
+      else
+        @libraries[:start] << lib
+      end
+
+      add_library_callback(lib, &block) if block_given?
+    end
+
+    # add a callback that gets (usually) executed after loading the library
+    def add_library_callback(lib, &block)
+      lib = lib.to_s
+      @lib_hooks[lib] << block
+    end
+
+    # replace all callbacks with the new one given in the block
+    # a callback that gets (usually) executed after loading the library
+    def replace_library_callback(lib, &block)
+      lib = lib.to_s
+      @lib_hooks[lib].clear
+      @lib_hooks[lib] << block
+    end
+
+    # don't load a specific library
+    def remove_library(lib)
+      lib = lib.to_s
+
+      @libraries[:start].delete lib
+      @libraries[:sub_session].delete lib
+      @libraries[:autoload].reject!{|_,e,| e == lib }
+      @libraries[:thread].each{ |_,libs| libs.delete lib }
+      @libraries[:late].delete lib
+      @libraries[:late_thread].each{ |_,libs| libs.delete lib }
+
+      @lib_hooks.delete lib
+    end
+
+    # add extensions packages
+    def add_package(pkg)
+      @packages << pkg.to_s
+    end
+
+    # remove extension package
+    def remove_package(pkg)
+      @packages.delete pkg.to_s
+    end
+
+    # actually require registered packages
+    def load_packages
+      @packages.each{ |pkg|
+        require "irbtools/#{pkg}"
+      }
+    end
+
+    # te be triggered when a library has loaded
+    def library_loaded(lib)
+      @lib_hooks[lib.to_s].each{ |hook| hook.call }
+    end
+
+    # actually load libraries
+    def load_libraries(libs)
+      remember_verbose_and_debug = $VERBOSE, $DEBUG
+      $VERBOSE = $DEBUG = false
+
+      libs.each{ |lib|
+        begin
+          require lib.to_s
+          library_loaded(lib)
+        rescue Exception => err
+          warn "Error while loading a library into IRB:\n\n### #{err.class}\n" +
+               err.message + "\n\n### STACKTRACE\n  " + err.backtrace*"\n  " + "\n\n\n"
+        end
+      }
+      $VERBOSE, $DEBUG = remember_verbose_and_debug
+    end
+
+    # configure irb
+    def configure_irb!
+      if defined?(IRB)
+        IRB.conf[:AUTO_INDENT]  = true                 # simple auto indent
+        IRB.conf[:EVAL_HISTORY] = 42424242424242424242 # creates the special __ variable
+        IRB.conf[:SAVE_HISTORY] = 2000                 # how many lines will go to ~/.irb_history
+
+        # prompt
+        (IRB.conf[:PROMPT] ||= {} ).merge!( {:IRBTOOLS => {
+          :PROMPT_I => ">> ",    # normal
+          :PROMPT_N => "|  ",    # indenting
+          :PROMPT_C => " > ",    # continuing a statement
+          :PROMPT_S => "%l> ",   # continuing a string
+          :RETURN   => "=> %s \n",
+          :AUTO_INDENT => true,
+        }})
+
+        IRB.conf[:PROMPT_MODE] = :IRBTOOLS
+      end
+    end
+
+    # check if we are in a RIPL session
+    def ripl?
+      defined?(Ripl) && Ripl.started?
+    end
+
+    # loads all the stuff
+    def start
+      require 'irbtools'
+    end
+  end
+end