cheat sheets.

$ command line ruby cheat sheets
-- RadRails Ruby Cheat Sheet -- 
all
all? { |${e}| ${cursor} }

am
alias_method :${new_name}, :${old_name}

any
any? { |${e}| ${cursor} }

app
if __FILE__ == $$PROGRAM_NAME
	${cursor}
end

Array
Array.new(${10}) { |${i}|${cursor} }

art
assert_redirected_to :action => "${index}"

as
assert(${test}, "${message}")

asa
assert(${var} = assigns(:${var}), "@${var} should be defined")

ase
assert_equal(${expected}, ${actual})

asid
assert_in_delta(${expected_float}, ${actual_float}, ${20})

asio
assert_instance_of(${ExpectedClass}, ${actual_instance})

asko
assert_kind_of(${ExpectedKind}, ${actual_instance})

asm
assert_match(/${expected_pattern}/, ${actual_string})

asn
assert_nil(${instance})

asne
assert_not_equal(${unexpected}, ${actual})

asnm
assert_no_match(/${unexpected_pattern}/, ${actual_string})

asnn
assert_not_nil(${instance})

asnnv
assert_not_nil(${var} = assigns(:${var}))

asnr
assert_nothing_raised(${Exception}) { ${cursor} }

asns
assert_not_same(${unexpected}, ${actual})

asnt
assert_nothing_thrown { ${cursor} }

aso
assert_operator(${left}, :${operator}, ${right})

asr
assert_raise(${Exception}) { ${cursor} }

asrdt
assert_redirected_to(${path}, '${message}')

asre
assert_response :${success}

asrt
assert_respond_to(${object}, :${method})

ass
assert_same(${expected}, ${actual})

ass
assert_send([${object}, :${message}, ${args}])

ast
assert_throws(:${expected}) { ${cursor} }

b
=begin rdoc
	${cursor}
=end

begin
begin
	${paste}
rescue ${Exception} => ${e}
	${cursor}
end


bm
TESTS = ${10_000}
Benchmark.bmbm(${10}) do |results|
  ${cursor}
end

bt
belongs_to :${object}

btf
belongs_to :${object}, :class_name => '${class_name}', :foreign_key => :${foreign_key}

case
case ${object}
when ${condition}
	${cursor}
end

cl
classify { |${e}| ${cursor} }

cla
class ${ClassName} < DelegateClass(${ParentClass})
	def initialize${1}
		super(${del_obj})
		
		${cursor}
	end
	
	
end

cla
class ${ClassName} < ${ParentClass}
	def initialize${1}
		${cursor}
	end
	
	
end

cla
class ${ClassName} < Struct.new(:${attr_names})
	def initialize(*args)
		super
		
		${cursor}
	end
	
	
end

cla
class ${ClassName}
	${cursor}
end

cla
class ${ClassName}
	def initialize${1}
		${cursor}
	end
	
	
end

cla
class << ${self}
	${cursor}
end

cla
class ${BlankSlate}
	instance_methods.each { |meth| undef_method(meth) unless meth =~ /\A__/ }
	
	def initialize${var}
		@${delegate} = ${delegate_object}
		
		${cursor}
	end
	
	def method_missing(meth, *args, &block)
		@${delegate}.send(meth, *args, &block)
	end
	
	
end

clafn
split("::").inject(Object) { |par, const| par.const_get(const) }

class
class ${ClassName}
	${cursor}
end

col
collect { |${e}| ${cursor} }

collect
collect { |${element}| ${element}.${cursor} }

Comp
include Comparable

def <=>(other)
	${cursor}
end

dee
Marshal.load(Marshal.dump(${obj_to_copy}))

def
def ${method_name}
	${cursor}
end

defd
def_delegator :${del_obj}, :${del_meth}, :${new_name}

defds
def_delegators :${del_obj}, :${del_methods}

deff
def ${method_name}
	${cursor}
end

defs
def self.${class_method_name}
	${cursor}
end

deft
def test_${case_name}
	${cursor}
end

deli
delete_if { |${e}| ${cursor} }

det
detect { |${e}| ${cursor} }

Dir
Dir.glob(${glob}) { |${file}| ${cursor} }

do
do
	${cursor}
end

doo
do |${object}|
	${cursor}
end

dow
downto(${0}) { |${n}|${cursor} }

ea
each { |${e}| ${cursor} }

eab
each_byte { |${byte}| ${cursor} }

eac
each_char { |${chr}| ${cursor} }

