snippet enc # encoding: utf-8 snippet #! #!/usr/bin/env ruby # New Block snippet =b =begin rdoc ${0} =end snippet prot protected ${0} snippet priv private ${0} snippet y :yields: ${0:arguments} snippet rb #!/usr/bin/env ruby -wKU snippet beg begin ${0} rescue ${1:Exception} => ${2:e} end snippet req require require '${1}' snippet reqr require_relative '${1}' snippet # # => snippet case case ${1:object} when ${2:condition} ${0} end snippet when when ${1:condition} ${0} snippet def def ${1:method_name} ${0} end snippet deft def test_${1:case_name} ${0} end snippet descendants class Class def descendants ObjectSpace.each_object(::Class).select { |klass| klass < self } end end snippet if if ${1:condition} ${0} end snippet ife if ${1:condition} ${2} else ${0} end snippet eif elsif ${1:condition} ${0} snippet ifee if ${1:condition} $2 elsif ${3:condition} $4 else $0 end snippet unless unless ${1:condition} ${0} end snippet unlesse unless ${1:condition} $2 else $0 end snippet unlesee unless ${1:condition} $2 elsif ${3:condition} $4 else $0 end snippet wh while ${1:condition} ${0} end snippet for for ${1:e} in ${2:c} ${0} end snippet until until ${1:condition} ${0} end snippet cla class .. end class ${1:`substitute(vim_snippets#Filename(), '\(_\|^\)\(.\)', '\u\2', 'g')`} ${0} end snippet clai class .. initialize .. end class ${1:`substitute(vim_snippets#Filename(), '\(_\|^\)\(.\)', '\u\2', 'g')`} def initialize(${2:args}) ${0} end end snippet cla< class .. < ParentClass .. initialize .. end class ${1:`substitute(vim_snippets#Filename(), '\(_\|^\)\(.\)', '\u\2', 'g')`} < ${2:ParentClass} def initialize(${3:args}) ${0} end end snippet blankslate class BlankSlate .. initialize .. end class ${0:BlankSlate} instance_methods.each { |meth| undef_method(meth) unless meth =~ /\A__/ } end snippet claself class << self .. end class << ${1:self} ${0} end # class .. < DelegateClass .. initialize .. end snippet cla- class ${1:`substitute(vim_snippets#Filename(), '\(_\|^\)\(.\)', '\u\2', 'g')`} < DelegateClass(${2:ParentClass}) def initialize(${3:args}) super(${4:del_obj}) ${0} end end snippet mod module .. end module ${1:`substitute(vim_snippets#Filename(), '\(_\|^\)\(.\)', '\u\2', 'g')`} ${0} end snippet mod module .. ClassMethods .. end module ${1:`substitute(vim_snippets#Filename(), '\(_\|^\)\(.\)', '\u\2', 'g')`} module ClassMethods ${0} end module InstanceMethods end def self.included(receiver) receiver.extend ClassMethods receiver.send :include, InstanceMethods end end # attr_reader snippet r attr_reader :${0:attr_names} # attr_writer snippet w attr_writer :${0:attr_names} # attr_accessor snippet rw attr_accessor :${0:attr_names} snippet atp attr_protected :${0:attr_names} snippet ata attr_accessible :${0:attr_names} snippet ana accepts_nested_attributes_for :${0:association} # ivc == instance variable cache snippet ivc @${1:variable_name} ||= ${0:cached_value} # include Enumerable snippet Enum include Enumerable def each(&block) ${0} end # include Comparable snippet Comp include Comparable def <=>(other) ${0} end # extend Forwardable snippet Forw- extend Forwardable # def self snippet defs def self.${1:class_method_name} ${0} end # def initialize snippet definit def initialize(${1:args}) ${0} end # def method_missing snippet defmm def method_missing(meth, *args, &blk) ${0} end snippet defd def_delegator :${1:@del_obj}, :${2:del_meth}, :${0:new_name} snippet defds def_delegators :${1:@del_obj}, :${0:del_methods} snippet am alias_method :${1:new_name}, :${0:old_name} snippet app if __FILE__ == $PROGRAM_NAME ${0} end # usage_if() snippet usai if ARGV.${1} abort "Usage: #{$PROGRAM_NAME} ${2:ARGS_GO_HERE}"${0} end # usage_unless() snippet usau unless ARGV.${1} abort "Usage: #{$PROGRAM_NAME} ${2:ARGS_GO_HERE}"${0} end snippet array Array.new(${1:10}) { |${2:i}| ${0} } snippet hash Hash.new { |${1:hash}, ${2:key}| $1[$2] = ${0} } snippet file File.foreach() { |line| .. } File.foreach(${1:'path/to/file'}) { |${2:line}| ${0} } snippet file File.read() File.read(${1:'path/to/file'}) snippet Dir Dir.global() { |file| .. } Dir.glob(${1:'dir/glob/*'}) { |${2:file}| ${0} } snippet Dir Dir[".."] Dir[${1:'glob/**/*.rb'}] snippet dir Filename.dirname(__FILE__) snippet deli delete_if { |${1:e}| ${0} } snippet fil fill(${1:range}) { |${2:i}| ${0} } # flatten_once() snippet flao reduce(Array.new) { |${1:arr}, ${2:a}| $1.push(*$2) } snippet zip zip(${1:enums}) { |${2:row}| ${0} } # downto(0) { |n| .. } snippet dow downto(${1:0}) { |${2:n}| ${0} } snippet ste step(${1:2}) { |${2:n}| ${0} } snippet tim times { |${1:n}| ${0} } snippet upt upto(${1:1.0/0.0}) { |${2:n}| ${0} } snippet loo loop { ${0} } snippet ea each { |${1:e}| ${0} } snippet ead each do |${1:e}| ${0} end snippet eab each_byte { |${1:byte}| ${0} } snippet eac- each_char { |chr| .. } each_char { |${1:chr}| ${0} } snippet eac- each_cons(..) { |group| .. } each_cons(${1:2}) { |${2:group}| ${0} } snippet eai each_index { |${1:i}| ${0} } snippet eaid each_index do |${1:i}| ${0} end snippet eak each_key { |${1:key}| ${0} } snippet eakd each_key do |${1:key}| ${0} end snippet eal each_line { |${1:line}| ${0} } snippet eald each_line do |${1:line}| ${0} end snippet eap each_pair { |${1:name}, ${2:val}| ${0} } snippet eapd each_pair do |${1:name}, ${2:val}| ${0} end snippet eas- each_slice(${1:2}) { |${2:group}| ${0} } snippet easd- each_slice(${1:2}) do |${2:group}| ${0} end snippet eav each_value { |${1:val}| ${0} } snippet eavd each_value do |${1:val}| ${0} end snippet eawi each_with_index { |${1:e}, ${2:i}| ${0} } snippet eawid each_with_index do |${1:e}, ${2:i}| ${0} end snippet eawo each_with_object(${1:init}) { |${2:e}, ${3:var}| ${0} } snippet eawod each_with_object(${1:init}) do |${2:e}, ${3:var}| ${0} end snippet reve reverse_each { |${1:e}| ${0} } snippet reved reverse_each do |${1:e}| ${0} end snippet inj inject(${1:init}) { |${2:mem}, ${3:var}| ${0} } snippet injd inject(${1:init}) do |${2:mem}, ${3:var}| ${0} end snippet red reduce(${1:init}) { |${2:mem}, ${3:var}| ${0} } snippet redd reduce(${1:init}) do |${2:mem}, ${3:var}| ${0} end snippet map map { |${1:e}| ${0} } snippet mapd map do |${1:e}| ${0} end snippet mapwi- enum_with_index.map { |${1:e}, ${2:i}| ${0} } snippet sor sort { |a, b| ${0} } snippet sorb sort_by { |${1:e}| ${0} } snippet ran sort_by { rand } snippet all all? { |${1:e}| ${0} } snippet any any? { |${1:e}| ${0} } snippet cl classify { |${1:e}| ${0} } snippet col collect { |${1:e}| ${0} } snippet cold collect do |${1:e}| ${0} end snippet det detect { |${1:e}| ${0} } snippet detd detect do |${1:e}| ${0} end snippet fet fetch(${1:name}) { |${2:key}| ${0} } snippet fin find { |${1:e}| ${0} } snippet find find do |${1:e}| ${0} end snippet fina find_all { |${1:e}| ${0} } snippet finad find_all do |${1:e}| ${0} end snippet gre grep(${1:/pattern/}) { |${2:match}| ${0} } snippet sub ${1:g}sub(${2:/pattern/}) { |${3:match}| ${0} } snippet sca scan(${1:/pattern/}) { |${2:match}| ${0} } snippet scad scan(${1:/pattern/}) do |${2:match}| ${0} end snippet max max { |a, b| ${0} } snippet min min { |a, b| ${0} } snippet par partition { |${1:e}| ${0} } snippet pard partition do |${1:e}| ${0} end snippet rej reject { |${1:e}| ${0} } snippet rejd reject do |${1:e}| ${0} end snippet sel select { |${1:e}| ${0} } snippet seld select do |${1:e}| ${0} end snippet lam lambda { |${1:args}| ${0} } snippet -> -> { ${0} } snippet ->a ->(${1:args}) { ${0} } # I'm pretty sure that ruby users expect do to expand to do .. end snippet do do ${0} end # this is for one or more variables. typing a ", " is that cheap that it may # not be worth adding another snippet. should 0/1 placeholders change order? # its a good idea to think about the var name, so use it first snippet dov do |${1:v}| ${2} end snippet : ${1:key}: ${2:'value'} snippet ope open('${1:path/or/url/or/pipe}', '${2:w}') { |${3:io}| ${0} } # path_from_here() snippet fpath File.join(File.dirname(__FILE__), *['${1:rel path here}']) # unix_filter {} snippet unif ARGF.each_line${1} do |${2:line}| ${0} end # option_parse {} snippet optp require 'optparse' options = { ${0:default: 'args'} } ARGV.options do |opts| opts.banner = "Usage: #{File.basename($PROGRAM_NAME)}" end snippet opt opts.on('-${1:o}', '--${2:long-option-name}', ${3:String}, '${4:Option description.}') do |${5:opt}| ${0} end snippet tc require 'test/unit' require '${1:library_file_name}' class Test${2:$1} < Test::Unit::TestCase def test_${3:case_name} ${0} end end snippet ts require 'test/unit' require 'tc_${1:test_case_file}' require 'tc_${2:test_case_file}' snippet as assert ${1:test}, '${2:Failure message.}' snippet ase assert_equal ${1:expected}, ${2:actual} snippet asne assert_not_equal ${1:unexpected}, ${2:actual} snippet asid assert_in_delta ${1:expected_float}, ${2:actual_float}, ${3:2**-20} snippet asi assert_includes ${1:collection}, ${2:object} snippet asio assert_instance_of ${1:ExpectedClass}, ${2:actual_instance} snippet asko assert_kind_of ${1:ExpectedKind}, ${2:actual_instance} snippet asn assert_nil ${1:instance} snippet asnn assert_not_nil ${1:instance} snippet asm assert_match(/${1:expected_pattern}/, ${2:actual_string}) snippet asnm assert_no_match(/${1:unexpected_pattern}/, ${2:actual_string}) snippet aso assert_operator ${1:left}, :${2:operator}, ${3:right} snippet asr assert_raise ${1:Exception} { ${0} } snippet asrd assert_raise ${1:Exception} do ${0} end snippet asnr assert_nothing_raised ${1:Exception} { ${0} } snippet asnrd assert_nothing_raised ${1:Exception} do ${0} end snippet asrt assert_respond_to ${1:object}, :${2:method} snippet ass assert_same(..) assert_same ${1:expected}, ${2:actual} snippet ass assert_send(..) assert_send [${1:object}, :${2:message}, ${3:args}] snippet asns assert_not_same ${1:unexpected}, ${2:actual} snippet ast assert_throws :${1:expected}, -> { ${0} } snippet astd assert_throws :${1:expected} do ${0} end snippet asnt assert_nothing_thrown { ${0} } snippet asntd assert_nothing_thrown do ${0} end snippet fl flunk '${1:Failure message.}' # Benchmark.bmbm do .. end snippet bm- TESTS = ${1:10_000} Benchmark.bmbm do |results| ${0} end snippet rep results.report('${1:name}:') { TESTS.times { ${0} } } # Marshal.dump(.., file) snippet Md File.open('${1:path/to/file.dump}', 'wb') { |${2:file}| Marshal.dump(${3:obj}, $2) } # Mashal.load(obj) snippet Ml File.open('${1:path/to/file.dump}', 'rb') { |${2:file}| Marshal.load($2) } # deep_copy(..) snippet deec Marshal.load(Marshal.dump(${1:obj_to_copy})) snippet Pn- PStore.new('${1:file_name.pstore}') snippet tra transaction(${1:true}) { ${0} } # xmlread(..) snippet xml- REXML::Document.new(File.read('${1:path/to/file}')) # xpath(..) { .. } snippet xpa elements.each('${1://Xpath}') do |${2:node}| ${0} 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:`vim_snippets#Filename()`} do ${0} end snippet tas desc '${1:Task description}' task ${2:task_name: [:dependent, :tasks]} do ${0} end # block snippet b { |${1:var}| ${0} } snippet begin begin fail 'A test exception.' rescue Exception => e puts e.message puts e.backtrace.inspect else # other exception ensure # always executed end #debugging snippet debug require 'byebug'; byebug snippet debug19 require 'debugger'; debugger snippet debug18 require 'ruby-debug'; debugger snippet pry require 'pry'; binding.pry snippet strf strftime('${1:%Y-%m-%d %H:%M:%S %z}')${0} # # Minitest snippets # snippet mb must_be ${0} snippet wb wont_be ${0} snippet mbe must_be_empty snippet wbe wont_be_empty snippet mbio must_be_instance_of ${0:Class} snippet wbio wont_be_instance_of ${0:Class} snippet mbko must_be_kind_of ${0:Class} snippet wbko wont_be_kind_of ${0:Class} snippet mbn must_be_nil snippet wbn wont_be_nil snippet mbsa must_be_same_as ${0:other} snippet wbsa wont_be_same_as ${0:other} snippet mbsi -> { ${0} }.must_be_silent snippet mbwd must_be_within_delta ${1:0.1}, ${2:0.1} snippet wbwd wont_be_within_delta ${1:0.1}, ${2:0.1} snippet mbwe must_be_within_epsilon ${1:0.1}, ${2:0.1} snippet wbwe wont_be_within_epsilon ${1:0.1}, ${2:0.1} snippet me must_equal ${0:other} snippet we wont_equal ${0:other} snippet mi must_include ${0:what} snippet wi wont_include ${0:what} snippet mm must_match /${0:regex}/ snippet wm wont_match /${0:regex}/ snippet mout -> { ${1} }.must_output '${0}' snippet mra -> { ${1} }.must_raise ${0:Exception} snippet mrt must_respond_to :${0:method} snippet wrt wont_respond_to :${0:method} snippet msend must_send [ ${1:what}, :${2:method}, ${3:args} ] snippet mthrow -> { throw :${1:error} }.must_throw :${2:error} ########################## # Rspec snippets # ########################## snippet desc describe ${1:`substitute(substitute(vim_snippets#Filename(), '_spec$', '', ''), '\(_\|^\)\(.\)', '\u\2', 'g')`} do ${0} end snippet descm describe '${1:#method}' do ${0:pending 'Not implemented'} end snippet cont context '${1:message}' do ${0} end snippet bef before :${1:each} do ${0} end snippet aft after :${1:each} do ${0} end snippet let let(:${1:object}) { ${0} } snippet let! let!(:${1:object}) { ${0} } snippet subj subject { ${0} } snippet s. subject.${0:method} snippet spec specify { subject.${0} } snippet exp expect(${1:object}).to ${0} snippet expb expect { ${1:object} }.to ${0} snippet experr expect { ${1:object} }.to raise_error ${2:StandardError}, /${0:message_regex}/ snippet shared shared_examples ${0:'shared examples name'} snippet ibl it_behaves_like ${0:'shared examples name'} snippet it it '${1:spec_name}' do ${0} end snippet its its(:${1:method}) { should ${0} } snippet is it { should ${0} } snippet isn it { should_not ${0} } snippet iexp it { expect(${1:object}).${1} ${0} } snippet iexpb it { expect { ${1:object} }.${1} ${0} } snippet iiexp it { is_expected.to ${0} } snippet iiexpn it { is_expected.not_to ${0} }