irbrc i railsrc

# vim: ft=ruby
IRB_START_TIME = Time.now
print "Loading... "
ARGV.concat [ "--readline", "--prompt-mode", "simple" ]

require 'rubygems'
require 'pp'
require 'irb/completion'
require 'irb/ext/save-history'

# require ...
%w(
  wirble 
  map_by_method 
  what_methods
  duration
).each do |gem|
    begin 
        require gem
    rescue LoadError
        puts "Error loading #{gem}. Run 'sudo gem install #{gem}'"
    end
end

IRB.conf[:SAVE_HISTORY] = 1000
IRB.conf[:AUTO_INDENT] = true
IRB.conf[:USE_READLINE] = true
IRB.conf[:HISTORY_FILE] = "#{ENV['HOME']}/.irb-save-history"
IRB.conf[:PROMPT_MODE] = :SIMPLE

if Object.const_defined?(:Wirble)
    Wirble.init(:debug => true)
    Wirble.colorize
end

# object.local_methods
class Object 
    def local_methods(obj = self)
        obj.methods(false).sort
    end
end

# method finder
class Object
  def what?(*a)
    MethodFinder.new(self, *a) unless $in_method_find
  end
  def megaClone
    begin self.clone; rescue; self; end
  end
end
class MethodFinder
  def initialize( obj, *args )
    @obj = obj
    @args = args
  end
  def ==( val )
    MethodFinder.show( @obj, val, *@args )
  end

  # Find all methods on [anObject] which, when called with [args] return [expectedResult]
  def self.find( anObject, expectedResult, *args, &block )
    $in_method_find = true
    eval 'class DummyOut; def write(*args); end; end;'
    stdout, stderr = $stdout, $stderr
    $stdout = $stderr = DummyOut.new
    # change this back to == if you become worried about speed or something
    res = anObject.methods.select { |name| anObject.method(name).arity <= args.size }.
             select { |name| begin anObject.megaClone.method( name ).call( *args, &block ) == expectedResult; 
                             rescue Object; end }
    $stdout, $stderr = stdout, stderr
    $in_method_find = false
    res
  end

  # Pretty-prints the results of the previous method
  def self.show( anObject, expectedResult, *args, &block)
    find( anObject, expectedResult, *args, &block).each { |name|
      print "#{anObject.inspect}.#{name}" 
      print "(" + args.map { |o| o.inspect }.join(", ") + ")" unless args.empty?
      puts " == #{expectedResult.inspect}" 
    }
  end
end

# show_regexp - stolen from the pickaxe
def show_regexp(a, re)
   if a =~ re
      "#{$`}<<#{$&}>>#{$'}"
   else
      "no match"
   end
end
# Convenience method on Regexp so you can do
# /an/.show_match("banana")
class Regexp
    def show_match(a)
        show_regexp(a, self)
    end
end
require 'irb_callbacks'
require 'benchmark'
module IRB
    def self.around_eval(&block)
        @timing = Benchmark.realtime do
            block.call
        end
    end

    def self.after_output
        if @timing > 1
            puts "=> #{'%.3f' % @timing} seconds :("
        end
    end
end

# duration
at_exit { puts Duration.new(Time.now - IRB_START_TIME) }

puts "OK"
load File.dirname(__FILE__) + '/.railsrc' if $0 == 'irb' && ENV['RAILS_ENV']

print "Loading railsrc..."
# vim: ft=ruby

require 'logger'
# require 'activesupport'
Object.const_set(:RAILS_DEFAULT_LOGGER, Logger.new(STDOUT))

def sql(query)
  pp(ActiveRecord::Base.connection.select_all(query))
end

def define_model_find_shortcuts
  model_files = Dir.glob("app/models/**/*.rb" )
  table_names = model_files.map { |f| File.basename(f).split('.' )[0..-2].join }
  table_names.each do |table_name|
    Object.instance_eval do
      define_method(table_name) do |*args|
        table_name.camelize.constantize.send(:find, *args)
      end
    end
  end
end
IRB.conf[:IRB_RC] = Proc.new { define_model_find_shortcuts }

rails_root = File.basename(Dir.pwd)
IRB.conf[:PROMPT] ||= {}
IRB.conf[:PROMPT][:RAILS] = {
    :PROMPT_I => "#{rails_root}> ",
    :PROMPT_S => "#{rails_root}* ",
    :PROMPT_C => "#{rails_root}? ",
    :RETURN   => "=> %s\n" 
}
IRB.conf[:PROMPT_MODE] = :RAILS

puts "OK"