eac
each_cons(${2}) { |${group}| ${cursor} }

each
each { |${element}| ${element}.${cursor} }

each_with_index
each_with_index { |${element}, ${idx}| ${element}.${cursor} }

eai
each_index { |${i}| ${cursor} }

eak
each_key { |${key}| ${cursor} }

eal
each_line${1} { |${line}| ${cursor} }

eap
each_pair { |${name}, ${val}| ${cursor} }

eas
each_slice(${2}) { |${group}| ${cursor} }

eav
each_value { |${val}| ${cursor} }

eawi
each_with_index { |${e}, ${i}| ${cursor} }

elsif
elsif ${condition}
	${cursor}

Enum
include Enumerable

def each(&block)
	${cursor}
end

fet
fetch(${name}) { |${key}|${cursor} }

fil
fill(${range}) { |${i}|${cursor} }

File
File.foreach(${file}) { |${line}| ${cursor} }

fin
find { |${e}| ${cursor} }

fina
find_all { |${e}| ${cursor} }

fl
flunk("${message}")

flao
inject(Array.new) { |${arr}, ${a}| ${arr}.push(*${a}) }

flash
flash[:${notice}] = "${Successfully}"${cursor}

forin
for ${element} in ${collection}
	${element}.${cursor}
end

Forw
extend Forwardable

gre
grep(${pattern}) { |${match}| ${cursor} }

gsu
gsub(/${pattern}/) { |${match}|${cursor} }

habtm
has_and_belongs_to_many :${object}

Hash
Hash.new { |${hash}, ${key}| ${hash}[${key}] = ${cursor} }

hm
has_many :${models}

hmf
has_many :${models}, :class_name => '${class_name}', :foreign_key => :${foreign_key}

hmt
has_many :${models}, :through => :${join_models}

ho
has_one :${model}

hof
has_one :${model}, :class_name => '${class_name}', :foreign_key => :${foreign_key}

hp
:${key} => ${value}

if
if ${condition}
	${cursor}
end

ife
if ${condition}
	${2}
else
	${3}
end

inj
inject(${init}) { |${mem}, ${var}| ${cursor} }

inject
inject(${object}) { |${injection}, ${element}| ${4} }${cursor}

lam
lambda { |${args}|${cursor} }

log
logger.debug "${message}"${cursor}

loge
logger.error "${message}"${cursor}

logf
logger.fatal "${message}"${cursor}

logi
logger.info "${message}"${cursor}

logw
logger.warn "${message}"${cursor}

mac
add_column :${table}, :${column}, :${string}

map
map { |${e}| ${cursor} }

mapwi
enum_with_index.map { |${e}, ${i}| ${cursor} }

max
max { |a, b| ${cursor} }

mcc
t.column :${title}, :${string}${cursor}

mccc
t.column :${title}, :${string}
mccc${cursor}

mct
create_table :${table} do |t|
    ${cursor}
end

Md
File.open(${dump}, "w") { |${file}| Marshal.dump(${obj}, ${file}) }

mdt
drop_table :${table}
${cursor}

min
min { |a, b| ${cursor} }

Ml
File.open(${dump}) { |${file}| Marshal.load(${file}) }

mm
def method_missing(meth, *args, &block)
	${cursor}
end

mnc
rename_column :${column}, :${new_column}

mnt
rename_table :${table}, :${new_name}${cursor}

mod
module ${ModuleName}
	module ClassMethods
		${cursor}
	end
	
	extend ClassMethods
	
	def self.included(receiver)
		receiver.extend(ClassMethods)
	end
	
	
end

mod
module ${ModuleName}
	${cursor}
end

mod
module ${ModuleName}
	module_function
	
	${cursor}
end

mrc
remove_column :${table}, :${column}

ope
open(${pipe}) { |${io}| ${cursor} }

opt
opts.on( "-${o}", "--${option}"${1},
         "${description}" ) do |${opt}|
	${cursor}
end

optp
require "optparse"
require "ostruct"

options = OpenStruct.new(${default})

ARGV.options do |opts|
	opts.banner = "Usage:  #{File.basename($$PROGRAM_NAME)}  [OPTIONS]${1}"
	
	opts.separator ""
	opts.separator "Specific Options:"
	
	${cursor}
	
	opts.separator "Common Options:"
	
	opts.on( "-h", "--help",
	         "Show this message." ) do
		puts opts
		exit
	end
	
	begin
		opts.parse!
	rescue
		puts opts
		exit
	end
end


par
partition { |${e}| ${cursor} }

