From 7cb9a56c62d3540432cbcf78364569be19eb9e8a Mon Sep 17 00:00:00 2001 From: Daniel Hahler Date: Wed, 6 May 2015 15:12:26 +0200 Subject: [PATCH] Improve handling of lookup in previous lines - Handle jedi-vim call signatures when looking for colon and function def in previous line. This adds `jedi\S` to s:skip_special_chars and improves the algorithm to find the colon in the previous line in `s:indent_like_previous_line`. - Add `s:match_expr_on_line` and use it for `nothing_after_opening_paren`. - Handle comments after opening paren (#32). NOTE: This handles older Vim versions, where `synconcealed` behaves different (returns an empty list for non-concealed) and `getcurpos` is not available (Vim 7.3.429 (used on Travis)). Fixes: https://github.com/hynek/vim-python-pep8-indent/issues/32 --- indent/python.vim | 61 ++++++++++++++++++++++++++++++++------ spec/indent/indent_spec.rb | 38 ++++++++++++++++++++++++ 2 files changed, 90 insertions(+), 9 deletions(-) diff --git a/indent/python.vim b/indent/python.vim index 007c7e1..a1dd43f 100644 --- a/indent/python.vim +++ b/indent/python.vim @@ -43,9 +43,25 @@ let s:paren_pairs = ['()', '{}', '[]'] let s:control_statement = '^\s*\(class\|def\|if\|while\|with\|for\|except\)\>' let s:stop_statement = '^\s*\(break\|continue\|raise\|return\|pass\)\>' -" Skip strings and comments +" 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") ' . - \ '=~? "string\\|comment"' + \ '=~? "\\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 + let s:skip_search = 'synIDattr(synID(line("."), col("."), 0), "name") ' . \ '=~? "comment"' @@ -134,6 +150,27 @@ function! s:find_start_of_block(lnum, types) return 0 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. function! s:indent_like_opening_paren(lnum) let [paren_lnum, paren_col] = s:find_opening_paren(a:lnum) @@ -143,7 +180,8 @@ function! s:indent_like_opening_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 @@ -204,13 +242,18 @@ function! s:indent_like_previous_line(lnum) call cursor(lnum, len(text)) let ignore_last_char = eval(s:skip_special_chars) - " Search for final colon that is not inside a string or comment. - while search(':\s*\%(#.*\)\?$', 'bcW', lnum) - if eval(s:skip_special_chars) + " Search for final colon that is not inside something to be ignored. + while search(':', 'bcW', lnum) + let curpos = getpos(".")[2] + if curpos == 1 | break | endif + if eval(s:skip_special_chars) + normal! h + continue + endif + if !s:match_expr_on_line(s:skip_special_chars, lnum, curpos) + return base + s:sw() + endif normal! h - else - return base + s:sw() - endif endwhile if text =~ '\\$' && !ignore_last_char diff --git a/spec/indent/indent_spec.rb b/spec/indent/indent_spec.rb index cd37f1f..1999d27 100644 --- a/spec/indent/indent_spec.rb +++ b/spec/indent/indent_spec.rb @@ -76,6 +76,21 @@ shared_examples_for "vim" do end end + describe "when after an '{' that is followed by a comment" do + before { vim.feedkeys 'imydict = { # comment\' } + + it "indent by one level" do + indent.should == shiftwidth + vim.feedkeys '1: 1,\' + indent.should == shiftwidth + end + + it "lines up the closing parenthesis" do + vim.feedkeys '}' + indent.should == 0 + end + end + describe "when using gq to reindent a '(' that is" do before { vim.feedkeys 'itest(' } it "something and has a string without spaces at the end" do @@ -129,6 +144,15 @@ shared_examples_for "vim" do end end + describe "when the previous line has a colon in a string" do + before { vim.feedkeys 'itest(":".join(["1","2"]))\' } + it "does not indent" do + vim.feedkeys 'if True:' + indent.should == 0 + proposed_indent.should == 0 + end + end + describe "when after an '(' that is followed by an unfinished string" do before { vim.feedkeys 'itest("""' } @@ -374,6 +398,20 @@ shared_examples_for "vim" do end end + describe "when jedi-vim call signatures are used" do + before { vim.command 'syn match jediFunction "JEDI_CALL_SIGNATURE" keepend extend' } + + it "ignores the call signature after a colon" do + vim.feedkeys 'iif True: JEDI_CALL_SIGNATURE\' + indent.should == shiftwidth + end + + it "ignores the call signature after a function" do + vim.feedkeys 'idef f( JEDI_CALL_SIGNATURE\' + indent.should == shiftwidth * 2 + end + end + def shiftwidth @shiftwidth ||= vim.echo("exists('*shiftwidth') ? shiftwidth() : &sw").to_i end -- 2.39.5