/radrails_ruby.yml

--- 
radrails_ruby: |-
  -- 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} }