utils 0.0.0

data/lib/utils/config/vim/plugin/IndentAnything.vim

@@ -0,0 +1,675 @@
+"
+" Copyright 2006 Tye Zdrojewski 
+"
+" Licensed under the Apache License, Version 2.0 (the "License"); you may not
+" use this file except in compliance with the License. You may obtain a copy of
+" the License at
+" 
+" 	http://www.apache.org/licenses/LICENSE-2.0
+" 
+" Unless required by applicable law or agreed to in writing, software distributed
+" under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+" CONDITIONS OF ANY KIND, either express or implied. See the License for the
+" specific language governing permissions and limitations under the License.
+"
+"
+"
+" Plugin:
+"
+"   Indent Anything
+"
+" Version: 1.2.2
+"
+" Description:
+"
+"   This is an indentation script that calculates the indent level based
+"   on begin/end syntax pairs and line-continuation patterns.  It allows one
+"   to create an indent script without writing any code, taking it's
+"   instruction from configurable values.
+"
+"   Included with this script is Javascript indentation, an example that
+"   explains the configurable values.
+"
+"
+" Installation:
+"
+"   Place this file in your home directory under ~/.vim/indent/, or replace
+"   the system indent/javascript.vim file to affect all users.
+"
+" Maintainer: Tye Z. <zdro@yahoo.com>
+"
+" Customization:
+"
+"   The only thing that can really be customized at this point is whether or
+"   not a line is echoed explaining the indentation result.  To turn this on,
+"   set the following variable like so:
+"
+"       let b:indent_anything_echo = 1
+"
+"
+" History:
+"
+"   1.2 - made some functions script-local to prevent naming collisions
+"       - fixed some broken indentation in the middle of a block comment,
+"         which showed up in Javascript indentation.
+"
+"   1.2.2 - Fixed a bug causing the line after a single-line block comment to
+"           always have an indent of '0' (i.e. the line after /* comment */).
+"         - Added Apache 2 license
+"
+"
+
+let s:supportedVimVersion = 700
+
+if version < s:supportedVimVersion
+    echoerr "IndentAnything only supported for Vim " . s:supportedVimVersion . " and up."
+    finish
+endif
+
+
+"
+" Initialize everything needed by this script.  Only set those values that are
+" not set already.
+"
+function! IndentAnythingInit()
+    let b:IndentAnythingInitialized = 1
+    " Start with a regular expression that will never match.  Matching
+    " will influence behavior, which the defaults should not do.
+    let s:nonMatcher = '[x]\&[^x]'
+    if !exists('b:commentRE')
+        let b:commentRE      = s:nonMatcher
+    endif
+    if !exists('b:lineCommentRE')
+        let b:lineCommentRE  = s:nonMatcher
+    endif
+    if !exists('b:blockCommentRE')
+        let b:blockCommentRE = s:nonMatcher
+    endif
+    if !exists('b:stringRE')
+        let b:stringRE            = s:nonMatcher
+    endif
+    if !exists('b:singleQuoteStringRE')
+        let b:singleQuoteStringRE = s:nonMatcher
+    endif
+    if !exists('b:doubleQuoteStringRE')
+        let b:doubleQuoteStringRE = s:nonMatcher
+    endif
+
+    if !exists('b:blockCommentStartRE')
+        let b:blockCommentStartRE  = s:nonMatcher
+    endif
+    if !exists('b:blockCommentMiddleRE')
+        let b:blockCommentMiddleRE = s:nonMatcher
+    endif
+    if !exists('b:blockCommentEndRE')
+        let b:blockCommentEndRE    = s:nonMatcher
+    endif
+    if !exists('b:blockCommentMiddleExtra')
+        let b:blockCommentMiddleExtra = 0
+    endif
+
+    if !exists('b:indentTrios')
+        let b:indentTrios = []
+    endif
+    if !exists('b:lineContList')
+        let b:lineContList = []
+    endif
+
+    if !exists('b:contTraversesLineComments')
+        let b:contTraversesLineComments = 1
+    endif
+
+    if !exists('b:indent_anything_echo')
+        let b:indent_anything_echo = 0
+    endif
+endfunction
+
+function! SynHere()
+    return synIDattr(synID(line('.'), col('.'), 1), "name")
+endfunction
+"
+" Returns true if the cursor is currently inside a comment or a string
+"
+function! InCommentOrString()
+    let syn = synIDattr(synID(line("."), col("."), 1), "name")
+    if syn =~ b:commentRE || syn =~ b:stringRE
+        return 1
+    endif
+    return 0
+endfunction
+
+"
+" Returns true if the given line is a comment line (b:lineCommentRE)
+"
+function! IsLineComment(linenum)
+    let cursor = getpos('.')
+    exec a:linenum
+    normal ^
+    let l:iscomment = 0
+    let l:syn = synIDattr(synID(line('.'), col('.'), 1), "name")
+    if l:syn =~ b:lineCommentRE " b:commentRE || l:syn =~ b:stringRE
+        let l:iscomment = 1
+    endif
+    call setpos('.', cursor)
+    return l:iscomment
+endfunction
+
+"
+" Returns true if the given line is a comment line (b:lineCommentRE)
+"
+function! IsComment(linenum)
+    let cursor = getpos('.')
+    exec a:linenum
+    normal ^
+    let l:iscomment = 0
+    let l:syn = synIDattr(synID(line('.'), col('.'), 1), "name")
+    if l:syn =~ b:commentRE " b:commentRE || l:syn =~ b:stringRE
+        let l:iscomment = 1
+    endif
+    call setpos('.', cursor)
+    return l:iscomment
+endfunction
+
+"
+" Returns true if the given line is a comment line (b:lineCommentRE)
+"
+function! IsBlockComment(linenum)
+    let cursor = getpos('.')
+    exec a:linenum
+    normal ^
+    let l:iscomment = 0
+    let l:syn = synIDattr(synID(line('.'), col('.'), 1), "name")
+    if l:syn =~ b:blockCommentRE " b:commentRE || l:syn =~ b:stringRE
+        let l:iscomment = 1
+    endif
+    call setpos('.', cursor)
+    return l:iscomment
+endfunction
+
+"
+" Get the first line at or on the given line that is not blank and is not a
+" comment line.
+"
+function! GetPrevNonBlankNonComment(begin)
+    let cursor = getpos('.')
+
+    let l:prevbegin = a:begin
+    while 1
+        let l:lnum = prevnonblank(l:prevbegin)
+        if l:lnum == 0
+            return 0
+        endif
+
+        "if IsLineComment(l:lnum)
+        if IsComment(l:lnum)
+            let l:prevbegin -= 1
+            continue
+        endif
+
+        break
+    endwhile
+
+    " Restore original cursor location
+    call setpos('.', cursor)
+    return l:lnum
+endfunction
+
+"
+" This does all the work.  Does indentation for:
+"
+"       - All pairs defined in b:indentTrios
+"       - All line continuations in b:lineContList
+"       - Block comments
+"
+function! IndentAnything()
+
+    if !exists('b:IndentAnythingInitialized')
+        call IndentAnythingInit()
+    endif
+
+    let adj = 0  " Adjustment
+
+    let g:lastindent = ""
+    let b:hardindent = -1
+    let currlnum = v:lnum
+    let currlnum = line('.')
+    let currline = getline(currlnum)
+    let lastline = ''
+    let prevline = ''
+
+    " Find non-blank lines above the current line.
+    let lastlnum = prevnonblank(currlnum - 1)
+    let prevlnum = prevnonblank(lastlnum - 1)
+    if lastlnum != 0 
+        let lastline = getline(lastlnum)
+    endif
+    if prevlnum != 0
+        let prevline = getline(prevlnum)
+    endif
+    if b:contTraversesLineComments
+        let lastcodelnum = GetPrevNonBlankNonComment(currlnum - 1)
+        let prevcodelnum = GetPrevNonBlankNonComment(lastcodelnum - 1)
+        if lastcodelnum !=0 
+            let lastcodeline = getline(lastcodelnum)
+        endif
+    endif
+
+    " Start from the first char on the line.  Vim doesn't seem to consistently
+    " place the cursor there before calling the indent routines.
+    call cursor(0, 1)
+    call search('\S', 'W')
+
+    let l:cur = getpos('.')
+
+    "
+    " Call indentation adjustment functions.
+    "
+
+    "
+    " Block comments
+    "
+    let l:BlockCommentAdj = 0
+    let l:BlockCommentAdj += s:GetBlockCommentIndent(currlnum, lastlnum)
+    let adj += l:BlockCommentAdj
+
+    "
+    " Pairs
+    "
+    let b:lastclosed = { 'at' : 0 }
+    let b:pairadj = 0
+    if !l:BlockCommentAdj
+        " If we're not in the middle of a block comment (because we haven't
+        " made any adjustments for that), then process block indentation.
+        for trio in b:indentTrios
+            let b:pairadj += s:GetPairIndent(currline, lastline, lastlnum, 
+                        \ trio[0], trio[1], trio[2])
+        endfor
+    endif
+    let adj += b:pairadj
+
+    "
+    " Line continuations
+    "
+    let contadj = 0
+    let isBlockCommentStart = currline =~ '^\s*' . b:blockCommentStartRE
+    let isBlockCommentMid = (IsBlockComment(currlnum) && !isBlockCommentStart)
+    if !isBlockCommentMid
+        " If the current line is not the middle of a block comment, then
+        " process line continuations.
+        for ContRule in b:lineContList
+            if b:contTraversesLineComments "&& !isBlockCommentStart
+                let contadj = s:GetContIndent(ContRule, currline, lastcodeline, lastcodelnum, prevcodelnum)
+            else
+                let contadj = s:GetContIndent(ContRule, currline, lastline, lastlnum, prevlnum)
+            endif
+            " This is for line continuation patterns, of which there can be only
+            " one per line to indicate continuation
+            if contadj
+                break
+            endif
+        endfor
+        let adj += contadj
+    endif
+
+
+    "
+    " Find the previous indent to which we will add the adjustment
+    "
+    let prevind = indent(lastlnum)
+
+    if l:BlockCommentAdj
+        let g:lastindent .= " indent (prevblockcomment: " . prevind . " at " . lastcodelnum . ") "
+    elseif contadj && b:contTraversesLineComments
+        " If we have adjusted for line continuation, then use the indentation
+        " for the previous code line
+        let prevind = indent(lastcodelnum)
+        let g:lastindent .= " indent (prevcode: " . prevind . " at " . lastcodelnum . ") "
+
+    elseif (isBlockCommentStart || !IsBlockComment(currlnum)) && IsBlockComment(lastlnum)
+        " If this is the first line after a block comment, then add the
+        " adjustment to the line where the block comment started.
+        let prevind = s:GetPostBlockCommentIndent(lastlnum)
+        let g:lastindent .= " indent (prevblock: " . prevind . " at " . lastlnum . ") "
+
+    elseif exists("b:defaultIndentExpr")
+        let g:lastindent .= " using defaultIndentExpr (" . b:defaultIndentExpr . ") "
+        exec "let prevind = " . b:defaultIndentExpr
+    else
+        " Default to adjusting the previous line's indent.
+        let g:lastindent .= " indent (prev: " . prevind . " at " . lastlnum . ") "
+    endif
+
+    " Just in case there is no previous indent.
+    let prevind = (prevind == -1 ? 0 : prevind)
+
+    if b:indent_anything_echo
+        echom g:lastindent
+    endif
+
+    call setpos('.', l:cur)
+
+    return adj + prevind
+
+endfunction
+
+"
+" Get the adjustment for the second line of a block comment.  The second line
+" will be aligned under the start of the block, even if it is not at the
+" beginning of the line.  Extra adjustment (b:blockCommentMiddleExtra) will
+" be added.
+"
+function! s:GetBlockCommentIndent(CurrLNum, LastLNum)
+    let l:cursor = getpos('.')
+    let l:adj = 0
+    if a:LastLNum == searchpair(b:blockCommentStartRE, '', b:blockCommentEndRE, 'bWr')
+                \ && a:LastLNum > 0
+        let l:adj = col('.') + b:blockCommentMiddleExtra
+        normal ^
+        let l:adj -= col('.')
+    endif
+    call setpos('.', l:cursor)
+    return l:adj
+endfunction
+
+function! s:GetPostBlockCommentIndent(LastLNum)
+
+    let l:cursor = getpos('.')
+    let l:ind = 0
+    let l:comment_start_lnum = 0;
+
+    " Find beginning of block comment containing the start of line LastLNum
+    exec a:LastLNum
+    normal ^
+    let l:comment_start_lnum = searchpair(
+                \ b:blockCommentStartRE, b:blockCommentMiddleRE, b:blockCommentEndRE, 'bWr')
+
+    " Assume that the LastLNum is a block comment.  If the comment both
+    " started and stopped on LastLNum, then searchpair will return 0.  In that
+    " case, we just want to return the indent of LastLNum itself.
+    if 0 == l:comment_start_lnum
+        let l:comment_start_lnum = a:LastLNum
+    endif
+
+    let l:ind = indent(l:comment_start_lnum)
+
+    if 1 || l:ind != 0 && b:indent_anything_echo 
+        let g:lastindent = g:lastindent . 
+                    \ "GetPostBlockCommentIndent: " . l:ind
+    endif
+
+    call setpos('.', l:cursor)
+
+    "return l:ind
+    return l:ind > 0 ? l:ind : 0
+
+endfunction
+
+"
+" Get additional indentation based on blocks of code, as defined by the Head
+" and Tail patterns.
+"
+function! s:GetPairIndent(CurrLine, LastLine, LastLNum, Head, Mid, Tail)
+
+    let levels = 0
+    let adj = 0
+    let origcol = col(".")
+    let origline = line(".")
+
+
+    "
+    " How many levels were started on the last line?  Search backwards for
+    " pair starters until we're not on the last nonblank.  If the last line
+    " doesn't contain the pair-starter, then don't bother with searchpair();
+    " it's a performance bottleneck because (I think) it will always search
+    " all the way back until it finds a match or can't search any more.
+    "
+    "
+    if a:LastLine =~ a:Head
+        while 1
+            "
+            " Include the limit of the search to be the last line.  BIG
+            " performance booster!  That also means we only have to see *if*
+            " there was a match, and not worry about where it is.
+            "
+            "let pairstart = searchpair(a:Head, a:Mid, a:Tail, 'Wb')
+            "if pairstart == 0 || pairstart != a:LastLNum
+            let pairstart = searchpair(a:Head, a:Mid, a:Tail, 'Wb', '', a:LastLNum)
+            if pairstart == 0 "|| pairstart != a:LastLNum
+                break
+            endif
+            let syn = synIDattr(synID(line("."), col("."), 1), "name")
+            " Also continue on the off chance that we find the match on the
+            " current line.  This shouldn't happen, but the pattern might
+            " start with whitespace.
+            if syn =~ b:commentRE || syn =~ b:stringRE || pairstart == origline
+                continue
+            endif
+            let levels += 1
+        endwhile
+    endif
+
+    " If we aren't within a level that was started on the last line, then
+    " check how many levels were closed on the last line.
+    "
+    if levels == 0
+
+        " Move to the beginning of the last line
+        call cursor(a:LastLNum,0)
+        normal ^
+
+        " If the line starts with an open, The close shouldn't be counted as
+        " such, because we're looking for closes that didn't start on this
+        " line.
+        if a:LastLine =~ '^\s*' . a:Head || 
+                    \ (a:Mid != '' && a:LastLine =~ '^\s*' . a:Mid)
+            let levels = 1
+        endif
+
+        "
+        " Count the closes on the last line (i.e. LastLNum), stopping once
+        " we've hit comments.  If the line doesn't even contain the end of the
+        " pair, don't bother with searchpair() (same aforementioned
+        " rationale).
+        "
+        if a:LastLine =~ a:Tail
+            while 1
+                "
+                " Include the limit of the search to be the last line.  BIG
+                " performance booster!  That also means we only have to see
+                " *if* there was a match, and not worry about where it is.
+                "
+                "let pairend = searchpair(a:Head, a:Mid, a:Tail, 'W')
+                "if pairend == 0 || a:LastLNum != pairend 
+                "let pairend = searchpair(a:Head, a:Mid, a:Tail, 'W', '', a:LastLNum)
+                let pairend = searchpair(a:Head, a:Mid, a:Tail, 'W',
+                            \'InCommentOrString()', a:LastLNum)
+                if pairend == 0 "|| a:LastLNum != pairend 
+
+                    " STARTS with a:Tail, since we already know the line
+                    " matches it.
+                    if b:lastclosed.at < col('.') && (
+                                \ a:LastLine =~ '^\s*' . a:Tail 
+                                \ || (a:Mid != '' && a:LastLine =~ '^\s*' . a:Mid) )
+                        let b:lastclosed = { 
+                                    \ 'at' : col('.'), 
+                                    \ 'head' : a:Head,
+                                    \ 'mid' : a:Mid,
+                                    \ 'tail' : a:Tail }
+                    endif
+
+
+                    break
+                endif
+                " This might not be needed with the expr included in the
+                " search call.
+                "let syn = synIDattr(synID(line("."), col("."), 1), "name")
+                "if syn =~ b:commentRE || syn =~ b:stringRE || syn == ''
+                "    break
+                "endif
+                let levels -= 1
+
+                " Track the last close to try to match pairs that start on
+                " line continuations
+                if b:lastclosed.at < col('.')
+                    let b:lastclosed = { 
+                                \ 'at'   : col('.'), 
+                                \ 'head' : a:Head,
+                                \ 'mid'  : a:Mid,
+                                \ 'tail' : a:Tail }
+                endif
+            endwhile
+        endif
+    endif
+
+    " This is redundant, as per above
+    " If the current line starts with a close, count it.  It won't effect the
+    " indentation of the next line because it is the first thing on the line
+    " and won't be counted as a "close on the last line".
+    if a:CurrLine =~ '^\s*' . a:Tail 
+                \ || (a:Mid != '' && a:CurrLine =~ '^\s*' . a:Mid)
+        let levels -= 1
+    endif
+
+    " Restore original cursor location
+    call cursor(origline, origcol)
+
+    let adj = &sw*levels
+    if adj != 0 && b:indent_anything_echo
+        let g:lastindent = g:lastindent . 
+                    \ "GetPairIndent(" . a:Head . "/" . b:lastclosed.at . "):" . adj . " "
+    endif
+
+    return adj
+
+endfunction
+
+
+function! s:GetContIndent(Rule, CurrLine, LastLine, LastLNum, PrevLNum)
+
+    let adj = 0
+    let origcol = col(".")
+    let origline = line(".")
+    let lastcont = 0
+    let prevcont = 0
+
+    let l:lastlnum = a:LastLNum
+    let l:prevlnum = a:PrevLNum
+
+    let l:preblockstart = -1
+
+    " Get the last matching line number.  If the match occurs w/in a comment
+    " or string, then it's a non-match.
+    "
+    "let lastmatchlnum = search(a:Rule.pattern, 'Wb', a:PrevLNum)
+    let lastmatchlnum = search(a:Rule.pattern, 'Wb', a:LastLNum)
+    let syn = synIDattr(synID(line("."), col("."), 1), "name")
+
+    "if syn =~ b:commentRE || syn =~ b:stringRE
+    if syn =~ b:commentRE || syn =~ b:stringRE || b:lastclosed.at > 0
+        let lastmatchlnum = 0
+    endif
+
+    " Should be able to just search to the line....
+    " " Figure out the last and previous continuation status
+    " if lastmatchlnum && lastmatchlnum == a:LastLNum 
+    "     let lastcont = 1
+    " endif
+    if lastmatchlnum == a:LastLNum
+        let lastcont = 1
+    endif
+
+    " start checking at the start of the block that ended on the prev line
+    if b:lastclosed.at > 0
+        call cursor(a:LastLNum, b:lastclosed.at)
+        " TODO: add 'skip' to skip comments
+        let l:preblockstart = searchpair(b:lastclosed.head, b:lastclosed.mid, b:lastclosed.tail, 'bW')
+        let g:lastindent .= ' postpair ("' . b:lastclosed.head . '"): '
+                    \ . l:preblockstart . '/' . col('.') . ' '
+
+        if b:contTraversesLineComments
+            let l:prevlnum = GetPrevNonBlankNonComment(line('.') - 1)
+        else
+            let l:prevlnum = prevnonblank(line('.') - 1)
+        endif
+    endif
+
+
+    " Get the previous matching line number.  If the match occurs w/in a
+    " comment or string, then it's a non-match.  Use the adjusted, local
+    " prevlnum as the limit of the search, since we don't care about matches
+    " beyond that.
+    let prevmatchlnum = search(a:Rule.pattern, 'Wb', l:prevlnum)
+
+
+    let syn = synIDattr(synID(line("."), col("."), 1), "name")
+    " Handle:
+    "  if ()
+    "    if () {
+    "      this_line; // should not be reduced
+    "if syn =~ b:commentRE || syn =~ b:stringRE
+    if syn =~ b:commentRE || syn =~ b:stringRE
+        let prevmatchlnum = 0
+    endif
+
+    " Should be able to just search to the line....
+    " if ( lastmatchlnum && lastmatchlnum == a:PrevLNum ) 
+    "             \ || ( prevmatchlnum && prevmatchlnum == l:prevlnum )
+    "     let prevcont = 1
+    " endif
+    "
+    " If there is a previous line, it is a continued line, and we haven't
+    " already done a positive adjustment for a pair/block, then reduce.
+    " Don't undo a positive adjustment for a pair because the previous line
+    " was a continued line.  That will happen after the end of the block.
+    "if prevmatchlnum == l:prevlnum && b:pairadj <= 0
+    if l:prevlnum && prevmatchlnum == l:prevlnum && b:pairadj <= 0
+        let prevcont = 1
+    endif
+
+    "echom "lastcont: " . lastcont . 
+    "            \ ", prevcont: " . prevcont . 
+    "            \ ", lastmatchlnum: " . lastmatchlnum .
+    "            \ ", prevmatchlnum: " . prevmatchlnum .
+    "            \ ", lastlnum: " . a:LastLNum . 
+    "            \ ", PrevLNum: " . a:PrevLNum
+    let firstcont = (lastcont && !prevcont)
+    let firstcont = ((lastcont && !prevcont) || (lastcont && b:pairadj))
+
+    " If we are adjusting the current line for a pair, then don't count this
+    " line as a post-continuation line.  The post continuation line will be
+    " after the close of said pair.
+    let postcont  = (!lastcont && prevcont)
+    "let postcont  = (!lastcont && prevcont && !b:pairadj )
+
+    let g:lastindent .= 'lastcont (' . lastcont . '), prevcont (' . prevcont . ') '
+
+
+    "if firstcont && a:CurrLine !~ '^\s*{'
+    if firstcont 
+        if has_key(a:Rule, 'ignore') && a:CurrLine =~ a:Rule.ignore
+            let g:lastindent .= "(ignoring '" . a:Rule.ignore . "') "
+        else
+            let adj = adj + &sw
+        endif
+        "elseif postcont && a:LastLine !~ '^\s*{' "&& !b:pairadj
+    elseif postcont 
+        if has_key(a:Rule, 'ignore') && a:LastLine =~ a:Rule.ignore
+            let g:lastindent .= "(ignoring '" . a:Rule.ignore . "') "
+        else
+            let adj = adj - &sw
+        endif
+    endif
+
+    call cursor(origline, origcol)
+
+    if adj != 0 && b:indent_anything_echo
+        let g:lastindent = g:lastindent . 
+                    \ "GetContIndent('" . a:Rule.pattern . "'):" . adj . " "
+    endif
+    return adj
+
+endfunction
+
+
+
+