mirror of
https://github.com/gryf/.vim.git
synced 2025-12-17 19:40:29 +01:00
Separated filetype specific settings into ftplugin directory,
added pydoc plugin added surround plugin instead of annoying (in the end) delimitMate plugin. removed some experimental files with colors added jythongold folding for python added rst snippets added tmux configuration filetype added pylint compiler updated pyflakes
This commit is contained in:
27
ftplugin/python/common.vim
Normal file
27
ftplugin/python/common.vim
Normal file
@@ -0,0 +1,27 @@
|
||||
set cinkeys-=0#
|
||||
set expandtab
|
||||
set foldlevel=100
|
||||
set foldmethod=indent
|
||||
set indentkeys-=0#
|
||||
set list
|
||||
set noautoindent
|
||||
set shiftwidth=4
|
||||
set smartindent cinwords=if,elif,else,for,while,try,except,finally,def,class,with
|
||||
set smarttab
|
||||
set softtabstop=4
|
||||
set tabstop=4
|
||||
set textwidth=78
|
||||
|
||||
inoremap # X<BS>#
|
||||
|
||||
"set ofu=syntaxcomplete#Complete
|
||||
|
||||
let g:pylint_onwrite = 0 " I don't want to run pylint on every save
|
||||
compiler pylint
|
||||
|
||||
"autocmd FileType python setlocal omnifunc=pysmell#Complete
|
||||
let python_highlight_all=1
|
||||
|
||||
"Load views for py files
|
||||
autocmd BufWinLeave *.py mkview
|
||||
autocmd BufWinEnter *.py silent loadview
|
||||
231
ftplugin/python/jpythonfold.vim
Normal file
231
ftplugin/python/jpythonfold.vim
Normal file
@@ -0,0 +1,231 @@
|
||||
" Fold routines for python code, version 3.2
|
||||
" Source: http://www.vim.org/scripts/script.php?script_id=2527
|
||||
" Last Change: 2009 Feb 25
|
||||
" Author: Jurjen Bos
|
||||
" Bug fixes and helpful comments: Grissiom, David Froger, Andrew McNabb
|
||||
|
||||
" Principles:
|
||||
" - a def/class starts a fold
|
||||
" a line with indent less than the previous def/class ends a fold
|
||||
" empty lines and comment lines are linked to the previous fold
|
||||
" comment lines outside a def/class are never folded
|
||||
" other lines outside a def/class are folded together as a group
|
||||
" for algorithm, see bottom of script
|
||||
|
||||
" - optionally, you can get empty lines between folds, see (***)
|
||||
" - another option is to ignore non-python files see (**)
|
||||
" - you can also modify the def/class check,
|
||||
" allowing for multiline def and class definitions see (*)
|
||||
|
||||
" Note for vim 7 users:
|
||||
" Vim 6 line numbers always take 8 columns, while vim 7 has a numberwidth variable
|
||||
" you can change the 8 below to &numberwidth if you have vim 7,
|
||||
" this is only really useful when you plan to use more than 8 columns (i.e. never)
|
||||
|
||||
" Note for masochists trying to read this:
|
||||
" I wanted to keep the functions short, so I replaced occurences of
|
||||
" if condition
|
||||
" statement
|
||||
" by
|
||||
" if condition | statement
|
||||
" wherever I found that useful
|
||||
|
||||
" (*)
|
||||
" class definitions are supposed to ontain a colon on the same line.
|
||||
" function definitions are *not* required to have a colon, to allow for multiline defs.
|
||||
" I you disagree, use instead of the pattern '^\s*\(class\s.*:\|def\s\)'
|
||||
" to enforce : for defs: '^\s*\(class\|def\)\s.*:'
|
||||
" you'll have to do this in two places.
|
||||
let s:defpat = '^\s*\(@\|class\s.*:\|def\s\)'
|
||||
|
||||
" (**) Ignore non-python files
|
||||
" Commented out because some python files are not recognized by Vim
|
||||
"if &filetype != 'python'
|
||||
" finish
|
||||
"endif
|
||||
|
||||
setlocal foldmethod=expr
|
||||
setlocal foldexpr=GetPythonFold(v:lnum)
|
||||
setlocal foldtext=PythonFoldText()
|
||||
|
||||
function! PythonFoldText()
|
||||
let fs = v:foldstart
|
||||
while getline(fs) =~ '^\s*@' | let fs = nextnonblank(fs + 1)
|
||||
endwhile
|
||||
let line = getline(fs)
|
||||
let nnum = nextnonblank(fs + 1)
|
||||
let nextline = getline(nnum)
|
||||
"get the document string: next line is ''' or """
|
||||
if nextline =~ "^\\s\\+[\"']\\{3}\\s*$"
|
||||
let line = line . " " . matchstr(getline(nextnonblank(nnum + 1)), '^\s*\zs.*\ze$')
|
||||
"next line starts with qoutes, and has text
|
||||
elseif nextline =~ "^\\s\\+[\"']\\{1,3}"
|
||||
let line = line." ".matchstr(nextline, "^\\s\\+[\"']\\{1,3}\\zs.\\{-}\\ze['\"]\\{0,3}$")
|
||||
elseif nextline =~ '^\s\+pass\s*$'
|
||||
let line = line . ' pass'
|
||||
endif
|
||||
"compute the width of the visible part of the window (see Note above)
|
||||
let w = winwidth(0) - &foldcolumn - (&number ? 8 : 0)
|
||||
let size = 1 + v:foldend - v:foldstart
|
||||
"compute expansion string
|
||||
let spcs = '................'
|
||||
while strlen(spcs) < w | let spcs = spcs . spcs
|
||||
endwhile
|
||||
"expand tabs (mail me if you have tabstop>10)
|
||||
let onetab = strpart(' ', 0, &tabstop)
|
||||
let line = substitute(line, '\t', onetab, 'g')
|
||||
return strpart(line.spcs, 0, w-strlen(size)-7).'.'.size.' lines'
|
||||
endfunction
|
||||
|
||||
function! GetBlockIndent(lnum)
|
||||
" Auxiliary function; determines the indent level of the surrounding def/class
|
||||
" "global" lines are level 0, first def &shiftwidth, and so on
|
||||
" scan backwards for class/def that is shallower or equal
|
||||
let ind = 100
|
||||
let p = a:lnum+1
|
||||
while indent(p) >= 0
|
||||
let p = p - 1
|
||||
" skip empty and comment lines
|
||||
if getline(p) =~ '^$\|^\s*#' | continue
|
||||
" zero-level regular line
|
||||
elseif indent(p) == 0 | return 0
|
||||
" skip deeper or equal lines
|
||||
elseif indent(p) >= ind || getline(p) =~ '^$\|^\s*#' | continue
|
||||
" indent is strictly less at this point: check for def/class
|
||||
elseif getline(p) =~ s:defpat && getline(p) !~ '^\s*@'
|
||||
" level is one more than this def/class
|
||||
return indent(p) + &shiftwidth
|
||||
endif
|
||||
" shallower line that is neither class nor def: continue search at new level
|
||||
let ind = indent(p)
|
||||
endwhile
|
||||
"beginning of file
|
||||
return 0
|
||||
endfunction
|
||||
|
||||
" Clever debug code, use as: call PrintIfCount(n,"Line: ".a:lnum.", value: ".x)
|
||||
let s:counter=0
|
||||
function! PrintIfCount(n,t)
|
||||
"Print text the nth time this function is called
|
||||
let s:counter = s:counter+1
|
||||
if s:counter==a:n | echo a:t
|
||||
endif
|
||||
endfunction
|
||||
|
||||
function! GetPythonFold(lnum)
|
||||
" Determine folding level in Python source (see "higher foldlevel theory" below)
|
||||
let line = getline(a:lnum)
|
||||
let ind = indent(a:lnum)
|
||||
" Case D***: class and def start a fold
|
||||
" If previous line is @, it is not the first
|
||||
if line =~ s:defpat && getline(prevnonblank(a:lnum-1)) !~ '^\s*@'
|
||||
" let's see if this range of 0 or more @'s end in a class/def
|
||||
let n = a:lnum
|
||||
while getline(n) =~ '^\s*@' | let n = nextnonblank(n + 1)
|
||||
endwhile
|
||||
" yes, we have a match: this is the first of a real def/class with decorators
|
||||
if getline(n) =~ s:defpat
|
||||
return ">".(ind/&shiftwidth+1)
|
||||
endif
|
||||
" Case E***: empty lines fold with previous
|
||||
" (***) change '=' to -1 if you want empty lines/comment out of a fold
|
||||
elseif line == '' | return '='
|
||||
endif
|
||||
" now we need the indent from previous
|
||||
let p = prevnonblank(a:lnum-1)
|
||||
while p>0 && getline(p) =~ '^\s*#' | let p = prevnonblank(p-1)
|
||||
endwhile
|
||||
let pind = indent(p)
|
||||
" If previous was definition: count as one level deeper
|
||||
if getline(p) =~ s:defpat && getline(prevnonblank(a:lnum - 1)) !~ '^\s*@'
|
||||
let pind = pind + &shiftwidth
|
||||
" if begin of file: take zero
|
||||
elseif p==0 | let pind = 0
|
||||
endif
|
||||
" Case S*=* and C*=*: indent equal
|
||||
if ind>0 && ind==pind | return '='
|
||||
" Case S*>* and C*>*: indent increase
|
||||
elseif ind>pind | return '='
|
||||
" All cases with 0 indent
|
||||
elseif ind==0
|
||||
" Case C*=0*: separate global code blocks
|
||||
if pind==0 && line =~ '^#' | return 0
|
||||
" Case S*<0* and S*=0*: global code
|
||||
elseif line !~'^#'
|
||||
" Case S*<0*: new global statement if/while/for/try/with
|
||||
if 0<pind && line!~'^else\s*:\|^except.*:\|^elif.*:\|^finally\s*:' | return '>1'
|
||||
" Case S*=0*, after level 0 comment
|
||||
elseif 0==pind && getline(prevnonblank(a:lnum-1)) =~ '^\s*#' | return '>1'
|
||||
" Case S*=0*, other, stay 1
|
||||
else | return '='
|
||||
endif
|
||||
endif
|
||||
" Case C*<0= and C*<0<: compute next indent
|
||||
let n = nextnonblank(a:lnum+1)
|
||||
while n>0 && getline(n) =~'^\s*#' | let n = nextnonblank(n+1)
|
||||
endwhile
|
||||
" Case C*<0=: split definitions
|
||||
if indent(n)==0 | return 0
|
||||
" Case C*<0<: shallow comment
|
||||
else | return -1
|
||||
end
|
||||
endif
|
||||
" now we really need to compute the actual fold indent
|
||||
" do the hard computation
|
||||
let blockindent = GetBlockIndent(a:lnum)
|
||||
" Case SG<* and CG<*: global code, level 1
|
||||
if blockindent==0 | return 1
|
||||
endif
|
||||
" now we need the indent from next
|
||||
let n = nextnonblank(a:lnum+1)
|
||||
while n>0 && getline(n) =~'^\s*#' | let n = nextnonblank(n+1)
|
||||
endwhile
|
||||
let nind = indent(n)
|
||||
" Case CR<= and CR<>
|
||||
"if line !~ '^\s*#' | call PrintIfCount(4,"Line: ".a:lnum.", blockindent: ".blockindent.", n: ".n.", nind: ".nind.", p: ".p.", pind: ".pind)
|
||||
endif
|
||||
if line =~ '^\s*#' && ind>=nind | return -1
|
||||
" Case CR<<: return next indent
|
||||
elseif line =~ '^\s*#' | return nind / &shiftwidth
|
||||
" Case SR<*: return actual indent
|
||||
else | return blockindent / &shiftwidth
|
||||
endif
|
||||
endfunction
|
||||
|
||||
" higher foldlevel theory
|
||||
" There are five kinds of statements: S (code), D (def/class), E (empty), C (comment)
|
||||
|
||||
" Note that a decorator statement (beginning with @) counts as definition,
|
||||
" but that of a sequence of @,@,@,def only the first one counts
|
||||
" This means that a definiion only counts if not preceded by a decorator
|
||||
|
||||
" There are two kinds of folds: R (regular), G (global statements)
|
||||
|
||||
" There are five indent situations with respect to the previous non-emtpy non-comment line:
|
||||
" > (indent), < (dedent), = (same); < and = combine with 0 (indent is zero)
|
||||
" Note: if the previous line is class/def, its indent is interpreted as one higher
|
||||
|
||||
" There are three indent situations with respect to the next (non-E non-C) line:
|
||||
" > (dedent), < (indent), = (same)
|
||||
|
||||
" Situations (in order of the script):
|
||||
" stat fold prev next
|
||||
" SDEC RG ><=00 ><=
|
||||
" D * * * begin fold level if previous is not @: '>'.ind/&sw+1
|
||||
" E * * * keep with previous: '='
|
||||
" S * = * stays the same: '='
|
||||
" C * = * combine with previous: '='
|
||||
" S * > * stays the same: '='
|
||||
" C * > * combine with previous: '='
|
||||
" C * =0 * separate blocks: 0
|
||||
" S * <0 * becomes new level 1: >1 (except except/else: 1)
|
||||
" S * =0 * stays 1: '=' (after level 0 comment: '>1')
|
||||
" C * <0 = split definitions: 0
|
||||
" C * <0 < shallow comment: -1
|
||||
" C * <0 > [never occurs]
|
||||
" S G < * global, not the first: 1
|
||||
" C G < * indent isn't 0: 1
|
||||
" C R < = foldlevel as computed for next line: -1
|
||||
" C R < > foldlevel as computed for next line: -1
|
||||
" S R < * compute foldlevel the hard way: use function
|
||||
" C R < < foldlevel as computed for this line: use function
|
||||
@@ -43,6 +43,7 @@ sys.path.insert(0, scriptdir)
|
||||
|
||||
from pyflakes import checker, ast, messages
|
||||
from operator import attrgetter
|
||||
import re
|
||||
|
||||
class SyntaxError(messages.Message):
|
||||
message = 'could not compile: %s'
|
||||
@@ -55,7 +56,20 @@ class blackhole(object):
|
||||
|
||||
def check(buffer):
|
||||
filename = buffer.name
|
||||
contents = '\n'.join(buffer[:]) + '\n'
|
||||
contents = buffer[:]
|
||||
|
||||
# shebang usually found at the top of the file, followed by source code encoding marker.
|
||||
# assume everything else that follows is encoded in the encoding.
|
||||
encoding_found = False
|
||||
for n, line in enumerate(contents):
|
||||
if not encoding_found:
|
||||
if re.match(r'^# -\*- coding: .+? -*-', line):
|
||||
encoding_found = True
|
||||
else:
|
||||
# skip all preceeding lines
|
||||
contents = [''] * n + contents[n:]
|
||||
break
|
||||
contents = '\n'.join(contents) + '\n'
|
||||
|
||||
vimenc = vim.eval('&encoding')
|
||||
if vimenc:
|
||||
|
||||
Reference in New Issue
Block a user