Type the trigger, then press Tab, to expand a code template. Press Tab or enter to work your way through each parameter.
| Description | Trigger | Code |
|---|
| Add # => Marker |
# |
# => |
| Hash Pair :key => "value" |
: |
:${1 default="key"} => "${2 default="value"}"${4 default=", "} |
| all? { |e| ... } |
all |
all? { |${1 default="e"}| ${cursor} } |
| alias_method ... |
am |
alias_method :${1 default="new_name"}, :${0 default="old_name"} |
| any? { |e| ... } |
any |
any? { |${1 default="e"}| ${cursor} } |
| application_code { ... } |
app |
if __FILE__ == $PROGRAM_NAME
${cursor}
end |
| assert_redirected_to |
art |
assert_redirected_to :action => "${1 default="index"}" |
| assert(...) |
as |
assert(${1 default="test"}, "${0 default="Failure message."}") |
| assert_equal(...) |
ase |
assert_equal(${1 default="expected"}, ${0 default="actual"}) |
| assert_in_delta(...) |
asid |
assert_in_delta(${1 default="expected_float"}, ${2 default="actual_float"}, ${0 default="2 ** -20"}) |
| assert_instance_of(...) |
asio |
assert_instance_of(${1 default="ExpectedClass"}, ${0 default="actual_instance"}) |
| assert_kind_of(...) |
asko |
assert_kind_of(${1 default="ExpectedKind"}, ${0 default="actual_instance"}) |
| assert_match(...) |
asm |
assert_match(/${1 default="expected_pattern"}/, ${0 default="actual_string"}) |
| assert_nil(...) |
asn |
assert_nil(${0 default="instance"}) |
| assert_not_equal(...) |
asne |
assert_not_equal(${1 default="unexpected"}, ${0 default="actual"}) |
| assert_no_match(...) |
asnm |
assert_no_match(/${1 default="unexpected_pattern"}/, ${0 default="actual_string"}) |
| assert_not_nil(...) |
asnn |
assert_not_nil(${0 default="instance"}) |
| assert_nothing_raised(...) { ... } |
asnr |
assert_nothing_raised(${1 default="Exception"}) { ${cursor} } |
| assert_not_same(...) |
asns |
assert_not_same(${1 default="unexpected"}, ${0 default="actual"}) |
| assert_nothing_thrown { ... } |
asnt |
assert_nothing_thrown { ${cursor} } |
| assert_operator(...) |
aso |
assert_operator(${1 default="left"}, :${2 default="operator"}, ${0 default="right"}) |
| assert_raise(...) { ... } |
asr |
assert_raise(${1 default="Exception"}) { ${cursor} } |
| assert_response |
asre |
assert_response :${1 default="success"} |
| assert_respond_to(...) |
asrt |
assert_respond_to(${1 default="object"}, :${0 default="method"}) |
| assert_same(...) |
ass |
assert_same(${1 default="expected"}, ${0 default="actual"}) |
| assert_throws(...) { ... } |
ast |
assert_throws(:${1 default="expected"}) { ${cursor} } |
| begin rescue end |
begin |
begin
${selection line}${cursor}
rescue ${Exception} => ${unusedlocal defaults="ex,boom,bang,var"}
${code}
end |
| Benchmark.bmbm do ... end |
bm- |
TESTS = ${1 default="10_000"}
Benchmark.bmbm do |results|
${cursor}
end |
| belongs_to |
bt |
belongs_to :${1 default="object"} |
| case ... | end |
case |
case ${1 default="object"}
when ${2 default="condition"}
${cursor}
end |
| classify { |e| ... } |
cl |
classify { |${1 default="e"}| ${cursor} } |
| ClassName = Struct ... do ... end |
cla |
${1 default="ClassName"} = Struct.new(:${2 default="attr_names"}) do
def ${3 default="method_name"}
${cursor}
end
end |
| class_from_name() |
clafn |
split("::").inject(Object) { |par, const| par.const_get(const) } |
| collect { |e| ... } |
col |
collect { |${1 default="e"}| ${cursor} } |
| include Comparable ... |
Comp |
include Comparable
def <=>(other)
${cursor}
end |
| deep_copy(...) |
deec |
Marshal.load(Marshal.dump(${0 default="obj_to_copy"})) |
| def ... | end |
def |
def ${1 default="method_name"}
${cursor}
end |
| def_delegator ... |
defd |
def_delegator :${1 default="@del_obj"}, :${2 default="del_meth"}, :${3 default="new_name"} |
| def_delegators ... |
defds |
def_delegators :${1 default="@del_obj"}, :${0 default="del_methods"} |
| def method_missing ... end |
defmm |
def method_missing(meth, *args, &blk)
${cursor}
end |
| def self ... end |
defs |
def self.${1 default="class_method_name"}
${cursor}
end |
| def test_ ... end |
deft |
def test_${1 default="case_name"}
${cursor}
end |
| delete_if { |e| ... } |
deli |
delete_if { |${1 default="e"}| ${cursor} } |
| detect { |e| ... } |
det |
detect { |${1 default="e"}| ${cursor} } |
| Dir.glob("...") { |file| ... } |
Dir |
Dir.glob() { |${3 default="file"}| ${cursor} } |
| do { |e| ... } |
do |
do |${unusedlocal defaults="i,j,k"}|
${selection line}${cursor}
end |
| do ... end |
dop |
do
${selection line}${cursor}
end |
| each { |e| ... } |
ea |
each { |${1 default="e"}| ${cursor} } |
| each_byte { |byte| ... } |
eab |
each_byte { |${1 default="byte"}| ${cursor} } |
| each_char { |chr| ... } |
eac- |
each_char { |${1 default="chr"}| ${cursor} } |
| each_index { |i| ... } |
eai |
each_index { |${1 default="i"}| ${cursor} } |
| each_key { |key| ... } |
eak |
each_key { |${1 default="key"}| ${cursor} } |
| each_line { |line| ... } |
eal |
each_line${tabStop1 default=""} { |${2 default="line"}| ${cursor} } |
| each_pair { |name, val| ... } |
eap |
each_pair { |${1 default="name"}, ${2 default="val"}| ${cursor} } |
| each_slice(...) { |group| ... } |
eas- |
each_slice(${1 default="2"}) { |${2 default="group"}| ${cursor} } |
| each_value { |val| ... } |
eav |
each_value { |${1 default="val"}| ${cursor} } |
| each_with_index { |e, i| ... } |
eawi |
each_with_index { |${1 default="e"}, ${2 default="i"}| ${cursor} } |
| elsif ... |
elsif |
elsif ${1 default="condition"}
${cursor} |
| __END__ |
end |
__END__ |
| include Enumerable ... |
Enum |
include Enumerable
def each(&block)
${cursor}
end |
| File.foreach ("...") { |line| ... } |
File |
File.foreach("${1 default="path/to/file"}") { |${3 default="line"}| ${cursor} } |
| find { |e| ... } |
fin |
find { |${1 default="e"}| ${cursor} } |
| find_all { |e| ... } |
fina |
find_all { |${1 default="e"}| ${cursor} } |
| flunk(...) |
fl |
flunk("${0 default="Failure message."}") |
| flatten_once() |
flao |
inject(Array.new) { |${1 default="arr"}, ${2 default="a"}| ${1 editable="false"}.push(*${2 editable="false"}) } |
| flash[... | ] |
flash |
flash[:${1 default="notice"}] = "${2 default="Successfully created..."}"${cursor} |
| extend Forwardable |
Forw- |
extend Forwardable |
| grep(/pattern/) { |match| ... } |
gre |
grep() { |${3 default="match"}| ${cursor} } |
| has_and_belongs_to_many |
habtm |
has_and_belongs_to_many :${1 default="object"} |
| Hash.new { |hash, key| hash[key] = ... } |
Hash |
Hash.new { |${1 default="hash"}, ${2 default="key"}| ${1 editable="false"}[${2 editable="false"}] = ${cursor} } |
| has_many |
hm |
has_many :${1 default="objects"} |
| has_one |
ho |
has_one :${1 default="object"} |
| if ... | end |
if |
if ${condition}
${selection line}${cursor}
end |
| if ... | else ... | end |
ife |
if ${condition}
${selection line}${tabStop1 default=""}
else
${tabStop2 default=""}
end |
| import Java class |
jc |
require 'java'
include_class '${0 default="package.class"}' |
| => |
l |
=> |
| logger.debug |
log |
logger.debug "${1 default="message"}"${cursor} |
| loop { ... } |
loo |
loop { ${cursor} } |
| map { |e| ... } |
map |
map { |${1 default="e"}| ${cursor} } |
| map_with_index { |e, i| ... } |
mapwi- |
enum_with_index.map { |${1 default="e"}, ${2 default="i"}| ${cursor} } |
| max { |a, b| ... } |
max |
max { |a, b| ${cursor} } |
| Create Several Columns |
mccc |
t.column :${1 default="title"}, :${2 default="string"}
mccc${cursor} |
| Add Column |
mcol |
add_column :${1 default="table"}, :${2 default="column"}, :${3 default="string"} |
| Marshal.dump(..., file) |
Md |
File.open("${1 default="path/to/file"}.dump", "w") { |${3 default="file"}| Marshal.dump(${4 default="obj"}, ${3 editable="false"}) } |
| min { |a, b| ... } |
min |
min { |a, b| ${cursor} } |
| Marshal.load(obj) |
Ml |
File.open("${1 default="path/to/file"}.dump") { |${3 default="file"}| Marshal.load(${3 editable="false"}) } |
| module ... ClassMethods ... end |
mod |
module ${1 default="ModuleName"}
module ClassMethods
${cursor}
end
module InstanceMethods
end
def self.included(receiver)
receiver.extend ClassMethods
receiver.send :include, InstanceMethods
end
end |
| module end |
module |
module ${name}
${cursor}
end |
| map(&:sym_proc) |
mp |
map(&:${1 default="id"}) |
| Create Table |
mtab |
create_table :${1 default="table"} do |t|
${cursor}
end |
| partition { |e| ... } |
par |
partition { |${1 default="e"}| ${cursor} } |
| path_from_here( ... ) |
patfh |
File.join(File.dirname(__FILE__), *%w[${1 default="rel path here"}]) |
| PStore.new( ... ) |
Pn- |
PStore.new() |
| attr_reader ... |
r |
attr_reader :${0 default="attr_names"} |
| render (action) |
ra |
render :action => "${1 default="action"}" |
| render (action, layout) |
ral |
render :action => "${1 default="action"}", :layout => "${2 default="layoutname"}" |
| randomize() |
ran |
sort_by { rand } |
| #!/usr/bin/env ruby -wKU |
rb |
#!/usr/bin/env ruby -wKU |
| render_component (action) |
rcea |
render_component :action => "${1 default="index"}" |
| render_component (controller) |
rcec |
render_component :controller => "${1 default="items"}" |
| render_component (controller, action) |
rceca |
render_component :controller => "${1 default="items"}", :action => "${2 default="index"}" |
| RAILS_DEFAULT_LOGGER.debug |
rdb |
RAILS_DEFAULT_LOGGER.debug "${1 default="message"}"${cursor} |
| redirect_to (action) |
rea |
redirect_to :action => "${1 default="index"}" |
| redirect_to (action, id) |
reai |
redirect_to :action => "${1 default="show"}", :id => ${0 default="@item"} |
| redirect_to (controller) |
rec |
redirect_to :controller => "${1 default="items"}" |
| redirect_to (controller, action) |
reca |
redirect_to :controller => "${1 default="items"}", :action => "${2 default="list"}" |
| redirect_to (controller, action, id) |
recai |
redirect_to :controller => "${1 default="items"}", :action => "${2 default="show"}", :id => ${0 default="@item"} |
| reject { |e| ... } |
rej |
reject { |${1 default="e"}| ${cursor} } |
| results.report(...) { ... } |
rep |
results.report("${1 default="name"}:") { TESTS.times { ${cursor} } } |
| require "..." |
req |
require "${cursor}" |
| reverse_each { |e| ... } |
reve |
reverse_each { |${1 default="e"}| ${cursor} } |
| render (file) |
rf |
render :file => "${1 default="filepath"}" |
| render (file, use_full_path) |
rfu |
render :file => "${1 default="filepath"}", :use_full_path => ${2 default="false"} |
| render (inline) |
ri |
render :inline => "${1 default="<%= |
| render (inline, locals) |
ril |
render :inline => "${1 default="<%= 'hello' %>"}", :locals => { ${2 default=":name"} => "${3 default="value"}"${tabStop4 default=""} } |
| render (inline, type) |
rit |
render :inline => "${1 default="<%= 'hello' %>"}", :type => ${2 default=":rxml"} |
| render (layout) |
rl |
render :layout => "${1 default="layoutname"}" |
| render (nothing) |
rn |
render :nothing => ${1 default="true"} |
| render (nothing, status) |
rns |
render :nothing => ${1 default="true"}, :status => ${2 default="401"} |
| render (partial) |
rp |
render :partial => "${1 default="item"}" |
| render (partial, collection) |
rpc |
render :partial => "${1 default="item"}", :collection => ${2 default="items"} |
| render (partial, locals) |
rpl |
render :partial => "${1 default="item"}", :locals => { :${2 default="name"} => "${3 default="value"}"${tabStop4 default=""} } |
| render (partial, object) |
rpo |
render :partial => "${1 default="item"}", :object => ${2 default="object"} |
| render (partial, status) |
rps |
render :partial => "${1 default="item"}", :status => ${2 default="500"} |
| render (text) |
rt |
render :text => "${1 default="text to render..."}" |
| render (text, layout) |
rtl |
render :text => "${1 default="text to render..."}", :layout => "${2 default="layoutname"}" |
| render (text, layout => true) |
rtlt |
render :text => "${1 default="text to render..."}", :layout => ${2 default="true"} |
| render (text, status) |
rts |
render :text => "${1 default="text to render..."}", :status => ${2 default="401"} |
| attr_accessor ... |
rw |
attr_accessor :${0 default="attr_names"} |
| scan(/.../) { |match| ... } |
sca |
scan(/${1 default="pattern"}/) { |${2 default="match"}| ${cursor} } |
| select { |e| ... } |
sel |
select { |${1 default="e"}| ${cursor} } |
| singleton_class() |
sin |
class << self; self end |
| sort { |a, b| ... } |
sor |
sort { |a, b| ${cursor} } |
| sort_by { |e| ... } |
sorb |
sort_by { |${1 default="e"}| ${cursor} } |
| class ... < Test::Unit::TestCase ... end |
tc |
require "test/unit"
require "${1 default="library_file_name"}"
class Test < Test::Unit::TestCase
def test_${3 default="case_name"}
${cursor}
end
end |
| require "tc_..." ... |
ts |
require "test/unit"
require "tc_${1 default="test_case_file"}"
require "tc_${2 default="test_case_file"}" |
| unix_filter { ... } |
uni |
ARGF.each_line${tabStop1 default=""} do |${2 default="line"}|
${cursor}
end |
| unless ... | end |
unless |
unless ${1 default="condition"}
${cursor}
end |
| until ... end |
until |
until ${1 default="condition"}
${cursor}
end |
| usage_if() |
usai |
if ARGV.${tabStop1 default=""}
abort "Usage: #{$PROGRAM_NAME} ${2 default="ARGS_GO_HERE"}"
end |
| usage_unless() |
usau |
unless ARGV.${tabStop1 default=""}
abort "Usage: #{$PROGRAM_NAME} ${2 default="ARGS_GO_HERE"}"
end |
| validates_associated |
va |
validates_associated :${1 default="attribute"} |
| validates_associated if |
vaif |
validates_associated :${1 default="attribute"} |
| validates_confirmation_of |
vc |
validates_confirmation_of :${1 default="attribute"} |
| validates_confirmation_of if |
vcif |
validates_confirmation_of :${1 default="attribute"} |
| validates_exclusion_of |
ve |
validates_exclusion_of :${1 default="attribute"} |
| validates_exclusion_of if |
veif |
validates_exclusion_of :${1 default="attribute"} |
| verify ... render |
verify |
verify :only => [:${tabStop1 default=""}], :method => :post, :render => {:status => 500, :text => "use HTTP-POST"} |
| validates_length_of |
vl |
validates_length_of :${1 default="attribute"}, :within => ${2 default="3..20"} |
| validates_presence_of |
vp |
validates_presence_of :${1 default="attribute"} |
| validates_presence_of if |
vpif |
validates_presence_of :${1 default="attribute"}, :if => proc { |obj| ${5 default="obj.condition?"} }} |
| validates_uniqueness_of |
vu |
validates_uniqueness_of :${1 default="attribute"} |
| validates_uniqueness_of if |
vuif |
validates_uniqueness_of :${1 default="attribute"} |
| attr_writer ... |
w |
attr_writer :${0 default="attr_names"} |
| when ... | |
when |
when ${1 default="condition"}
${cursor} |
| while ... end |
while |
while ${1 default="condition"}
${cursor}
end |
| :yields: |
y |
:yields: ${0 default="arguments"} |
| YAML.dump(..., file) |
Yd- |
File.open("${1 default="path/to/file"}.yaml", "w") { |${3 default="file"}| YAML.dump(${4 default="obj"}, ${3 editable="false"}) } |
| YAML.load(file) |
Yl- |
File.open("${1 default="path/to/file"}.yaml") { |${3 default="file"}| YAML.load(${3 editable="false"}) } |
| zip(enums) { |row| ... } |
zip |
zip(${1 default="enums"}) { |${2 default="row"}| ${cursor} } |
