Act_as_storable (actuar como almacenables)

IRB.conf[:AUTO_INDENT] = true
IRB.conf[:USE_READLINE] = true
IRB.conf[:LOAD_MODULES] = [] unless IRB.conf.key?(:LOAD_MODULES)
unless IRB.conf[:LOAD_MODULES].include?('irb/completion')
  IRB.conf[:LOAD_MODULES] << 'irb/completion'
end
# load libraries
require 'rubygems'
require 'wirble'
# start wirble (with color)
Wirble.init
Wirble.colorize
#Irb History to file, all session is save to ~/.irb-history
module Readline
  module History
    LOG = "#{ENV['HOME']}/.irb-history"
    def self.write_log(line)
      File.open(LOG, 'ab') {|f| f << "#{line}\n"}
    end
    def self.start_session_log
      write_log("# session start: #{Time.now}\n")
      at_exit { write_log("# session stop: #{Time.now}\n") }
    end
  end
  alias :old_readline :readline
  def readline(*args)
    ln = old_readline(*args)
    begin
      History.write_log(ln)
    rescue
    end
    ln
  end
end
Readline::History.start_session_log                                                                               

# Quick benchmarking
def quick(repetitions, *blocks)
  require 'benchmark'
  Benchmark.bmbm {|b|
    blocks.each {|block|
      b.report {repetitions.times &block}
    }
  }
  nil
end                                                                                         

def reset_irb()
  exec $0
end                                    

def split(array)
  length = (array.length / 3.0).ceil
  [array[0, length], array[length, 2*length], array[2*length, 3*length]]
end                                                                                                                                        

class Object
  # Return only the methods not present on basic objects
  def exclusive_methods
    methods_array = (self.methods - Object.new.methods).sort
    length        = methods_array.length
    col           = 4
    inicio        = -1
    arr           = []
    while inicio < length do
      arr << methods_array.slice(inicio+1..inicio+col)
      inicio += col
    end
    arr_final = []
    arr.each do |subarr|
      str = String.new
      subarr.each do |elemento|
        str_spaces = ""
        elem=(30-elemento.length).times {str_spaces+=" "}
        str << "#{elemento}#{str_spaces}"
      end
      arr_final << str
    end
    puts arr_final
  end
end                                                                                                                                        

module Kernel
  def r(arg)
    puts `ri "#{arg}" -f ansi`
  end
  private :r
end                                                                                                                                        

class Object
  def puts_ri_documentation_for(obj, meth)
    case self
    when Module
      candidates = ancestors.map{|klass| "#{klass}::#{meth}"}
      candidates.concat(class << self; ancestors end.map{|k| "#{k}##{meth}"})
    else
      candidates = self.class.ancestors.map{|klass|  "#{klass}##{meth}"}
    end
    candidates.each do |candidate|
      puts "TRYING #{candidate}"
      desc = `ri '#{candidate}' -f ansi`
      unless desc.chomp == "nil"
      # uncomment to use ri (and some patience)
      #desc = `ri -T '#{candidate}' 2>/dev/null`
      #unless desc.empty?
        puts desc
        return true
      end
    end
    false
  end
  private :puts_ri_documentation_for                                                                                                      

  def method_missing(meth, *args, &block)
    if md = /ri_(.*)/.match(meth.to_s)
      unless puts_ri_documentation_for(self,md[1])
        "Ri doesn't know about ##{meth}"
      end
    else
      super
    end
  end                                                                                                                                      

  def ri_(meth)
    unless puts_ri_documentation_for(self,meth.to_s)
      "Ri doesn't know about ##{meth}"
    end
  end
end                                                                                                                                        

RICompletionProc = proc{|input|
  bind = IRB.conf[:MAIN_CONTEXT].workspace.binding
  case input
  when /(\s*(.*)\.ri_)(.*)/
    pre = $1
    receiver = $2
    meth = $3 ? /\A#{Regexp.quote($3)}/ : /./ #}
    begin
      candidates = eval("#{receiver}.methods", bind).map do |m|
        case m
        when /[A-Za-z_]/; m
        else # needs escaping
          %{"#{m}"}
        end
      end
      candidates = candidates.grep(meth)
      candidates.map{|s| pre + s }
    rescue Exception
      candidates = []
    end
  when /([A-Z]\w+)#(\w*)/ #}
    klass = $1
    meth = $2 ? /\A#{Regexp.quote($2)}/ : /./
    candidates = eval("#{klass}.instance_methods(false)", bind)
    candidates = candidates.grep(meth)
    candidates.map{|s| "'" + klass + '#' + s + "'"}
  else
    IRB::InputCompletor::CompletionProc.call(input)
  end
}
Readline.basic_word_break_characters= " \t\n\\><=;|&"
Readline.completion_proc = RICompletionProc