aboutsummaryrefslogtreecommitdiff
path: root/vim/bundle/vim-snippets/snippets/ruby.snippets
diff options
context:
space:
mode:
Diffstat (limited to 'vim/bundle/vim-snippets/snippets/ruby.snippets')
m---------vim/bundle/vim-snippets0
-rw-r--r--vim/bundle/vim-snippets/snippets/ruby.snippets731
2 files changed, 0 insertions, 731 deletions
diff --git a/vim/bundle/vim-snippets b/vim/bundle/vim-snippets
new file mode 160000
+Subproject 15d7e5ec26ec93adee4051b6359be90a943aa38
diff --git a/vim/bundle/vim-snippets/snippets/ruby.snippets b/vim/bundle/vim-snippets/snippets/ruby.snippets
deleted file mode 100644
index 772f464..0000000
--- a/vim/bundle/vim-snippets/snippets/ruby.snippets
+++ /dev/null
@@ -1,731 +0,0 @@
-snippet enc
- # encoding: utf-8
-snippet frozen
- # frozen_string_literal: true
-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} }
-snippet agg
- aggregate_failures '${1:message}' do
- ${0}
- end
generated by cgit v1.2.3 (git 2.25.1) at 2024-09-22 02:07:08 +0000