check in snipmate 0.83

[etc/vim.git] / .vim / snippets / ruby.snippets

# #!/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