rf-

def insert_before(klass, options={})
  instance     = new(nil, options)
  call_without = "call_without_#{instance.object_id}"
  call_with    = "call_with_#{instance.object_id}"

  klass.class_eval do
    define_method call_with do |env|
      instance.app = proc { |env| send call_without, env }
      instance.call(env)
    end

rf-

def self.method_missing(name, *args)
  name
end

def function(*param_names, &block)
  klass = Class.new { attr_accessor :this, *param_names }
  this  = TOPLEVEL_BINDING.eval('self')

  proc do |*params|
    context = klass.new

rf-

str = "foobar"[2..-1]
p str                # => "obar"
p str.rindex(/a/)    # => 0
p "obar".rindex(/a/) # => 2

str = "foobar"[3..-1]
p str               # => "bar"
p str.rindex(/a/)   # => nil
p "bar".rindex(/a/) # => 1

rf-

require 'pry'
require 'pry-exception_explorer'
require 'pry-exception_explorer/shim_builder'

binary_name = "lib_overrides.#{PryExceptionExplorer::ShimBuilder::Dyname}"

if !File.exists? File.join PryExceptionExplorer::ShimBuilder.dir, binary_name
  puts "First run, building shim"
  PryExceptionExplorer::ShimBuilder.compile
  puts "Hopefully built...!"

rf-

[1] pry(main)> def x
[1] pry(main)*   puts 'called x'  
[1] pry(main)*   callcc { |cc| return cc }  
[1] pry(main)* end    
=> nil
[2] pry(main)> def y
[2] pry(main)*   puts 'called y'  
[2] pry(main)*   x.call  
[2] pry(main)* ensure    
[2] pry(main)*   puts 'ensure block'    

rf-

# Recursively retrieve nested attributes (or method calls) from an object.
def get_path(obj, *path)
  if obj.is_a?(Array)
    obj.map { |o| get_path(o, *path) }
  else
    if path.count > 1
      next_obj = obj.send(path.first)
      get_path(next_obj, *path.drop(1))
    else
      obj.send(path.first)

rf-

  def draw_chart(collection, attribute=nil, &block)
    if attribute
      grouped = collection.group_by(&attribute)
    elsif block
      grouped = collection.group_by(&block)
    else
      raise "Must provide either an attribute or block to group by!"
    end

    # try to sort them, but if they're not sortable, don't worry about it

rf-

#!/usr/bin/ruby

result = `/usr/bin/osascript <<EOT
tell application "Terminal"
activate
set Input to display dialog "Gimme some text:" with title "Hello" with icon 0 default answer "" buttons {"OK"} default button 1
return text returned of Input as string
end tell
EOT
`

rf-

class Module
  def hookable(method_name)
    return nil if method_defined?("#{method_name}_without_hooks")

    alias_method "#{method_name}_without_hooks", method_name
    metaclass = class << self; self; end
    hooks = []

    define_method(method_name) do |*arguments|
      hooks.inject(lambda { |*args| send("#{method_name}_without_hooks", *args) }) do |blk, next_blk|

rf-

#!/usr/bin/env ruby

require 'benchmark'
require 'ostruct'

unlocked = 100000.times.map { o = OpenStruct.new; o.timestamp = Time.now - Kernel.rand(10000000); o } ; nil

method1 = lambda {
  achievements_per_day = Hash.new(0)
  unlocked.each do |achievement|