utils 0.0.39 → 0.0.40

data/lib/utils/config/vim/autoload/rails.vim

@@ -4021,15 +4021,15 @@ function! s:BufAbbreviations()
       Rabbrev coo[ cookies
       Rabbrev fl[ flash
       Rabbrev rr( render
-      Rabbrev ra( render :action\ =>\ 
-      Rabbrev rc( render :controller\ =>\ 
-      Rabbrev rf( render :file\ =>\ 
-      Rabbrev ri( render :inline\ =>\ 
-      Rabbrev rj( render :json\ =>\ 
-      Rabbrev rl( render :layout\ =>\ 
-      Rabbrev rp( render :partial\ =>\ 
-      Rabbrev rt( render :text\ =>\ 
-      Rabbrev rx( render :xml\ =>\ 
+      Rabbrev ra( render :action\ =>\
+      Rabbrev rc( render :controller\ =>\
+      Rabbrev rf( render :file\ =>\
+      Rabbrev ri( render :inline\ =>\
+      Rabbrev rj( render :json\ =>\
+      Rabbrev rl( render :layout\ =>\
+      Rabbrev rp( render :partial\ =>\
+      Rabbrev rt( render :text\ =>\
+      Rabbrev rx( render :xml\ =>\
     endif
     if buffer.type_name('view','helper')
       Rabbrev dotiw distance_of_time_in_words
@@ -4037,8 +4037,8 @@ function! s:BufAbbreviations()
     endif
     if buffer.type_name('controller')
       Rabbrev re(  redirect_to
-      Rabbrev rea( redirect_to :action\ =>\ 
-      Rabbrev rec( redirect_to :controller\ =>\ 
+      Rabbrev rea( redirect_to :action\ =>\
+      Rabbrev rec( redirect_to :controller\ =>\
       Rabbrev rst( respond_to
     endif
     if buffer.type_name() ==# 'model' || buffer.type_name('model-arb')
@@ -4076,13 +4076,13 @@ function! s:BufAbbreviations()
       Rabbrev asre( assert_response
       Rabbrev art(  assert_redirected_to
     endif
-    Rabbrev :a    :action\ =>\ 
+    Rabbrev :a    :action\ =>\
     " hax
-    Rabbrev :c    :co________\ =>\ 
+    Rabbrev :c    :co________\ =>\
     inoreabbrev <buffer> <silent> :c <C-R>=<SID>TheCWord()<CR>
-    Rabbrev :i    :id\ =>\ 
-    Rabbrev :o    :object\ =>\ 
-    Rabbrev :p    :partial\ =>\ 
+    Rabbrev :i    :id\ =>\
+    Rabbrev :o    :object\ =>\
+    Rabbrev :p    :partial\ =>\
     Rabbrev logd( logger.debug
     Rabbrev logi( logger.info
     Rabbrev logw( logger.warn

data/lib/utils/editor.rb

@@ -6,15 +6,26 @@ module Utils
 
     module SourceLocationExtension
       def source_location
+        filename   = nil
+        linenumber = nil
         if respond_to?(:to_str)
           if (string = to_str) =~ FILE_LINENUMBER_REGEXP
-            [ $1, $2.to_i ]
+            filename = $1
+            linenumber = $2.to_i
+            [ $1, linenumber ]
           else
-            [ string, 1 ]
+            filename = string
           end
         else
-          [ to_s, 1 ]
+          filename = to_s
         end
+        array = linenumber ? [ filename, linenumber ] : [ filename, 1 ]
+        array.singleton_class.instance_eval do
+          define_method(:filename) { filename }
+          define_method(:linenumber) { linenumber }
+          define_method(:to_s) { [ filename, linenumber ].compact * ':' }
+        end
+        array
       end
     end
 
@@ -38,6 +49,7 @@ module Utils
     alias wait? wait
 
     def vim
+      vim_in_path = [`which gvim`, `which vim`].map(&:chomp).find(&:full?)
       @vim ||=
         case `uname -s`
         when /\Adarwin/i
@@ -46,10 +58,10 @@ module Utils
           then
             File.join(path, 'Contents/MacOS/Vim')
           else
-            'vim'
+            vim_in_path
           end
         else
-          'vim'
+          vim_in_path
         end
     end
 

data/lib/utils/file_xt.rb

@@ -1,5 +1,8 @@
+require 'dslkit/polite'
+
 module Utils
   module FileXt
+    extend DSLKit::Concern
     include File::Constants
 
     SEEK_SET = File::SEEK_SET
@@ -30,12 +33,6 @@ module Utils
       end
     end
 
-    def self.included(modul)
-      modul.instance_eval do
-        extend ClassMethods
-      end
-    end
-
     module ClassMethods
       def binary?(name)
         File.open(name, 'rb') { |f| f.binary? }

data/lib/utils/find.rb

@@ -1,42 +1,146 @@
+require 'pathname'
+
 module Utils
   module Find
-    #
-    # Calls the associated block with the name of every file and directory listed
-    # as arguments, then recursively on their subdirectories, and so on.
-    #
-    # See the +Find+ module documentation for an example.
-    #
-    def find(*paths) # :yield: path
-      paths.collect!{|d| d.dup}
-      while file = paths.shift
-        catch(:prune) do
-          yield file.dup.taint
-          next unless File.exist? file
+    class ConfigurableFinder
+      module PathExtension
+        attr_writer :finder
+
+        def file
+          tried = false
           begin
-            if File.stat(file).directory? then
-              d = Dir.open(file)
+            file = @finder.get_file(self)
+            if file
+              file.closed? and file.reopen
+            else
+              file = File.new(self)
+              @finder.add_file self, file
+            end
+            return file
+          rescue Errno::EMFILE
+            tried and raise
+            @finder.close_files
+            tried = true
+            retry
+          rescue Errno::ENOENT, Errno::EACCES
+            return
+          end
+        end
+
+        def pathname
+          Pathname.new(self)
+        end
+
+        def suffix
+          pathname.extname[1..-1]
+        end
+
+        def exist?
+          !!file
+        end
+
+        def stat
+          file and file.stat
+        end
+
+        def lstat
+          file and file.lstat
+        end
+      end
+
+      def initialize(opts = {})
+        @files = {}
+        opts[:suffix].full? { |s| @suffix = [*s] }
+        @follow_symlinks = opts.fetch(:follow_symlinks, false)
+      end
+
+      def include_suffix?(suffix)
+        @suffix.nil? || @suffix.include?(suffix)
+      end
+
+      def visit_file?(file)
+        suffix = File.extname(file).full?(:[], 1..-1) || ''
+        include_suffix?(suffix)
+      end
+
+      def prepare_file(file)
+        path = file.dup.taint
+        path.extend PathExtension
+        path.finder = self
+        path
+      end
+
+      def get_file(path)
+        @files[path]
+      end
+
+      def add_file(path, file)
+        @files[path] = file
+        self
+      end
+
+      def close_files
+        @files.each_value do |f|
+          f.closed? or f.close
+        end
+        nil
+      end
+
+      def stat(file)
+        @follow_symlinks ? file.stat : file.lstat
+      end
+
+      def find(*paths, &block)
+        block_given? or return enum_for(__method__, *paths)
+
+        paths.map! do |d|
+          File.exist?(d) or raise Errno::ENOENT
+          d.dup
+        end
+
+        while file = paths.shift
+          catch(:prune) do
+            file = prepare_file(file)
+            visit_file?(file) and yield file
+            begin
+              s = stat(file) or next
+            rescue Errno::ENOENT, Errno::EACCES, Errno::ENOTDIR, Errno::ELOOP, Errno::ENAMETOOLONG
+              next
+            end
+            if s.directory? then
               begin
-                for f in d
-                  next if f == "." or f == ".."
-                  if File::ALT_SEPARATOR and file =~ /^(?:[\/\\]|[A-Za-z]:[\/\\]?)$/ then
-                    f = file + f
-                  elsif file == "/" then
-                    f = "/" + f
-                  else
-                    f = File.join(file, f)
-                  end
-                  paths.unshift f.untaint
-                end
-              ensure
-                d.close
+                tried = false
+                fs = Dir.entries(file)
+              rescue Errno::EMFILE
+                tried and raise
+                close_files
+                tried = true
+                retry
+              rescue Errno::ENOENT, Errno::EACCES, Errno::ENOTDIR, Errno::ELOOP, Errno::ENAMETOOLONG
+                next
+              end
+              fs.sort!
+              fs.reverse_each do |f|
+                next if f == "." or f == ".."
+                f = File.join(file, f)
+                paths.unshift f.untaint
               end
             end
-          rescue Errno::ENOENT, Errno::EACCES
           end
         end
       end
     end
 
+    # Calls the associated block with the name of every file and directory
+    # listed as arguments, then recursively on their subdirectories, and so on.
+    #
+    # See the +Find+ module documentation for an example.
+    #
+    def find(*paths, &block) # :yield: path
+      paths, options = paths.extract_last_argument_options
+      ConfigurableFinder.new(options).find(*paths, &block)
+    end
+
     #
     # Skips the current file or directory, restarting the loop with the next
     # entry. If the current file is a directory, that directory will not be

data/lib/utils/finder.rb

@@ -36,8 +36,8 @@ class Utils::Finder
   end
 
   def attempt_match?(path)
-    stat = File.stat(path)
-    stat.symlink? and stat = File.lstat(path)
+    stat = path.stat
+    stat.symlink? and stat = path.lstat
     if @only_directory
       stat.directory?
     elsif @directory
@@ -54,10 +54,10 @@ class Utils::Finder
     pathes = []
     find(*@roots) do |filename|
       begin
-        bn, s = File.basename(filename), File.stat(filename)
+        bn, s = filename.pathname.basename, filename.stat
         if s.directory? && @config.discover.prune?(bn)
           $DEBUG and warn "Pruning #{filename.inspect}."
-          Utils::Find.prune
+          prune
         end
         if s.file? && @config.discover.skip?(bn)
           $DEBUG and warn "Skipping #{filename.inspect}."
@@ -73,7 +73,7 @@ class Utils::Finder
     @suffixes = @args['I'].ask_and_send(:split, /[\s,]+/).to_a
     pathes = pathes.map! do |path, dir, file|
       if @suffixes.full?
-        @suffixes.include?(File.extname(file)[1..-1]) or next
+        @suffixes.include?(path.suffix) or next
       end
       if do_match = attempt_match?(path) and $DEBUG
         warn "Attempt match of #{path.inspect}"

data/lib/utils/grepper.rb

@@ -6,6 +6,7 @@ class ::File
 end
 
 class Utils::Grepper
+  include Utils::Find
   include Utils::Patterns
   include Term::ANSIColor
 
@@ -71,9 +72,11 @@ class Utils::Grepper
     bn, s = File.basename(filename), File.stat(filename)
     if s.directory? && @config.search.prune?(bn)
       $DEBUG and warn "Pruning #{filename.inspect}."
-      Utils::Find.prune
+      prune
     end
-    if s.file? && !@config.search.skip?(bn) && (!@name_pattern || @name_pattern.match(bn))
+    if s.file? && !@config.search.skip?(bn) &&
+      (!@name_pattern || @name_pattern.match(bn))
+    then
       File.open(filename, 'rb') do |file|
         if file.binary? != true
           $DEBUG and warn "Matching #{filename.inspect}."
@@ -147,8 +150,8 @@ class Utils::Grepper
   def search
     @suffixes = @args['I'].ask_and_send(:split, /[\s,]+/).to_a
     for dir in @roots
-      Utils::Find.find(dir) do |filename|
-        if @suffixes.empty? || @suffixes.include?(File.extname(filename)[1..-1])
+      find(dir) do |filename|
+        if @suffixes.empty? || @suffixes.include?(filename.suffix)
           match(filename)
         end
       end

data/lib/utils/irb.rb

@@ -0,0 +1,507 @@
+require 'tins/xt'
+require 'irb/completion'
+require 'enumerator'
+require 'pp'
+require_maybe 'ap'
+if Readline.respond_to?(:point) && Readline.respond_to?(:line_buffer)
+  require 'pry-editline'
+end
+require 'utils'
+$editor = Utils::Editor.new
+$pager = ENV['PAGER'] || 'less -r'
+
+if IRB.conf[:PROMPT]
+  IRB.conf[:PROMPT][:CUSTOM] = {
+    :PROMPT_I =>  ">> ",
+    :PROMPT_N =>  ">> ",
+    :PROMPT_S =>  "%l> ",
+    :PROMPT_C =>  "+> ",
+    :RETURN   =>  " # => %s\n"
+  }
+  IRB.conf[:PROMPT_MODE] = :CUSTOM
+end
+
+module Utils
+  module IRB
+
+    module Shell
+      require 'fileutils'
+      include FileUtils
+      require 'utils/find'
+      include Utils::Find
+
+      # Start _ri_ for +pattern+. If +pattern+ is not string like, call it with
+      # pattern.class.name as argument.
+      def ri(*patterns)
+        patterns.map! { |p| p.respond_to?(:to_str) ? p.to_str : p.class.name }
+        system "ri #{patterns.map { |p| "'#{p}'" } * ' '} | #{$pager}"
+      end
+
+      # Restart this irb.
+      def irb_restart
+        exec $0
+      end
+
+      # Return all instance methods of obj's class.
+      def irb_all_class_instance_methods(obj)
+        methods = obj.class.instance_methods
+        irb_wrap_methods obj, methods
+      end
+
+      # Return instance methods of obj's class without the inherited/mixed in
+      # methods.
+      def irb_class_instance_methods(obj)
+        methods = obj.class.instance_methods(false)
+        irb_wrap_methods obj, methods
+      end
+
+      # Return all instance methods defined in module modul.
+      def irb_all_instance_methods(modul)
+        methods = modul.instance_methods
+        irb_wrap_methods modul, methods, true
+      end
+
+      # Return instance methods defined in module modul without the inherited/mixed
+      # in methods.
+      def irb_instance_methods(modul)
+        methods = modul.instance_methods(false)
+        irb_wrap_methods modul, methods, true
+      end
+
+      # Return all methods of obj (including obj's eigenmethods.)
+      def irb_all_methods(obj)
+        methods = obj.methods
+        irb_wrap_methods obj, methods
+      end
+
+      # Return instance methods of obj's class without the inherited/mixed in
+      # methods, but including obj's eigenmethods.
+      def irb_methods(obj)
+        methods = obj.class.ancestors[1..-1].inject(obj.methods) do |all, a|
+          all -= a.instance_methods
+        end
+        irb_wrap_methods obj, methods
+      end
+
+      # Return all eigen methods of obj.
+      def irb_eigen_methods(obj)
+        irb_wrap_methods obj, obj.methods(false)
+      end
+
+      def irb_wrap_methods(obj, methods, modul = false)
+        methods.map do |name|
+          MethodWrapper.new(obj, name, modul) rescue nil
+        end.compact.sort!
+      end
+
+      class WrapperBase
+        include Comparable
+
+        def initialize(name)
+          @name =
+            case
+            when name.respond_to?(:to_str)
+              name.to_str
+            when name.respond_to?(:to_sym)
+              name.to_sym.to_s
+            else
+              name.to_s
+            end
+        end
+
+        attr_reader :name
+
+        attr_reader :description
+
+        alias to_str name
+
+        alias inspect description
+
+        alias to_s description
+
+        def ==(name)
+          @name = name
+        end
+
+        alias eql? ==
+
+        def hash
+          @name.hash
+        end
+
+        def <=>(other)
+          @name <=> other.name
+        end
+      end
+
+      class MethodWrapper < WrapperBase
+        def initialize(obj, name, modul)
+          super(name)
+          if modul
+            @arity = obj.instance_method(name).arity
+          else
+            @arity = obj.method(name).arity
+          end
+          @description = "#@name(#@arity)"
+        end
+
+        attr_reader :arity
+      end
+
+      class ConstantWrapper < WrapperBase
+        def initialize(obj, name)
+          super(name)
+          @klass = obj.class
+          @description = "#@name:#@klass"
+        end
+
+        attr_reader :klass
+      end
+
+      # Return all the constants defined in +modul+.
+      def irb_constants(modul)
+        modul.constants.map { |c| ConstantWrapper.new(modul.const_get(c), c) }.sort
+      end
+
+      # Return all the subclasses of +klass+. TODO implement subclasses w/out rails
+      def irb_subclasses(klass)
+        klass.subclasses.map { |c| ConstantWrapper.new(eval(c), c) }.sort
+      end
+
+      unless Object.const_defined?(:Infinity)
+        Infinity = 1.0 / 0 # I like to define the infinite.
+      end
+
+      # Output all kinds of information about +obj+. If detailed is given output
+      # details about the methods (+ arity) in inheritance chain of +obj+ as well.
+      # * detailed as 0 output instance methods only of part 0 (the first) of the
+      #   chain.
+      # * detailed as 1..2 output instance methods of +obj+ inherited from parts 1
+      #   and 2 of the the chain.
+      def irb_info(obj, detailed = nil)
+        if Module === obj
+          modul = obj
+          klassp = Class === modul
+          if klassp
+            begin
+              allocated = modul.allocate
+            rescue TypeError
+            else
+              obj = allocated
+            end
+          end
+        else
+          modul = obj.class
+        end
+        inspected = obj.inspect
+        puts "obj = #{inspected.size > 40 ? inspected[0, 40] + '...' : inspected} is of class #{obj.class}."
+        am = irb_all_methods(obj).size
+        ms = irb_methods(obj).size
+        ems = irb_eigen_methods(obj).size
+        puts "obj: #{am} methods, #{ms} only local#{ems > 0 ? " (#{ems} eigenmethods),": ','} #{am - ms} inherited/mixed in."
+        acim = irb_all_class_instance_methods(obj).size
+        cim = irb_class_instance_methods(obj).size
+        puts "obj: #{acim} instance methods, #{cim} local, #{acim - cim} only inherited/mixed in."
+        if klassp
+          s = modul.superclass
+          puts "Superclass of #{modul}: #{s}"
+        end
+        a = []
+        ec = true
+        begin
+          a << (class << obj; self; end)
+        rescue TypeError
+          ec = false
+        end
+        a.concat modul.ancestors
+        if ec
+          puts "Ancestors of #{modul}: (#{a[0]},) #{a[1..-1].map { |k| "#{k}#{k == s ? '*' : ''}" } * ', '}"
+        else
+          puts "Ancestors of #{modul}: #{a[0..-1].map { |k| "#{k}#{k == s ? '*' : ''}" } * ', '}"
+        end
+        if Class === modul and detailed
+          if detailed.respond_to? :to_int
+            detailed = detailed..detailed
+          end
+          detailed.each do |i|
+            break if i >= a.size
+            k = a[i]
+            puts "#{k}:"
+            puts irb_wrap_methods(obj, k.instance_methods(false)).sort
+          end
+        end
+        nil
+      end
+
+      # Output *all* the irb_info about +obj+. You may need to buy a bigger screen for
+      # this or use:
+      #  less { irb_fullinfo object }
+      def irb_fullinfo(obj)
+        irb_info obj, 0..Infinity
+      end
+
+      def capture_output(with_stderr = false)
+        return "missing block" unless block_given?
+        require 'tempfile'
+        begin
+          old_stdout, $stdout = $stdout, Tempfile.new('irb')
+          if with_stderr
+            old_stderr, $stderr = $stderr, $stdout
+          end
+          yield
+        ensure
+          $stdout, temp = old_stdout, $stdout
+          with_stderr and $stderr = old_stderr
+        end
+        temp.rewind
+        temp.read
+      end
+
+      # Use pager on the output of the commands given in the block.
+      def less(with_stderr = false, &block)
+        IO.popen($pager, 'w') do |f|
+          f.write capture_output(with_stderr, &block)
+          f.close_write
+        end
+        nil
+      end
+
+      def irb_time
+        s = Time.now
+        yield
+        d = Time.now - s
+        warn "Took %.3fs seconds." % d
+        d
+      end
+
+      def irb_time_tap
+        r = nil
+        irb_time { r = yield }
+        r
+      end
+
+      def irb_time_watch(duration = 1)
+        start = Time.now
+        pre = nil
+        loop do
+          cur = [ yield ].flatten
+          unless pre
+            pre = cur.map(&:to_f)
+            cur = [ yield ].flatten
+          end
+          expired = Time.now - start
+          diffs = cur.zip(pre).map { |c, p| c - p }
+          rates = diffs.map { |d| d / duration }
+          warn "#{expired} #{cur.zip(rates, diffs).map(&:inspect) * ' '} # / per sec."
+          pre = cur.map(&:to_f)
+          sleep duration
+        end
+      end
+
+      def irb_write(filename, text = nil)
+        File.secure_write filename, text, 'wb'
+      end
+
+      def irb_read(filename, chunk_size = 8_192)
+        if block_given?
+          File.open(filename) do |file|
+            until file.eof?
+              yield file.read(chunk_size)
+            end
+          end
+        else
+          IO.read filename
+        end
+      end
+
+      def irb_load!(*files)
+        files = files.map { |f| f.gsub(/(\.rb)?\Z/, '.rb') }
+        loaded = {}
+        for file in files
+          catch :found do
+            Find.find('.') do |f|
+              File.directory?(f) and next
+              md5_f = Utils::MD5.md5(f)
+              if f.end_with?(file) and !loaded[md5_f]
+                Kernel.load f
+                loaded[md5_f] = true
+                STDERR.puts "Loaded '#{f}'."
+              end
+            end
+            Find.find('.') do |f|
+              File.directory?(f) and next
+              md5_f = Utils::MD5.md5(f)
+              if f.end_with?(file) and !loaded[md5_f]
+                Kernel.load f
+                loaded[md5_f] = true
+                STDERR.puts "Loaded '#{f}'."
+              end
+            end
+          end
+        end
+        nil
+      end
+
+      def irb_edit(*files)
+        $editor.full?(:edit, *files)
+      end
+
+      # List contents of directory
+      def ls(*args)
+        puts `ls #{args.map { |x| "'#{x}'" } * ' '}`
+      end
+
+      if defined?(ActiveRecord::Base)
+        $logger = Logger.new(STDERR)
+        def irb_toggle_logging
+          require 'logger'
+          if ActiveRecord::Base.logger != $logger
+            $old_logger = ActiveRecord::Base.logger
+            ActiveRecord::Base.logger = $logger
+            true
+          else
+            ActiveRecord::Base.logger = $old_logger
+            false
+          end
+        end
+      end
+    end
+
+    module Module
+      # Start +ri+ for +module#pattern+, trying to find a method matching +pattern+
+      # for all modules in the ancestors chain of this module.
+      def ri(pattern = nil)
+        if pattern
+          pattern = pattern.to_sym.to_s if pattern.respond_to? :to_sym
+          ancestors.each do |a|
+            if method = a.instance_methods(false).find { |m| pattern === m }
+              a = Object if a == Kernel # ri seems to be confused
+              system "ri #{a}##{method} | #{$pager}"
+            end
+          end
+        else
+          system "ri #{self} | #{$pager}"
+        end
+        return
+      end
+    end
+
+    module Regexp
+      # Show the match of this Regexp on the +string+.
+      def show_match(string)
+        string =~ self ? "#{$`}<<#{$&}>>#{$'}" : "no match"
+      end
+    end
+
+    module String
+      # Pipe this string into +cmd+.
+      def |(cmd)
+        IO.popen(cmd, 'w+') do |f|
+          f.write self
+          f.close_write
+          return f.read
+        end
+      end
+
+      # Write this string into file +filename+.
+      def >>(filename)
+        File.secure_write(filename, self)
+      end
+    end
+
+    module Relation
+      def explain
+        connection.select_all("EXPLAIN #{to_sql}")
+      end
+    end
+  end
+end
+
+module IRB
+  class Context
+    def init_save_history
+      unless (class<<@io;self;end).include?(HistorySavingAbility)
+        @io.extend(HistorySavingAbility)
+      end
+    end
+
+    def save_history
+      IRB.conf[:SAVE_HISTORY]
+    end
+
+    def save_history=(val)
+      IRB.conf[:SAVE_HISTORY] = val
+      if val
+        main_context = IRB.conf[:MAIN_CONTEXT]
+        main_context = self unless main_context
+        main_context.init_save_history
+      end
+    end
+
+    def history_file
+      IRB.conf[:HISTORY_FILE]
+    end
+
+    def history_file=(hist)
+      IRB.conf[:HISTORY_FILE] = hist
+    end
+  end
+
+  module HistorySavingAbility
+    include Readline
+
+    def HistorySavingAbility.create_finalizer
+      at_exit do
+        if num = IRB.conf[:SAVE_HISTORY] and (num = num.to_i) > 0
+          if hf = IRB.conf[:HISTORY_FILE]
+            file = File.expand_path(hf)
+          end
+          file = IRB.rc_file("_history") unless file
+          open(file, 'w' ) do |f|
+            hist = HISTORY.to_a
+            f.puts(hist[-num..-1] || hist)
+          end
+        end
+      end
+    end
+
+    def HistorySavingAbility.extended(obj)
+      HistorySavingAbility.create_finalizer
+      obj.load_history
+      obj
+    end
+
+    def load_history
+      hist = IRB.conf[:HISTORY_FILE]
+      hist = IRB.rc_file("_history") unless hist
+      if File.exist?(hist)
+        open(hist) do |f|
+          f.each {|l| HISTORY << l.chomp}
+        end
+      end
+    end
+  end
+end
+IRB.conf[:SAVE_HISTORY] = 1000
+
+if defined?(ActiveRecord::Relation)
+  class ActiveRecord::Relation
+    include Utils::IRB::Relation
+  end
+end
+
+class String
+  include Utils::IRB::String
+end
+
+class Object
+  include Utils::IRB::Shell
+end
+
+class Module
+  include Utils::IRB::Module
+end
+
+class Regexp
+  include Utils::IRB::Regexp
+end