Improve handling of multiline strings (#50)

[etc/vim.git] / indent / python.vim

diff --git a/indent/python.vim b/indent/python.vim
index 4306985849589e65f32734163261d71ab571637b..6bf45a8bf20405e2d51b47c66464fb4817671ce5 100644 (file)
--- a/indent/python.vim
+++ b/indent/python.vim
@@ -32,13 +32,19 @@ setlocal tabstop=4
 setlocal softtabstop=4
 setlocal shiftwidth=4
 
+if !exists('g:python_pep8_indent_multiline_string')
+    let g:python_pep8_indent_multiline_string = 0
+endif
+
 let s:maxoff = 50
 let s:block_rules = {
             \ '^\s*elif\>': ['if', 'elif'],
-            \ '^\s*else\>': ['if', 'elif', 'for', 'try', 'except'],
             \ '^\s*except\>': ['try', 'except'],
             \ '^\s*finally\>': ['try', 'except', 'else']
             \ }
+let s:block_rules_multiple = {
+            \ '^\s*else\>': ['if', 'elif', 'for', 'try', 'except'],
+            \ }
 let s:paren_pairs = ['()', '{}', '[]']
 if &ft == 'pyrex' || &ft == 'cython'
     let b:control_statement = '\v^\s*(class|def|if|while|with|for|except|cdef|cpdef)>'
@@ -136,22 +142,28 @@ function! s:find_start_of_multiline_statement(lnum)
     endwhile
 endfunction
 
-" Find the block starter that matches the current line
-function! s:find_start_of_block(lnum, types)
+" Find possible indent(s) of the block starter that matches the current line.
+function! s:find_start_of_block(lnum, types, multiple)
+    let r = []
     let re = '\V\^\s\*\('.join(a:types, '\|').'\)\>'
-
     let lnum = a:lnum
     let last_indent = indent(lnum) + 1
     while lnum > 0 && last_indent > 0
-        if indent(lnum) < last_indent
+        let indent = indent(lnum)
+        if indent < last_indent
             if getline(lnum) =~# re
-                return lnum
+                if !a:multiple
+                    return [indent]
+                endif
+                if !len(r) || index(r, indent) == -1
+                    let r += [indent]
+                endif
             endif
             let last_indent = indent(lnum)
         endif
         let lnum = prevnonblank(lnum - 1)
     endwhile
-    return 0
+    return r
 endfunction
 
 " Is "expr" true for every position in "lnum", beginning at "start"?
@@ -212,20 +224,31 @@ endfunction
 " Match indent of first block of this type.
 function! s:indent_like_block(lnum)
     let text = getline(a:lnum)
+    for [multiple, block_rules] in [
+                \ [0, s:block_rules],
+                \ [1, s:block_rules_multiple]]
+        for [line_re, blocks] in items(block_rules)
+            if text !~# line_re
+                continue
+            endif
 
-    for [line_re, blocks] in items(s:block_rules)
-        if text !~# line_re
-            continue
-        endif
-
-        let lnum = s:find_start_of_block(a:lnum - 1, blocks)
-        if lnum > 0
-            return indent(lnum)
-        else
-            return -1
-        endif
+            let indents = s:find_start_of_block(a:lnum - 1, blocks, multiple)
+            if !len(indents)
+                return -1
+            endif
+            if len(indents) == 1
+                return indents[0]
+            endif
+            " Multiple valid indents, e.g. for 'else' with both try and if.
+            let indent = indent(a:lnum)
+            for possible_indent in indents
+                if indent == possible_indent
+                    return indent
+                endif
+            endfor
+            return -2
+        endfor
     endfor
-
     return -2
 endfunction
 
@@ -281,10 +304,7 @@ function! s:indent_like_previous_line(lnum)
         return -1
     endif
 
-    " If this line is dedented and the number of indent spaces is valid
-    " (multiple of the indentation size), trust the user
-    let dedent_size = current - base
-    if dedent_size < 0 && current % s:sw() == 0
+    if s:is_dedented_already(current, base)
         return -1
     endif
 
@@ -292,6 +312,13 @@ function! s:indent_like_previous_line(lnum)
     return base
 endfunction
 
+" If this line is dedented and the number of indent spaces is valid
+" (multiple of the indentation size), trust the user.
+function! s:is_dedented_already(current, base)
+    let dedent_size = a:current - a:base
+    return (dedent_size < 0 && a:current % s:sw() == 0) ? 1 : 0
+endfunction
+
 " Is the syntax at lnum (and optionally cnum) a python string?
 function! s:is_python_string(lnum, ...)
     let line = getline(a:lnum)
@@ -310,28 +337,40 @@ function! s:is_python_string(lnum, ...)
 endfunction
 
 function! GetPythonPEPIndent(lnum)
-
     " First line has indent 0
     if a:lnum == 1
         return 0
     endif
 
     " Multilinestrings: continous, docstring or starting.
-    if s:is_python_string(a:lnum)
+    if s:is_python_string(a:lnum, 1)
+                \ && s:is_python_string(a:lnum-1, len(getline(a:lnum-1)))
+        " Keep existing indent.
+        if match(getline(a:lnum), '\v^\s*\S') != -1
+            return -1
+        endif
+
         if s:is_python_string(a:lnum-1)
             " Previous line is (completely) a string.
-            return s:indent_like_previous_line(a:lnum)
+            return indent(a:lnum-1)
         endif
 
         if match(getline(a:lnum-1), '^\s*\%("""\|''''''\)') != -1
             " docstring.
-            return s:indent_like_previous_line(a:lnum)
+            return indent(a:lnum-1)
         endif
 
-        if s:is_python_string(a:lnum-1, len(getline(a:lnum-1)))
-            " String started in previous line.
-            return 0
+        let indent_multi = get(b:, 'python_pep8_indent_multiline_string',
+                    \ get(g:, 'python_pep8_indent_multiline_string', 0))
+        if indent_multi != -2
+            return indent_multi
+        endif
+
+        if match(getline(a:lnum-1), '\v%("""|'''''')$') != -1
+            " Opening multiline string, started in previous line.
+            return indent(a:lnum-1) + s:sw()
         endif
+        return s:indent_like_opening_paren(a:lnum)
     endif
 
     " Parens: If we can find an open parenthesis/bracket/brace, line up with it.