]> git.madduck.net Git - etc/vim.git/blobdiff - indent/python.vim

madduck's git repository

Every one of the projects in this repository is available at the canonical URL git://git.madduck.net/madduck/pub/<projectpath> — see each project's metadata for the exact URL.

All patches and comments are welcome. Please squash your changes to logical commits before using git-format-patch and git-send-email to patches@git.madduck.net. If you'd read over the Git project's submission guidelines and adhered to them, I'd be especially grateful.

SSH access, as well as push access can be individually arranged.

If you use my repositories frequently, consider adding the following snippet to ~/.gitconfig and using the third clone URL listed for each project:

[url "git://git.madduck.net/madduck/"]
  insteadOf = madduck:

Take over maintainership, move it to Vimjas org
[etc/vim.git] / indent / python.vim
index 0f58516bc995c80c57da79d5a856904f6dc58626..8a479f49f265bac94c8c66399cc11481581e2325 100644 (file)
@@ -1,9 +1,23 @@
 " PEP8 compatible Python indent file
 " Language:         Python
 " PEP8 compatible Python indent file
 " Language:         Python
-" Maintainer:       Hynek Schlawack <hs@ox.cx>
+" Maintainer:       Daniel Hahler <https://daniel.hahler.de/>
+" Prev Maintainer:  Hynek Schlawack <hs@ox.cx>
 " Prev Maintainer:  Eric Mc Sween <em@tomcom.de> (address invalid)
 " Original Author:  David Bustos <bustos@caltech.edu> (address invalid)
 " Prev Maintainer:  Eric Mc Sween <em@tomcom.de> (address invalid)
 " Original Author:  David Bustos <bustos@caltech.edu> (address invalid)
-" License:          Public Domain
+" License:          CC0
+"
+" vim-python-pep8-indent - A nicer Python indentation style for vim.
+" Written in 2004 by David Bustos <bustos@caltech.edu>
+" Maintained from 2004-2005 by Eric Mc Sween <em@tomcom.de>
+" Maintained from 2013 by Hynek Schlawack <hs@ox.cx>
+" Maintained from 2017 by Daniel Hahler <https://daniel.hahler.de/>
+"
+" To the extent possible under law, the author(s) have dedicated all copyright
+" and related and neighboring rights to this software to the public domain
+" worldwide. This software is distributed without any warranty.
+" You should have received a copy of the CC0 Public Domain Dedication along
+" with this software. If not, see
+" <http://creativecommons.org/publicdomain/zero/1.0/>.
 
 " Only load this indent file when no other was loaded.
 if exists("b:did_indent")
 
 " Only load this indent file when no other was loaded.
 if exists("b:did_indent")
@@ -20,22 +34,52 @@ setlocal tabstop=4
 setlocal softtabstop=4
 setlocal shiftwidth=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 = {
 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']
-  \ }
+            \ '^\s*elif\>': ['if', 'elif'],
+            \ '^\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 = ['()', '{}', '[]']
 let s:paren_pairs = ['()', '{}', '[]']
-let s:control_statement = '^\s*\(if\|while\|with\|for\|except\)\>'
+if &ft == 'pyrex' || &ft == 'cython'
+    let b:control_statement = '\v^\s*(class|def|if|while|with|for|except|cdef|cpdef)>'
+else
+    let b:control_statement = '\v^\s*(class|def|if|while|with|for|except)>'
+endif
 let s:stop_statement = '^\s*\(break\|continue\|raise\|return\|pass\)\>'
 
 let s:stop_statement = '^\s*\(break\|continue\|raise\|return\|pass\)\>'
 
-" Skip strings and comments
-let s:skip = 'synIDattr(synID(line("."), col("."), 0), "name") ' .
-           \ '=~? "string\\|comment"'
+" Skip strings and comments. Return 1 for chars to skip.
+" jedi* refers to syntax definitions from jedi-vim for call signatures, which
+" are inserted temporarily into the buffer.
+let s:skip_special_chars = 'synIDattr(synID(line("."), col("."), 0), "name") ' .
+            \ '=~? "\\vstring|comment|jedi\\S"'
+
+let s:skip_after_opening_paren = 'synIDattr(synID(line("."), col("."), 0), "name") ' .
+            \ '=~? "\\vcomment|jedi\\S"'
+
+" Also ignore anything concealed.
+" Wrapper around synconcealed for older Vim (7.3.429, used on Travis CI).
+function! s:is_concealed(line, col)
+    let concealed = synconcealed(a:line, a:col)
+    return len(concealed) && concealed[0]
+endfunction
+if has('conceal')
+    let s:skip_special_chars .= '|| s:is_concealed(line("."), col("."))'
+endif
 
 
-" compatibility with vim patch 7.3.629: 'sw' can be set to -1 to follow 'ts'
+
+let s:skip_search = 'synIDattr(synID(line("."), col("."), 0), "name") ' .
+            \ '=~? "comment"'
+
+" Use 'shiftwidth()' instead of '&sw'.
+" (Since Vim patch 7.3.629, 'shiftwidth' can be set to 0 to follow 'tabstop').
 if exists('*shiftwidth')
     function! s:sw()
         return shiftwidth()
 if exists('*shiftwidth')
     function! s:sw()
         return shiftwidth()
