Refactoring for GTabularize

autoload/tabular.vim

@@ -219,9 +219,7 @@ function! tabular#TabularizeStrings(strings, delim, ...)
   "     intentionally
   "   - Don't strip leading spaces from the first element; we like indenting.
   for line in lines
-    if len(line) == 1 && len(tabular#LineInclusionPattern())
+    if len(line) == 1 && s:do_gtabularize
-      " FIXME Does LineInclusionPattern even need to be a pattern?  Can it
-      "       just be a boolean?  That's all I've needed to use it as...
       continue " Leave non-matching lines unchanged for GTabularize
     endif
 
@@ -238,7 +236,7 @@ function! tabular#TabularizeStrings(strings, delim, ...)
   " Find the max length of each field
   let maxes = []
   for line in lines
-    if len(line) == 1 && len(tabular#LineInclusionPattern())
+    if len(line) == 1 && s:do_gtabularize
       continue " non-matching lines don't affect field widths for GTabularize
     endif
 
@@ -257,7 +255,7 @@ function! tabular#TabularizeStrings(strings, delim, ...)
   for idx in range(len(lines))
     let line = lines[idx]
 
-    if len(line) == 1 && len(tabular#LineInclusionPattern())
+    if len(line) == 1 && s:do_gtabularize
       let lines[idx] = line[0] " GTabularize just ignores non-matching lines
       continue
     endif
@@ -299,65 +297,57 @@ endfunction
 " The remaining arguments must each be a filter to apply to the text.
 " Each filter must either be a String evaluating to a function to be called.
 function! tabular#PipeRange(includepat, ...) range
-  try
+  exe a:firstline . ',' . a:lastline
-    let top = a:firstline
+      \ . 'call tabular#PipeRangeWithOptions(a:includepat, a:000, {})'
-    let bot = a:lastline
+endfunction
 
-    if get(s:, 'tabularize_mode', '') ==# 'GTabularize'
+" Extended version of tabular#PipeRange, which
-      " Save the include pattern for future use by TabularizeStrings (and by
+" 1) Takes the list of filters as an explicit list rather than as varargs
-      " any Pipeline that wants to handle it) for GTabularize; it can be
+" 2) Supports passing a dictionary of options to control the routine.
-      " queried later via tabular#LineInclusionPattern
+"    Currently, the only supported option is 'mode', which determines whether
-      let s:line_inclusion_pattern = a:includepat
+"    to behave as :Tabularize or as :GTabularize
-    else
+" This allows me to add new features here without breaking API compatibility
-      " In the default mode, apply range extension logic
+" in the future.
-      if a:includepat != '' && top == bot
+function! tabular#PipeRangeWithOptions(includepat, filterlist, options) range
-        if top < 0 || top > line('$') || getline(top) !~ a:includepat
+  let top = a:firstline
-          return
+  let bot = a:lastline
-        endif
+
-        while top > 1 && getline(top-1) =~ a:includepat
+  let s:do_gtabularize = (a:options['mode'] ==# 'GTabularize')
-          let top -= 1
+
-        endwhile
+  if !s:do_gtabularize
-        while bot < line('$') && getline(bot+1) =~ a:includepat
+    " In the default mode, apply range extension logic
-          let bot += 1
+    if a:includepat != '' && top == bot
-        endwhile
+      if top < 0 || top > line('$') || getline(top) !~ a:includepat
+        return
       endif
+      while top > 1 && getline(top-1) =~ a:includepat
+        let top -= 1
+      endwhile
+      while bot < line('$') && getline(bot+1) =~ a:includepat
+        let bot += 1
+      endwhile
+    endif
+  endif
+
+  let lines = map(range(top, bot), 'getline(v:val)')
+
+  for filter in a:filterlist
+    if type(filter) != type("")
+      echoerr "PipeRange: Bad filter: " . string(filter)
     endif
 
-    let lines = map(range(top, bot), 'getline(v:val)')
+    call s:FilterString(lines, filter)
 
-    for filter in a:000
+    unlet filter
-      if type(filter) != type("")
+  endfor
-        echoerr "PipeRange: Bad filter: " . string(filter)
-      endif
 
-      call s:FilterString(lines, filter)
+  call s:SetLines(top, bot - top + 1, lines)
-
-      unlet filter
-    endfor
-
-    call s:SetLines(top, bot - top + 1, lines)
-  finally
-    unlet! s:line_inclusion_pattern
-  endtry
 endfunction
 
-" For passing the current mode to autoload/tabular.vim from plugin/Tabular.vim
+" Part of the public interface so interested pipelines can query this and
-" FIXME This could be done more cleanly if the :AddTabularize* functions
+" adjust their behavior appropriately.
-"       didn't hardcode the arguments to the PipeRange call...
+function! tabular#DoGTabularize()
-function! tabular#SetTabularizeMode(mode)
+  return s:do_gtabularize
-  if len(a:mode)
-    let s:tabularize_mode = a:mode
-  else
-    unlet! s:tabularize_mode
-  endif
-endfunction
-
-" Part of the public interface so interested pipelines can query this.
-" When not in GTabularize mode, an empty string will be returned, otherwise
-" the pattern to be used to determine whether a line should be changed is
-" returned.
-function! tabular#LineInclusionPattern()
-  return get(s:, 'line_inclusion_pattern', '')
 endfunction
 
 function! s:SplitDelimTest(string, delim, expected)

plugin/Tabular.vim

@@ -194,9 +194,7 @@ function! AddTabularPattern(command, force)
 
     let command .= ")"
 
-    let commandmap[name] = ":call tabular#PipeRange("
+    let commandmap[name] = { 'pattern' : pattern, 'commands' : [ command ] }
-          \ . string(pattern) . ","
-          \ . string(command) . ")"
   catch
     echohl ErrorMsg
     echomsg "AddTabularPattern: " . v:exception
@@ -249,15 +247,7 @@ function! AddTabularPipeline(command, force)
       throw "Must provide a list of functions!"
     endif
 
-    let cmd = ":call tabular#PipeRange(" . string(pattern)
+    let commandmap[name] = { 'pattern' : pattern, 'commands' : commandlist }
-
-    for command in commandlist
-      let cmd .= "," . string(command)
-    endfor
-
-    let cmd .= ")"
-
-    let commandmap[name] = cmd
   catch
     echohl ErrorMsg
     echomsg "AddTabularPipeline: " . v:exception
@@ -273,7 +263,15 @@ endfunction
 com! -nargs=* -range -complete=customlist,<SID>CompleteTabularizeCommand
    \ Tabularize <line1>,<line2>call Tabularize(<q-args>)
 
-function! Tabularize(command) range
+function! Tabularize(command, ...) range
+  if a:0
+    let options = a:1
+  else
+    let options = {}
+  endif
+
+  let piperange_opt = { 'mode': get(options, 'mode', '') }
+
   if empty(a:command)
     if !exists("s:last_tabularize_command")
       echohl ErrorMsg
@@ -301,17 +299,19 @@ function! Tabularize(command) range
 
       let cmd .= ")"
 
-      exe range . 'call tabular#PipeRange(pattern, cmd)'
+      exe range . 'call tabular#PipeRangeWithOptions(pattern, [ cmd ], '
+                      \ . 'piperange_opt)'
     else
       if exists('b:TabularCommands') && has_key(b:TabularCommands, command)
-        let command = b:TabularCommands[command]
+        let usercmd = b:TabularCommands[command]
       elseif has_key(s:TabularCommands, command)
-        let command = s:TabularCommands[command]
+        let usercmd = s:TabularCommands[command]
       else
         throw "Unrecognized command " . string(command)
       endif
 
-      exe range . command
+      exe range . 'call tabular#PipeRangeWithOptions(usercmd["pattern"], '
+                      \ . 'usercmd["commands"], piperange_opt)'
     endif
   catch
     echohl ErrorMsg
@@ -339,17 +339,8 @@ endfunction
 "   3) If called without a range, it will act on all lines in the buffer (like
 "      :global) rather than only a single line
 com! -nargs=* -range=% -complete=customlist,<SID>CompleteTabularizeCommand
-   \ GTabularize <line1>,<line2>call GTabularize(<q-args>)
+   \ GTabularize <line1>,<line2>
-
+   \ call Tabularize(<q-args>, { 'mode': 'GTabularize' } )
-function! GTabularize(command) range
-  call tabular#SetTabularizeMode('GTabularize')
-  try
-    exe a:firstline . ',' . a:lastline
-        \ . 'call Tabularize(' . string(a:command) . ')'
-  finally
-    call tabular#SetTabularizeMode('')
-  endtry
-endfunction
 
 " Stupid vimscript crap, part 2                                           {{{1
 let &cpo = s:savecpo