From 9931e0888b2419326ae10ebbfae532261c5c125f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Karel=20Ko=C4=8D=C3=AD?= Date: Thu, 30 Jun 2016 16:11:56 +0200 Subject: Fix submodules --- vim/bundle/vim-snippets | 1 + vim/bundle/vim-snippets/snippets/ruby.snippets | 731 ------------------------- 2 files changed, 1 insertion(+), 731 deletions(-) create mode 160000 vim/bundle/vim-snippets delete mode 100644 vim/bundle/vim-snippets/snippets/ruby.snippets (limited to 'vim/bundle/vim-snippets/snippets/ruby.snippets') diff --git a/vim/bundle/vim-snippets b/vim/bundle/vim-snippets new file mode 160000 index 0000000..15d7e5e --- /dev/null +++ b/vim/bundle/vim-snippets @@ -0,0 +1 @@ +Subproject commit 15d7e5ec26ec93adee4051b6359be90a943aa38d 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 -- cgit v1.2.3