930 lines
21 KiB
JavaScript
930 lines
21 KiB
JavaScript
|
(self.webpackChunkant_design_pro=self.webpackChunkant_design_pro||[]).push([[15750],{15750:function(n,i,p){n=p.nmd(n),ace.define("ace/snippets/ruby.snippets",["require","exports","module"],function(t,e,s){s.exports=`########################################
|
||
|
|
# Ruby snippets - for Rails, see below #
|
||
|
|
########################################
|
||
|
|
|
||
|
|
# encoding for Ruby 1.9
|
||
|
|
snippet enc
|
||
|
|
# encoding: utf-8
|
||
|
|
|
||
|
|
# #!/usr/bin/env ruby
|
||
|
|
snippet #!
|
||
|
|
#!/usr/bin/env ruby
|
||
|
|
# encoding: utf-8
|
||
|
|
|
||
|
|
# New Block
|
||
|
|
snippet =b
|
||
|
|
=begin rdoc
|
||
|
|
\${1}
|
||
|
|
=end
|
||
|
|
snippet y
|
||
|
|
:yields: \${1:arguments}
|
||
|
|
snippet rb
|
||
|
|
#!/usr/bin/env ruby -wKU
|
||
|
|
snippet beg
|
||
|
|
begin
|
||
|
|
\${3}
|
||
|
|
rescue \${1:Exception} => \${2:e}
|
||
|
|
end
|
||
|
|
|
||
|
|
snippet req require
|
||
|
|
require "\${1}"\${2}
|
||
|
|
snippet #
|
||
|
|
# =>
|
||
|
|
snippet end
|
||
|
|
__END__
|
||
|
|
snippet case
|
||
|
|
case \${1:object}
|
||
|
|
when \${2:condition}
|
||
|
|
\${3}
|
||
|
|
end
|
||
|
|
snippet when
|
||
|
|
when \${1:condition}
|
||
|
|
\${2}
|
||
|
|
snippet def
|
||
|
|
def \${1:method_name}
|
||
|
|
\${2}
|
||
|
|
end
|
||
|
|
snippet deft
|
||
|
|
def test_\${1:case_name}
|
||
|
|
\${2}
|
||
|
|
end
|
||
|
|
snippet if
|
||
|
|
if \${1:condition}
|
||
|
|
\${2}
|
||
|
|
end
|
||
|
|
snippet ife
|
||
|
|
if \${1:condition}
|
||
|
|
\${2}
|
||
|
|
else
|
||
|
|
\${3}
|
||
|
|
end
|
||
|
|
snippet elsif
|
||
|
|
elsif \${1:condition}
|
||
|
|
\${2}
|
||
|
|
snippet unless
|
||
|
|
unless \${1:condition}
|
||
|
|
\${2}
|
||
|
|
end
|
||
|
|
snippet while
|
||
|
|
while \${1:condition}
|
||
|
|
\${2}
|
||
|
|
end
|
||
|
|
snippet for
|
||
|
|
for \${1:e} in \${2:c}
|
||
|
|
\${3}
|
||
|
|
end
|
||
|
|
snippet until
|
||
|
|
until \${1:condition}
|
||
|
|
\${2}
|
||
|
|
end
|
||
|
|
snippet cla class .. end
|
||
|
|
class \${1:\`substitute(Filename(), '\\(_\\|^\\)\\(.\\)', '\\u\\2', 'g')\`}
|
||
|
|
\${2}
|
||
|
|
end
|
||
|
|
snippet cla class .. initialize .. end
|
||
|
|
class \${1:\`substitute(Filename(), '\\(_\\|^\\)\\(.\\)', '\\u\\2', 'g')\`}
|
||
|
|
def initialize(\${2:args})
|
||
|
|
\${3}
|
||
|
|
end
|
||
|
|
end
|
||
|
|
snippet cla class .. < ParentClass .. initialize .. end
|
||
|
|
class \${1:\`substitute(Filename(), '\\(_\\|^\\)\\(.\\)', '\\u\\2', 'g')\`} < \${2:ParentClass}
|
||
|
|
def initialize(\${3:args})
|
||
|
|
\${4}
|
||
|
|
end
|
||
|
|
end
|
||
|
|
snippet cla ClassName = Struct .. do .. end
|
||
|
|
\${1:\`substitute(Filename(), '\\(_\\|^\\)\\(.\\)', '\\u\\2', 'g')\`} = Struct.new(:\${2:attr_names}) do
|
||
|
|
def \${3:method_name}
|
||
|
|
\${4}
|
||
|
|
end
|
||
|
|
end
|
||
|
|
snippet cla class BlankSlate .. initialize .. end
|
||
|
|
class \${1:BlankSlate}
|
||
|
|
instance_methods.each { |meth| undef_method(meth) unless meth =~ /\\A__/ }
|
||
|
|
end
|
||
|
|
snippet cla class << self .. end
|
||
|
|
class << \${1:self}
|
||
|
|
\${2}
|
||
|
|
end
|
||
|
|
# class .. < DelegateClass .. initialize .. end
|
||
|
|
snippet cla-
|
||
|
|
class \${1:\`substitute(Filename(), '\\(_\\|^\\)\\(.\\)', '\\u\\2', 'g')\`} < DelegateClass(\${2:ParentClass})
|
||
|
|
def initialize(\${3:args})
|
||
|
|
super(\${4:del_obj})
|
||
|
|
|
||
|
|
\${5}
|
||
|
|
end
|
||
|
|
end
|
||
|
|
snippet mod module .. end
|
||
|
|
module \${1:\`substitute(Filename(), '\\(_\\|^\\)\\(.\\)', '\\u\\2', 'g')\`}
|
||
|
|
\${2}
|
||
|
|
end
|
||
|
|
snippet mod module .. module_function .. end
|
||
|
|
module \${1:\`substitute(Filename(), '\\(_\\|^\\)\\(.\\)', '\\u\\2', 'g')\`}
|
||
|
|
module_function
|
||
|
|
|
||
|
|
\${2}
|
||
|
|
end
|
||
|
|
snippet mod module .. ClassMethods .. end
|
||
|
|
module \${1:\`substitute(Filename(), '\\(_\\|^\\)\\(.\\)', '\\u\\2', 'g')\`}
|
||
|
|
module ClassMethods
|
||
|
|
\${2}
|
||
|
|
end
|
||
|
|
|
||
|
|
module InstanceMethods
|
||
|
|
|
||
|
|
end
|
||
|
|
|
||
|
|
def self.included(receiver)
|
||
|
|
receiver.extend ClassMethods
|
||
|
|
receiver.send :include, InstanceMethods
|
||
|
|
end
|
||
|
|
end
|
||
|
|
# attr_reader
|
||
|
|
snippet r
|
||
|
|
attr_reader :\${1:attr_names}
|
||
|
|
# attr_writer
|
||
|
|
snippet w
|
||
|
|
attr_writer :\${1:attr_names}
|
||
|
|
# attr_accessor
|
||
|
|
snippet rw
|
||
|
|
attr_accessor :\${1:attr_names}
|
||
|
|
snippet atp
|
||
|
|
attr_protected :\${1:attr_names}
|
||
|
|
snippet ata
|
||
|
|
attr_accessible :\${1:attr_names}
|
||
|
|
# include Enumerable
|
||
|
|
snippet Enum
|
||
|
|
include Enumerable
|
||
|
|
|
||
|
|
def each(&block)
|
||
|
|
\${1}
|
||
|
|
end
|
||
|
|
# include Comparable
|
||
|
|
snippet Comp
|
||
|
|
include Comparable
|
||
|
|
|
||
|
|
def <=>(other)
|
||
|
|
\${1}
|
||
|
|
end
|
||
|
|
# extend Forwardable
|
||
|
|
snippet Forw-
|
||
|
|
extend Forwardable
|
||
|
|
# def self
|
||
|
|
snippet defs
|
||
|
|
def self.\${1:class_method_name}
|
||
|
|
\${2}
|
||
|
|
end
|
||
|
|
# def method_missing
|
||
|
|
snippet defmm
|
||
|
|
def method_missing(meth, *args, &blk)
|
||
|
|
\${1}
|
||
|
|
end
|
||
|
|
snippet defd
|
||
|
|
def_delegator :\${1:@del_obj}, :\${2:del_meth}, :\${3:new_name}
|
||
|
|
snippet defds
|
||
|
|
def_delegators :\${1:@del_obj}, :\${2:del_methods}
|
||
|
|
snippet am
|
||
|
|
alias_method :\${1:new_name}, :\${2:old_name}
|
||
|
|
snippet app
|
||
|
|
if __FILE__ == $PROGRAM_NAME
|
||
|
|
\${1}
|
||
|
|
end
|
||
|
|
# usage_if()
|
||
|
|
snippet usai
|
||
|
|
if ARGV.\${1}
|
||
|
|
abort "Usage: #{$PROGRAM_NAME} \${2:ARGS_GO_HERE}"\${3}
|
||
|
|
end
|
||
|
|
# usage_unless()
|
||
|
|
snippet usau
|
||
|
|
unless ARGV.\${1}
|
||
|
|
abort "Usage: #{$PROGRAM_NAME} \${2:ARGS_GO_HERE}"\${3}
|
||
|
|
end
|
||
|
|
snippet array
|
||
|
|
Array.new(\${1:10}) { |\${2:i}| \${3} }
|
||
|
|
snippet hash
|
||
|
|
Hash.new { |\${1:hash}, \${2:key}| $1[$2] = \${3} }
|
||
|
|
snippet file File.foreach() { |line| .. }
|
||
|
|
File.foreach(\${1:"path/to/file"}) { |\${2:line}| \${3} }
|
||
|
|
snippet file File.read()
|
||
|
|
File.read(\${1:"path/to/file"})\${2}
|
||
|
|
snippet Dir Dir.global() { |file| .. }
|
||
|
|
Dir.glob(\${1:"dir/glob/*"}) { |\${2:file}| \${3} }
|
||
|
|
snippet Dir Dir[".."]
|
||
|
|
Dir[\${1:"glob/**/*.rb"}]\${2}
|
||
|
|
snippet dir
|
||
|
|
Filename.dirname(__FILE__)
|
||
|
|
snippet deli
|
||
|
|
delete_if { |\${1:e}| \${2} }
|
||
|
|
snippet fil
|
||
|
|
fill(\${1:range}) { |\${2:i}| \${3} }
|
||
|
|
# flatten_once()
|
||
|
|
snippet flao
|
||
|
|
inject(Array.new) { |\${1:arr}, \${2:a}| $1.push(*$2)}\${3}
|
||
|
|
snippet zip
|
||
|
|
zip(\${1:enums}) { |\${2:row}| \${3} }
|
||
|
|
# downto(0) { |n| .. }
|
||
|
|
snippet dow
|
||
|
|
downto(\${1:0}) { |\${2:n}| \${3} }
|
||
|
|
snippet ste
|
||
|
|
step(\${1:2}) { |\${2:n}| \${3} }
|
||
|
|
snippet tim
|
||
|
|
times { |\${1:n}| \${2} }
|
||
|
|
snippet upt
|
||
|
|
upto(\${1:1.0/0.0}) { |\${2:n}| \${3} }
|
||
|
|
snippet loo
|
||
|
|
loop { \${1} }
|
||
|
|
snippet ea
|
||
|
|
each { |\${1:e}| \${2} }
|
||
|
|
snippet ead
|
||
|
|
each do |\${1:e}|
|
||
|
|
\${2}
|
||
|
|
end
|
||
|
|
snippet eab
|
||
|
|
each_byte { |\${1:byte}| \${2} }
|
||
|
|
snippet eac- each_char { |chr| .. }
|
||
|
|
each_char { |\${1:chr}| \${2} }
|
||
|
|
snippet eac- each_cons(..) { |group| .. }
|
||
|
|
each_cons(\${1:2}) { |\${2:group}| \${3} }
|
||
|
|
snippet eai
|
||
|
|
each_index { |\${1:i}| \${2} }
|
||
|
|
snippet eaid
|
||
|
|
each_index do |\${1:i}|
|
||
|
|
\${2}
|
||
|
|
end
|
||
|
|
snippet eak
|
||
|
|
each_key { |\${1:key}| \${2} }
|
||
|
|
snippet eakd
|
||
|
|
each_key do |\${1:key}|
|
||
|
|
\${2}
|
||
|
|
end
|
||
|
|
snippet eal
|
||
|
|
each_line { |\${1:line}| \${2} }
|
||
|
|
snippet eald
|
||
|
|
each_line do |\${1:line}|
|
||
|
|
\${2}
|
||
|
|
end
|
||
|
|
snippet eap
|
||
|
|
each_pair { |\${1:name}, \${2:val}| \${3} }
|
||
|
|
snippet eapd
|
||
|
|
each_pair do |\${1:name}, \${2:val}|
|
||
|
|
\${3}
|
||
|
|
end
|
||
|
|
snippet eas-
|
||
|
|
each_slice(\${1:2}) { |\${2:group}| \${3} }
|
||
|
|
snippet easd-
|
||
|
|
each_slice(\${1:2}) do |\${2:group}|
|
||
|
|
\${3}
|
||
|
|
end
|
||
|
|
snippet eav
|
||
|
|
each_value { |\${1:val}| \${2} }
|
||
|
|
snippet eavd
|
||
|
|
each_value do |\${1:val}|
|
||
|
|
\${2}
|
||
|
|
end
|
||
|
|
snippet eawi
|
||
|
|
each_with_index { |\${1:e}, \${2:i}| \${3} }
|
||
|
|
snippet eawid
|
||
|
|
each_with_index do |\${1:e},\${2:i}|
|
||
|
|
\${3}
|
||
|
|
end
|
||
|
|
snippet reve
|
||
|
|
reverse_each { |\${1:e}| \${2} }
|
||
|
|
snippet reved
|
||
|
|
reverse_each do |\${1:e}|
|
||
|
|
\${2}
|
||
|
|
end
|
||
|
|
snippet inj
|
||
|
|
inject(\${1:init}) { |\${2:mem}, \${3:var}| \${4} }
|
||
|
|
snippet injd
|
||
|
|
inject(\${1:init}) do |\${2:mem}, \${3:var}|
|
||
|
|
\${4}
|
||
|
|
end
|
||
|
|
snippet map
|
||
|
|
map { |\${1:e}| \${2} }
|
||
|
|
snippet mapd
|
||
|
|
map do |\${1:e}|
|
||
|
|
\${2}
|
||
|
|
end
|
||
|
|
snippet mapwi-
|
||
|
|
enum_with_index.map { |\${1:e}, \${2:i}| \${3} }
|
||
|
|
snippet sor
|
||
|
|
sort { |a, b| \${1} }
|
||
|
|
snippet sorb
|
||
|
|
sort_by { |\${1:e}| \${2} }
|
||
|
|
snippet ran
|
||
|
|
sort_by { rand }
|
||
|
|
snippet all
|
||
|
|
all? { |\${1:e}| \${2} }
|
||
|
|
snippet any
|
||
|
|
any? { |\${1:e}| \${2} }
|
||
|
|
snippet cl
|
||
|
|
classify { |\${1:e}| \${2} }
|
||
|
|
snippet col
|
||
|
|
collect { |\${1:e}| \${2} }
|
||
|
|
snippet cold
|
||
|
|
collect do |\${1:e}|
|
||
|
|
\${2}
|
||
|
|
end
|
||
|
|
snippet det
|
||
|
|
detect { |\${1:e}| \${2} }
|
||
|
|
snippet detd
|
||
|
|
detect do |\${1:e}|
|
||
|
|
\${2}
|
||
|
|
end
|
||
|
|
snippet fet
|
||
|
|
fetch(\${1:name}) { |\${2:key}| \${3} }
|
||
|
|
snippet fin
|
||
|
|
find { |\${1:e}| \${2} }
|
||
|
|
snippet find
|
||
|
|
find do |\${1:e}|
|
||
|
|
\${2}
|
||
|
|
end
|
||
|
|
snippet fina
|
||
|
|
find_all { |\${1:e}| \${2} }
|
||
|
|
snippet finad
|
||
|
|
find_all do |\${1:e}|
|
||
|
|
\${2}
|
||
|
|
end
|
||
|
|
snippet gre
|
||
|
|
grep(\${1:/pattern/}) { |\${2:match}| \${3} }
|
||
|
|
snippet sub
|
||
|
|
\${1:g}sub(\${2:/pattern/}) { |\${3:match}| \${4} }
|
||
|
|
snippet sca
|
||
|
|
scan(\${1:/pattern/}) { |\${2:match}| \${3} }
|
||
|
|
snippet scad
|
||
|
|
scan(\${1:/pattern/}) do |\${2:match}|
|
||
|
|
\${3}
|
||
|
|
end
|
||
|
|
snippet max
|
||
|
|
max { |a, b| \${1} }
|
||
|
|
snippet min
|
||
|
|
min { |a, b| \${1} }
|
||
|
|
snippet par
|
||
|
|
partition { |\${1:e}| \${2} }
|
||
|
|
snippet pard
|
||
|
|
partition do |\${1:e}|
|
||
|
|
\${2}
|
||
|
|
end
|
||
|
|
snippet rej
|
||
|
|
reject { |\${1:e}| \${2} }
|
||
|
|
snippet rejd
|
||
|
|
reject do |\${1:e}|
|
||
|
|
\${2}
|
||
|
|
end
|
||
|
|
snippet sel
|
||
|
|
select { |\${1:e}| \${2} }
|
||
|
|
snippet seld
|
||
|
|
select do |\${1:e}|
|
||
|
|
\${2}
|
||
|
|
end
|
||
|
|
snippet lam
|
||
|
|
lambda { |\${1:args}| \${2} }
|
||
|
|
snippet doo
|
||
|
|
do
|
||
|
|
\${1}
|
||
|
|
end
|
||
|
|
snippet dov
|
||
|
|
do |\${1:variable}|
|
||
|
|
\${2}
|
||
|
|
end
|
||
|
|
snippet :
|
||
|
|
:\${1:key} => \${2:"value"}\${3}
|
||
|
|
snippet ope
|
||
|
|
open(\${1:"path/or/url/or/pipe"}, "\${2:w}") { |\${3:io}| \${4} }
|
||
|
|
# path_from_here()
|
||
|
|
snippet fpath
|
||
|
|
File.join(File.dirname(__FILE__), *%2[\${1:rel path here}])\${2}
|
||
|
|
# unix_filter {}
|
||
|
|
snippet unif
|
||
|
|
ARGF.each_line\${1} do |\${2:line}|
|
||
|
|
\${3}
|
||
|
|
end
|
||
|
|
# option_parse {}
|
||
|
|
snippet optp
|
||
|
|
require "optparse"
|
||
|
|
|
||
|
|
options = {\${1:default => "args"}}
|
||
|
|
|
||
|
|
ARGV.options do |opts|
|
||
|
|
opts.banner = "Usage: #{File.basename($PROGRAM_NAME)}
|
||
|
|
snippet opt
|
||
|
|
opts.on( "-\${1:o}", "--\${2:long-option-name}", \${3:String},
|
||
|
|
"\${4:Option description.}") do |\${5:opt}|
|
||
|
|
\${6}
|
||
|
|
end
|
||
|
|
snippet tc
|
||
|
|
require "test/unit"
|
||
|
|
|
||
|
|
require "\${1:library_file_name}"
|
||
|
|
|
||
|
|
class Test\${2:$1} < Test::Unit::TestCase
|
||
|
|
def test_\${3:case_name}
|
||
|
|
\${4}
|
||
|
|
end
|
||
|
|
end
|
||
|
|
snippet ts
|
||
|
|
require "test/unit"
|
||
|
|
|
||
|
|
require "tc_\${1:test_case_file}"
|
||
|
|
require "tc_\${2:test_case_file}"\${3}
|
||
|
|
snippet as
|
||
|
|
assert \${1:test}, "\${2:Failure message.}"\${3}
|
||
|
|
snippet ase
|
||
|
|
assert_equal \${1:expected}, \${2:actual}\${3}
|
||
|
|
snippet asne
|
||
|
|
assert_not_equal \${1:unexpected}, \${2:actual}\${3}
|
||
|
|
snippet asid
|
||
|
|
assert_in_delta \${1:expected_float}, \${2:actual_float}, \${3:2 ** -20}\${4}
|
||
|
|
snippet asio
|
||
|
|
assert_instance_of \${1:ExpectedClass}, \${2:actual_instance}\${3}
|
||
|
|
snippet asko
|
||
|
|
assert_kind_of \${1:ExpectedKind}, \${2:actual_instance}\${3}
|
||
|
|
snippet asn
|
||
|
|
assert_nil \${1:instance}\${2}
|
||
|
|
snippet asnn
|
||
|
|
assert_not_nil \${1:instance}\${2}
|
||
|
|
snippet asm
|
||
|
|
assert_match /\${1:expected_pattern}/, \${2:actual_string}\${3}
|
||
|
|
snippet asnm
|
||
|
|
assert_no_match /\${1:unexpected_pattern}/, \${2:actual_string}\${3}
|
||
|
|
snippet aso
|
||
|
|
assert_operator \${1:left}, :\${2:operator}, \${3:right}\${4}
|
||
|
|
snippet asr
|
||
|
|
assert_raise \${1:Exception} { \${2} }
|
||
|
|
snippet asrd
|
||
|
|
assert_raise \${1:Exception} do
|
||
|
|
\${2}
|
||
|
|
end
|
||
|
|
snippet asnr
|
||
|
|
assert_nothing_raised \${1:Exception} { \${2} }
|
||
|
|
snippet asnrd
|
||
|
|
assert_nothing_raised \${1:Exception} do
|
||
|
|
\${2}
|
||
|
|
end
|
||
|
|
snippet asrt
|
||
|
|
assert_respond_to \${1:object}, :\${2:method}\${3}
|
||
|
|
snippet ass assert_same(..)
|
||
|
|
assert_same \${1:expected}, \${2:actual}\${3}
|
||
|
|
snippet ass assert_send(..)
|
||
|
|
assert_send [\${1:object}, :\${2:message}, \${3:args}]\${4}
|
||
|
|
snippet asns
|
||
|
|
assert_not_same \${1:unexpected}, \${2:actual}\${3}
|
||
|
|
snippet ast
|
||
|
|
assert_throws :\${1:expected} { \${2} }
|
||
|
|
snippet astd
|
||
|
|
assert_throws :\${1:expected} do
|
||
|
|
\${2}
|
||
|
|
end
|
||
|
|
snippet asnt
|
||
|
|
assert_nothing_thrown { \${1} }
|
||
|
|
snippet asntd
|
||
|
|
assert_nothing_thrown do
|
||
|
|
\${1}
|
||
|
|
end
|
||
|
|
snippet fl
|
||
|
|
flunk "\${1:Failure message.}"\${2}
|
||
|
|
# Benchmark.bmbm do .. end
|
||
|
|
snippet bm-
|
||
|
|
TESTS = \${1:10_000}
|
||
|
|
Benchmark.bmbm do |results|
|
||
|
|
\${2}
|
||
|
|
end
|
||
|
|
snippet rep
|
||
|
|
results.report("\${1:name}:") { TESTS.times { \${2} }}
|
||
|
|
# Marshal.dump(.., file)
|
||
|
|
snippet Md
|
||
|
|
File.open(\${1:"path/to/file.dump"}, "wb") { |\${2:file}| Marshal.dump(\${3:obj}, $2) }\${4}
|
||
|
|
# Mashal.load(obj)
|
||
|
|
snippet Ml
|
||
|
|
File.open(\${1:"path/to/file.dump"}, "rb") { |\${2:file}| Marshal.load($2) }\${3}
|
||
|
|
# deep_copy(..)
|
||
|
|
snippet deec
|
||
|
|
Marshal.load(Marshal.dump(\${1:obj_to_copy}))\${2}
|
||
|
|
snippet Pn-
|
||
|
|
PStore.new(\${1:"file_name.pstore"})\${2}
|
||
|
|
snippet tra
|
||
|
|
transaction(\${1:true}) { \${2} }
|
||
|
|
# xmlread(..)
|
||
|
|
snippet xml-
|
||
|
|
REXML::Document.new(File.read(\${1:"path/to/file"}))\${2}
|
||
|
|
# xpath(..) { .. }
|
||
|
|
snippet xpa
|
||
|
|
elements.each(\${1:"//Xpath"}) do |\${2:node}|
|
||
|
|
\${3}
|
||
|
|
end
|
||
|
|
# class_from_name()
|
||
|
|
snippet clafn
|
||
|
|
split("::").inject(Object) { |par, const| par.const_get(const) }
|
||
|
|
# singleton_class()
|
||
|
|
snippet sinc
|
||
|
|
class << self; self end
|
||
|
|
snippet nam
|
||
|
|
namespace :\${1:\`Filename()\`} do
|
||
|
|
\${2}
|
||
|
|
end
|
||
|
|
snippet tas
|
||
|
|
desc "\${1:Task description}"
|
||
|
|
task :\${2:task_name => [:dependent, :tasks]} do
|
||
|
|
\${3}
|
||
|
|
end
|
||
|
|
# block
|
||
|
|
snippet b
|
||
|
|
{ |\${1:var}| \${2} }
|
||
|
|
snippet begin
|
||
|
|
begin
|
||
|
|
raise 'A test exception.'
|
||
|
|
rescue Exception => e
|
||
|
|
puts e.message
|
||
|
|
puts e.backtrace.inspect
|
||
|
|
else
|
||
|
|
# other exception
|
||
|
|
ensure
|
||
|
|
# always executed
|
||
|
|
end
|
||
|
|
|
||
|
|
#debugging
|
||
|
|
snippet debug
|
||
|
|
require 'ruby-debug'; debugger; true;
|
||
|
|
snippet pry
|
||
|
|
require 'pry'; binding.pry
|
||
|
|
|
||
|
|
#############################################
|
||
|
|
# Rails snippets - for pure Ruby, see above #
|
||
|
|
#############################################
|
||
|
|
snippet art
|
||
|
|
assert_redirected_to \${1::action => "\${2:index}"}
|
||
|
|
snippet artnp
|
||
|
|
assert_redirected_to \${1:parent}_\${2:child}_path(\${3:@$1}, \${4:@$2})
|
||
|
|
snippet artnpp
|
||
|
|
assert_redirected_to \${1:parent}_\${2:child}_path(\${3:@$1})
|
||
|
|
snippet artp
|
||
|
|
assert_redirected_to \${1:model}_path(\${2:@$1})
|
||
|
|
snippet artpp
|
||
|
|
assert_redirected_to \${1:model}s_path
|
||
|
|
snippet asd
|
||
|
|
assert_difference "\${1:Model}.\${2:count}", $1 do
|
||
|
|
\${3}
|
||
|
|
end
|
||
|
|
snippet asnd
|
||
|
|
assert_no_difference "\${1:Model}.\${2:count}" do
|
||
|
|
\${3}
|
||
|
|
end
|
||
|
|
snippet asre
|
||
|
|
assert_response :\${1:success}, @response.body\${2}
|
||
|
|
snippet asrj
|
||
|
|
assert_rjs :\${1:replace}, "\${2:dom id}"
|
||
|
|
snippet ass assert_select(..)
|
||
|
|
assert_select '\${1:path}', :\${2:text} => '\${3:inner_html' \${4:do}
|
||
|
|
snippet bf
|
||
|
|
before_filter :\${1:method}
|
||
|
|
snippet bt
|
||
|
|
belongs_to :\${1:association}
|
||
|
|
snippet crw
|
||
|
|
cattr_accessor :\${1:attr_names}
|
||
|
|
snippet defcreate
|
||
|
|
def create
|
||
|
|
@\${1:model_class_name} = \${2:ModelClassName}.new(params[:$1])
|
||
|
|
|
||
|
|
respond_to do |wants|
|
||
|
|
if @$1.save
|
||
|
|
flash[:notice] = '$2 was successfully created.'
|
||
|
|
wants.html { redirect_to(@$1) }
|
||
|
|
wants.xml { render :xml => @$1, :status => :created, :location => @$1 }
|
||
|
|
else
|
||
|
|
wants.html { render :action => "new" }
|
||
|
|
wants.xml { render :xml => @$1.errors, :status => :unprocessable_entity }
|
||
|
|
end
|
||
|
|
end
|
||
|
|
end\${3}
|
||
|
|
snippet defdestroy
|
||
|
|
def destroy
|
||
|
|
@\${1:model_class_name} = \${2:ModelClassName}.find(params[:id])
|
||
|
|
@$1.destroy
|
||
|
|
|
||
|
|
respond_to do |wants|
|
||
|
|
wants.html { redirect_to($1s_url) }
|
||
|
|
wants.xml { head :ok }
|
||
|
|
end
|
||
|
|
end\${3}
|
||
|
|
snippet defedit
|
||
|
|
def edit
|
||
|
|
@\${1:model_class_name} = \${2:ModelClassName}.find(params[:id])
|
||
|
|
end
|
||
|
|
snippet defindex
|
||
|
|
def index
|
||
|
|
@\${1:model_class_name} = \${2:ModelClassName}.all
|
||
|
|
|
||
|
|
respond_to do |wants|
|
||
|
|
wants.html # index.html.erb
|
||
|
|
wants.xml { render :xml => @$1s }
|
||
|
|
end
|
||
|
|
end\${3}
|
||
|
|
snippet defnew
|
||
|
|
def new
|
||
|
|
@\${1:model_class_name} = \${2:ModelClassName}.new
|
||
|
|
|
||
|
|
respond_to do |wants|
|
||
|
|
wants.html # new.html.erb
|
||
|
|
wants.xml { render :xml => @$1 }
|
||
|
|
end
|
||
|
|
end\${3}
|
||
|
|
snippet defshow
|
||
|
|
def show
|
||
|
|
@\${1:model_class_name} = \${2:ModelClassName}.find(params[:id])
|
||
|
|
|
||
|
|
respond_to do |wants|
|
||
|
|
wants.html # show.html.erb
|
||
|
|
wants.xml { render :xml => @$1 }
|
||
|
|
end
|
||
|
|
end\${3}
|
||
|
|
snippet defupdate
|
||
|
|
def update
|
||
|
|
@\${1:model_class_name} = \${2:ModelClassName}.find(params[:id])
|
||
|
|
|
||
|
|
respond_to do |wants|
|
||
|
|
if @$1.update_attributes(params[:$1])
|
||
|
|
flash[:notice] = '$2 was successfully updated.'
|
||
|
|
wants.html { redirect_to(@$1) }
|
||
|
|
wants.xml { head :ok }
|
||
|
|
else
|
||
|
|
wants.html { render :action => "edit" }
|
||
|
|
wants.xml { render :xml => @$1.errors, :status => :unprocessable_entity }
|
||
|
|
end
|
||
|
|
end
|
||
|
|
end\${3}
|
||
|
|
snippet flash
|
||
|
|
flash[:\${1:notice}] = "\${2}"
|
||
|
|
snippet habtm
|
||
|
|
has_and_belongs_to_many :\${1:object}, :join_table => "\${2:table_name}", :foreign_key => "\${3}_id"\${4}
|
||
|
|
snippet hm
|
||
|
|
has_many :\${1:object}
|
||
|
|
snippet hmd
|
||
|
|
has_many :\${1:other}s, :class_name => "\${2:$1}", :foreign_key => "\${3:$1}_id", :dependent => :destroy\${4}
|
||
|
|
snippet hmt
|
||
|
|
has_many :\${1:object}, :through => :\${2:object}
|
||
|
|
snippet ho
|
||
|
|
has_one :\${1:object}
|
||
|
|
snippet i18
|
||
|
|
I18n.t('\${1:type.key}')\${2}
|
||
|
|
snippet ist
|
||
|
|
<%= image_submit_tag("\${1:agree.png}", :id => "\${2:id}"\${3} %>
|
||
|
|
snippet log
|
||
|
|
Rails.logger.\${1:debug} \${2}
|
||
|
|
snippet log2
|
||
|
|
RAILS_DEFAULT_LOGGER.\${1:debug} \${2}
|
||
|
|
snippet logd
|
||
|
|
logger.debug { "\${1:message}" }\${2}
|
||
|
|
snippet loge
|
||
|
|
logger.error { "\${1:message}" }\${2}
|
||
|
|
snippet logf
|
||
|
|
logger.fatal { "\${1:message}" }\${2}
|
||
|
|
snippet logi
|
||
|
|
logger.info { "\${1:message}" }\${2}
|
||
|
|
snippet logw
|
||
|
|
logger.warn { "\${1:message}" }\${2}
|
||
|
|
snippet mapc
|
||
|
|
\${1:map}.\${2:connect} '\${3:controller/:action/:id}'
|
||
|
|
snippet mapca
|
||
|
|
\${1:map}.catch_all "*\${2:anything}", :controller => "\${3:default}", :action => "\${4:error}"\${5}
|
||
|
|
snippet mapr
|
||
|
|
\${1:map}.resource :\${2:resource}
|
||
|
|
snippet maprs
|
||
|
|
\${1:map}.resources :\${2:resource}
|
||
|
|
snippet mapwo
|
||
|
|
\${1:map}.with_options :\${2:controller} => '\${3:thing}' do |$3|
|
||
|
|
\${4}
|
||
|
|
end
|
||
|
|
snippet mbs
|
||
|
|
before_save :\${1:method}
|
||
|
|
snippet mcht
|
||
|
|
change_table :\${1:table_name} do |t|
|
||
|
|
\${2}
|
||
|
|
end
|
||
|
|
snippet mp
|
||
|
|
map(&:\${1:id})
|
||
|
|
snippet mrw
|
||
|
|
mattr_accessor :\${1:attr_names}
|
||
|
|
snippet oa
|
||
|
|
order("\${1:field}")
|
||
|
|
snippet od
|
||
|
|
order("\${1:field} DESC")
|
||
|
|
snippet pa
|
||
|
|
params[:\${1:id}]\${2}
|
||
|
|
snippet ra
|
||
|
|
render :action => "\${1:action}"
|
||
|
|
snippet ral
|
||
|
|
render :action => "\${1:action}", :layout => "\${2:layoutname}"
|
||
|
|
snippet rest
|
||
|
|
respond_to do |wants|
|
||
|
|
wants.\${1:html} { \${2} }
|
||
|
|
end
|
||
|
|
snippet rf
|
||
|
|
render :file => "\${1:filepath}"
|
||
|
|
snippet rfu
|
||
|
|
render :file => "\${1:filepath}", :use_full_path => \${2:false}
|
||
|
|
snippet ri
|
||
|
|
render :inline => "\${1:<%= 'hello' %>}"
|
||
|
|
snippet ril
|
||
|
|
render :inline => "\${1:<%= 'hello' %>}", :locals => { \${2::name} => "\${3:value}"\${4} }
|
||
|
|
snippet rit
|
||
|
|
render :inline => "\${1:<%= 'hello' %>}", :type => \${2::rxml}
|
||
|
|
snippet rjson
|
||
|
|
render :json => \${1:text to render}
|
||
|
|
snippet rl
|
||
|
|
render :layout => "\${1:layoutname}"
|
||
|
|
snippet rn
|
||
|
|
render :nothing => \${1:true}
|
||
|
|
snippet rns
|
||
|
|
render :nothing => \${1:true}, :status => \${2:401}
|
||
|
|
snippet rp
|
||
|
|
render :partial => "\${1:item}"
|
||
|
|
snippet rpc
|
||
|
|
render :partial => "\${1:item}", :collection => \${2:@$1s}
|
||
|
|
snippet rpl
|
||
|
|
render :partial => "\${1:item}", :locals => { :\${2:$1} => \${3:@$1}
|
||
|
|
snippet rpo
|
||
|
|
render :partial => "\${1:item}", :object => \${2:@$1}
|
||
|
|
snippet rps
|
||
|
|
render :partial => "\${1:item}", :status => \${2:500}
|
||
|
|
snippet rt
|
||
|
|
render :text => "\${1:text to render}"
|
||
|
|
snippet rtl
|
||
|
|
render :text => "\${1:text to render}", :layout => "\${2:layoutname}"
|
||
|
|
snippet rtlt
|
||
|
|
render :text => "\${1:text to render}", :layout => \${2:true}
|
||
|
|
snippet rts
|
||
|
|
render :text => "\${1:text to render}", :status => \${2:401}
|
||
|
|
snippet ru
|
||
|
|
render :update do |\${1:page}|
|
||
|
|
$1.\${2}
|
||
|
|
end
|
||
|
|
snippet rxml
|
||
|
|
render :xml => \${1:text to render}
|
||
|
|
snippet sc
|
||
|
|
scope :\${1:name}, :where(:@\${2:field} => \${3:value})
|
||
|
|
snippet sl
|
||
|
|
scope :\${1:name}, lambda do |\${2:value}|
|
||
|
|
where("\${3:field = ?}", \${4:bind var})
|
||
|
|
end
|
||
|
|
snippet sha1
|
||
|
|
Digest::SHA1.hexdigest(\${1:string})
|
||
|
|
snippet sweeper
|
||
|
|
class \${1:ModelClassName}Sweeper < ActionController::Caching::Sweeper
|
||
|
|
observe $1
|
||
|
|
|
||
|
|
def after_save(\${2:model_class_name})
|
||
|
|
expire_cache($2)
|
||
|
|
end
|
||
|
|
|
||
|
|
def after_destroy($2)
|
||
|
|
expire_cache($2)
|
||
|
|
end
|
||
|
|
|
||
|
|
def expire_cache($2)
|
||
|
|
expire_page
|
||
|
|
end
|
||
|
|
end
|
||
|
|
snippet tcb
|
||
|
|
t.boolean :\${1:title}
|
||
|
|
\${2}
|
||
|
|
snippet tcbi
|
||
|
|
t.binary :\${1:title}, :limit => \${2:2}.megabytes
|
||
|
|
\${3}
|
||
|
|
snippet tcd
|
||
|
|
t.decimal :\${1:title}, :precision => \${2:10}, :scale => \${3:2}
|
||
|
|
\${4}
|
||
|
|
snippet tcda
|
||
|
|
t.date :\${1:title}
|
||
|
|
\${2}
|
||
|
|
snippet tcdt
|
||
|
|
t.datetime :\${1:title}
|
||
|
|
\${2}
|
||
|
|
snippet tcf
|
||
|
|
t.float :\${1:title}
|
||
|
|
\${2}
|
||
|
|
snippet tch
|
||
|
|
t.change :\${1:name}, :\${2:string}, :\${3:limit} => \${4:80}
|
||
|
|
\${5}
|
||
|
|
snippet tci
|
||
|
|
t.integer :\${1:title}
|
||
|
|
\${2}
|
||
|
|
snippet tcl
|
||
|
|
t.integer :lock_version, :null => false, :default => 0
|
||
|
|
\${1}
|
||
|
|
snippet tcr
|
||
|
|
t.references :\${1:taggable}, :polymorphic => { :default => '\${2:Photo}' }
|
||
|
|
\${3}
|
||
|
|
snippet tcs
|
||
|
|
t.string :\${1:title}
|
||
|
|
\${2}
|
||
|
|
snippet tct
|
||
|
|
t.text :\${1:title}
|
||
|
|
\${2}
|
||
|
|
snippet tcti
|
||
|
|
t.time :\${1:title}
|
||
|
|
\${2}
|
||
|
|
snippet tcts
|
||
|
|
t.timestamp :\${1:title}
|
||
|
|
\${2}
|
||
|
|
snippet tctss
|
||
|
|
t.timestamps
|
||
|
|
\${1}
|
||
|
|
snippet va
|
||
|
|
validates_associated :\${1:attribute}
|
||
|
|
snippet vao
|
||
|
|
validates_acceptance_of :\${1:terms}
|
||
|
|
snippet vc
|
||
|
|
validates_confirmation_of :\${1:attribute}
|
||
|
|
snippet ve
|
||
|
|
validates_exclusion_of :\${1:attribute}, :in => \${2:%w( mov avi )}
|
||
|
|
snippet vf
|
||
|
|
validates_format_of :\${1:attribute}, :with => /\${2:regex}/
|
||
|
|
snippet vi
|
||
|
|
validates_inclusion_of :\${1:attribute}, :in => %w(\${2: mov avi })
|
||
|
|
snippet vl
|
||
|
|
validates_length_of :\${1:attribute}, :within => \${2:3}..\${3:20}
|
||
|
|
snippet vn
|
||
|
|
validates_numericality_of :\${1:attribute}
|
||
|
|
snippet vpo
|
||
|
|
validates_presence_of :\${1:attribute}
|
||
|
|
snippet vu
|
||
|
|
validates_uniqueness_of :\${1:attribute}
|
||
|
|
snippet wants
|
||
|
|
wants.\${1:js|xml|html} { \${2} }
|
||
|
|
snippet wc
|
||
|
|
where(\${1:"conditions"}\${2:, bind_var})
|
||
|
|
snippet wh
|
||
|
|
where(\${1:field} => \${2:value})
|
||
|
|
snippet xdelete
|
||
|
|
xhr :delete, :\${1:destroy}, :id => \${2:1}\${3}
|
||
|
|
snippet xget
|
||
|
|
xhr :get, :\${1:show}, :id => \${2:1}\${3}
|
||
|
|
snippet xpost
|
||
|
|
xhr :post, :\${1:create}, :\${2:object} => { \${3} }
|
||
|
|
snippet xput
|
||
|
|
xhr :put, :\${1:update}, :id => \${2:1}, :\${3:object} => { \${4} }\${5}
|
||
|
|
snippet test
|
||
|
|
test "should \${1:do something}" do
|
||
|
|
\${2}
|
||
|
|
end
|
||
|
|
#migrations
|
||
|
|
snippet mac
|
||
|
|
add_column :\${1:table_name}, :\${2:column_name}, :\${3:data_type}
|
||
|
|
snippet mrc
|
||
|
|
remove_column :\${1:table_name}, :\${2:column_name}
|
||
|
|
snippet mrnc
|
||
|
|
rename_column :\${1:table_name}, :\${2:old_column_name}, :\${3:new_column_name}
|
||
|
|
snippet mcc
|
||
|
|
change_column :\${1:table}, :\${2:column}, :\${3:type}
|
||
|
|
snippet mccc
|
||
|
|
t.column :\${1:title}, :\${2:string}
|
||
|
|
snippet mct
|
||
|
|
create_table :\${1:table_name} do |t|
|
||
|
|
t.column :\${2:name}, :\${3:type}
|
||
|
|
end
|
||
|
|
snippet migration
|
||
|
|
class \${1:class_name} < ActiveRecord::Migration
|
||
|
|
def self.up
|
||
|
|
\${2}
|
||
|
|
end
|
||
|
|
|
||
|
|
def self.down
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
snippet trc
|
||
|
|
t.remove :\${1:column}
|
||
|
|
snippet tre
|
||
|
|
t.rename :\${1:old_column_name}, :\${2:new_column_name}
|
||
|
|
\${3}
|
||
|
|
snippet tref
|
||
|
|
t.references :\${1:model}
|
||
|
|
|
||
|
|
#rspec
|
||
|
|
snippet it
|
||
|
|
it "\${1:spec_name}" do
|
||
|
|
\${2}
|
||
|
|
end
|
||
|
|
snippet itp
|
||
|
|
it "\${1:spec_name}"
|
||
|
|
\${2}
|
||
|
|
snippet desc
|
||
|
|
describe \${1:class_name} do
|
||
|
|
\${2}
|
||
|
|
end
|
||
|
|
snippet cont
|
||
|
|
context "\${1:message}" do
|
||
|
|
\${2}
|
||
|
|
end
|
||
|
|
snippet bef
|
||
|
|
before :\${1:each} do
|
||
|
|
\${2}
|
||
|
|
end
|
||
|
|
snippet aft
|
||
|
|
after :\${1:each} do
|
||
|
|
\${2}
|
||
|
|
end
|
||
|
|
`}),ace.define("ace/snippets/ruby",["require","exports","module","ace/snippets/ruby.snippets"],function(t,e,s){"use strict";e.snippetText=t("./ruby.snippets"),e.scope="ruby"}),function(){ace.require(["ace/snippets/ruby"],function(t){n&&(n.exports=t)})}()}}]);
|