web-interface.assets.54a10f3bddad1e6da452fee7124fe846.js Maven / Gradle / Ivy
(()=>{var i=(t,n)=>()=>(n||t((n={exports:{}}).exports,n),n.exports);var a=i((p,e)=>{ace.define("ace/snippets/ruby.snippets",["require","exports","module"],function(t,n,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,n,s){"use strict";n.snippetText=t("./ruby.snippets"),n.scope="ruby"});(function(){ace.require(["ace/snippets/ruby"],function(t){typeof e=="object"&&typeof p=="object"&&e&&(e.exports=t)})})()});a();})();
//# sourceMappingURL=54a10f3bddad1e6da452fee7124fe846.js.map© 2015 - 2024 Weber Informatics LLC | Privacy Policy