]> git.madduck.net Git - etc/vim.git/blobdiff - .vim/snippets/ruby.snippets

madduck's git repository

Every one of the projects in this repository is available at the canonical URL git://git.madduck.net/madduck/pub/<projectpath> — see each project's metadata for the exact URL.

All patches and comments are welcome. Please squash your changes to logical commits before using git-format-patch and git-send-email to patches@git.madduck.net. If you'd read over the Git project's submission guidelines and adhered to them, I'd be especially grateful.

SSH access, as well as push access can be individually arranged.

If you use my repositories frequently, consider adding the following snippet to ~/.gitconfig and using the third clone URL listed for each project:

[url "git://git.madduck.net/madduck/"]
  insteadOf = madduck:

Merge commit '907d4569b0384e76f9e3ca4a6a7ee917712c031d' into tmp
[etc/vim.git] / .vim / snippets / ruby.snippets
deleted file mode 100644 (file)
index bf1d7f1765a38d34b404d9bdff8acf65ecf72fc7..0000000000000000000000000000000000000000
+++ /dev/null
@@ -1,420 +0,0 @@
-# #!/usr/bin/ruby
-snippet #!
-       #!/usr/bin/ruby
-
-# New Block
-snippet =b
-       =begin rdoc
-               ${1}
-       =end
-snippet y
-       :yields: ${1:arguments}
-snippet rb
-       #!/usr/bin/env ruby -wKU
-
-snippet req
-       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 until
-       until ${1:condition}
-               ${2}
-       end
-snippet cla class .. end
-       class ${1:`substitute(Filename(), '^.', '\u&', '')`}
-               ${2}
-       end
-snippet cla class .. initialize .. end
-       class ${1:`substitute(Filename(), '^.', '\u&', '')`}
-               def initialize(${2:args})
-                       ${3}
-               end
-
-
-       end
-snippet cla class .. < ParentClass .. initialize .. end
-       class ${1:`substitute(Filename(), '^.', '\u&', '')`} < ${2:ParentClass}
-               def initialize(${3:args})
-                       ${4}
-               end
-
-
-       end
-snippet cla ClassName = Struct .. do .. end
-       ${1:`substitute(Filename(), '^.', '\u&', '')`} = 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__/ }
-snippet cla class << self .. end
-       class << ${1:self}
-               ${2}
-       end
-# class .. < DelegateClass .. initialize .. end
-snippet cla-
-       class ${1:`substitute(Filename(), '^.', '\u&', '')`} < DelegateClass(${2:ParentClass})
-               def initialize(${3:args})
-                       super(${4:del_obj})
-
-                       ${5}
-               end
-
-
-       end
-snippet mod module .. end
-       module ${1:`substitute(Filename(), '^.', '\u&', '')`}
-               ${2}
-       end
-snippet mod module .. module_function .. end
-       module ${1:`substitute(Filename(), '^.', '\u&', '')`}
-               module_function
-
-               ${2}
-       end
-snippet mod module .. ClassMethods .. end
-       module ${1:`substitute(Filename(), '^.', '\u&', '')`}
-               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}
-# 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 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 eak
-       each_key { |${1:key}| ${2} }
-snippet eal
-       each_line { |${1:line}| ${2} }
-snippet eap
-       each_pair { |${1:name}, ${2:val}| ${3} }
-snippet eas-
-       each_slice(${1:2}) { |${2:group}| ${3} }
-snippet eav
-       each_value { |${1:val}| ${2} }
-snippet eawi
-       each_with_index { |${1:e}, ${2:i}| ${3} }
-snippet reve
-       reverse_each { |${1:e}| ${2} }
-snippet inj
-       inject(${1:init}) { |${2:mem}, ${3:var}| ${4} }
-snippet map
-       map { |${1:e}| ${2} }
-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 det
-       detect { |${1:e}| ${2} }
-snippet fet
-       fetch(${1:name}) { |${2:key}| ${3} }
-snippet fin
-       find { |${1:e}| ${2} }
-snippet fina
-       find_all { |${1:e}| ${2} }
-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 max
-       max { |a, b|, ${1} }
-snippet min
-       min { |a, b|, ${1} }
-snippet par
-       partition { |${1:e}|, ${2} }
-snippet rej
-       reject { |${1:e}|, ${2} }
-snippet sel
-       select { |${1:e}|, ${2} }
-snippet lam
-       lambda { |${1:args}| ${2} }
-snippet do
-       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 patfh
-       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 asnr
-       assert_nothing_raised(${1:Exception}) { ${2} }
-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 asnt
-       assert_nothing_thrown { ${1} }
-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
new file mode 120000 (symlink)
index 0000000000000000000000000000000000000000..66f6f72dc32bab8f041c03c9e46b9189a8c5fdd4
--- /dev/null
@@ -0,0 +1 @@
+/usr/share/vim/addons/snippets/ruby.snippets
\ No newline at end of file