Add current configurations from old repository

1 files changed, 731 insertions, 0 deletions

diff --git a/vim/bundle/vim-snippets/snippets/ruby.snippets b/vim/bundle/vim-snippets/snippets/ruby.snippets
new file mode 100644
index 0000000..772f464
--- /dev/null
+++ b/vim/bundle/vim-snippets/snippets/ruby.snippets
@@ -0,0 +1,731 @@
+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