adding new stuff

plugins/bundle/xptemplate/ftplugin/ruby/ruby.xpt.vim

@@ -0,0 +1,821 @@
+XPTemplate priority=lang keyword=:%#
+
+" containers
+let s:f = g:XPTfuncs()
+
+" inclusion
+XPTinclude
+      \ _common/common
+
+" ========================= Function and Variables =============================
+
+fun! s:f.RubyCamelCase(...) "{{{
+  let str = a:0 == 0 ? self.V() : a:1
+  let r = substitute(substitute(str, "[\/ _]", ' ', 'g'), '\<.', '\u&', 'g')
+  return substitute(r, " ", '', 'g')
+endfunction "}}}
+
+fun! s:f.RubySnakeCase(...) "{{{
+  let str = a:0 == 0 ? self.V() : a:1
+  return substitute(str," ",'_','g')
+endfunction "}}}
+
+" Multiple each snippet {{{
+"{{{ s:each_list
+let s:each_list = [ 'byte', 'char', 'cons', 'index', 'key',
+      \'line', 'pair', 'slice', 'value' ]
+"}}}
+
+fun! s:f.RubyEachPopup() "{{{
+  let l = []
+  for i in s:each_list
+    let l += [{'word': i, 'menu': 'each_' . i . '{ |..| ... }'}]
+  endfor
+  return l
+endfunction "}}}
+
+fun! s:f.RubyEachBrace() "{{{
+  let v = self.SV('^_','','')
+  if v == ''
+    return ''
+  elseif v =~# 'slice\|cons'
+    return '_' . v.'(`val^3^)'
+  else
+    return '_' . v
+  endif
+endfunction "}}}
+
+fun! s:f.RubyEachPair() "{{{
+  let v = self.R('what')
+  if v =~# 'pair'
+    return '`el1^, `el2^'
+  elseif v == ''
+    return '`el^'
+  else
+    if v =~ 'slice\|cons'
+      let v = substitute(v,'val','','')
+    endif
+    return '`' . substitute(v,'[^a-z]','','g') . '^'
+  endif
+endfunction "}}}
+" End multiple each snippet }}}
+
+" Multiple assert snippet {{{
+"{{{ s:assert_map
+let s:assert_map = {
+      \'block'          : ''                                                        . ' { `cursor^ }',
+      \'equals'         : '(`expected^, `actual^`, `message^)'                      . '',
+      \'in_delta'       : '(`expected float^, `actual float^, `delta^`, `message^)' . '',
+      \'instance_of'    : '(`klass^, `object to compare^`, `message^)'              . '',
+      \'kind_of'        : '(`klass^, `object to compare^`, `message^)'              . '',
+      \'match'          : '(/`regexp^/`^, `string^`, `message^)'                    . '',
+      \'not_equal'      : '(`expected^, `actual^`, `message^)'                      . '',
+      \'nil'            : '(`object^`, `message^)'                                  . '',
+      \'no_match'       : '(/`regexp^/`^, `string^`, `message^)'                    . '',
+      \'not_nil'        : '(`object^`, `message^)'                                  . '',
+      \'nothing_raised' : '(`exception^)'                                           . ' { `cursor^ }',
+      \'not_same'       : '(`expected^, `actual^`, `message^)'                      . '',
+      \'nothing_thrown' : '`(`message`)^'                                           . ' { `cursor^ }',
+      \'operator'       : '(`obj1^, `operator^, `obj2^`, `message^)'                . '',
+      \'raise'          : '(`exception^)'                                           . ' { `cursor^ }',
+      \'respond_to'     : '(`object^, `respond to this message^`, `message^)'       . '',
+      \'same'           : '(`expected^, `actual^`, `message^)'                      . '',
+      \'send'           : '([`receiver^, `method^, `args^]`, `message^)'            . '',
+      \'throws'         : '(`expected symbol^`, `message^)'                         . ' { `cursor^ }',
+      \}
+"}}}
+
+fun! s:RubyAssertPopupSort(a, b) "{{{
+    return a:a.word == a:b.word ? 0 : a:a.word > a:b.word ? 1 : -1
+endfunction "}}}
+
+fun! s:f.RubyAssertPopup() "{{{
+  let list = []
+  for [k, v] in items(s:assert_map)
+    let list += [{ 'word' : k, 'menu' : 'assert_' . k . substitute(v, '`.\{-}^', '..', 'g') }]
+  endfor
+  return sort(list, 's:RubyAssertPopupSort')
+endfunction "}}}
+
+fun! s:f.RubyAssertMethod() "{{{
+  let v = self.SV('^_', '', '')
+  if v == ''
+    return v . '(`^`, `message^)'
+  endif
+  if has_key(s:assert_map, v)
+    return '_' . v . s:assert_map[v]
+  else
+    return ''
+  endif
+endfunction "}}}
+" End multiple assert snippet }}}
+
+" Repeat an item inside its edges.
+" Behave like ExpandIfNotEmpty() but within edges
+fun! s:f.RepeatInsideEdges(sep) "{{{
+  let [edgeLeft, edgeRight] = self.ItemEdges()
+  let v = self.V()
+  let n = self.N()
+  if v == '' || v == self.ItemFullname()
+    return ''
+  endif
+
+
+  let v = self.ItemStrippedValue()
+  let [ markLeft, markRight ] = XPTmark()
+
+  let newName = 'n' . n
+  let res  = edgeLeft . v
+  let res .= markLeft . a:sep .  markLeft . newName . markRight
+  let res .= 'ExpandIfNotEmpty("' . a:sep . '", "' . newName . '")' . markRight . markRight
+  let res .=  edgeRight
+
+
+  return res
+endfunction "}}}
+
+" Remove an item if its value hasn't change
+fun! s:f.RemoveIfUnchanged() "{{{
+  let v = self.V()
+  let [lft, rt] = self.ItemEdges()
+  if v == lft . self.N() . rt
+    return ''
+  else
+    return v
+  end
+endfunction "}}}
+
+
+
+" ================================= Snippets ===================================
+
+XPT # syn=string " #{..}
+#{`^}
+
+
+XPT : " :... => ...
+:`key^ => `value^
+
+
+XPT % " %**[..]
+XSET _=Choose(['w', 'W', 'q', 'Q'])
+%`_^[`^]
+
+
+XPT BEG " BEGIN { .. }
+BEGIN {
+    `cursor^
+}
+
+
+XPT Comp " include Comparable def <=> ...
+include Comparable
+
+def <=>(other)
+    `cursor^
+end
+
+
+XPT END " END { .. }
+END {
+    `cursor^
+}
+
+
+XPT Enum " include Enumerable def each ...
+include Enumerable
+
+def each(&block)
+    `cursor^
+end
+
+
+XPT Forw " extend Forwardable
+extend Forwardable
+
+
+XPT Md " Marshall Dump
+File.open(`filename^, "wb") { |`file^| Marshal.dump(`obj^, `file^) }
+
+
+XPT Ml " Marshall Load
+File.open(`filename^, "rb") { |`file^| Marshal.load(`file^) }
+
+
+XPT Pn " PStore.new\(..)
+PStore.new(`filename^)
+
+
+XPT Yd " YAML dump
+File.open("`filename^.yaml", "wb") { |`file^| YAML.dump(`obj^,`file^) }
+
+
+XPT Yl " YAML load
+File.open("`filename^.yaml") { |`file^| YAML.load(`file^) }
+
+
+XPT _d " __DATA__
+__DATA__
+
+
+XPT _e " __END__
+__END__
+
+
+XPT _f " __FILE__
+__FILE__
+
+
+XPT ali " alias : .. : ..
+XSET new.post=RubySnakeCase()
+XSET old=old_{R("new")}
+XSET old.post=RubySnakeCase()
+alias :`new^ :`old^
+
+
+XPT all " all? { .. }
+all? { |`element^| `cursor^ }
+
+
+XPT amm " alias_method : .. : ..
+XSET new.post=RubySnakeCase()
+XSET old=old_{R("new")}
+XSET old.post=RubySnakeCase()
+alias_method :`new^, :`old^
+
+
+XPT any " any? { |..| .. }
+any? { |`element^| `cursor^ }
+
+
+XPT app " if __FILE__ == $PROGRAM_NAME ...
+if __FILE__ == $PROGRAM_NAME
+    `cursor^
+end
+
+
+XPT array " Array.new\(..) { ... }
+Array.new(`size^) { |`i^| `cursor^ }
+
+XPT ass " assert**\(..) ...
+XSET what=RubyAssertPopup()
+XSET what|post=RubyAssertMethod()
+XSET message|post=RemoveIfUnchanged()
+assert`_`what^
+
+
+XPT attr " attr_** :...
+XSET what=Choose(["accessor", "reader", "writer"])
+XSET what|post=SV("^_$",'','')
+XSET attr*|post=ExpandIfNotEmpty(', :', 'attr*')
+attr`_`what^ :`attr*^
+
+XPT begin " begin .. rescue .. else .. end
+XSET block=# block
+XSET Exception|post=RubyCamelCase()
+begin
+    `expr^
+``rescue...`
+{{^rescue `Exception^` => `e^
+    `block^
+``rescue...`
+^`}}^``else...`
+{{^else
+    `block^
+`}}^``ensure...`
+{{^ensure
+    `cursor^
+`}}^end
+
+XPT bm " Benchmark.bmbm do ... end
+XSET times=10_000
+TESTS = `times^
+
+Benchmark.bmbm do |result|
+    `cursor^
+end
+
+
+XPT case " case .. when .. end
+XSET block=# block
+case `target^`
+when `comparison^
+    `block^
+``when...`
+{{^when `comparison^
+    `block^
+``when...`
+^`}}^``else...`
+{{^else
+    `cursor^
+`}}^end
+
+
+XPT cfy " classify { |..| .. }
+classify { |`element^| `cursor^ }
+
+
+XPT cl " class .. end
+XSET ClassName.post=RubyCamelCase()
+class `ClassName^
+    `cursor^
+end
+
+
+XPT cld " class .. < DelegateClass .. end
+XSET ClassName.post=RubyCamelCase()
+XSET ParentClass.post=RubyCamelCase()
+XSET arg*|post=RepeatInsideEdges(', ')
+class `ClassName^ < DelegateClass(`ParentClass^)
+    def initialize`(`arg*`)^
+        super(`delegate object^)
+
+        `cursor^
+    end
+end
+
+
+XPT cli " class .. def initialize\(..) ...
+XSET ClassName|post=RubyCamelCase()
+XSET name|post=RubySnakeCase()
+XSET init=Trigger('defi')
+XSET def=Trigger('def')
+class `ClassName^
+    `init^`
+    `def...^
+
+    `def^`
+    `def...^
+end
+
+
+XPT cls " class << .. end
+XSET self=self
+class << `self^
+    `cursor^
+end
+
+
+XPT clstr " .. = Struct.new ...
+XSETm do...|post
+ do
+    `cursor^
+end
+XSETm END
+XSET ClassName|post=RubyCamelCase()
+XSET attr*|post=RepeatInsideEdges(', :')
+`ClassName^ = Struct.new`(:`attr*`)^` `do...^
+
+
+XPT col " collect { .. }
+collect { |`obj^| `cursor^ }
+
+
+XPT deec " Deep copy
+Marshal.load(Marshal.dump(`obj^))
+
+
+XPT def " def .. end
+XSET method|post=RubySnakeCase()
+XSET arg*|post=RepeatInsideEdges(', ')
+def `method^`(`arg*`)^
+    `cursor^
+end
+
+
+XPT defd " def_delegator : ...
+def_delegator :`del obj^, :`del meth^, :`new name^
+
+
+XPT defds " def_delegators : ...
+def_delegators :`del obj^, :`del methods^
+
+
+XPT defi " def initialize .. end
+XSET arg*|post=RepeatInsideEdges(', ')
+def initialize`(`arg*`)^
+    `cursor^
+end
+
+
+XPT defmm " def method_missing\(..) .. end
+def method_missing(meth, *args, &block)
+    `cursor^
+end
+
+
+XPT defs " def self... end
+XSET method.post=RubySnakeCase()
+XSET arg*|post=RepeatInsideEdges(', ')
+def self.`method^`(`arg*`)^
+    `cursor^
+end
+
+
+XPT deft " def test_.. .. end
+XSET name|post=RubySnakeCase()
+XSET arg*|post=RepeatInsideEdges(', ')
+def test_`name^
+    `cursor^
+end
+
+
+XPT deli " delete_if { |..| .. }
+delete_if { |`arg^| `cursor^ }
+
+
+XPT det " detect { .. }
+detect { |`obj^| `cursor^ }
+
+
+XPT dir " Dir[..]
+XSET _='/**/*'
+Dir[`_^]
+
+
+XPT dirg " Dir.glob\(..) { |..| .. }
+Dir.glob(`dir^) { |`file^| `cursor^ }
+
+
+XPT do " do |..| .. end
+XSET arg*|post=RepeatInsideEdges(', ')
+do` |`arg*`|^
+    `cursor^
+end
+
+
+XPT dow " downto\(..) { .. }
+XSET arg=i
+XSET lbound=0
+downto(`lbound^) { |`arg^| `cursor^ }
+
+
+XPT each " each_** { .. }
+XSET what=RubyEachPopup()
+XSET what|post=RubyEachBrace()
+XSET vars=RubyEachPair()
+each`_`what^ { |`vars^| `cursor^ }
+
+
+XPT fdir " File.dirname\(..)
+File.dirname(`^)
+
+
+XPT fet " fetch\(..) { |..| .. }
+fetch(`name^) { |`key^| `cursor^ }
+
+
+XPT file " File.foreach\(..) ...
+File.foreach('`filename^') { |`line^| `cursor^ }
+
+
+XPT fin " find { |..| .. }
+find { |`element^| `cursor^ }
+
+
+XPT fina " find_all { |..| .. }
+find_all { |`element^| `cursor^ }
+
+
+XPT fjoin " File.join\(..)
+File.join(`dir^, `path^)
+
+
+XPT fla " flatten_once
+inject(Array.new) { |`arr^, `a^| `arr^.push(*`a^) }
+
+
+XPT fread " File.read\(..)
+File.read(`filename^)
+
+
+XPT grep " grep\(..) { |..| .. }
+grep(/`pattern^/) { |`match^| `cursor^ }
+
+
+XPT gsub " gsub\(..) { |..| .. }
+gsub(/`pattern^/) { |`match^| `cursor^ }
+
+
+XPT hash " Hash.new { ... }
+Hash.new { |`hash^,`key^| `hash^[`key^] = `cursor^ }
+
+XPT if " if .. end
+if `boolean exp^
+    `cursor^
+end
+
+XPT ife " if .. else .. end
+XSET block=# block
+if `boolean exp^
+    `block^
+else
+    `cursor^
+end
+
+XPT ifei " if .. elsif .. else .. end
+XSET block=# block
+if `boolean exp^`
+    `block^
+``elsif...`
+{{^elsif `comparison^
+    `block^
+``elsif...`
+^`}}^``else...`
+{{^else
+    `cursor^
+`}}^end
+
+
+XPT inj " inject\(..) { |..| .. }
+inject`(`arg`)^ { |`accumulator^, `element^| `cursor^ }
+
+
+XPT lam " lambda { .. }
+XSET arg*|post=RepeatInsideEdges(', ')
+lambda {` |`arg*`|^ `cursor^ }
+
+
+XPT loop " loop do ... end
+loop do
+    `cursor^
+end
+
+XPT map " map { |..| .. }
+map { |`arg^| `cursor^ }
+
+
+XPT max " max { |..| .. }
+max { |`element1^, `element2^| `cursor^ }
+
+
+XPT min " min { |..| .. }
+min { |`element1^, `element2^| `cursor^ }
+
+
+XPT mod " module .. .. end
+XSET module name|post=RubyCamelCase()
+module `module name^
+    `cursor^
+end
+
+
+XPT modf " module .. module_function .. end
+XSET module name|post=RubyCamelCase()
+module `module name^
+    module_function
+
+    `cursor^
+end
+
+
+XPT nam " Rake Namespace
+XSET ns=fileRoot()
+namespace :`ns^ do
+    `cursor^
+end
+
+
+XPT new " Instanciate new object
+XSET Object|post=RubyCamelCase()
+XSET arg*|post=RepeatInsideEdges(', ')
+`var^ = `Object^.new`(`arg*`)^
+
+
+XPT open " open\(..) { |..| .. }
+XSET mode...|post=, '`wb^'
+open(`filename^`, `mode...^) { |`io^| `cursor^ }
+
+
+XPT par " partition { |..| .. }
+partition { |`element^| `cursor^ }
+
+
+XPT pathf " Path from here
+XSET path=../lib
+File.join(File.dirname(__FILE__), "`path^")
+
+
+XPT rdoc syn=comment " RDoc description
+=begin rdoc
+# `cursor^
+#=end
+
+
+XPT rej " reject { |..| .. }
+reject { |`element^| `cursor^ }
+
+
+XPT rep " Benchmark report
+result.report("`name^: ") { TESTS.times { `cursor^ } }
+
+
+XPT req " require ..
+require '`lib^'
+
+
+XPT reqs " %w[..].map { |lib| require lib }
+XSET lib*|post=ExpandIfNotEmpty(' ', 'lib*')
+%w[`lib*^].map { |lib| require lib }
+
+..XPT
+
+
+XPT reve " reverse_each { .. }
+reverse_each { |`element^| `cursor^ }
+
+
+XPT ruby " #!/usr/bin/env ruby
+XSET enc=Echo(&fenc ? &fenc : &enc)
+#!/usr/bin/env ruby
+# -*- encoding: `enc^ -*-
+
+XPT shebang alias=ruby
+
+XPT sb alias=ruby
+
+
+
+XPT scan " scan\(..) { |..| .. }
+scan(/`pattern^/) { |`match^| `cursor^ }
+
+
+XPT sel " select { |..| .. }
+select { |`element^| `cursor^ }
+
+
+XPT sinc " class << self; self; end
+class << self; self; end
+
+
+XPT sor " sort { |..| .. }
+sort { |`element1^, `element2^| `element1^ <=> `element2^ }
+
+
+XPT sorb " sort_by { |..| .. }
+sort_by {` |`arg`|^ `cursor^ }
+
+
+XPT ste " step\(..) { .. }
+step(`count^`, `step^) { |`i^| `cursor^ }
+
+
+XPT sub " sub\(..) { |..| .. }
+sub(/`pattern^/) { |`match^| `cursor^ }
+
+
+XPT subcl " class .. < .. end
+XSET ClassName.post=RubyCamelCase()
+XSET Parent.post=RubyCamelCase()
+class `ClassName^ < `Parent^
+    `cursor^
+end
+
+
+XPT tas " Rake Task
+XSET task name|post=RubySnakeCase()
+XSET dep*|post=RepeatInsideEdges(', :')
+desc "`task description^"
+task :`task name^` => [:`dep*`]^ do
+    `cursor^
+end
+
+
+XPT tc " require 'test/unit' ... class Test.. < Test::Unit:TestCase ...
+XSET ClassName=RubyCamelCase(R("module"))
+XSET ClassName.post=RubyCamelCase()
+XSET deft=Trigger('deft')
+require "test/unit"
+require "`module^"
+
+class Test`ClassName^ < Test::Unit::TestCase
+    `deft^`
+
+    `deft...`{{^
+
+    `deft^`
+
+    `deft...`^`}}^
+end
+
+
+XPT tif " .. ? .. : ..
+(`boolean exp^) ? `exp if true^ : `exp if false^
+
+
+XPT tim " times { .. }
+times {` |`i`|^ `cursor^ }
+
+
+XPT tra " transaction\(..) { ... }
+transaction(`true^) { `cursor^ }
+
+
+XPT unif " Unix Filter
+ARGF.each_line do |`line^|
+    `cursor^
+end
+
+
+XPT unless " unless .. end
+unless `boolean cond^
+    `cursor^
+end
+
+
+XPT until " until .. end
+until `boolean cond^
+    `cursor^
+end
+
+
+XPT upt " upto\(..) { .. }
+upto(`ubound^) { |`i^| `cursor^ }
+
+
+XPT usai " if ARGV.. abort\("Usage...
+XSET args=[options]
+if ARGV`^
+    abort "Usage: #{$PROGRAM_NAME} `args^"
+end
+
+
+XPT usau " unless ARGV.. abort\("Usage...
+XSET args=[options]
+unless ARGV`^
+    abort "Usage: #{$PROGRAM_NAME} `args^"
+end
+
+
+XPT while " while .. end
+while `boolean cond^
+    `cursor^
+end
+
+
+XPT wid " with_index { .. }
+with_index { |`element^, `index^| `cursor^ }
+
+
+XPT xml " REXML::Document.new\(..)
+REXML::Document.new(File.read(`filename^))
+
+
+XPT y syn=comment " :yields:
+:yields:
+
+
+XPT zip " zip\(..) { |..| .. }
+zip(`enum^) { |`row^| `cursor^ }
+
+
+
+
+" ================================= Wrapper ===================================
+
+
+
+XPT invoke_ wraponly=wrapped " ..(SEL)
+XSET name|post=RubySnakeCase()
+`name^(`wrapped^)
+
+
+XPT def_ wraponly=wrapped " def ..() SEL end
+XSET method_name|post=RubySnakeCase()
+XSET arg*|post=RepeatInsideEdges(', ')
+def `method_name^`(`arg*`)^
+    `wrapped^
+end
+
+
+XPT class_ wraponly=wrapped " class .. SEL end
+XSET _|post=RubyCamelCase()
+class `_^
+    `wrapped^
+end
+
+
+XPT module_ wraponly=wrapped " module .. SEL end
+XSET _|post=RubyCamelCase()
+module `_^
+    `wrapped^
+end
+
+
+XPT begin_ wraponly=wrapped " begin SEL rescue .. else .. end
+XSET Exception|post=RubyCamelCase()
+XSET block=# block
+begin
+    `wrapped^
+``rescue...`
+{{^rescue `Exception^` => `e^
+    `block^
+``rescue...`
+^`}}^``else...`
+{{^else
+    `block^
+`}}^``ensure...`
+{{^ensure
+    `cursor^
+`}}^end
+