@@ -67,13 +111,13 @@ function! s:find_opening_paren(...)
 
     let stopline = max([0, line('.') - s:maxoff])
 
 
     let stopline = max([0, line('.') - s:maxoff])
 
-    " Return if cursor is in a comment or string
-    exe 'if' s:skip '| return [0, 0] | endif'
+    " Return if cursor is in a comment.
+    exe 'if' s:skip_search '| return [0, 0] | endif'
 
     let positions = []
     for p in s:paren_pairs
         call add(positions, searchpairpos(
 
     let positions = []
     for p in s:paren_pairs
         call add(positions, searchpairpos(
-           \ '\V'.p[0], '', '\V'.p[1], 'bnW', s:skip, stopline))
+           \ '\V'.p[0], '', '\V'.p[1], 'bnW', s:skip_special_chars, stopline))
     endfor
 
     " Remove empty matches and return the type with the closest match
     endfor
 
     " Remove empty matches and return the type with the closest match
@@ -100,22 +144,55 @@ function! s:find_start_of_multiline_statement(lnum)
     endwhile
 endfunction
 
     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 types = copy(a:types)
     let re = '\V\^\s\*\('.join(a:types, '\|').'\)\>'
     let re = '\V\^\s\*\('.join(a:types, '\|').'\)\>'
-
     let lnum = a:lnum
     let last_indent = indent(lnum) + 1
     while lnum > 0 && last_indent > 0
     let lnum = a:lnum
     let last_indent = indent(lnum) + 1
     while lnum > 0 && last_indent > 0
-        if indent(lnum) < last_indent
-            if getline(lnum) =~# re
-                return lnum
-            endif
+        let indent = indent(lnum)
+        if indent < last_indent
+            for type in types
+                let re = '\v^\s*'.type.'>'
+                if getline(lnum) =~# re
+                    if !a:multiple
+                        return [indent]
+                    endif
+                    if index(r, indent) == -1
+                        let r += [indent]
+                    endif
+                    " Remove any handled type, e.g. 'if'.
+                    call remove(types, index(types, type))
+                endif
+            endfor
             let last_indent = indent(lnum)
         endif
         let lnum = prevnonblank(lnum - 1)
     endwhile
             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"?
+" (optionally up to a:1 / 4th argument)
+function! s:match_expr_on_line(expr, lnum, start, ...)
+    let text = getline(a:lnum)
+    let end = a:0 ? a:1 : len(text)
+    if a:start > end
+        return 1
+    endif
+    let save_pos = getpos('.')
+    let r = 1
+    for i in range(a:start, end)
+        call cursor(a:lnum, i)
+        if !(eval(a:expr) || text[i-1] =~ '\s')
+            let r = 0
+            break
+        endif
+    endfor
+    call setpos('.', save_pos)
+    return r
 endfunction
 
 " Line up with open parenthesis/bracket/brace.
 endfunction
 
 " Line up with open parenthesis/bracket/brace.
@@ -127,7 +204,8 @@ function! s:indent_like_opening_paren(lnum)
     let text = getline(paren_lnum)
     let base = indent(paren_lnum)
 
     let text = getline(paren_lnum)
     let base = indent(paren_lnum)
 
-    let nothing_after_opening_paren = text =~ '\%'.(paren_col + 1).'c\s*$'
+    let nothing_after_opening_paren = s:match_expr_on_line(
+                \ s:skip_after_opening_paren, paren_lnum, paren_col+1)
     let starts_with_closing_paren = getline(a:lnum) =~ '^\s*[])}]'
 
     if nothing_after_opening_paren
     let starts_with_closing_paren = getline(a:lnum) =~ '^\s*[])}]'
 
     if nothing_after_opening_paren
@@ -144,7 +222,7 @@ function! s:indent_like_opening_paren(lnum)
     " If this line is the continuation of a control statement
     " indent further to distinguish the continuation line
     " from the next logical line.
     " If this line is the continuation of a control statement
     " indent further to distinguish the continuation line
     " from the next logical line.
-    if text =~# s:control_statement && res == base + s:sw()
+    if text =~# b:control_statement && res == base + s:sw()
         return base + s:sw() * 2
     else
         return res
         return base + s:sw() * 2
     else
         return res
@@ -154,20 +232,32 @@ endfunction
 " Match indent of first block of this type.
 function! s:indent_like_block(lnum)
     let text = getline(a:lnum)
 " 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 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
 
 
-        let lnum = s:find_start_of_block(a:lnum - 1, blocks)
-        if lnum > 0
-            return indent(lnum)
-        else
-            return -1
-        endif
+            " Multiple valid indents, e.g. for 'else' with both try and if.
+            let indent = indent(a:lnum)
+            if index(indents, indent) != -1
+                " The indent is valid, keep it.
+                return indent
+            endif
+            " Fallback to the first/nearest one.
+            return indents[0]
+        endfor
     endfor
     endfor