params
params[:${id}]

patfh
File.join(File.dirname(__FILE__), *%w[${here}])

Pn
PStore.new(${file_name})

ra
render :action => "${action}"

ral
render :action => "${action}", :layout => "${layoutname}"

ran
sort_by { rand }

rb
#!/usr/bin/env ruby -w



rcea
render_component :action => "${index}"

rcec
render_component :controller => "${items}"

rceca
render_component :controller => "${items}", :action => "${index}"

rdb
RAILS_DEFAULT_LOGGER.debug "${message}"${cursor}

rea
redirect_to :action => "${index}"

reai
redirect_to :action => "${show}", :id => ${item}

rec
redirect_to :controller => "${items}"

reca
redirect_to :controller => "${items}", :action => "${list}"

recai
redirect_to :controller => "${items}", :action => "${show}", :id => ${item}

rej
reject { |${e}| ${cursor} }

reject
reject { |${element}| ${element}.${cursor} }

rep
results.report("${name}:") { TESTS.times { ${cursor} } }

req
require "${cursor}"

reve
reverse_each { |${e}| ${cursor} }

rf
render(:file => "${filepath}")

rfu
render(:file => "${filepath}", :use_full_path => ${false})

ri
render(:inline => "${hello}")

ril
render(:inline => "${hello}", :locals => { ${name} => "${value}"${4} })

rit
render(:inline => "${hello}", :type => ${rxml})

rl
render(:layout => "${layoutname}")

rn
render(:nothing => ${true})

rns
render(:nothing => ${true}, :status => ${401})

ro
attr_reader :${attr_names}

rp
render(:partial => "${item}")

rpc
render(:partial => "${item}", :collection => ${items})

rpl
render(:partial => "${item}", :locals => { :${name} => ${value} })

rpo
render(:partial => "${item}", :object => ${object})

rps
render(:partial => "${item}", :status => ${500})

rt
render(:text => "${render}")

rtl
render(:text => "${render}", :layout => "${layoutname}")

rtlt
render(:text => "${render}", :layout => ${true})

rts
render(:text => "${render}", :status => ${401})

rw
attr_accessor :${attr_names}

sca
scan(/${pattern}/) { |${match}| ${cursor} }

sel
select { |${e}| ${cursor} }

select
select { |${element}| ${element}.${2} }${cursor}

session
session[:${User}]

sin
class << self; self end

sor
sort { |a, b| ${cursor} }

sorb
sort_by { |${e}| ${cursor} }

ste
step(${2}) { |${n}|${cursor} }

sub
sub(/${pattern}/) { |${match}|${cursor} }

tc
require "test/unit"

require "${library_file_name}"

class Test${amp} < Test::Unit::TestCase
	def test_${case_name}
		${cursor}
	end
end

tim
times { |${n}|${cursor} }

tra
transaction${1} { ${cursor} }

ts
require "test/unit"

require "tc_${test_case_file}"
require "tc_${test_case_file}"


uni
ARGF.each_line${1} do |${line}|
	${cursor}
end

unless
unless ${condition}
	${cursor}
end

until
until ${condition}
	${cursor}
end

upt
upto(${0}) { |${n}|${cursor} }

usai
if ARGV.${1}
  puts "Usage:  #{$$PROGRAM_NAME} ${ARGS_GO_HERE}"
  exit
end

usau
unless ARGV.${1}
  puts "Usage:  #{$$PROGRAM_NAME} ${ARGS_GO_HERE}"
  exit
end

va
validates_associated :${attribute}

vc
validates_confirmation_of :${attribute}

ve
validates_exclusion_of :${attribute}

verify
verify :only => [:${1}], :session => :user, :params => :id, :redirect_to => {:action => '${index}'}


verify
verify :only => [:${1}], :method => :post, :render => {:status => 500, :text => "use HTTP-POST"}


vl
validates_length_of :${attribute}, :within => ${20}

vp
validates_presence_of :${attribute}

vpif
validates_presence_of :${attribute}, :if => proc { |obj| ${condition} }}

vu
validates_uniqueness_of :${attribute}

when
when ${condition}
	${cursor}

while
while ${condition}
	${cursor}
end

wo
attr_writer :${attr_names}

Yd
File.open(${yaml}, "w") { |${file}| YAML.dump(${obj}, ${file}) }

yields
 :yields: ${arguments}

Yl
File.open(${yaml}) { |${file}| YAML.load(${file}) }

zip
zip(${enums}) { |${row}| ${cursor} }