-
     return -2
 endfunction
 
     return -2
 endfunction
 
@@ -186,22 +276,26 @@ function! s:indent_like_previous_line(lnum)
 
     " Jump to last character in previous line.
     call cursor(lnum, len(text))
 
     " Jump to last character in previous line.
     call cursor(lnum, len(text))
-    let ignore_last_char = eval(s:skip)
-
-    " Search for final colon that is not inside a string or comment.
-    while search(':\s*\%(#.*\)\?$', 'bcW', lnum)
-      if eval(s:skip)
-        normal! h
-      else
-        return base + s:sw()
-      endif
+    let ignore_last_char = eval(s:skip_special_chars)
+
+    " Search for final colon that is not inside something to be ignored.
+    while 1
+        let curpos = getpos(".")[2]
+        if curpos == 1 | break | endif
+        if eval(s:skip_special_chars) || text[curpos-1] =~ '\s'
+            normal! h
+            continue
+        elseif text[curpos-1] == ':'
+            return base + s:sw()
+        endif
+        break
     endwhile
 
     if text =~ '\\$' && !ignore_last_char
         " If this line is the continuation of a control statement
         " indent further to distinguish the continuation line
         " from the next logical line.
     endwhile
 
     if text =~ '\\$' && !ignore_last_char
         " If this line is the continuation of a control statement
         " indent further to distinguish the continuation line
         " from the next logical line.
-        if getline(start) =~# s:control_statement
+        if getline(start) =~# b:control_statement
             return base + s:sw() * 2
         endif
 
             return base + s:sw() * 2
         endif
 
@@ -219,10 +313,7 @@ function! s:indent_like_previous_line(lnum)
         return -1
     endif
 
         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
 
         return -1
     endif
 
@@ -230,13 +321,94 @@ function! s:indent_like_previous_line(lnum)
     return base
 endfunction
 
     return base
 endfunction
 
-function! GetPythonPEPIndent(lnum)
+" 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)
+    let linelen = len(line)
+    if linelen < 1
+      let linelen = 1
+    endif
+    let cols = a:0 ? type(a:1) != type([]) ? [a:1] : a:1 : range(1, linelen)
+    for cnum in cols
+        if match(map(synstack(a:lnum, cnum),
+                    \ 'synIDattr(v:val,"name")'), 'python\S*String') == -1
+            return 0
+        end
+    endfor
+    return 1
+endfunction
+
+function! GetPythonPEPIndent(lnum)
     " First line has indent 0
     if a:lnum == 1
         return 0
     endif
 
     " First line has indent 0
     if a:lnum == 1
         return 0
     endif
 
+    let line = getline(a:lnum)
+    let prevline = getline(a:lnum-1)
+
+    " Multilinestrings: continous, docstring or starting.
+    if s:is_python_string(a:lnum-1, len(prevline))
+                \ && (s:is_python_string(a:lnum, 1)
+                \     || match(line, '^\%("""\|''''''\)') != -1)
+
+        " Indent closing quotes as the line with the opening ones.
+        let match_quotes = match(line, '^\s*\zs\%("""\|''''''\)')
+        if match_quotes != -1
+            " closing multiline string
+            let quotes = line[match_quotes:match_quotes+2]
+            let pairpos = searchpairpos(quotes, '', quotes, 'b')
+            if pairpos[0] != 0
+                return indent(pairpos[0])
+            else
+                " TODO: test to cover this!
+            endif
+        endif
+
+        if s:is_python_string(a:lnum-1)
+            " Previous line is (completely) a string.
+            return indent(a:lnum-1)
+        endif
+
+        if match(prevline, '^\s*\%("""\|''''''\)') != -1
+            " docstring.
+            return indent(a:lnum-1)
+        endif
+
+        let indent_multi = get(b:, 'python_pep8_indent_multiline_string',
+                    \ get(g:, 'python_pep8_indent_multiline_string', 0))
+        if match(prevline, '\v%("""|'''''')$') != -1
+            " Opening multiline string, started in previous line.
+            if (&autoindent && indent(a:lnum) == indent(a:lnum-1))
+                        \ || match(line, '\v^\s+$') != -1
+                " <CR> with empty line or to split up 'foo("""bar' into
+                " 'foo("""' and 'bar'.
+                if indent_multi == -2
+                    return indent(a:lnum-1) + s:sw()
+                endif
+                return indent_multi
+            endif
+        endif
+
+        " Keep existing indent.
+        if match(line, '\v^\s*\S') != -1
+            return -1
+        endif
+
+        if indent_multi != -2
+            return indent_multi
+        endif
+
+        return s:indent_like_opening_paren(a:lnum)
+    endif
+
     " Parens: If we can find an open parenthesis/bracket/brace, line up with it.
     let indent = s:indent_like_opening_paren(a:lnum)
     if indent >= -1
     " Parens: If we can find an open parenthesis/bracket/brace, line up with it.
     let indent = s:indent_like_opening_paren(a:lnum)
     if indent >= -1