From 8265dca5d5a7cb37a85dd82823dde2f9f69a3abe Mon Sep 17 00:00:00 2001 From: amix Date: Fri, 7 Feb 2014 10:41:15 +0000 Subject: [PATCH] Updated plugins. Switched to Ack as standard search tool (much better than grep/vimgrep) --- sources_non_forked/goyo.vim/plugin/goyo.vim | 4 +- .../pyflakes-pathogen/.gitignore | 1 + .../pyflakes-pathogen/README.rst | 11 + .../ftplugin/python/README.rst | 80 +++ .../ftplugin/python/pyflakes.vim | 325 +++++++++ .../ftplugin/python/pyflakes/LICENSE | 21 + .../ftplugin/python/pyflakes/NEWS.txt | 29 + .../ftplugin/python/pyflakes/README.rst | 36 + .../ftplugin/python/pyflakes/TODO | 11 + .../python/pyflakes/pyflakes/__init__.py | 2 + .../ftplugin/python/pyflakes/pyflakes/ast.py | 311 ++++++++ .../python/pyflakes/pyflakes/checker.py | 625 ++++++++++++++++ .../python/pyflakes/pyflakes/messages.py | 96 +++ .../pyflakes/pyflakes/scripts/__init__.py | 0 .../pyflakes/pyflakes/scripts/pyflakes.py | 90 +++ .../python/pyflakes/pyflakes/test/__init__.py | 0 .../python/pyflakes/pyflakes/test/harness.py | 27 + .../pyflakes/pyflakes/test/test_imports.py | 673 ++++++++++++++++++ .../pyflakes/pyflakes/test/test_other.py | 575 +++++++++++++++ .../pyflakes/pyflakes/test/test_script.py | 185 +++++ .../pyflakes/test/test_undefined_names.py | 265 +++++++ .../ftplugin/python/pyflakes/setup.py | 28 + .../ftplugin/python/quickfix.diff | 124 ++++ .../tlib/autoload/tlib/World.vim | 50 +- .../tlib/autoload/tlib/agent.vim | 5 +- .../tlib/autoload/tlib/file.vim | 6 +- .../tlib/autoload/tlib/scratch.vim | 10 +- sources_non_forked/tlib/doc/tlib.txt | 2 +- sources_non_forked/tlib/plugin/02tlib.vim | 4 +- sources_non_forked/vim-airline/LICENSE | 2 +- sources_non_forked/vim-airline/README.md | 8 +- .../vim-airline/autoload/airline.vim | 2 +- .../vim-airline/autoload/airline/builder.vim | 2 +- .../vim-airline/autoload/airline/debug.vim | 2 +- .../autoload/airline/deprecation.vim | 2 +- .../autoload/airline/extensions.vim | 11 +- .../autoload/airline/extensions/branch.vim | 13 +- .../airline/extensions/bufferline.vim | 2 +- .../autoload/airline/extensions/commandt.vim | 2 +- .../autoload/airline/extensions/csv.vim | 2 +- .../autoload/airline/extensions/ctrlp.vim | 2 +- .../autoload/airline/extensions/default.vim | 2 +- .../autoload/airline/extensions/eclim.vim | 2 +- .../autoload/airline/extensions/example.vim | 2 +- .../autoload/airline/extensions/hunks.vim | 2 +- .../autoload/airline/extensions/netrw.vim | 32 + .../airline/extensions/promptline.vim | 33 + .../autoload/airline/extensions/quickfix.vim | 2 +- .../autoload/airline/extensions/syntastic.vim | 2 +- .../autoload/airline/extensions/tabline.vim | 2 +- .../airline/extensions/tabline/default.vim | 2 +- .../extensions/tabline/unique_tail.vim | 2 +- .../tabline/unique_tail_improved.vim | 2 +- .../autoload/airline/extensions/tagbar.vim | 2 +- .../autoload/airline/extensions/tmuxline.vim | 2 +- .../autoload/airline/extensions/undotree.vim | 2 +- .../autoload/airline/extensions/unite.vim | 2 +- .../airline/extensions/virtualenv.vim | 2 +- .../airline/extensions/whitespace.vim | 2 +- .../autoload/airline/highlighter.vim | 2 +- .../vim-airline/autoload/airline/init.vim | 2 +- .../vim-airline/autoload/airline/parts.vim | 2 +- .../vim-airline/autoload/airline/section.vim | 2 +- .../vim-airline/autoload/airline/themes.vim | 2 +- .../autoload/airline/themes/kalisi.vim | 57 ++ .../vim-airline/autoload/airline/util.vim | 2 +- .../vim-airline/doc/airline.txt | 24 +- .../vim-airline/plugin/airline.vim | 2 +- .../vim-fugitive/plugin/fugitive.vim | 3 + .../vim-snipmate/Contributors.md | 1 + sources_non_forked/vim-snipmate/README.md | 11 +- .../vim-snipmate/autoload/snipMate.vim | 12 +- sources_non_forked/vim-snippets/README.md | 26 + .../vim-snippets/snippets/puppet.snippets | 90 +-- update_plugins.py | 1 + vimrcs/basic.vim | 16 +- 76 files changed, 3855 insertions(+), 143 deletions(-) create mode 100644 sources_non_forked/pyflakes-pathogen/.gitignore create mode 100644 sources_non_forked/pyflakes-pathogen/README.rst create mode 100644 sources_non_forked/pyflakes-pathogen/ftplugin/python/README.rst create mode 100644 sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes.vim create mode 100644 sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/LICENSE create mode 100644 sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/NEWS.txt create mode 100644 sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/README.rst create mode 100644 sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/TODO create mode 100644 sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/__init__.py create mode 100644 sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/ast.py create mode 100644 sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/checker.py create mode 100644 sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/messages.py create mode 100644 sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/scripts/__init__.py create mode 100644 sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/scripts/pyflakes.py create mode 100644 sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/test/__init__.py create mode 100644 sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/test/harness.py create mode 100644 sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/test/test_imports.py create mode 100644 sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/test/test_other.py create mode 100644 sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/test/test_script.py create mode 100644 sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/test/test_undefined_names.py create mode 100644 sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/setup.py create mode 100644 sources_non_forked/pyflakes-pathogen/ftplugin/python/quickfix.diff create mode 100644 sources_non_forked/vim-airline/autoload/airline/extensions/netrw.vim create mode 100644 sources_non_forked/vim-airline/autoload/airline/extensions/promptline.vim create mode 100644 sources_non_forked/vim-airline/autoload/airline/themes/kalisi.vim diff --git a/sources_non_forked/goyo.vim/plugin/goyo.vim b/sources_non_forked/goyo.vim/plugin/goyo.vim index a2beb4a339..751162ce78 100644 --- a/sources_non_forked/goyo.vim/plugin/goyo.vim +++ b/sources_non_forked/goyo.vim/plugin/goyo.vim @@ -259,7 +259,7 @@ function! s:goyo_off() for [k, v] in items(goyo_revert) execute printf("let &%s = %s", k, string(v)) endfor - execute 'colo '. g:colors_name + execute 'colo '. get(g:, 'colors_name', 'default') if goyo_disabled_gitgutter silent! GitGutterEnable @@ -267,7 +267,7 @@ function! s:goyo_off() if goyo_disabled_airline && !exists("#airline") AirlineToggle - AirlineRefresh + silent! AirlineRefresh endif if goyo_disabled_powerline && !exists("#PowerlineMain") diff --git a/sources_non_forked/pyflakes-pathogen/.gitignore b/sources_non_forked/pyflakes-pathogen/.gitignore new file mode 100644 index 0000000000..0d20b6487c --- /dev/null +++ b/sources_non_forked/pyflakes-pathogen/.gitignore @@ -0,0 +1 @@ +*.pyc diff --git a/sources_non_forked/pyflakes-pathogen/README.rst b/sources_non_forked/pyflakes-pathogen/README.rst new file mode 100644 index 0000000000..b36ea38865 --- /dev/null +++ b/sources_non_forked/pyflakes-pathogen/README.rst @@ -0,0 +1,11 @@ +Pyflakes +========== + +This is just a manual dump of the vim pyflakes plugin from: +http://www.vim.org/scripts/script.php?script_id=2441 + +The purpose is to try to make this compatible with pathogen plugin. So creating +the dir structure and hopefully this means we can just keep the norm and git +clone the repo into the bundle directory and things will load up magically. + + diff --git a/sources_non_forked/pyflakes-pathogen/ftplugin/python/README.rst b/sources_non_forked/pyflakes-pathogen/ftplugin/python/README.rst new file mode 100644 index 0000000000..124fc3ec1d --- /dev/null +++ b/sources_non_forked/pyflakes-pathogen/ftplugin/python/README.rst @@ -0,0 +1,80 @@ +pyflakes-vim +============ + +A Vim plugin for checking Python code on the fly. + +PyFlakes catches common Python errors like mistyping a variable name or +accessing a local before it is bound, and also gives warnings for things like +unused imports. + +pyflakes-vim uses the output from PyFlakes to highlight errors in your code. +To locate errors quickly, use quickfix_ commands like :cc. + +Make sure to check vim.org_ for the latest updates. + +.. _pyflakes.vim: http://www.vim.org/scripts/script.php?script_id=2441 +.. _vim.org: http://www.vim.org/scripts/script.php?script_id=2441 +.. _quickfix: http://vimdoc.sourceforge.net/htmldoc/quickfix.html#quickfix + +Quick Installation +------------------ + +1. Make sure your ``.vimrc`` has:: + + filetype on " enables filetype detection + filetype plugin on " enables filetype specific plugins + +2. Download the latest release_. + +3. Unzip ``pyflakes.vim`` and the ``pyflakes`` directory into + ``~/.vim/ftplugin/python`` (or somewhere similar on your + `runtime path`_ that will be sourced for Python files). + +.. _release: http://www.vim.org/scripts/script.php?script_id=2441 +.. _runtime path: http://vimdoc.sourceforge.net/htmldoc/options.html#'runtimepath' + +Installation +------------ + +If you downloaded this from vim.org_, then just drop the contents of the zip +file into ``~/.vim/ftplugin/python``. + +Otherwise, if you're running "from source," you'll need PyFlakes on your +PYTHONPATH somewhere. I recommend getting my PyFlakes_ fork, which retains +column number information and has therfore has more specific error locations. + +.. _vim.org: http://www.vim.org/scripts/script.php?script_id=2441 +.. _PyFlakes: http://github.com/kevinw/pyflakes + +Hacking +------- + +:: + + git clone git://github.com/kevinw/pyflakes-vim.git + cd pyflakes-vim + git clone git://github.com/kevinw/pyflakes.git + +Options +------- + +Set this option to you vimrc file to disable quickfix support:: + + let g:pyflakes_use_quickfix = 0 + +The value is set to 1 by default. + +TODO +---- + * signs_ support (show warning and error icons to left of the buffer area) + * configuration variables + * parse or intercept useful output from the warnings module + +.. _signs: http://www.vim.org/htmldoc/sign.html + +Changelog +--------- + +Please see http://www.vim.org/scripts/script.php?script_id=2441 for a history of +all changes. + diff --git a/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes.vim b/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes.vim new file mode 100644 index 0000000000..a6e84b6a13 --- /dev/null +++ b/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes.vim @@ -0,0 +1,325 @@ +" pyflakes.vim - A script to highlight Python code on the fly with warnings +" from Pyflakes, a Python lint tool. +" +" Place this script and the accompanying pyflakes directory in +" .vim/ftplugin/python. +" +" See README for additional installation and information. +" +" Thanks to matlib.vim for ideas/code on interactive linting. +" +" Maintainer: Kevin Watters +" Version: 0.1 +if !has('python') + " exit if python is not available. + finish +endif + +if exists("b:did_pyflakes_plugin") + finish " only load once +else + let b:did_pyflakes_plugin = 1 +endif + +if !exists('g:pyflakes_builtins') + let g:pyflakes_builtins = [] +endif + +if !exists("b:did_python_init") + let b:did_python_init = 0 + + if !has('python') + echoerr "Error: the pyflakes.vim plugin requires Vim to be compiled with +python" + finish + endif + +if !exists('g:pyflakes_use_quickfix') + let g:pyflakes_use_quickfix = 1 +endif + + + python << EOF +import vim +import os.path +import sys + +if sys.version_info[:2] < (2, 5): + raise AssertionError('Vim must be compiled with Python 2.5 or higher; you have ' + sys.version) + +# get the directory this script is in: the pyflakes python module should be installed there. +scriptdir = os.path.join(os.path.dirname(vim.eval('expand("")')), 'pyflakes') +sys.path.insert(0, scriptdir) + +import ast +from pyflakes import checker, messages +from operator import attrgetter +import re + +class loc(object): + def __init__(self, lineno, col=None): + self.lineno = lineno + self.col_offset = col + +class SyntaxError(messages.Message): + message = 'could not compile: %s' + def __init__(self, filename, lineno, col, message): + messages.Message.__init__(self, filename, loc(lineno, col)) + self.message_args = (message,) + +class blackhole(object): + write = flush = lambda *a, **k: None + +def check(buffer): + filename = buffer.name + 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 n >= 2: + break + elif re.match(r'#.*coding[:=]\s*([-\w.]+)', line): + contents = ['']*(n+1) + contents[n+1:] + break + + contents = '\n'.join(contents) + '\n' + + vimenc = vim.eval('&encoding') + if vimenc: + contents = contents.decode(vimenc) + + builtins = set(['__file__']) + try: + builtins.update(set(eval(vim.eval('string(g:pyflakes_builtins)')))) + except Exception: + pass + + try: + # TODO: use warnings filters instead of ignoring stderr + old_stderr, sys.stderr = sys.stderr, blackhole() + try: + tree = ast.parse(contents, filename or '') + finally: + sys.stderr = old_stderr + except: + try: + value = sys.exc_info()[1] + lineno, offset, line = value[1][1:] + except IndexError: + lineno, offset, line = 1, 0, '' + if line and line.endswith("\n"): + line = line[:-1] + + return [SyntaxError(filename, lineno, offset, str(value))] + else: + # pyflakes looks to _MAGIC_GLOBALS in checker.py to see which + # UndefinedNames to ignore + old_globals = getattr(checker,' _MAGIC_GLOBALS', []) + checker._MAGIC_GLOBALS = set(old_globals) | builtins + + w = checker.Checker(tree, filename) + + checker._MAGIC_GLOBALS = old_globals + + w.messages.sort(key = attrgetter('lineno')) + return w.messages + + +def vim_quote(s): + return s.replace("'", "''") +EOF + let b:did_python_init = 1 +endif + +if !b:did_python_init + finish +endif + +au BufLeave call s:ClearPyflakes() + +au BufEnter call s:RunPyflakes() +au InsertLeave call s:RunPyflakes() +au InsertEnter call s:RunPyflakes() +au BufWritePost call s:RunPyflakes() + +au CursorHold call s:RunPyflakes() +au CursorHoldI call s:RunPyflakes() + +au CursorHold call s:GetPyflakesMessage() +au CursorMoved call s:GetPyflakesMessage() + +if !exists("*s:PyflakesUpdate") + function s:PyflakesUpdate() + silent call s:RunPyflakes() + call s:GetPyflakesMessage() + endfunction +endif + +" Call this function in your .vimrc to update PyFlakes +if !exists(":PyflakesUpdate") + command PyflakesUpdate :call s:PyflakesUpdate() +endif + +" Hook common text manipulation commands to update PyFlakes +" TODO: is there a more general "text op" autocommand we could register +" for here? +noremap dd dd:PyflakesUpdate +noremap dw dw:PyflakesUpdate +noremap u u:PyflakesUpdate +noremap :PyflakesUpdate + +" WideMsg() prints [long] message up to (&columns-1) length +" guaranteed without "Press Enter" prompt. +if !exists("*s:WideMsg") + function s:WideMsg(msg) + let x=&ruler | let y=&showcmd + set noruler noshowcmd + redraw + echo strpart(a:msg, 0, &columns-1) + let &ruler=x | let &showcmd=y + endfun +endif + +if !exists("*s:GetQuickFixStackCount") + function s:GetQuickFixStackCount() + let l:stack_count = 0 + try + silent colder 9 + catch /E380:/ + endtry + + try + for i in range(9) + silent cnewer + let l:stack_count = l:stack_count + 1 + endfor + catch /E381:/ + return l:stack_count + endtry + endfunction +endif + +if !exists("*s:ActivatePyflakesQuickFixWindow") + function s:ActivatePyflakesQuickFixWindow() + try + silent colder 9 " go to the bottom of quickfix stack + catch /E380:/ + endtry + + if s:pyflakes_qf > 0 + try + exe "silent cnewer " . s:pyflakes_qf + catch /E381:/ + echoerr "Could not activate Pyflakes Quickfix Window." + endtry + endif + endfunction +endif + +if !exists("*s:RunPyflakes") + function s:RunPyflakes() + highlight link PyFlakes SpellBad + + if exists("b:cleared") + if b:cleared == 0 + silent call s:ClearPyflakes() + let b:cleared = 1 + endif + else + let b:cleared = 1 + endif + + let b:matched = [] + let b:matchedlines = {} + + let b:qf_list = [] + let b:qf_window_count = -1 + + python << EOF +for w in check(vim.current.buffer): + vim.command('let s:matchDict = {}') + vim.command("let s:matchDict['lineNum'] = " + str(w.lineno)) + vim.command("let s:matchDict['message'] = '%s'" % vim_quote(w.message % w.message_args)) + vim.command("let b:matchedlines[" + str(w.lineno) + "] = s:matchDict") + + vim.command("let l:qf_item = {}") + vim.command("let l:qf_item.bufnr = bufnr('%')") + vim.command("let l:qf_item.filename = expand('%')") + vim.command("let l:qf_item.lnum = %s" % str(w.lineno)) + vim.command("let l:qf_item.text = '%s'" % vim_quote(w.message % w.message_args)) + vim.command("let l:qf_item.type = 'E'") + + if getattr(w, 'col', None) is None or isinstance(w, SyntaxError): + # without column information, just highlight the whole line + # (minus the newline) + vim.command(r"let s:mID = matchadd('PyFlakes', '\%" + str(w.lineno) + r"l\n\@!')") + else: + # with a column number, highlight the first keyword there + vim.command(r"let s:mID = matchadd('PyFlakes', '^\%" + str(w.lineno) + r"l\_.\{-}\zs\k\+\k\@!\%>" + str(w.col) + r"c')") + + vim.command("let l:qf_item.vcol = 1") + vim.command("let l:qf_item.col = %s" % str(w.col + 1)) + + vim.command("call add(b:matched, s:matchDict)") + vim.command("call add(b:qf_list, l:qf_item)") +EOF + if g:pyflakes_use_quickfix == 1 + if exists("s:pyflakes_qf") + " if pyflakes quickfix window is already created, reuse it + call s:ActivatePyflakesQuickFixWindow() + call setqflist(b:qf_list, 'r') + else + " one pyflakes quickfix window for all buffer + call setqflist(b:qf_list, '') + let s:pyflakes_qf = s:GetQuickFixStackCount() + endif + endif + + let b:cleared = 0 + endfunction +end + +" keep track of whether or not we are showing a message +let b:showing_message = 0 + +if !exists("*s:GetPyflakesMessage") + function s:GetPyflakesMessage() + let s:cursorPos = getpos(".") + + " Bail if RunPyflakes hasn't been called yet. + if !exists('b:matchedlines') + return + endif + + " if there's a message for the line the cursor is currently on, echo + " it to the console + if has_key(b:matchedlines, s:cursorPos[1]) + let s:pyflakesMatch = get(b:matchedlines, s:cursorPos[1]) + call s:WideMsg(s:pyflakesMatch['message']) + let b:showing_message = 1 + return + endif + + " otherwise, if we're showing a message, clear it + if b:showing_message == 1 + echo + let b:showing_message = 0 + endif + endfunction +endif + +if !exists('*s:ClearPyflakes') + function s:ClearPyflakes() + let s:matches = getmatches() + for s:matchId in s:matches + if s:matchId['group'] == 'PyFlakes' + call matchdelete(s:matchId['id']) + endif + endfor + let b:matched = [] + let b:matchedlines = {} + let b:cleared = 1 + endfunction +endif + diff --git a/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/LICENSE b/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/LICENSE new file mode 100644 index 0000000000..42b8cf3c96 --- /dev/null +++ b/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/LICENSE @@ -0,0 +1,21 @@ + +Copyright (c) 2005 Divmod, Inc., http://www.divmod.com/ + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/NEWS.txt b/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/NEWS.txt new file mode 100644 index 0000000000..2a3e316583 --- /dev/null +++ b/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/NEWS.txt @@ -0,0 +1,29 @@ +0.4.0 (2009-11-25): + - Fix reporting for certain SyntaxErrors which lack line number + information. + - Check for syntax errors more rigorously. + - Support checking names used with the class decorator syntax in versions + of Python which have it. + - Detect local variables which are bound but never used. + - Handle permission errors when trying to read source files. + - Handle problems with the encoding of source files. + - Support importing dotted names so as not to incorrectly report them as + redefined unused names. + - Support all forms of the with statement. + - Consider static `__all__` definitions and avoid reporting unused names + if the names are listed there. + - Fix incorrect checking of class names with respect to the names of their + bases in the class statement. + - Support the `__path__` global in `__init__.py`. + +0.3.0 (2009-01-30): + - Display more informative SyntaxError messages. + - Don't hang flymake with unmatched triple quotes (only report a single + line of source for a multiline syntax error). + - Recognize __builtins__ as a defined name. + - Improve pyflakes support for python versions 2.3-2.5 + - Support for if-else expressions and with statements. + - Warn instead of error on non-existant file paths. + - Check for __future__ imports after other statements. + - Add reporting for some types of import shadowing. + - Improve reporting of unbound locals diff --git a/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/README.rst b/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/README.rst new file mode 100644 index 0000000000..9ac34fc0f4 --- /dev/null +++ b/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/README.rst @@ -0,0 +1,36 @@ +pyflakes +======== + +This version of PyFlakes_ has been improved to use Python's newer ``ast`` +module, instead of ``compiler``. So code checking happens faster, and will stay +up to date with new language changes. + +.. _PyFlakes: http://http://www.divmod.org/trac/wiki/DivmodPyflakes + +TODO +---- + +Importing several modules from the same package results in unnecessary warnings: + +:: + + import a.b + import a.c # Redefinition of unused "a" from line 1 + +The following construct for defining a function differently depending on some +condition results in a redefinition warning: + +:: + + if some_condition: + def foo(): do_foo() + else: + def foo(): do_bar() # redefinition of function 'foo' from line 2 + +IDE Integration +--------------- + +* vim: pyflakes-vim_ + +.. _pyflakes-vim: http://github.com/kevinw/pyflakes-vim + diff --git a/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/TODO b/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/TODO new file mode 100644 index 0000000000..69f3f12c6a --- /dev/null +++ b/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/TODO @@ -0,0 +1,11 @@ + - Check for methods that override other methods except that they vary by case. + - assign/increment + unbound local error not caught + def foo(): + bar = 5 + def meep(): + bar += 2 + meep() + print bar + + print foo() + diff --git a/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/__init__.py b/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/__init__.py new file mode 100644 index 0000000000..652a8f4789 --- /dev/null +++ b/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/__init__.py @@ -0,0 +1,2 @@ + +__version__ = '0.4.0' diff --git a/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/ast.py b/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/ast.py new file mode 100644 index 0000000000..d52025f46c --- /dev/null +++ b/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/ast.py @@ -0,0 +1,311 @@ +# -*- coding: utf-8 -*- +""" + ast + ~~~ + + The `ast` module helps Python applications to process trees of the Python + abstract syntax grammar. The abstract syntax itself might change with + each Python release; this module helps to find out programmatically what + the current grammar looks like and allows modifications of it. + + An abstract syntax tree can be generated by passing `ast.PyCF_ONLY_AST` as + a flag to the `compile()` builtin function or by using the `parse()` + function from this module. The result will be a tree of objects whose + classes all inherit from `ast.AST`. + + A modified abstract syntax tree can be compiled into a Python code object + using the built-in `compile()` function. + + Additionally various helper functions are provided that make working with + the trees simpler. The main intention of the helper functions and this + module in general is to provide an easy to use interface for libraries + that work tightly with the python syntax (template engines for example). + + + :copyright: Copyright 2008 by Armin Ronacher. + :license: Python License. +""" +from _ast import * +from _ast import __version__ + + +def parse(expr, filename='', mode='exec'): + """ + Parse an expression into an AST node. + Equivalent to compile(expr, filename, mode, PyCF_ONLY_AST). + """ + return compile(expr, filename, mode, PyCF_ONLY_AST) + + +def literal_eval(node_or_string): + """ + Safely evaluate an expression node or a string containing a Python + expression. The string or node provided may only consist of the following + Python literal structures: strings, numbers, tuples, lists, dicts, booleans, + and None. + """ + _safe_names = {'None': None, 'True': True, 'False': False} + if isinstance(node_or_string, basestring): + node_or_string = parse(node_or_string, mode='eval') + if isinstance(node_or_string, Expression): + node_or_string = node_or_string.body + def _convert(node): + if isinstance(node, Str): + return node.s + elif isinstance(node, Num): + return node.n + elif isinstance(node, Tuple): + return tuple(map(_convert, node.elts)) + elif isinstance(node, List): + return list(map(_convert, node.elts)) + elif isinstance(node, Dict): + return dict((_convert(k), _convert(v)) for k, v + in zip(node.keys, node.values)) + elif isinstance(node, Name): + if node.id in _safe_names: + return _safe_names[node.id] + raise ValueError('malformed string') + return _convert(node_or_string) + + +def dump(node, annotate_fields=True, include_attributes=False): + """ + Return a formatted dump of the tree in *node*. This is mainly useful for + debugging purposes. The returned string will show the names and the values + for fields. This makes the code impossible to evaluate, so if evaluation is + wanted *annotate_fields* must be set to False. Attributes such as line + numbers and column offsets are not dumped by default. If this is wanted, + *include_attributes* can be set to True. + """ + def _format(node): + if isinstance(node, AST): + fields = [(a, _format(b)) for a, b in iter_fields(node)] + rv = '%s(%s' % (node.__class__.__name__, ', '.join( + ('%s=%s' % field for field in fields) + if annotate_fields else + (b for a, b in fields) + )) + if include_attributes and node._attributes: + rv += fields and ', ' or ' ' + rv += ', '.join('%s=%s' % (a, _format(getattr(node, a))) + for a in node._attributes) + return rv + ')' + elif isinstance(node, list): + return '[%s]' % ', '.join(_format(x) for x in node) + return repr(node) + if not isinstance(node, AST): + raise TypeError('expected AST, got %r' % node.__class__.__name__) + return _format(node) + + +def copy_location(new_node, old_node): + """ + Copy source location (`lineno` and `col_offset` attributes) from + *old_node* to *new_node* if possible, and return *new_node*. + """ + for attr in 'lineno', 'col_offset': + if attr in old_node._attributes and attr in new_node._attributes \ + and hasattr(old_node, attr): + setattr(new_node, attr, getattr(old_node, attr)) + return new_node + + +def fix_missing_locations(node): + """ + When you compile a node tree with compile(), the compiler expects lineno and + col_offset attributes for every node that supports them. This is rather + tedious to fill in for generated nodes, so this helper adds these attributes + recursively where not already set, by setting them to the values of the + parent node. It works recursively starting at *node*. + """ + def _fix(node, lineno, col_offset): + if 'lineno' in node._attributes: + if not hasattr(node, 'lineno'): + node.lineno = lineno + else: + lineno = node.lineno + if 'col_offset' in node._attributes: + if not hasattr(node, 'col_offset'): + node.col_offset = col_offset + else: + col_offset = node.col_offset + for child in iter_child_nodes(node): + _fix(child, lineno, col_offset) + _fix(node, 1, 0) + return node + +def add_col_end(node): + def _fix(node, next): + children = list(iter_child_nodes(node)) + for i, child in enumerate(children): + next_offset = children[i+1].col_offset if i < len(children) else next.col_offset + child.col_end = next_offset + + +def increment_lineno(node, n=1): + """ + Increment the line number of each node in the tree starting at *node* by *n*. + This is useful to "move code" to a different location in a file. + """ + if 'lineno' in node._attributes: + node.lineno = getattr(node, 'lineno', 0) + n + for child in walk(node): + if 'lineno' in child._attributes: + child.lineno = getattr(child, 'lineno', 0) + n + return node + + +def iter_fields(node): + """ + Yield a tuple of ``(fieldname, value)`` for each field in ``node._fields`` + that is present on *node*. + """ + if node._fields is None: + return + + for field in node._fields: + try: + yield field, getattr(node, field) + except AttributeError: + pass + + +def iter_child_nodes(node): + """ + Yield all direct child nodes of *node*, that is, all fields that are nodes + and all items of fields that are lists of nodes. + """ + for name, field in iter_fields(node): + if isinstance(field, AST): + yield field + elif isinstance(field, list): + for item in field: + if isinstance(item, AST): + yield item + + +def get_docstring(node, clean=True): + """ + Return the docstring for the given node or None if no docstring can + be found. If the node provided does not have docstrings a TypeError + will be raised. + """ + if not isinstance(node, (FunctionDef, ClassDef, Module)): + raise TypeError("%r can't have docstrings" % node.__class__.__name__) + if node.body and isinstance(node.body[0], Expr) and \ + isinstance(node.body[0].value, Str): + if clean: + import inspect + return inspect.cleandoc(node.body[0].value.s) + return node.body[0].value.s + + +def walk(node): + """ + Recursively yield all child nodes of *node*, in no specified order. This is + useful if you only want to modify nodes in place and don't care about the + context. + """ + from collections import deque + todo = deque([node]) + while todo: + node = todo.popleft() + todo.extend(iter_child_nodes(node)) + yield node + + +class NodeVisitor(object): + """ + A node visitor base class that walks the abstract syntax tree and calls a + visitor function for every node found. This function may return a value + which is forwarded by the `visit` method. + + This class is meant to be subclassed, with the subclass adding visitor + methods. + + Per default the visitor functions for the nodes are ``'visit_'`` + + class name of the node. So a `TryFinally` node visit function would + be `visit_TryFinally`. This behavior can be changed by overriding + the `visit` method. If no visitor function exists for a node + (return value `None`) the `generic_visit` visitor is used instead. + + Don't use the `NodeVisitor` if you want to apply changes to nodes during + traversing. For this a special visitor exists (`NodeTransformer`) that + allows modifications. + """ + + def visit(self, node): + """Visit a node.""" + method = 'visit_' + node.__class__.__name__ + visitor = getattr(self, method, self.generic_visit) + return visitor(node) + + def generic_visit(self, node): + """Called if no explicit visitor function exists for a node.""" + for field, value in iter_fields(node): + if isinstance(value, list): + for item in value: + if isinstance(item, AST): + self.visit(item) + elif isinstance(value, AST): + self.visit(value) + + +class NodeTransformer(NodeVisitor): + """ + A :class:`NodeVisitor` subclass that walks the abstract syntax tree and + allows modification of nodes. + + The `NodeTransformer` will walk the AST and use the return value of the + visitor methods to replace or remove the old node. If the return value of + the visitor method is ``None``, the node will be removed from its location, + otherwise it is replaced with the return value. The return value may be the + original node in which case no replacement takes place. + + Here is an example transformer that rewrites all occurrences of name lookups + (``foo``) to ``data['foo']``:: + + class RewriteName(NodeTransformer): + + def visit_Name(self, node): + return copy_location(Subscript( + value=Name(id='data', ctx=Load()), + slice=Index(value=Str(s=node.id)), + ctx=node.ctx + ), node) + + Keep in mind that if the node you're operating on has child nodes you must + either transform the child nodes yourself or call the :meth:`generic_visit` + method for the node first. + + For nodes that were part of a collection of statements (that applies to all + statement nodes), the visitor may also return a list of nodes rather than + just a single node. + + Usually you use the transformer like this:: + + node = YourTransformer().visit(node) + """ + + def generic_visit(self, node): + for field, old_value in iter_fields(node): + old_value = getattr(node, field, None) + if isinstance(old_value, list): + new_values = [] + for value in old_value: + if isinstance(value, AST): + value = self.visit(value) + if value is None: + continue + elif not isinstance(value, AST): + new_values.extend(value) + continue + new_values.append(value) + old_value[:] = new_values + elif isinstance(old_value, AST): + new_node = self.visit(old_value) + if new_node is None: + delattr(node, field) + else: + setattr(node, field, new_node) + return node diff --git a/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/checker.py b/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/checker.py new file mode 100644 index 0000000000..7c348b8db4 --- /dev/null +++ b/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/checker.py @@ -0,0 +1,625 @@ +# -*- test-case-name: pyflakes -*- +# (c) 2005-2010 Divmod, Inc. +# See LICENSE file for details + +import __builtin__ +import os.path +import _ast + +from pyflakes import messages + + +# utility function to iterate over an AST node's children, adapted +# from Python 2.6's standard ast module +try: + import ast + iter_child_nodes = ast.iter_child_nodes +except (ImportError, AttributeError): + def iter_child_nodes(node, astcls=_ast.AST): + """ + Yield all direct child nodes of *node*, that is, all fields that are nodes + and all items of fields that are lists of nodes. + """ + for name in node._fields: + field = getattr(node, name, None) + if isinstance(field, astcls): + yield field + elif isinstance(field, list): + for item in field: + yield item + + +class Binding(object): + """ + Represents the binding of a value to a name. + + The checker uses this to keep track of which names have been bound and + which names have not. See L{Assignment} for a special type of binding that + is checked with stricter rules. + + @ivar used: pair of (L{Scope}, line-number) indicating the scope and + line number that this binding was last used + """ + + def __init__(self, name, source): + self.name = name + self.source = source + self.used = False + + + def __str__(self): + return self.name + + + def __repr__(self): + return '<%s object %r from line %r at 0x%x>' % (self.__class__.__name__, + self.name, + self.source.lineno, + id(self)) + + + +class UnBinding(Binding): + '''Created by the 'del' operator.''' + + + +class Importation(Binding): + """ + A binding created by an import statement. + + @ivar fullName: The complete name given to the import statement, + possibly including multiple dotted components. + @type fullName: C{str} + """ + def __init__(self, name, source): + self.fullName = name + name = name.split('.')[0] + super(Importation, self).__init__(name, source) + + + +class Argument(Binding): + """ + Represents binding a name as an argument. + """ + + + +class Assignment(Binding): + """ + Represents binding a name with an explicit assignment. + + The checker will raise warnings for any Assignment that isn't used. Also, + the checker does not consider assignments in tuple/list unpacking to be + Assignments, rather it treats them as simple Bindings. + """ + + + +class FunctionDefinition(Binding): + pass + + + +class ExportBinding(Binding): + """ + A binding created by an C{__all__} assignment. If the names in the list + can be determined statically, they will be treated as names for export and + additional checking applied to them. + + The only C{__all__} assignment that can be recognized is one which takes + the value of a literal list containing literal strings. For example:: + + __all__ = ["foo", "bar"] + + Names which are imported and not otherwise used but appear in the value of + C{__all__} will not have an unused import warning reported for them. + """ + def names(self): + """ + Return a list of the names referenced by this binding. + """ + names = [] + if isinstance(self.source, _ast.List): + for node in self.source.elts: + if isinstance(node, _ast.Str): + names.append(node.s) + return names + + + +class Scope(dict): + importStarred = False # set to True when import * is found + + + def __repr__(self): + return '<%s at 0x%x %s>' % (self.__class__.__name__, id(self), dict.__repr__(self)) + + + def __init__(self): + super(Scope, self).__init__() + + + +class ClassScope(Scope): + pass + + + +class FunctionScope(Scope): + """ + I represent a name scope for a function. + + @ivar globals: Names declared 'global' in this function. + """ + def __init__(self): + super(FunctionScope, self).__init__() + self.globals = {} + + + +class ModuleScope(Scope): + pass + + +# Globally defined names which are not attributes of the __builtin__ module. +_MAGIC_GLOBALS = ['__file__', '__builtins__'] + + + +class Checker(object): + """ + I check the cleanliness and sanity of Python code. + + @ivar _deferredFunctions: Tracking list used by L{deferFunction}. Elements + of the list are two-tuples. The first element is the callable passed + to L{deferFunction}. The second element is a copy of the scope stack + at the time L{deferFunction} was called. + + @ivar _deferredAssignments: Similar to C{_deferredFunctions}, but for + callables which are deferred assignment checks. + """ + + nodeDepth = 0 + traceTree = False + + def __init__(self, tree, filename='(none)'): + self._deferredFunctions = [] + self._deferredAssignments = [] + self.dead_scopes = [] + self.messages = [] + self.filename = filename + self.scopeStack = [ModuleScope()] + self.futuresAllowed = True + self.handleChildren(tree) + self._runDeferred(self._deferredFunctions) + # Set _deferredFunctions to None so that deferFunction will fail + # noisily if called after we've run through the deferred functions. + self._deferredFunctions = None + self._runDeferred(self._deferredAssignments) + # Set _deferredAssignments to None so that deferAssignment will fail + # noisly if called after we've run through the deferred assignments. + self._deferredAssignments = None + del self.scopeStack[1:] + self.popScope() + self.check_dead_scopes() + + + def deferFunction(self, callable): + ''' + Schedule a function handler to be called just before completion. + + This is used for handling function bodies, which must be deferred + because code later in the file might modify the global scope. When + `callable` is called, the scope at the time this is called will be + restored, however it will contain any new bindings added to it. + ''' + self._deferredFunctions.append((callable, self.scopeStack[:])) + + + def deferAssignment(self, callable): + """ + Schedule an assignment handler to be called just after deferred + function handlers. + """ + self._deferredAssignments.append((callable, self.scopeStack[:])) + + + def _runDeferred(self, deferred): + """ + Run the callables in C{deferred} using their associated scope stack. + """ + for handler, scope in deferred: + self.scopeStack = scope + handler() + + + def scope(self): + return self.scopeStack[-1] + scope = property(scope) + + def popScope(self): + self.dead_scopes.append(self.scopeStack.pop()) + + + def check_dead_scopes(self): + """ + Look at scopes which have been fully examined and report names in them + which were imported but unused. + """ + for scope in self.dead_scopes: + export = isinstance(scope.get('__all__'), ExportBinding) + if export: + all = scope['__all__'].names() + if os.path.split(self.filename)[1] != '__init__.py': + # Look for possible mistakes in the export list + undefined = set(all) - set(scope) + for name in undefined: + self.report( + messages.UndefinedExport, + scope['__all__'].source, + name) + else: + all = [] + + # Look for imported names that aren't used. + for importation in scope.itervalues(): + if isinstance(importation, Importation): + if not importation.used and importation.name not in all: + self.report( + messages.UnusedImport, + importation.source, + importation.name) + + + def pushFunctionScope(self): + self.scopeStack.append(FunctionScope()) + + def pushClassScope(self): + self.scopeStack.append(ClassScope()) + + def report(self, messageClass, *args, **kwargs): + self.messages.append(messageClass(self.filename, *args, **kwargs)) + + def handleChildren(self, tree): + for node in iter_child_nodes(tree): + self.handleNode(node, tree) + + def isDocstring(self, node): + """ + Determine if the given node is a docstring, as long as it is at the + correct place in the node tree. + """ + return isinstance(node, _ast.Str) or \ + (isinstance(node, _ast.Expr) and + isinstance(node.value, _ast.Str)) + + def handleNode(self, node, parent): + node.parent = parent + if self.traceTree: + print ' ' * self.nodeDepth + node.__class__.__name__ + self.nodeDepth += 1 + if self.futuresAllowed and not \ + (isinstance(node, _ast.ImportFrom) or self.isDocstring(node)): + self.futuresAllowed = False + nodeType = node.__class__.__name__.upper() + try: + handler = getattr(self, nodeType) + handler(node) + finally: + self.nodeDepth -= 1 + if self.traceTree: + print ' ' * self.nodeDepth + 'end ' + node.__class__.__name__ + + def ignore(self, node): + pass + + # "stmt" type nodes + RETURN = DELETE = PRINT = WHILE = IF = WITH = RAISE = TRYEXCEPT = \ + TRYFINALLY = ASSERT = EXEC = EXPR = handleChildren + + CONTINUE = BREAK = PASS = ignore + + # "expr" type nodes + BOOLOP = BINOP = UNARYOP = IFEXP = DICT = SET = YIELD = COMPARE = \ + CALL = REPR = ATTRIBUTE = SUBSCRIPT = LIST = TUPLE = handleChildren + + NUM = STR = ELLIPSIS = ignore + + # "slice" type nodes + SLICE = EXTSLICE = INDEX = handleChildren + + # expression contexts are node instances too, though being constants + LOAD = STORE = DEL = AUGLOAD = AUGSTORE = PARAM = ignore + + # same for operators + AND = OR = ADD = SUB = MULT = DIV = MOD = POW = LSHIFT = RSHIFT = \ + BITOR = BITXOR = BITAND = FLOORDIV = INVERT = NOT = UADD = USUB = \ + EQ = NOTEQ = LT = LTE = GT = GTE = IS = ISNOT = IN = NOTIN = ignore + + # additional node types + COMPREHENSION = EXCEPTHANDLER = KEYWORD = handleChildren + + def addBinding(self, loc, value, reportRedef=True): + '''Called when a binding is altered. + + - `loc` is the location (an object with lineno and optionally + col_offset attributes) of the statement responsible for the change + - `value` is the optional new value, a Binding instance, associated + with the binding; if None, the binding is deleted if it exists. + - if `reportRedef` is True (default), rebinding while unused will be + reported. + ''' + if (isinstance(self.scope.get(value.name), FunctionDefinition) + and isinstance(value, FunctionDefinition)): + self.report(messages.RedefinedFunction, + loc, value.name, self.scope[value.name].source) + + if not isinstance(self.scope, ClassScope): + for scope in self.scopeStack[::-1]: + existing = scope.get(value.name) + if (isinstance(existing, Importation) + and not existing.used + and (not isinstance(value, Importation) or value.fullName == existing.fullName) + and reportRedef): + + self.report(messages.RedefinedWhileUnused, + loc, value.name, scope[value.name].source) + + if isinstance(value, UnBinding): + try: + del self.scope[value.name] + except KeyError: + self.report(messages.UndefinedName, loc, value.name) + else: + self.scope[value.name] = value + + def GLOBAL(self, node): + """ + Keep track of globals declarations. + """ + if isinstance(self.scope, FunctionScope): + self.scope.globals.update(dict.fromkeys(node.names)) + + def LISTCOMP(self, node): + # handle generators before element + for gen in node.generators: + self.handleNode(gen, node) + self.handleNode(node.elt, node) + + GENERATOREXP = SETCOMP = LISTCOMP + + # dictionary comprehensions; introduced in Python 2.7 + def DICTCOMP(self, node): + for gen in node.generators: + self.handleNode(gen, node) + self.handleNode(node.key, node) + self.handleNode(node.value, node) + + def FOR(self, node): + """ + Process bindings for loop variables. + """ + vars = [] + def collectLoopVars(n): + if isinstance(n, _ast.Name): + vars.append(n.id) + elif isinstance(n, _ast.expr_context): + return + else: + for c in iter_child_nodes(n): + collectLoopVars(c) + + collectLoopVars(node.target) + for varn in vars: + if (isinstance(self.scope.get(varn), Importation) + # unused ones will get an unused import warning + and self.scope[varn].used): + self.report(messages.ImportShadowedByLoopVar, + node, varn, self.scope[varn].source) + + self.handleChildren(node) + + def NAME(self, node): + """ + Handle occurrence of Name (which can be a load/store/delete access.) + """ + # Locate the name in locals / function / globals scopes. + if isinstance(node.ctx, (_ast.Load, _ast.AugLoad)): + # try local scope + importStarred = self.scope.importStarred + try: + self.scope[node.id].used = (self.scope, node) + except KeyError: + pass + else: + return + + # try enclosing function scopes + + for scope in self.scopeStack[-2:0:-1]: + importStarred = importStarred or scope.importStarred + if not isinstance(scope, FunctionScope): + continue + try: + scope[node.id].used = (self.scope, node) + except KeyError: + pass + else: + return + + # try global scope + + importStarred = importStarred or self.scopeStack[0].importStarred + try: + self.scopeStack[0][node.id].used = (self.scope, node) + except KeyError: + if ((not hasattr(__builtin__, node.id)) + and node.id not in _MAGIC_GLOBALS + and not importStarred): + if (os.path.basename(self.filename) == '__init__.py' and + node.id == '__path__'): + # the special name __path__ is valid only in packages + pass + else: + self.report(messages.UndefinedName, node, node.id) + elif isinstance(node.ctx, (_ast.Store, _ast.AugStore)): + # if the name hasn't already been defined in the current scope + if isinstance(self.scope, FunctionScope) and node.id not in self.scope: + # for each function or module scope above us + for scope in self.scopeStack[:-1]: + if not isinstance(scope, (FunctionScope, ModuleScope)): + continue + # if the name was defined in that scope, and the name has + # been accessed already in the current scope, and hasn't + # been declared global + if (node.id in scope + and scope[node.id].used + and scope[node.id].used[0] is self.scope + and node.id not in self.scope.globals): + # then it's probably a mistake + self.report(messages.UndefinedLocal, + scope[node.id].used[1], + node.id, + scope[node.id].source) + break + + if isinstance(node.parent, + (_ast.For, _ast.comprehension, _ast.Tuple, _ast.List)): + binding = Binding(node.id, node) + elif (node.id == '__all__' and + isinstance(self.scope, ModuleScope)): + binding = ExportBinding(node.id, node.parent.value) + else: + binding = Assignment(node.id, node) + if node.id in self.scope: + binding.used = self.scope[node.id].used + self.addBinding(node, binding) + elif isinstance(node.ctx, _ast.Del): + if isinstance(self.scope, FunctionScope) and \ + node.id in self.scope.globals: + del self.scope.globals[node.id] + else: + self.addBinding(node, UnBinding(node.id, node)) + else: + # must be a Param context -- this only happens for names in function + # arguments, but these aren't dispatched through here + raise RuntimeError( + "Got impossible expression context: %r" % (node.ctx,)) + + + def FUNCTIONDEF(self, node): + # the decorators attribute is called decorator_list as of Python 2.6 + if hasattr(node, 'decorators'): + for deco in node.decorators: + self.handleNode(deco, node) + else: + for deco in node.decorator_list: + self.handleNode(deco, node) + self.addBinding(node, FunctionDefinition(node.name, node)) + self.LAMBDA(node) + + def LAMBDA(self, node): + for default in node.args.defaults: + self.handleNode(default, node) + + def runFunction(): + args = [] + + def addArgs(arglist): + for arg in arglist: + if isinstance(arg, _ast.Tuple): + addArgs(arg.elts) + else: + if arg.id in args: + self.report(messages.DuplicateArgument, + node, arg.id) + args.append(arg.id) + + self.pushFunctionScope() + addArgs(node.args.args) + # vararg/kwarg identifiers are not Name nodes + if node.args.vararg: + args.append(node.args.vararg) + if node.args.kwarg: + args.append(node.args.kwarg) + for name in args: + self.addBinding(node, Argument(name, node), reportRedef=False) + if isinstance(node.body, list): + # case for FunctionDefs + for stmt in node.body: + self.handleNode(stmt, node) + else: + # case for Lambdas + self.handleNode(node.body, node) + def checkUnusedAssignments(): + """ + Check to see if any assignments have not been used. + """ + for name, binding in self.scope.iteritems(): + if (not binding.used and not name in self.scope.globals + and isinstance(binding, Assignment)): + self.report(messages.UnusedVariable, + binding.source, name) + self.deferAssignment(checkUnusedAssignments) + self.popScope() + + self.deferFunction(runFunction) + + + def CLASSDEF(self, node): + """ + Check names used in a class definition, including its decorators, base + classes, and the body of its definition. Additionally, add its name to + the current scope. + """ + # decorator_list is present as of Python 2.6 + for deco in getattr(node, 'decorator_list', []): + self.handleNode(deco, node) + for baseNode in node.bases: + self.handleNode(baseNode, node) + self.pushClassScope() + for stmt in node.body: + self.handleNode(stmt, node) + self.popScope() + self.addBinding(node, Binding(node.name, node)) + + def ASSIGN(self, node): + self.handleNode(node.value, node) + for target in node.targets: + self.handleNode(target, node) + + def AUGASSIGN(self, node): + # AugAssign is awkward: must set the context explicitly and visit twice, + # once with AugLoad context, once with AugStore context + node.target.ctx = _ast.AugLoad() + self.handleNode(node.target, node) + self.handleNode(node.value, node) + node.target.ctx = _ast.AugStore() + self.handleNode(node.target, node) + + def IMPORT(self, node): + for alias in node.names: + name = alias.asname or alias.name + importation = Importation(name, node) + self.addBinding(node, importation) + + def IMPORTFROM(self, node): + if node.module == '__future__': + if not self.futuresAllowed: + self.report(messages.LateFutureImport, node, + [n.name for n in node.names]) + else: + self.futuresAllowed = False + + for alias in node.names: + if alias.name == '*': + self.scope.importStarred = True + self.report(messages.ImportStarUsed, node, node.module) + continue + name = alias.asname or alias.name + importation = Importation(name, node) + if node.module == '__future__': + importation.used = (self.scope, node) + self.addBinding(node, importation) diff --git a/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/messages.py b/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/messages.py new file mode 100644 index 0000000000..73bf4cc312 --- /dev/null +++ b/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/messages.py @@ -0,0 +1,96 @@ +# (c) 2005 Divmod, Inc. See LICENSE file for details + +class Message(object): + message = '' + message_args = () + def __init__(self, filename, loc, use_column=True): + self.filename = filename + self.lineno = loc.lineno + self.col = getattr(loc, 'col_offset', None) if use_column else None + + def __str__(self): + return '%s:%s: %s' % (self.filename, self.lineno, self.message % self.message_args) + + +class UnusedImport(Message): + message = '%r imported but unused' + def __init__(self, filename, loc, name): + Message.__init__(self, filename, loc, use_column=False) + self.message_args = (name,) + + +class RedefinedWhileUnused(Message): + message = 'redefinition of unused %r from line %r' + def __init__(self, filename, loc, name, orig_loc): + Message.__init__(self, filename, loc) + self.message_args = (name, orig_loc.lineno) + + +class ImportShadowedByLoopVar(Message): + message = 'import %r from line %r shadowed by loop variable' + def __init__(self, filename, loc, name, orig_loc): + Message.__init__(self, filename, loc) + self.message_args = (name, orig_loc.lineno) + + +class ImportStarUsed(Message): + message = "'from %s import *' used; unable to detect undefined names" + def __init__(self, filename, loc, modname): + Message.__init__(self, filename, loc) + self.message_args = (modname,) + + +class UndefinedName(Message): + message = 'undefined name %r' + def __init__(self, filename, loc, name): + Message.__init__(self, filename, loc) + self.message_args = (name,) + + + +class UndefinedExport(Message): + message = 'undefined name %r in __all__' + def __init__(self, filename, loc, name): + Message.__init__(self, filename, loc) + self.message_args = (name,) + + + +class UndefinedLocal(Message): + message = "local variable %r (defined in enclosing scope on line %r) referenced before assignment" + def __init__(self, filename, loc, name, orig_loc): + Message.__init__(self, filename, loc) + self.message_args = (name, orig_loc.lineno) + + +class DuplicateArgument(Message): + message = 'duplicate argument %r in function definition' + def __init__(self, filename, loc, name): + Message.__init__(self, filename, loc) + self.message_args = (name,) + + +class RedefinedFunction(Message): + message = 'redefinition of function %r from line %r' + def __init__(self, filename, loc, name, orig_loc): + Message.__init__(self, filename, loc) + self.message_args = (name, orig_loc.lineno) + + +class LateFutureImport(Message): + message = 'future import(s) %r after other statements' + def __init__(self, filename, loc, names): + Message.__init__(self, filename, loc) + self.message_args = (names,) + + +class UnusedVariable(Message): + """ + Indicates that a variable has been explicity assigned to but not actually + used. + """ + + message = 'local variable %r is assigned to but never used' + def __init__(self, filename, loc, names): + Message.__init__(self, filename, loc) + self.message_args = (names,) diff --git a/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/scripts/__init__.py b/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/scripts/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/scripts/pyflakes.py b/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/scripts/pyflakes.py new file mode 100644 index 0000000000..6b1dae2206 --- /dev/null +++ b/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/scripts/pyflakes.py @@ -0,0 +1,90 @@ + +""" +Implementation of the command-line I{pyflakes} tool. +""" + +import sys +import os +import _ast + +checker = __import__('pyflakes.checker').checker + +def check(codeString, filename): + """ + Check the Python source given by C{codeString} for flakes. + + @param codeString: The Python source to check. + @type codeString: C{str} + + @param filename: The name of the file the source came from, used to report + errors. + @type filename: C{str} + + @return: The number of warnings emitted. + @rtype: C{int} + """ + # First, compile into an AST and handle syntax errors. + try: + tree = compile(codeString, filename, "exec", _ast.PyCF_ONLY_AST) + except SyntaxError, value: + msg = value.args[0] + + (lineno, offset, text) = value.lineno, value.offset, value.text + + # If there's an encoding problem with the file, the text is None. + if text is None: + # Avoid using msg, since for the only known case, it contains a + # bogus message that claims the encoding the file declared was + # unknown. + print >> sys.stderr, "%s: problem decoding source" % (filename, ) + else: + line = text.splitlines()[-1] + + if offset is not None: + offset = offset - (len(text) - len(line)) + + print >> sys.stderr, '%s:%d: %s' % (filename, lineno, msg) + print >> sys.stderr, line + + if offset is not None: + print >> sys.stderr, " " * offset, "^" + + return 1 + else: + # Okay, it's syntactically valid. Now check it. + w = checker.Checker(tree, filename) + w.messages.sort(lambda a, b: cmp(a.lineno, b.lineno)) + for warning in w.messages: + print warning + return len(w.messages) + + +def checkPath(filename): + """ + Check the given path, printing out any warnings detected. + + @return: the number of warnings printed + """ + try: + return check(file(filename, 'U').read() + '\n', filename) + except IOError, msg: + print >> sys.stderr, "%s: %s" % (filename, msg.args[1]) + return 1 + + +def main(): + warnings = 0 + args = sys.argv[1:] + if args: + for arg in args: + if os.path.isdir(arg): + for dirpath, dirnames, filenames in os.walk(arg): + for filename in filenames: + if filename.endswith('.py'): + warnings += checkPath(os.path.join(dirpath, filename)) + else: + warnings += checkPath(arg) + else: + warnings += check(sys.stdin.read(), '') + + raise SystemExit(warnings > 0) diff --git a/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/test/__init__.py b/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/test/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/test/harness.py b/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/test/harness.py new file mode 100644 index 0000000000..7cd2277206 --- /dev/null +++ b/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/test/harness.py @@ -0,0 +1,27 @@ + +import textwrap +import _ast + +from twisted.trial import unittest + +from pyflakes import checker + + +class Test(unittest.TestCase): + + def flakes(self, input, *expectedOutputs, **kw): + ast = compile(textwrap.dedent(input), "", "exec", + _ast.PyCF_ONLY_AST) + w = checker.Checker(ast, **kw) + outputs = [type(o) for o in w.messages] + expectedOutputs = list(expectedOutputs) + outputs.sort() + expectedOutputs.sort() + self.assert_(outputs == expectedOutputs, '''\ +for input: +%s +expected outputs: +%s +but got: +%s''' % (input, repr(expectedOutputs), '\n'.join([str(o) for o in w.messages]))) + return w diff --git a/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/test/test_imports.py b/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/test/test_imports.py new file mode 100644 index 0000000000..08e4580a2a --- /dev/null +++ b/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/test/test_imports.py @@ -0,0 +1,673 @@ + +from sys import version_info + +from pyflakes import messages as m +from pyflakes.test import harness + +class Test(harness.Test): + + def test_unusedImport(self): + self.flakes('import fu, bar', m.UnusedImport, m.UnusedImport) + self.flakes('from baz import fu, bar', m.UnusedImport, m.UnusedImport) + + def test_aliasedImport(self): + self.flakes('import fu as FU, bar as FU', m.RedefinedWhileUnused, m.UnusedImport) + self.flakes('from moo import fu as FU, bar as FU', m.RedefinedWhileUnused, m.UnusedImport) + + def test_usedImport(self): + self.flakes('import fu; print fu') + self.flakes('from baz import fu; print fu') + + def test_redefinedWhileUnused(self): + self.flakes('import fu; fu = 3', m.RedefinedWhileUnused) + self.flakes('import fu; del fu', m.RedefinedWhileUnused) + self.flakes('import fu; fu, bar = 3', m.RedefinedWhileUnused) + self.flakes('import fu; [fu, bar] = 3', m.RedefinedWhileUnused) + + def test_redefinedByFunction(self): + self.flakes(''' + import fu + def fu(): + pass + ''', m.RedefinedWhileUnused) + + def test_redefinedInNestedFunction(self): + """ + Test that shadowing a global name with a nested function definition + generates a warning. + """ + self.flakes(''' + import fu + def bar(): + def baz(): + def fu(): + pass + ''', m.RedefinedWhileUnused, m.UnusedImport) + + def test_redefinedByClass(self): + self.flakes(''' + import fu + class fu: + pass + ''', m.RedefinedWhileUnused) + + + def test_redefinedBySubclass(self): + """ + If an imported name is redefined by a class statement which also uses + that name in the bases list, no warning is emitted. + """ + self.flakes(''' + from fu import bar + class bar(bar): + pass + ''') + + + def test_redefinedInClass(self): + """ + Test that shadowing a global with a class attribute does not produce a + warning. + """ + self.flakes(''' + import fu + class bar: + fu = 1 + print fu + ''') + + def test_usedInFunction(self): + self.flakes(''' + import fu + def fun(): + print fu + ''') + + def test_shadowedByParameter(self): + self.flakes(''' + import fu + def fun(fu): + print fu + ''', m.UnusedImport) + + self.flakes(''' + import fu + def fun(fu): + print fu + print fu + ''') + + def test_newAssignment(self): + self.flakes('fu = None') + + def test_usedInGetattr(self): + self.flakes('import fu; fu.bar.baz') + self.flakes('import fu; "bar".fu.baz', m.UnusedImport) + + def test_usedInSlice(self): + self.flakes('import fu; print fu.bar[1:]') + + def test_usedInIfBody(self): + self.flakes(''' + import fu + if True: print fu + ''') + + def test_usedInIfConditional(self): + self.flakes(''' + import fu + if fu: pass + ''') + + def test_usedInElifConditional(self): + self.flakes(''' + import fu + if False: pass + elif fu: pass + ''') + + def test_usedInElse(self): + self.flakes(''' + import fu + if False: pass + else: print fu + ''') + + def test_usedInCall(self): + self.flakes('import fu; fu.bar()') + + def test_usedInClass(self): + self.flakes(''' + import fu + class bar: + bar = fu + ''') + + def test_usedInClassBase(self): + self.flakes(''' + import fu + class bar(object, fu.baz): + pass + ''') + + def test_notUsedInNestedScope(self): + self.flakes(''' + import fu + def bleh(): + pass + print fu + ''') + + def test_usedInFor(self): + self.flakes(''' + import fu + for bar in range(9): + print fu + ''') + + def test_usedInForElse(self): + self.flakes(''' + import fu + for bar in range(10): + pass + else: + print fu + ''') + + def test_redefinedByFor(self): + self.flakes(''' + import fu + for fu in range(2): + pass + ''', m.RedefinedWhileUnused) + + def test_shadowedByFor(self): + """ + Test that shadowing a global name with a for loop variable generates a + warning. + """ + self.flakes(''' + import fu + fu.bar() + for fu in (): + pass + ''', m.ImportShadowedByLoopVar) + + def test_shadowedByForDeep(self): + """ + Test that shadowing a global name with a for loop variable nested in a + tuple unpack generates a warning. + """ + self.flakes(''' + import fu + fu.bar() + for (x, y, z, (a, b, c, (fu,))) in (): + pass + ''', m.ImportShadowedByLoopVar) + + def test_usedInReturn(self): + self.flakes(''' + import fu + def fun(): + return fu + ''') + + def test_usedInOperators(self): + self.flakes('import fu; 3 + fu.bar') + self.flakes('import fu; 3 % fu.bar') + self.flakes('import fu; 3 - fu.bar') + self.flakes('import fu; 3 * fu.bar') + self.flakes('import fu; 3 ** fu.bar') + self.flakes('import fu; 3 / fu.bar') + self.flakes('import fu; 3 // fu.bar') + self.flakes('import fu; -fu.bar') + self.flakes('import fu; ~fu.bar') + self.flakes('import fu; 1 == fu.bar') + self.flakes('import fu; 1 | fu.bar') + self.flakes('import fu; 1 & fu.bar') + self.flakes('import fu; 1 ^ fu.bar') + self.flakes('import fu; 1 >> fu.bar') + self.flakes('import fu; 1 << fu.bar') + + def test_usedInAssert(self): + self.flakes('import fu; assert fu.bar') + + def test_usedInSubscript(self): + self.flakes('import fu; fu.bar[1]') + + def test_usedInLogic(self): + self.flakes('import fu; fu and False') + self.flakes('import fu; fu or False') + self.flakes('import fu; not fu.bar') + + def test_usedInList(self): + self.flakes('import fu; [fu]') + + def test_usedInTuple(self): + self.flakes('import fu; (fu,)') + + def test_usedInTry(self): + self.flakes(''' + import fu + try: fu + except: pass + ''') + + def test_usedInExcept(self): + self.flakes(''' + import fu + try: fu + except: pass + ''') + + def test_redefinedByExcept(self): + self.flakes(''' + import fu + try: pass + except Exception, fu: pass + ''', m.RedefinedWhileUnused) + + def test_usedInRaise(self): + self.flakes(''' + import fu + raise fu.bar + ''') + + def test_usedInYield(self): + self.flakes(''' + import fu + def gen(): + yield fu + ''') + + def test_usedInDict(self): + self.flakes('import fu; {fu:None}') + self.flakes('import fu; {1:fu}') + + def test_usedInParameterDefault(self): + self.flakes(''' + import fu + def f(bar=fu): + pass + ''') + + def test_usedInAttributeAssign(self): + self.flakes('import fu; fu.bar = 1') + + def test_usedInKeywordArg(self): + self.flakes('import fu; fu.bar(stuff=fu)') + + def test_usedInAssignment(self): + self.flakes('import fu; bar=fu') + self.flakes('import fu; n=0; n+=fu') + + def test_usedInListComp(self): + self.flakes('import fu; [fu for _ in range(1)]') + self.flakes('import fu; [1 for _ in range(1) if fu]') + + def test_redefinedByListComp(self): + self.flakes('import fu; [1 for fu in range(1)]', m.RedefinedWhileUnused) + + + def test_usedInTryFinally(self): + self.flakes(''' + import fu + try: pass + finally: fu + ''') + + self.flakes(''' + import fu + try: fu + finally: pass + ''') + + def test_usedInWhile(self): + self.flakes(''' + import fu + while 0: + fu + ''') + + self.flakes(''' + import fu + while fu: pass + ''') + + def test_usedInGlobal(self): + self.flakes(''' + import fu + def f(): global fu + ''', m.UnusedImport) + + def test_usedInBackquote(self): + self.flakes('import fu; `fu`') + + def test_usedInExec(self): + self.flakes('import fu; exec "print 1" in fu.bar') + + def test_usedInLambda(self): + self.flakes('import fu; lambda: fu') + + def test_shadowedByLambda(self): + self.flakes('import fu; lambda fu: fu', m.UnusedImport) + + def test_usedInSliceObj(self): + self.flakes('import fu; "meow"[::fu]') + + def test_unusedInNestedScope(self): + self.flakes(''' + def bar(): + import fu + fu + ''', m.UnusedImport, m.UndefinedName) + + def test_methodsDontUseClassScope(self): + self.flakes(''' + class bar: + import fu + def fun(self): + fu + ''', m.UnusedImport, m.UndefinedName) + + def test_nestedFunctionsNestScope(self): + self.flakes(''' + def a(): + def b(): + fu + import fu + ''') + + def test_nestedClassAndFunctionScope(self): + self.flakes(''' + def a(): + import fu + class b: + def c(self): + print fu + ''') + + def test_importStar(self): + self.flakes('from fu import *', m.ImportStarUsed) + + + def test_packageImport(self): + """ + If a dotted name is imported and used, no warning is reported. + """ + self.flakes(''' + import fu.bar + fu.bar + ''') + + + def test_unusedPackageImport(self): + """ + If a dotted name is imported and not used, an unused import warning is + reported. + """ + self.flakes('import fu.bar', m.UnusedImport) + + + def test_duplicateSubmoduleImport(self): + """ + If a submodule of a package is imported twice, an unused import warning + and a redefined while unused warning are reported. + """ + self.flakes(''' + import fu.bar, fu.bar + fu.bar + ''', m.RedefinedWhileUnused) + self.flakes(''' + import fu.bar + import fu.bar + fu.bar + ''', m.RedefinedWhileUnused) + + + def test_differentSubmoduleImport(self): + """ + If two different submodules of a package are imported, no duplicate + import warning is reported for the package. + """ + self.flakes(''' + import fu.bar, fu.baz + fu.bar, fu.baz + ''') + self.flakes(''' + import fu.bar + import fu.baz + fu.bar, fu.baz + ''') + + def test_assignRHSFirst(self): + self.flakes('import fu; fu = fu') + self.flakes('import fu; fu, bar = fu') + self.flakes('import fu; [fu, bar] = fu') + self.flakes('import fu; fu += fu') + + def test_tryingMultipleImports(self): + self.flakes(''' + try: + import fu + except ImportError: + import bar as fu + ''') + test_tryingMultipleImports.todo = '' + + def test_nonGlobalDoesNotRedefine(self): + self.flakes(''' + import fu + def a(): + fu = 3 + return fu + fu + ''') + + def test_functionsRunLater(self): + self.flakes(''' + def a(): + fu + import fu + ''') + + def test_functionNamesAreBoundNow(self): + self.flakes(''' + import fu + def fu(): + fu + fu + ''', m.RedefinedWhileUnused) + + def test_ignoreNonImportRedefinitions(self): + self.flakes('a = 1; a = 2') + + def test_importingForImportError(self): + self.flakes(''' + try: + import fu + except ImportError: + pass + ''') + test_importingForImportError.todo = '' + + def test_importedInClass(self): + '''Imports in class scope can be used through self''' + self.flakes(''' + class c: + import i + def __init__(self): + self.i + ''') + test_importedInClass.todo = 'requires evaluating attribute access' + + def test_futureImport(self): + '''__future__ is special''' + self.flakes('from __future__ import division') + self.flakes(''' + "docstring is allowed before future import" + from __future__ import division + ''') + + def test_futureImportFirst(self): + """ + __future__ imports must come before anything else. + """ + self.flakes(''' + x = 5 + from __future__ import division + ''', m.LateFutureImport) + self.flakes(''' + from foo import bar + from __future__ import division + bar + ''', m.LateFutureImport) + + + +class TestSpecialAll(harness.Test): + """ + Tests for suppression of unused import warnings by C{__all__}. + """ + def test_ignoredInFunction(self): + """ + An C{__all__} definition does not suppress unused import warnings in a + function scope. + """ + self.flakes(''' + def foo(): + import bar + __all__ = ["bar"] + ''', m.UnusedImport, m.UnusedVariable) + + + def test_ignoredInClass(self): + """ + An C{__all__} definition does not suppress unused import warnings in a + class scope. + """ + self.flakes(''' + class foo: + import bar + __all__ = ["bar"] + ''', m.UnusedImport) + + + def test_warningSuppressed(self): + """ + If a name is imported and unused but is named in C{__all__}, no warning + is reported. + """ + self.flakes(''' + import foo + __all__ = ["foo"] + ''') + + + def test_unrecognizable(self): + """ + If C{__all__} is defined in a way that can't be recognized statically, + it is ignored. + """ + self.flakes(''' + import foo + __all__ = ["f" + "oo"] + ''', m.UnusedImport) + self.flakes(''' + import foo + __all__ = [] + ["foo"] + ''', m.UnusedImport) + + + def test_unboundExported(self): + """ + If C{__all__} includes a name which is not bound, a warning is emitted. + """ + self.flakes(''' + __all__ = ["foo"] + ''', m.UndefinedExport) + + # Skip this in __init__.py though, since the rules there are a little + # different. + for filename in ["foo/__init__.py", "__init__.py"]: + self.flakes(''' + __all__ = ["foo"] + ''', filename=filename) + + + def test_usedInGenExp(self): + """ + Using a global in a generator expression results in no warnings. + """ + self.flakes('import fu; (fu for _ in range(1))') + self.flakes('import fu; (1 for _ in range(1) if fu)') + + + def test_redefinedByGenExp(self): + """ + Re-using a global name as the loop variable for a generator + expression results in a redefinition warning. + """ + self.flakes('import fu; (1 for fu in range(1))', m.RedefinedWhileUnused) + + + def test_usedAsDecorator(self): + """ + Using a global name in a decorator statement results in no warnings, + but using an undefined name in a decorator statement results in an + undefined name warning. + """ + self.flakes(''' + from interior import decorate + @decorate + def f(): + return "hello" + ''') + + self.flakes(''' + from interior import decorate + @decorate('value') + def f(): + return "hello" + ''') + + self.flakes(''' + @decorate + def f(): + return "hello" + ''', m.UndefinedName) + + +class Python26Tests(harness.Test): + """ + Tests for checking of syntax which is valid in PYthon 2.6 and newer. + """ + if version_info < (2, 6): + skip = "Python 2.6 required for class decorator tests." + + + def test_usedAsClassDecorator(self): + """ + Using an imported name as a class decorator results in no warnings, + but using an undefined name as a class decorator results in an + undefined name warning. + """ + self.flakes(''' + from interior import decorate + @decorate + class foo: + pass + ''') + + self.flakes(''' + from interior import decorate + @decorate("foo") + class bar: + pass + ''') + + self.flakes(''' + @decorate + class foo: + pass + ''', m.UndefinedName) diff --git a/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/test/test_other.py b/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/test/test_other.py new file mode 100644 index 0000000000..2b7723ce57 --- /dev/null +++ b/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/test/test_other.py @@ -0,0 +1,575 @@ +# (c) 2005-2010 Divmod, Inc. +# See LICENSE file for details + +""" +Tests for various Pyflakes behavior. +""" + +from sys import version_info + +from pyflakes import messages as m +from pyflakes.test import harness + + +class Test(harness.Test): + + def test_duplicateArgs(self): + self.flakes('def fu(bar, bar): pass', m.DuplicateArgument) + + def test_localReferencedBeforeAssignment(self): + self.flakes(''' + a = 1 + def f(): + a; a=1 + f() + ''', m.UndefinedName) + test_localReferencedBeforeAssignment.todo = 'this requires finding all assignments in the function body first' + + def test_redefinedFunction(self): + """ + Test that shadowing a function definition with another one raises a + warning. + """ + self.flakes(''' + def a(): pass + def a(): pass + ''', m.RedefinedFunction) + + def test_redefinedClassFunction(self): + """ + Test that shadowing a function definition in a class suite with another + one raises a warning. + """ + self.flakes(''' + class A: + def a(): pass + def a(): pass + ''', m.RedefinedFunction) + + def test_functionDecorator(self): + """ + Test that shadowing a function definition with a decorated version of + that function does not raise a warning. + """ + self.flakes(''' + from somewhere import somedecorator + + def a(): pass + a = somedecorator(a) + ''') + + def test_classFunctionDecorator(self): + """ + Test that shadowing a function definition in a class suite with a + decorated version of that function does not raise a warning. + """ + self.flakes(''' + class A: + def a(): pass + a = classmethod(a) + ''') + + def test_unaryPlus(self): + '''Don't die on unary +''' + self.flakes('+1') + + + def test_undefinedBaseClass(self): + """ + If a name in the base list of a class definition is undefined, a + warning is emitted. + """ + self.flakes(''' + class foo(foo): + pass + ''', m.UndefinedName) + + + def test_classNameUndefinedInClassBody(self): + """ + If a class name is used in the body of that class's definition and + the name is not already defined, a warning is emitted. + """ + self.flakes(''' + class foo: + foo + ''', m.UndefinedName) + + + def test_classNameDefinedPreviously(self): + """ + If a class name is used in the body of that class's definition and + the name was previously defined in some other way, no warning is + emitted. + """ + self.flakes(''' + foo = None + class foo: + foo + ''') + + + def test_comparison(self): + """ + If a defined name is used on either side of any of the six comparison + operators, no warning is emitted. + """ + self.flakes(''' + x = 10 + y = 20 + x < y + x <= y + x == y + x != y + x >= y + x > y + ''') + + + def test_identity(self): + """ + If a deefined name is used on either side of an identity test, no + warning is emitted. + """ + self.flakes(''' + x = 10 + y = 20 + x is y + x is not y + ''') + + + def test_containment(self): + """ + If a defined name is used on either side of a containment test, no + warning is emitted. + """ + self.flakes(''' + x = 10 + y = 20 + x in y + x not in y + ''') + + + def test_loopControl(self): + """ + break and continue statements are supported. + """ + self.flakes(''' + for x in [1, 2]: + break + ''') + self.flakes(''' + for x in [1, 2]: + continue + ''') + + + def test_ellipsis(self): + """ + Ellipsis in a slice is supported. + """ + self.flakes(''' + [1, 2][...] + ''') + + + def test_extendedSlice(self): + """ + Extended slices are supported. + """ + self.flakes(''' + x = 3 + [1, 2][x,:] + ''') + + + +class TestUnusedAssignment(harness.Test): + """ + Tests for warning about unused assignments. + """ + + def test_unusedVariable(self): + """ + Warn when a variable in a function is assigned a value that's never + used. + """ + self.flakes(''' + def a(): + b = 1 + ''', m.UnusedVariable) + + + def test_assignToGlobal(self): + """ + Assigning to a global and then not using that global is perfectly + acceptable. Do not mistake it for an unused local variable. + """ + self.flakes(''' + b = 0 + def a(): + global b + b = 1 + ''') + + + def test_assignToMember(self): + """ + Assigning to a member of another object and then not using that member + variable is perfectly acceptable. Do not mistake it for an unused + local variable. + """ + # XXX: Adding this test didn't generate a failure. Maybe not + # necessary? + self.flakes(''' + class b: + pass + def a(): + b.foo = 1 + ''') + + + def test_assignInForLoop(self): + """ + Don't warn when a variable in a for loop is assigned to but not used. + """ + self.flakes(''' + def f(): + for i in range(10): + pass + ''') + + + def test_assignInListComprehension(self): + """ + Don't warn when a variable in a list comprehension is assigned to but + not used. + """ + self.flakes(''' + def f(): + [None for i in range(10)] + ''') + + + def test_generatorExpression(self): + """ + Don't warn when a variable in a generator expression is assigned to but not used. + """ + self.flakes(''' + def f(): + (None for i in range(10)) + ''') + + + def test_assignmentInsideLoop(self): + """ + Don't warn when a variable assignment occurs lexically after its use. + """ + self.flakes(''' + def f(): + x = None + for i in range(10): + if i > 2: + return x + x = i * 2 + ''') + + + def test_tupleUnpacking(self): + """ + Don't warn when a variable included in tuple unpacking is unused. It's + very common for variables in a tuple unpacking assignment to be unused + in good Python code, so warning will only create false positives. + """ + self.flakes(''' + def f(): + (x, y) = 1, 2 + ''') + + + def test_listUnpacking(self): + """ + Don't warn when a variable included in list unpacking is unused. + """ + self.flakes(''' + def f(): + [x, y] = [1, 2] + ''') + + + def test_closedOver(self): + """ + Don't warn when the assignment is used in an inner function. + """ + self.flakes(''' + def barMaker(): + foo = 5 + def bar(): + return foo + return bar + ''') + + + def test_doubleClosedOver(self): + """ + Don't warn when the assignment is used in an inner function, even if + that inner function itself is in an inner function. + """ + self.flakes(''' + def barMaker(): + foo = 5 + def bar(): + def baz(): + return foo + return bar + ''') + + + +class Python25Test(harness.Test): + """ + Tests for checking of syntax only available in Python 2.5 and newer. + """ + if version_info < (2, 5): + skip = "Python 2.5 required for if-else and with tests" + + def test_ifexp(self): + """ + Test C{foo if bar else baz} statements. + """ + self.flakes("a = 'moo' if True else 'oink'") + self.flakes("a = foo if True else 'oink'", m.UndefinedName) + self.flakes("a = 'moo' if True else bar", m.UndefinedName) + + + def test_withStatementNoNames(self): + """ + No warnings are emitted for using inside or after a nameless C{with} + statement a name defined beforehand. + """ + self.flakes(''' + from __future__ import with_statement + bar = None + with open("foo"): + bar + bar + ''') + + def test_withStatementSingleName(self): + """ + No warnings are emitted for using a name defined by a C{with} statement + within the suite or afterwards. + """ + self.flakes(''' + from __future__ import with_statement + with open('foo') as bar: + bar + bar + ''') + + + def test_withStatementAttributeName(self): + """ + No warnings are emitted for using an attribute as the target of a + C{with} statement. + """ + self.flakes(''' + from __future__ import with_statement + import foo + with open('foo') as foo.bar: + pass + ''') + + + def test_withStatementSubscript(self): + """ + No warnings are emitted for using a subscript as the target of a + C{with} statement. + """ + self.flakes(''' + from __future__ import with_statement + import foo + with open('foo') as foo[0]: + pass + ''') + + + def test_withStatementSubscriptUndefined(self): + """ + An undefined name warning is emitted if the subscript used as the + target of a C{with} statement is not defined. + """ + self.flakes(''' + from __future__ import with_statement + import foo + with open('foo') as foo[bar]: + pass + ''', m.UndefinedName) + + + def test_withStatementTupleNames(self): + """ + No warnings are emitted for using any of the tuple of names defined by + a C{with} statement within the suite or afterwards. + """ + self.flakes(''' + from __future__ import with_statement + with open('foo') as (bar, baz): + bar, baz + bar, baz + ''') + + + def test_withStatementListNames(self): + """ + No warnings are emitted for using any of the list of names defined by a + C{with} statement within the suite or afterwards. + """ + self.flakes(''' + from __future__ import with_statement + with open('foo') as [bar, baz]: + bar, baz + bar, baz + ''') + + + def test_withStatementComplicatedTarget(self): + """ + If the target of a C{with} statement uses any or all of the valid forms + for that part of the grammar (See + U{http://docs.python.org/reference/compound_stmts.html#the-with-statement}), + the names involved are checked both for definedness and any bindings + created are respected in the suite of the statement and afterwards. + """ + self.flakes(''' + from __future__ import with_statement + c = d = e = g = h = i = None + with open('foo') as [(a, b), c[d], e.f, g[h:i]]: + a, b, c, d, e, g, h, i + a, b, c, d, e, g, h, i + ''') + + + def test_withStatementSingleNameUndefined(self): + """ + An undefined name warning is emitted if the name first defined by a + C{with} statement is used before the C{with} statement. + """ + self.flakes(''' + from __future__ import with_statement + bar + with open('foo') as bar: + pass + ''', m.UndefinedName) + + + def test_withStatementTupleNamesUndefined(self): + """ + An undefined name warning is emitted if a name first defined by a the + tuple-unpacking form of the C{with} statement is used before the + C{with} statement. + """ + self.flakes(''' + from __future__ import with_statement + baz + with open('foo') as (bar, baz): + pass + ''', m.UndefinedName) + + + def test_withStatementSingleNameRedefined(self): + """ + A redefined name warning is emitted if a name bound by an import is + rebound by the name defined by a C{with} statement. + """ + self.flakes(''' + from __future__ import with_statement + import bar + with open('foo') as bar: + pass + ''', m.RedefinedWhileUnused) + + + def test_withStatementTupleNamesRedefined(self): + """ + A redefined name warning is emitted if a name bound by an import is + rebound by one of the names defined by the tuple-unpacking form of a + C{with} statement. + """ + self.flakes(''' + from __future__ import with_statement + import bar + with open('foo') as (bar, baz): + pass + ''', m.RedefinedWhileUnused) + + + def test_withStatementUndefinedInside(self): + """ + An undefined name warning is emitted if a name is used inside the + body of a C{with} statement without first being bound. + """ + self.flakes(''' + from __future__ import with_statement + with open('foo') as bar: + baz + ''', m.UndefinedName) + + + def test_withStatementNameDefinedInBody(self): + """ + A name defined in the body of a C{with} statement can be used after + the body ends without warning. + """ + self.flakes(''' + from __future__ import with_statement + with open('foo') as bar: + baz = 10 + baz + ''') + + + def test_withStatementUndefinedInExpression(self): + """ + An undefined name warning is emitted if a name in the I{test} + expression of a C{with} statement is undefined. + """ + self.flakes(''' + from __future__ import with_statement + with bar as baz: + pass + ''', m.UndefinedName) + + self.flakes(''' + from __future__ import with_statement + with bar as bar: + pass + ''', m.UndefinedName) + + + +class Python27Test(harness.Test): + """ + Tests for checking of syntax only available in Python 2.7 and newer. + """ + if version_info < (2, 7): + skip = "Python 2.7 required for dict/set comprehension tests" + + def test_dictComprehension(self): + """ + Dict comprehensions are properly handled. + """ + self.flakes(''' + a = {1: x for x in range(10)} + ''') + + def test_setComprehensionAndLiteral(self): + """ + Set comprehensions are properly handled. + """ + self.flakes(''' + a = {1, 2, 3} + b = {x for x in range(10)} + ''') diff --git a/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/test/test_script.py b/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/test/test_script.py new file mode 100644 index 0000000000..233e59ed78 --- /dev/null +++ b/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/test/test_script.py @@ -0,0 +1,185 @@ + +""" +Tests for L{pyflakes.scripts.pyflakes}. +""" + +import sys +from StringIO import StringIO + +from twisted.python.filepath import FilePath +from twisted.trial.unittest import TestCase + +from pyflakes.scripts.pyflakes import checkPath + +def withStderrTo(stderr, f): + """ + Call C{f} with C{sys.stderr} redirected to C{stderr}. + """ + (outer, sys.stderr) = (sys.stderr, stderr) + try: + return f() + finally: + sys.stderr = outer + + + +class CheckTests(TestCase): + """ + Tests for L{check} and L{checkPath} which check a file for flakes. + """ + def test_missingTrailingNewline(self): + """ + Source which doesn't end with a newline shouldn't cause any + exception to be raised nor an error indicator to be returned by + L{check}. + """ + fName = self.mktemp() + FilePath(fName).setContent("def foo():\n\tpass\n\t") + self.assertFalse(checkPath(fName)) + + + def test_checkPathNonExisting(self): + """ + L{checkPath} handles non-existing files. + """ + err = StringIO() + count = withStderrTo(err, lambda: checkPath('extremo')) + self.assertEquals(err.getvalue(), 'extremo: No such file or directory\n') + self.assertEquals(count, 1) + + + def test_multilineSyntaxError(self): + """ + Source which includes a syntax error which results in the raised + L{SyntaxError.text} containing multiple lines of source are reported + with only the last line of that source. + """ + source = """\ +def foo(): + ''' + +def bar(): + pass + +def baz(): + '''quux''' +""" + + # Sanity check - SyntaxError.text should be multiple lines, if it + # isn't, something this test was unprepared for has happened. + def evaluate(source): + exec source + exc = self.assertRaises(SyntaxError, evaluate, source) + self.assertTrue(exc.text.count('\n') > 1) + + sourcePath = FilePath(self.mktemp()) + sourcePath.setContent(source) + err = StringIO() + count = withStderrTo(err, lambda: checkPath(sourcePath.path)) + self.assertEqual(count, 1) + + self.assertEqual( + err.getvalue(), + """\ +%s:8: invalid syntax + '''quux''' + ^ +""" % (sourcePath.path,)) + + + def test_eofSyntaxError(self): + """ + The error reported for source files which end prematurely causing a + syntax error reflects the cause for the syntax error. + """ + source = "def foo(" + sourcePath = FilePath(self.mktemp()) + sourcePath.setContent(source) + err = StringIO() + count = withStderrTo(err, lambda: checkPath(sourcePath.path)) + self.assertEqual(count, 1) + self.assertEqual( + err.getvalue(), + """\ +%s:1: unexpected EOF while parsing +def foo( + ^ +""" % (sourcePath.path,)) + + + def test_nonDefaultFollowsDefaultSyntaxError(self): + """ + Source which has a non-default argument following a default argument + should include the line number of the syntax error. However these + exceptions do not include an offset. + """ + source = """\ +def foo(bar=baz, bax): + pass +""" + sourcePath = FilePath(self.mktemp()) + sourcePath.setContent(source) + err = StringIO() + count = withStderrTo(err, lambda: checkPath(sourcePath.path)) + self.assertEqual(count, 1) + self.assertEqual( + err.getvalue(), + """\ +%s:1: non-default argument follows default argument +def foo(bar=baz, bax): +""" % (sourcePath.path,)) + + + def test_nonKeywordAfterKeywordSyntaxError(self): + """ + Source which has a non-keyword argument after a keyword argument should + include the line number of the syntax error. However these exceptions + do not include an offset. + """ + source = """\ +foo(bar=baz, bax) +""" + sourcePath = FilePath(self.mktemp()) + sourcePath.setContent(source) + err = StringIO() + count = withStderrTo(err, lambda: checkPath(sourcePath.path)) + self.assertEqual(count, 1) + self.assertEqual( + err.getvalue(), + """\ +%s:1: non-keyword arg after keyword arg +foo(bar=baz, bax) +""" % (sourcePath.path,)) + + + def test_permissionDenied(self): + """ + If the a source file is not readable, this is reported on standard + error. + """ + sourcePath = FilePath(self.mktemp()) + sourcePath.setContent('') + sourcePath.chmod(0) + err = StringIO() + count = withStderrTo(err, lambda: checkPath(sourcePath.path)) + self.assertEquals(count, 1) + self.assertEquals( + err.getvalue(), "%s: Permission denied\n" % (sourcePath.path,)) + + + def test_misencodedFile(self): + """ + If a source file contains bytes which cannot be decoded, this is + reported on stderr. + """ + source = u"""\ +# coding: ascii +x = "\N{SNOWMAN}" +""".encode('utf-8') + sourcePath = FilePath(self.mktemp()) + sourcePath.setContent(source) + err = StringIO() + count = withStderrTo(err, lambda: checkPath(sourcePath.path)) + self.assertEquals(count, 1) + self.assertEquals( + err.getvalue(), "%s: problem decoding source\n" % (sourcePath.path,)) diff --git a/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/test/test_undefined_names.py b/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/test/test_undefined_names.py new file mode 100644 index 0000000000..309f0b9fe6 --- /dev/null +++ b/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/pyflakes/test/test_undefined_names.py @@ -0,0 +1,265 @@ + +from _ast import PyCF_ONLY_AST + +from twisted.trial.unittest import TestCase + +from pyflakes import messages as m, checker +from pyflakes.test import harness + + +class Test(harness.Test): + def test_undefined(self): + self.flakes('bar', m.UndefinedName) + + def test_definedInListComp(self): + self.flakes('[a for a in range(10) if a]') + + + def test_functionsNeedGlobalScope(self): + self.flakes(''' + class a: + def b(): + fu + fu = 1 + ''') + + def test_builtins(self): + self.flakes('range(10)') + + + def test_magicGlobalsFile(self): + """ + Use of the C{__file__} magic global should not emit an undefined name + warning. + """ + self.flakes('__file__') + + + def test_magicGlobalsBuiltins(self): + """ + Use of the C{__builtins__} magic global should not emit an undefined + name warning. + """ + self.flakes('__builtins__') + + + def test_magicGlobalsName(self): + """ + Use of the C{__name__} magic global should not emit an undefined name + warning. + """ + self.flakes('__name__') + + + def test_magicGlobalsPath(self): + """ + Use of the C{__path__} magic global should not emit an undefined name + warning, if you refer to it from a file called __init__.py. + """ + self.flakes('__path__', m.UndefinedName) + self.flakes('__path__', filename='package/__init__.py') + + + def test_globalImportStar(self): + '''Can't find undefined names with import *''' + self.flakes('from fu import *; bar', m.ImportStarUsed) + + def test_localImportStar(self): + '''A local import * still allows undefined names to be found in upper scopes''' + self.flakes(''' + def a(): + from fu import * + bar + ''', m.ImportStarUsed, m.UndefinedName) + + def test_unpackedParameter(self): + '''Unpacked function parameters create bindings''' + self.flakes(''' + def a((bar, baz)): + bar; baz + ''') + + def test_definedByGlobal(self): + '''"global" can make an otherwise undefined name in another function defined''' + self.flakes(''' + def a(): global fu; fu = 1 + def b(): fu + ''') + test_definedByGlobal.todo = '' + + def test_globalInGlobalScope(self): + """ + A global statement in the global scope is ignored. + """ + self.flakes(''' + global x + def foo(): + print x + ''', m.UndefinedName) + + def test_del(self): + '''del deletes bindings''' + self.flakes('a = 1; del a; a', m.UndefinedName) + + def test_delGlobal(self): + '''del a global binding from a function''' + self.flakes(''' + a = 1 + def f(): + global a + del a + a + ''') + + def test_delUndefined(self): + '''del an undefined name''' + self.flakes('del a', m.UndefinedName) + + def test_globalFromNestedScope(self): + '''global names are available from nested scopes''' + self.flakes(''' + a = 1 + def b(): + def c(): + a + ''') + + def test_laterRedefinedGlobalFromNestedScope(self): + """ + Test that referencing a local name that shadows a global, before it is + defined, generates a warning. + """ + self.flakes(''' + a = 1 + def fun(): + a + a = 2 + return a + ''', m.UndefinedLocal) + + def test_laterRedefinedGlobalFromNestedScope2(self): + """ + Test that referencing a local name in a nested scope that shadows a + global declared in an enclosing scope, before it is defined, generates + a warning. + """ + self.flakes(''' + a = 1 + def fun(): + global a + def fun2(): + a + a = 2 + return a + ''', m.UndefinedLocal) + + + def test_intermediateClassScopeIgnored(self): + """ + If a name defined in an enclosing scope is shadowed by a local variable + and the name is used locally before it is bound, an unbound local + warning is emitted, even if there is a class scope between the enclosing + scope and the local scope. + """ + self.flakes(''' + def f(): + x = 1 + class g: + def h(self): + a = x + x = None + print x, a + print x + ''', m.UndefinedLocal) + + + def test_doubleNestingReportsClosestName(self): + """ + Test that referencing a local name in a nested scope that shadows a + variable declared in two different outer scopes before it is defined + in the innermost scope generates an UnboundLocal warning which + refers to the nearest shadowed name. + """ + exc = self.flakes(''' + def a(): + x = 1 + def b(): + x = 2 # line 5 + def c(): + x + x = 3 + return x + return x + return x + ''', m.UndefinedLocal).messages[0] + self.assertEqual(exc.message_args, ('x', 5)) + + + def test_laterRedefinedGlobalFromNestedScope3(self): + """ + Test that referencing a local name in a nested scope that shadows a + global, before it is defined, generates a warning. + """ + self.flakes(''' + def fun(): + a = 1 + def fun2(): + a + a = 1 + return a + return a + ''', m.UndefinedLocal) + + def test_nestedClass(self): + '''nested classes can access enclosing scope''' + self.flakes(''' + def f(foo): + class C: + bar = foo + def f(self): + return foo + return C() + + f(123).f() + ''') + + def test_badNestedClass(self): + '''free variables in nested classes must bind at class creation''' + self.flakes(''' + def f(): + class C: + bar = foo + foo = 456 + return foo + f() + ''', m.UndefinedName) + + def test_definedAsStarArgs(self): + '''star and double-star arg names are defined''' + self.flakes(''' + def f(a, *b, **c): + print a, b, c + ''') + + def test_definedInGenExp(self): + """ + Using the loop variable of a generator expression results in no + warnings. + """ + self.flakes('(a for a in xrange(10) if a)') + + + +class NameTests(TestCase): + """ + Tests for some extra cases of name handling. + """ + def test_impossibleContext(self): + """ + A Name node with an unrecognized context results in a RuntimeError being + raised. + """ + tree = compile("x = 10", "", "exec", PyCF_ONLY_AST) + # Make it into something unrecognizable. + tree.body[0].targets[0].ctx = object() + self.assertRaises(RuntimeError, checker.Checker, tree) diff --git a/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/setup.py b/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/setup.py new file mode 100644 index 0000000000..8507337104 --- /dev/null +++ b/sources_non_forked/pyflakes-pathogen/ftplugin/python/pyflakes/setup.py @@ -0,0 +1,28 @@ +#!/usr/bin/python +# (c) 2005-2009 Divmod, Inc. See LICENSE file for details + +from distutils.core import setup + +setup( + name="pyflakes", + license="MIT", + version="0.4.0", + description="passive checker of Python programs", + author="Phil Frost", + maintainer="Moe Aboulkheir", + maintainer_email="moe@divmod.com", + url="http://www.divmod.org/trac/wiki/DivmodPyflakes", + packages=["pyflakes", "pyflakes.scripts", "pyflakes.test"], + scripts=["bin/pyflakes"], + long_description="""Pyflakes is program to analyze Python programs and detect various errors. It +works by parsing the source file, not importing it, so it is safe to use on +modules with side effects. It's also much faster.""", + classifiers=[ + "Development Status :: 6 - Mature", + "Environment :: Console", + "Intended Audience :: Developers", + "License :: OSI Approved :: MIT License", + "Programming Language :: Python", + "Topic :: Software Development", + "Topic :: Utilities", + ]) diff --git a/sources_non_forked/pyflakes-pathogen/ftplugin/python/quickfix.diff b/sources_non_forked/pyflakes-pathogen/ftplugin/python/quickfix.diff new file mode 100644 index 0000000000..ce2471f0f5 --- /dev/null +++ b/sources_non_forked/pyflakes-pathogen/ftplugin/python/quickfix.diff @@ -0,0 +1,124 @@ +diff --git a/README.rst b/README.rst +index 5f8467f..acff657 100644 +--- a/README.rst ++++ b/README.rst +@@ -8,11 +8,13 @@ accessing a local before it is bound, and also gives warnings for things like + unused imports. + + pyflakes-vim uses the output from PyFlakes to highlight errors in your code. ++To locate errors quickly, use quickfix_ commands: + + Make sure to check vim.org_ for the latest updates. + + .. _pyflakes.vim: http://www.vim.org/scripts/script.php?script_id=2441 + .. _vim.org: http://www.vim.org/scripts/script.php?script_id=2441 ++.. _quickfix: http://vimdoc.sourceforge.net/htmldoc/quickfix.html#quickfix + + Quick Installation + ------------------ +@@ -57,12 +59,10 @@ Hacking + TODO + ---- + * signs_ support (show warning and error icons to left of the buffer area) +- * quickfix_ support (allow jumping forward and back through the error list) + * configuration variables + * parse or intercept useful output from the warnings module + + .. _signs: http://www.vim.org/htmldoc/sign.html +-.. _quickfix: http://vimdoc.sourceforge.net/htmldoc/quickfix.html + + Changelog + --------- +diff --git a/pyflakes.vim b/pyflakes.vim +index 8aa508b..d6699bc 100644 +--- a/pyflakes.vim ++++ b/pyflakes.vim +@@ -159,6 +159,42 @@ if !exists("*s:WideMsg") + endfun + endif + ++if !exists("*s:GetQuickFixStackCount") ++ function s:GetQuickFixStackCount() ++ let l:stack_count = 0 ++ try ++ silent colder 9 ++ catch /E380:/ ++ endtry ++ ++ try ++ for i in range(9) ++ silent cnewer ++ let l:stack_count = l:stack_count + 1 ++ endfor ++ catch /E381:/ ++ return l:stack_count ++ endtry ++ endfunction ++endif ++ ++if !exists("*s:ActivatePyflakesQuickFixWindow") ++ function s:ActivatePyflakesQuickFixWindow() ++ try ++ silent colder 9 " go to the bottom of quickfix stack ++ catch /E380:/ ++ endtry ++ ++ if s:pyflakes_qf > 0 ++ try ++ exe "silent cnewer " . s:pyflakes_qf ++ catch /E381:/ ++ echoerr "Could not activate Pyflakes Quickfix Window." ++ endtry ++ endif ++ endfunction ++endif ++ + if !exists("*s:RunPyflakes") + function s:RunPyflakes() + highlight link PyFlakes SpellBad +@@ -174,12 +210,23 @@ if !exists("*s:RunPyflakes") + + let b:matched = [] + let b:matchedlines = {} ++ ++ let b:qf_list = [] ++ let b:qf_window_count = -1 ++ + python << EOF + for w in check(vim.current.buffer): + vim.command('let s:matchDict = {}') + vim.command("let s:matchDict['lineNum'] = " + str(w.lineno)) + vim.command("let s:matchDict['message'] = '%s'" % vim_quote(w.message % w.message_args)) + vim.command("let b:matchedlines[" + str(w.lineno) + "] = s:matchDict") ++ ++ vim.command("let l:qf_item = {}") ++ vim.command("let l:qf_item.bufnr = bufnr('%')") ++ vim.command("let l:qf_item.filename = expand('%')") ++ vim.command("let l:qf_item.lnum = %s" % str(w.lineno)) ++ vim.command("let l:qf_item.text = '%s'" % vim_quote(w.message % w.message_args)) ++ vim.command("let l:qf_item.type = 'E'") + + if w.col is None or isinstance(w, SyntaxError): + # without column information, just highlight the whole line +@@ -189,8 +236,21 @@ for w in check(vim.current.buffer): + # with a column number, highlight the first keyword there + vim.command(r"let s:mID = matchadd('PyFlakes', '^\%" + str(w.lineno) + r"l\_.\{-}\zs\k\+\k\@!\%>" + str(w.col) + r"c')") + ++ vim.command("let l:qf_item.vcol = 1") ++ vim.command("let l:qf_item.col = %s" % str(w.col + 1)) ++ + vim.command("call add(b:matched, s:matchDict)") ++ vim.command("call add(b:qf_list, l:qf_item)") + EOF ++ if exists("s:pyflakes_qf") ++ " if pyflakes quickfix window is already created, reuse it ++ call s:ActivatePyflakesQuickFixWindow() ++ call setqflist(b:qf_list, 'r') ++ else ++ " one pyflakes quickfix window for all buffer ++ call setqflist(b:qf_list, '') ++ let s:pyflakes_qf = s:GetQuickFixStackCount() ++ endif + let b:cleared = 0 + endfunction + end diff --git a/sources_non_forked/tlib/autoload/tlib/World.vim b/sources_non_forked/tlib/autoload/tlib/World.vim index daedb559ce..1387a35075 100644 --- a/sources_non_forked/tlib/autoload/tlib/World.vim +++ b/sources_non_forked/tlib/autoload/tlib/World.vim @@ -3,8 +3,8 @@ " @Website: http://www.vim.org/account/profile.php?user_id=4037 " @License: GPL (see http://www.gnu.org/licenses/gpl.txt) " @Created: 2007-05-01. -" @Last Change: 2013-09-26. -" @Revision: 0.1.1297 +" @Last Change: 2013-12-03. +" @Revision: 0.1.1310 " :filedoc: " A prototype used by |tlib#input#List|. @@ -161,12 +161,14 @@ else let self.width_filename = min([ \ get(self, 'width_filename', &co), \ empty(g:tlib#input#filename_max_width) ? &co : eval(g:tlib#input#filename_max_width), - \ max(map(copy(self.base), 'strwidth(fnamemodify(v:val, ":t"))')) + \ max(map(copy(self.base), 'strwidth(matchstr(v:val, "[^\\/]*$"))')) \ ]) - " TLogVAR self.width_filename + " TLogVAR self.width_filename + exec 'syntax match TLibDir /\%>'. (1 + self.width_filename) .'c \(|\|\[[^]]*\]\) \zs\(\(\a:\|\.\.\|\.\.\..\{-}\)\?[\/][^&<>*|]\{-}\)\?[^\/]\+$/ contained containedin=TLibMarker contains=TLibFilename' + exec 'syntax match TLibMarker /\%>'. (1 + self.width_filename) .'c \(|\|\[[^]]*\]\) \S.*$/ contains=TLibDir' + " exec 'syntax match TLibDir /\(|\|\[.\{-}\]\) \zs\(\(\a:\|\.\.\|\.\.\..\{-}\)\?[\/][^&<>*|]\{-}\)\?[^\/]\+$/ contained containedin=TLibMarker contains=TLibFilename' + " exec 'syntax match TLibMarker /\(|\|\[.\{-}\]\) \S.*$/ contains=TLibDir' exec 'syntax match TLibFilename /[^\/]\+$/ contained containedin=TLibDir' - exec 'syntax match TLibDir /\%>'. (1 + self.width_filename) .'c \(|\|\[[^]]*\]\) \zs\(\(\a:\|\.\.\|\.\.\..\{-}\)\?[\/][^&<>*|]\{-}\)\?[^\/]\+$/ contained containedin=TLibMarker contains=TLibFilename' - exec 'syntax match TLibMarker /\%>'. (1 + self.width_filename) .'c \(|\|\[[^]]*\]\) \S.*$/ contains=TLibDir' hi def link TLibMarker Special hi def link TLibDir Directory hi def link TLibFilename NonText @@ -206,24 +208,26 @@ else " TLogVAR use_indicators if use_indicators call insert(marker, '[') - let bnr = bufnr(a:file) - " TLogVAR a:file, bnr, self.bufnr - if bnr != -1 - if bnr == self.bufnr - call add(marker, '%') - else - call add(marker, bnr) - endif - if getbufvar(bnr, '&modified') - call add(marker, '+') - endif - if getbufvar(bnr, '&bufhidden') == 'hide' - call add(marker, 'h') + if g:tlib_inputlist_filename_indicators + let bnr = bufnr(a:file) + TLogVAR a:file, bnr, self.bufnr + if bnr != -1 + if bnr == self.bufnr + call add(marker, '%') + else + call add(marker, bnr) + endif + if getbufvar(bnr, '&modified') + call add(marker, '+') + endif + if getbufvar(bnr, '&bufhidden') == 'hide' + call add(marker, 'h') + endif + " if !buflisted(bnr) + " call add(marker, 'u') + " endif + " echom "DBG" a:file string(get(self,'filename_indicators')) endif - " if !buflisted(bnr) - " call add(marker, 'u') - " endif - " echom "DBG" a:file string(get(self,'filename_indicators')) endif if has_key(self, 'filename_indicators') && has_key(self.filename_indicators, a:file) if len(marker) > 1 diff --git a/sources_non_forked/tlib/autoload/tlib/agent.vim b/sources_non_forked/tlib/autoload/tlib/agent.vim index c0d9566a1c..61109e7b56 100644 --- a/sources_non_forked/tlib/autoload/tlib/agent.vim +++ b/sources_non_forked/tlib/autoload/tlib/agent.vim @@ -3,8 +3,8 @@ " @Website: http://www.vim.org/account/profile.php?user_id=4037 " @License: GPL (see http://www.gnu.org/licenses/gpl.txt) " @Created: 2007-06-24. -" @Last Change: 2013-09-26. -" @Revision: 0.1.240 +" @Last Change: 2013-11-05. +" @Revision: 0.1.242 " :filedoc: @@ -444,6 +444,7 @@ endf function! tlib#agent#EditFileInTab(world, selected) "{{{3 + " TLogVAR a:selected call a:world.CloseScratch() call tlib#file#With('tabedit', 'tab sbuffer', a:selected, a:world) return tlib#agent#Exit(a:world, a:selected) diff --git a/sources_non_forked/tlib/autoload/tlib/file.vim b/sources_non_forked/tlib/autoload/tlib/file.vim index e7ea855aa9..85009e3726 100644 --- a/sources_non_forked/tlib/autoload/tlib/file.vim +++ b/sources_non_forked/tlib/autoload/tlib/file.vim @@ -4,7 +4,7 @@ " @License: GPL (see http://www.gnu.org/licenses/gpl.txt) " @Created: 2007-06-30. " @Last Change: 2013-09-25. -" @Revision: 0.0.141 +" @Revision: 0.0.142 if &cp || exists("loaded_tlib_file_autoload") finish @@ -36,12 +36,12 @@ function! tlib#file#Split(filename) "{{{3 endf -" :display: tlib#file#Join(filename_parts, ?strip_slashes=0) +" :display: tlib#file#Join(filename_parts, ?strip_slashes=1) " EXAMPLES: > " tlib#file#Join(['foo', 'bar', 'filename.txt']) " => 'foo/bar/filename.txt' function! tlib#file#Join(filename_parts, ...) "{{{3 - TVarArg 'strip_slashes' + TVarArg ['strip_slashes', 1] " TLogVAR a:filename_parts, strip_slashes if strip_slashes " let rx = tlib#rx#Escape(g:tlib#dir#sep) .'$' diff --git a/sources_non_forked/tlib/autoload/tlib/scratch.vim b/sources_non_forked/tlib/autoload/tlib/scratch.vim index bb6e4be205..e043f050c3 100644 --- a/sources_non_forked/tlib/autoload/tlib/scratch.vim +++ b/sources_non_forked/tlib/autoload/tlib/scratch.vim @@ -3,8 +3,8 @@ " @Website: http://www.vim.org/account/profile.php?user_id=4037 " @License: GPL (see http://www.gnu.org/licenses/gpl.txt) " @Created: 2007-07-18. -" @Last Change: 2013-10-16. -" @Revision: 0.0.242 +" @Last Change: 2013-11-11. +" @Revision: 0.0.251 if &cp || exists("loaded_tlib_scratch_autoload") finish @@ -65,7 +65,7 @@ function! tlib#scratch#UseScratch(...) "{{{3 else let cmd = 'buffer!' endif - " TLogVAR cmd + " TLogVAR cmd, bn silent exec 'noautocmd keepalt keepj' cmd bn endif else @@ -77,7 +77,7 @@ function! tlib#scratch#UseScratch(...) "{{{3 else let cmd = 'edit' endif - " TLogVAR cmd + " TLogVAR cmd, id silent exec 'noautocmd keepalt keepj' cmd escape(id, '%#\ ') " silent exec 'split '. id endif @@ -100,7 +100,7 @@ function! tlib#scratch#UseScratch(...) "{{{3 endif endif let keyargs.scratch = bufnr('%') - " TLogVAR 2, winnr(), bufnr('%'), bufname("%") + " TLogVAR 2, winnr(), bufnr('%'), bufname("%"), keyargs.scratch return keyargs.scratch endf diff --git a/sources_non_forked/tlib/doc/tlib.txt b/sources_non_forked/tlib/doc/tlib.txt index f12563aaad..a295ce1946 100644 --- a/sources_non_forked/tlib/doc/tlib.txt +++ b/sources_non_forked/tlib/doc/tlib.txt @@ -1495,7 +1495,7 @@ tlib#file#Split(filename) < *tlib#file#Join()* -tlib#file#Join(filename_parts, ?strip_slashes=0) +tlib#file#Join(filename_parts, ?strip_slashes=1) EXAMPLES: > tlib#file#Join(['foo', 'bar', 'filename.txt']) => 'foo/bar/filename.txt' diff --git a/sources_non_forked/tlib/plugin/02tlib.vim b/sources_non_forked/tlib/plugin/02tlib.vim index 2cfe155a14..c60dfd3b10 100644 --- a/sources_non_forked/tlib/plugin/02tlib.vim +++ b/sources_non_forked/tlib/plugin/02tlib.vim @@ -4,7 +4,7 @@ " @License: GPL (see http://www.gnu.org/licenses/gpl.txt) " @Created: 2007-04-10. " @Last Change: 2013-09-25. -" @Revision: 746 +" @Revision: 748 " GetLatestVimScripts: 1863 1 tlib.vim if &cp || exists("loaded_tlib") @@ -14,7 +14,7 @@ if v:version < 700 "{{{2 echoerr "tlib requires Vim >= 7" finish endif -let loaded_tlib = 106 +let loaded_tlib = 107 let s:save_cpo = &cpo set cpo&vim diff --git a/sources_non_forked/vim-airline/LICENSE b/sources_non_forked/vim-airline/LICENSE index 46977354f1..9a5a8b7335 100644 --- a/sources_non_forked/vim-airline/LICENSE +++ b/sources_non_forked/vim-airline/LICENSE @@ -1,6 +1,6 @@ The MIT License (MIT) -Copyright (C) 2013 Bailey Ling +Copyright (C) 2013-2014 Bailey Ling Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), diff --git a/sources_non_forked/vim-airline/README.md b/sources_non_forked/vim-airline/README.md index 3ff5ac3a74..22d0687211 100644 --- a/sources_non_forked/vim-airline/README.md +++ b/sources_non_forked/vim-airline/README.md @@ -10,7 +10,7 @@ Lean & mean status/tabline for vim that's light as air. * Integrates with a variety of plugins, including: [vim-bufferline][6], [fugitive][4], [unite][9], [ctrlp][10], [minibufexpl][15], [gundo][16], [undotree][17], [nerdtree][18], [tagbar][19], [vim-gitgutter][29], [vim-signify][30], [syntastic][5], [eclim][34], [lawrencium][21], [virtualenv][31], [tmuxline][35]. * Looks good with regular fonts and provides configuration points so you can use unicode or powerline symbols. * Optimized for speed; it loads in under a millisecond. -* Extensive suite of themes for popular colorschemes including [solarized][23] (dark and light), [tomorrow][24] (all variants), [base16][32] (all variants), [molokai][25], [jellybeans][26] and others; have a look at the [screenshots][14] in the wiki. +* Extensive suite of themes for popular color schemes including [solarized][23] (dark and light), [tomorrow][24] (all variants), [base16][32] (all variants), [molokai][25], [jellybeans][26] and others; have a look at the [screenshots][14] in the wiki. * Supports 7.2 as the minimum Vim version. * The master branch tries to be as stable as possible, and new features are merged in only after they have gone through a [full regression test][33]. * Unit testing suite. @@ -70,6 +70,9 @@ vim-airline integrates with a variety of plugins out of the box. These extensio #### [tmuxline][35] ![image](https://f.cloud.github.com/assets/1532071/1559276/4c28fbac-4fc7-11e3-90ef-7e833d980f98.gif) +#### [promptline][36] +![airline-promptline-sc](https://f.cloud.github.com/assets/1532071/1871900/7d4b28a0-789d-11e3-90e4-16f37269981b.gif) + ## Extras vim-airline also supplies some supplementary stand-alone extensions. In addition to the tabline extension mentioned earlier, there is also: @@ -164,7 +167,7 @@ Contributions and pull requests are welcome. Please take note of the following # License -MIT License. Copyright (c) 2013 Bailey Ling. +MIT License. Copyright (c) 2013-2014 Bailey Ling. [![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/bling/vim-airline/trend.png)](https://bitdeli.com/free "Bitdeli Badge") @@ -204,3 +207,4 @@ MIT License. Copyright (c) 2013 Bailey Ling. [33]: https://github.com/bling/vim-airline/wiki/Test-Plan [34]: http://eclim.org [35]: https://github.com/edkolev/tmuxline.vim +[36]: https://github.com/edkolev/promptline.vim diff --git a/sources_non_forked/vim-airline/autoload/airline.vim b/sources_non_forked/vim-airline/autoload/airline.vim index 664c78e65b..de66fbacdc 100644 --- a/sources_non_forked/vim-airline/autoload/airline.vim +++ b/sources_non_forked/vim-airline/autoload/airline.vim @@ -1,4 +1,4 @@ -" MIT License. Copyright (c) 2013 Bailey Ling. +" MIT License. Copyright (c) 2013-2014 Bailey Ling. " vim: et ts=2 sts=2 sw=2 let g:airline_statusline_funcrefs = get(g:, 'airline_statusline_funcrefs', []) diff --git a/sources_non_forked/vim-airline/autoload/airline/builder.vim b/sources_non_forked/vim-airline/autoload/airline/builder.vim index c1658974f6..d03af12e67 100644 --- a/sources_non_forked/vim-airline/autoload/airline/builder.vim +++ b/sources_non_forked/vim-airline/autoload/airline/builder.vim @@ -1,4 +1,4 @@ -" MIT License. Copyright (c) 2013 Bailey Ling. +" MIT License. Copyright (c) 2013-2014 Bailey Ling. " vim: et ts=2 sts=2 sw=2 let s:prototype = {} diff --git a/sources_non_forked/vim-airline/autoload/airline/debug.vim b/sources_non_forked/vim-airline/autoload/airline/debug.vim index 04d7e59cbd..28424a6567 100644 --- a/sources_non_forked/vim-airline/autoload/airline/debug.vim +++ b/sources_non_forked/vim-airline/autoload/airline/debug.vim @@ -1,4 +1,4 @@ -" MIT License. Copyright (c) 2013 Bailey Ling. +" MIT License. Copyright (c) 2013-2014 Bailey Ling. " vim: et ts=2 sts=2 sw=2 function! airline#debug#profile1() diff --git a/sources_non_forked/vim-airline/autoload/airline/deprecation.vim b/sources_non_forked/vim-airline/autoload/airline/deprecation.vim index dd0567fc1b..cf7e787238 100644 --- a/sources_non_forked/vim-airline/autoload/airline/deprecation.vim +++ b/sources_non_forked/vim-airline/autoload/airline/deprecation.vim @@ -1,4 +1,4 @@ -" MIT License. Copyright (c) 2013 Bailey Ling. +" MIT License. Copyright (c) 2013-2014 Bailey Ling. " vim: et ts=2 sts=2 sw=2 function! airline#deprecation#check() diff --git a/sources_non_forked/vim-airline/autoload/airline/extensions.vim b/sources_non_forked/vim-airline/autoload/airline/extensions.vim index 790bfd1bd4..f32abd3c95 100644 --- a/sources_non_forked/vim-airline/autoload/airline/extensions.vim +++ b/sources_non_forked/vim-airline/autoload/airline/extensions.vim @@ -1,4 +1,4 @@ -" MIT License. Copyright (c) 2013 Bailey Ling. +" MIT License. Copyright (c) 2013-2014 Bailey Ling. " vim: et ts=2 sts=2 sw=2 let s:ext = {} @@ -20,7 +20,6 @@ endfunction let s:script_path = tolower(resolve(expand(':p:h'))) let s:filetype_overrides = { - \ 'netrw': [ 'netrw', '%f' ], \ 'nerdtree': [ 'NERD', '' ], \ 'gundo': [ 'Gundo', '' ], \ 'diff': [ 'diff', '' ], @@ -128,6 +127,10 @@ function! airline#extensions#load() call airline#extensions#unite#init(s:ext) endif + if exists(':NetrwSettings') + call airline#extensions#netrw#init(s:ext) + endif + if get(g:, 'loaded_vimfiler', 0) let g:vimfiler_force_overwrite_statusline = 0 endif @@ -199,6 +202,10 @@ function! airline#extensions#load() call airline#extensions#tmuxline#init(s:ext) endif + if get(g:, 'airline#extensions#promptline#enabled', 1) && exists(':PromptlineSnapshot') && len(get(g:, 'airline#extensions#promptline#snapshot_file', '')) + call airline#extensions#promptline#init(s:ext) + endif + " load all other extensions not part of the default distribution for file in split(globpath(&rtp, "autoload/airline/extensions/*.vim"), "\n") " we have to check both resolved and unresolved paths, since it's possible diff --git a/sources_non_forked/vim-airline/autoload/airline/extensions/branch.vim b/sources_non_forked/vim-airline/autoload/airline/extensions/branch.vim index 2177f64cd8..82fd139f2f 100644 --- a/sources_non_forked/vim-airline/autoload/airline/extensions/branch.vim +++ b/sources_non_forked/vim-airline/autoload/airline/extensions/branch.vim @@ -1,4 +1,4 @@ -" MIT License. Copyright (c) 2013 Bailey Ling. +" MIT License. Copyright (c) 2013-2014 Bailey Ling. " vim: et ts=2 sts=2 sw=2 let s:has_fugitive = exists('*fugitive#head') @@ -10,10 +10,6 @@ if !s:has_fugitive && !s:has_lawrencium && !s:has_vcscommand finish endif -let s:empty_message = get(g:, 'airline#extensions#branch#empty_message', - \ get(g:, 'airline_branch_empty_message', '')) -let s:symbol = get(g:, 'airline#extensions#branch#symbol', g:airline_symbols.branch) - function! airline#extensions#branch#head() let head = '' @@ -48,9 +44,12 @@ endfunction function! airline#extensions#branch#get_head() let head = airline#extensions#branch#head() + let empty_message = get(g:, 'airline#extensions#branch#empty_message', + \ get(g:, 'airline_branch_empty_message', '')) + let symbol = get(g:, 'airline#extensions#branch#symbol', g:airline_symbols.branch) return empty(head) - \ ? s:empty_message - \ : printf('%s%s', empty(s:symbol) ? '' : s:symbol.(g:airline_symbols.space), head) + \ ? empty_message + \ : printf('%s%s', empty(symbol) ? '' : symbol.(g:airline_symbols.space), head) endfunction function! s:check_in_path() diff --git a/sources_non_forked/vim-airline/autoload/airline/extensions/bufferline.vim b/sources_non_forked/vim-airline/autoload/airline/extensions/bufferline.vim index 0c6013cead..6dc97fe7a4 100644 --- a/sources_non_forked/vim-airline/autoload/airline/extensions/bufferline.vim +++ b/sources_non_forked/vim-airline/autoload/airline/extensions/bufferline.vim @@ -1,4 +1,4 @@ -" MIT License. Copyright (c) 2013 Bailey Ling. +" MIT License. Copyright (c) 2013-2014 Bailey Ling. " vim: et ts=2 sts=2 sw=2 if !exists('*bufferline#get_status_string') diff --git a/sources_non_forked/vim-airline/autoload/airline/extensions/commandt.vim b/sources_non_forked/vim-airline/autoload/airline/extensions/commandt.vim index 1353940b44..e549f27b70 100644 --- a/sources_non_forked/vim-airline/autoload/airline/extensions/commandt.vim +++ b/sources_non_forked/vim-airline/autoload/airline/extensions/commandt.vim @@ -1,4 +1,4 @@ -" MIT License. Copyright (c) 2013 Bailey Ling. +" MIT License. Copyright (c) 2013-2014 Bailey Ling. " vim: et ts=2 sts=2 sw=2 if !get(g:, 'command_t_loaded', 0) diff --git a/sources_non_forked/vim-airline/autoload/airline/extensions/csv.vim b/sources_non_forked/vim-airline/autoload/airline/extensions/csv.vim index d3a8cc847f..2c296ab3f8 100644 --- a/sources_non_forked/vim-airline/autoload/airline/extensions/csv.vim +++ b/sources_non_forked/vim-airline/autoload/airline/extensions/csv.vim @@ -1,4 +1,4 @@ -" MIT License. Copyright (c) 2013 Bailey Ling. +" MIT License. Copyright (c) 2013-2014 Bailey Ling. " vim: et ts=2 sts=2 sw=2 if !get(g:, 'loaded_csv', 0) && !exists(':Table') diff --git a/sources_non_forked/vim-airline/autoload/airline/extensions/ctrlp.vim b/sources_non_forked/vim-airline/autoload/airline/extensions/ctrlp.vim index 64e28854ae..11a89220ef 100644 --- a/sources_non_forked/vim-airline/autoload/airline/extensions/ctrlp.vim +++ b/sources_non_forked/vim-airline/autoload/airline/extensions/ctrlp.vim @@ -1,4 +1,4 @@ -" MIT License. Copyright (c) 2013 Bailey Ling. +" MIT License. Copyright (c) 2013-2014 Bailey Ling. " vim: et ts=2 sts=2 sw=2 if !get(g:, 'loaded_ctrlp', 0) diff --git a/sources_non_forked/vim-airline/autoload/airline/extensions/default.vim b/sources_non_forked/vim-airline/autoload/airline/extensions/default.vim index 5d21996f56..d01349dfa5 100644 --- a/sources_non_forked/vim-airline/autoload/airline/extensions/default.vim +++ b/sources_non_forked/vim-airline/autoload/airline/extensions/default.vim @@ -1,4 +1,4 @@ -" MIT License. Copyright (c) 2013 Bailey Ling. +" MIT License. Copyright (c) 2013-2014 Bailey Ling. " vim: et ts=2 sts=2 sw=2 let s:section_truncate_width = get(g:, 'airline#extensions#default#section_truncate_width', { diff --git a/sources_non_forked/vim-airline/autoload/airline/extensions/eclim.vim b/sources_non_forked/vim-airline/autoload/airline/extensions/eclim.vim index 6836046682..8a80813efb 100644 --- a/sources_non_forked/vim-airline/autoload/airline/extensions/eclim.vim +++ b/sources_non_forked/vim-airline/autoload/airline/extensions/eclim.vim @@ -1,4 +1,4 @@ -" MIT License. Copyright (c) 2013 Bailey Ling. +" MIT License. Copyright (c) 2013-2014 Bailey Ling. " vim: et ts=2 sts=2 sw=2 if !exists(':ProjectCreate') diff --git a/sources_non_forked/vim-airline/autoload/airline/extensions/example.vim b/sources_non_forked/vim-airline/autoload/airline/extensions/example.vim index 0c64f2c86c..4a1932d8b1 100644 --- a/sources_non_forked/vim-airline/autoload/airline/extensions/example.vim +++ b/sources_non_forked/vim-airline/autoload/airline/extensions/example.vim @@ -1,4 +1,4 @@ -" MIT License. Copyright (c) 2013 Bailey Ling. +" MIT License. Copyright (c) 2013-2014 Bailey Ling. " vim: et ts=2 sts=2 sw=2 " we don't actually want this loaded :P diff --git a/sources_non_forked/vim-airline/autoload/airline/extensions/hunks.vim b/sources_non_forked/vim-airline/autoload/airline/extensions/hunks.vim index 084dd7b5a2..6827f5d7a8 100644 --- a/sources_non_forked/vim-airline/autoload/airline/extensions/hunks.vim +++ b/sources_non_forked/vim-airline/autoload/airline/extensions/hunks.vim @@ -1,4 +1,4 @@ -" MIT License. Copyright (c) 2013 Bailey Ling. +" MIT License. Copyright (c) 2013-2014 Bailey Ling. " vim: et ts=2 sts=2 sw=2 if !get(g:, 'loaded_signify', 0) && !get(g:, 'loaded_gitgutter', 0) diff --git a/sources_non_forked/vim-airline/autoload/airline/extensions/netrw.vim b/sources_non_forked/vim-airline/autoload/airline/extensions/netrw.vim new file mode 100644 index 0000000000..debb088842 --- /dev/null +++ b/sources_non_forked/vim-airline/autoload/airline/extensions/netrw.vim @@ -0,0 +1,32 @@ +" MIT License. Copyright (c) 2013-2014 Bailey Ling. +" vim: et ts=2 sts=2 sw=2 + +if !exists(':NetrwSettings') + finish +endif + +function! airline#extensions#netrw#apply(...) + if &ft == 'netrw' + let spc = g:airline_symbols.space + + call a:1.add_section('airline_a', spc.'netrw'.spc) + if exists('*airline#extensions#branch#get_head') + call a:1.add_section('airline_b', spc.'%{airline#extensions#branch#get_head()}'.spc) + endif + call a:1.add_section('airline_c', spc.'%f'.spc) + call a:1.split() + call a:1.add_section('airline_y', spc.'%{airline#extensions#netrw#sortstring()}'.spc) + return 1 + endif +endfunction + +function! airline#extensions#netrw#init(ext) + let g:netrw_force_overwrite_statusline = 0 + call a:ext.add_statusline_func('airline#extensions#netrw#apply') +endfunction + + +function! airline#extensions#netrw#sortstring() + let order = (g:netrw_sort_direction =~ 'n') ? '+' : '-' + return g:netrw_sort_by . (g:airline_symbols.space) . '[' . order . ']' +endfunction diff --git a/sources_non_forked/vim-airline/autoload/airline/extensions/promptline.vim b/sources_non_forked/vim-airline/autoload/airline/extensions/promptline.vim new file mode 100644 index 0000000000..50b9708f55 --- /dev/null +++ b/sources_non_forked/vim-airline/autoload/airline/extensions/promptline.vim @@ -0,0 +1,33 @@ +" MIT License. Copyright (c) 2013-2014 Bailey Ling. +" vim: et ts=2 sts=2 sw=2 + +if !exists(':PromptlineSnapshot') + finish +endif + +if !exists('airline#extensions#promptline#snapshot_file') || !len('airline#extensions#promptline#snapshot_file') + finish +endif + +let s:prompt_snapshot_file = get(g:, 'airline#extensions#promptline#snapshot_file', '') +let s:color_template = get(g:, 'airline#extensions#promptline#color_template', 'normal') + +function! airline#extensions#promptline#init(ext) + call a:ext.add_theme_func('airline#extensions#promptline#set_prompt_colors') +endfunction + +function! airline#extensions#promptline#set_prompt_colors(palette) + let color_template = has_key(a:palette, s:color_template) ? s:color_template : 'normal' + let mode_palette = a:palette[color_template] + + if !has_key(g:, 'promptline_symbols') + let g:promptline_symbols = { + \ 'left' : g:airline_left_sep, + \ 'right' : g:airline_right_sep, + \ 'left_alt' : g:airline_left_alt_sep, + \ 'right_alt' : g:airline_right_alt_sep} + endif + + let promptline_theme = promptline#api#create_theme_from_airline(mode_palette) + call promptline#api#create_snapshot_with_theme(s:prompt_snapshot_file, promptline_theme) +endfunction diff --git a/sources_non_forked/vim-airline/autoload/airline/extensions/quickfix.vim b/sources_non_forked/vim-airline/autoload/airline/extensions/quickfix.vim index f000e0275f..8efc527549 100644 --- a/sources_non_forked/vim-airline/autoload/airline/extensions/quickfix.vim +++ b/sources_non_forked/vim-airline/autoload/airline/extensions/quickfix.vim @@ -1,4 +1,4 @@ -" MIT License. Copyright (c) 2013 Bailey Ling. +" MIT License. Copyright (c) 2013-2014 Bailey Ling. " vim: et ts=2 sts=2 sw=2 let g:airline#extensions#quickfix#quickfix_text = 'Quickfix' diff --git a/sources_non_forked/vim-airline/autoload/airline/extensions/syntastic.vim b/sources_non_forked/vim-airline/autoload/airline/extensions/syntastic.vim index 3ecc1eb103..f7179af81c 100644 --- a/sources_non_forked/vim-airline/autoload/airline/extensions/syntastic.vim +++ b/sources_non_forked/vim-airline/autoload/airline/extensions/syntastic.vim @@ -1,4 +1,4 @@ -" MIT License. Copyright (c) 2013 Bailey Ling. +" MIT License. Copyright (c) 2013-2014 Bailey Ling. " vim: et ts=2 sts=2 sw=2 if !exists(':SyntasticCheck') diff --git a/sources_non_forked/vim-airline/autoload/airline/extensions/tabline.vim b/sources_non_forked/vim-airline/autoload/airline/extensions/tabline.vim index 0bad224f78..90aff5d87e 100644 --- a/sources_non_forked/vim-airline/autoload/airline/extensions/tabline.vim +++ b/sources_non_forked/vim-airline/autoload/airline/extensions/tabline.vim @@ -1,4 +1,4 @@ -" MIT License. Copyright (c) 2013 Bailey Ling. +" MIT License. Copyright (c) 2013-2014 Bailey Ling. " vim: et ts=2 sts=2 sw=2 let s:formatter = get(g:, 'airline#extensions#tabline#formatter', 'default') diff --git a/sources_non_forked/vim-airline/autoload/airline/extensions/tabline/default.vim b/sources_non_forked/vim-airline/autoload/airline/extensions/tabline/default.vim index f1c87e4fbc..4f1ed40e05 100644 --- a/sources_non_forked/vim-airline/autoload/airline/extensions/tabline/default.vim +++ b/sources_non_forked/vim-airline/autoload/airline/extensions/tabline/default.vim @@ -1,4 +1,4 @@ -" MIT License. Copyright (c) 2013 Bailey Ling. +" MIT License. Copyright (c) 2013-2014 Bailey Ling. " vim: et ts=2 sts=2 sw=2 let s:fmod = get(g:, 'airline#extensions#tabline#fnamemod', ':~:.') diff --git a/sources_non_forked/vim-airline/autoload/airline/extensions/tabline/unique_tail.vim b/sources_non_forked/vim-airline/autoload/airline/extensions/tabline/unique_tail.vim index eb622f5e4e..e4a790d9a3 100644 --- a/sources_non_forked/vim-airline/autoload/airline/extensions/tabline/unique_tail.vim +++ b/sources_non_forked/vim-airline/autoload/airline/extensions/tabline/unique_tail.vim @@ -1,4 +1,4 @@ -" MIT License. Copyright (c) 2013 Bailey Ling. +" MIT License. Copyright (c) 2013-2014 Bailey Ling. " vim: et ts=2 sts=2 sw=2 function! airline#extensions#tabline#unique_tail#format(bufnr, buffers) diff --git a/sources_non_forked/vim-airline/autoload/airline/extensions/tabline/unique_tail_improved.vim b/sources_non_forked/vim-airline/autoload/airline/extensions/tabline/unique_tail_improved.vim index 12b28ae638..1b4dfa3f00 100644 --- a/sources_non_forked/vim-airline/autoload/airline/extensions/tabline/unique_tail_improved.vim +++ b/sources_non_forked/vim-airline/autoload/airline/extensions/tabline/unique_tail_improved.vim @@ -1,4 +1,4 @@ -" MIT License. Copyright (c) 2013 Bailey Ling. +" MIT License. Copyright (c) 2013-2014 Bailey Ling. " vim: et ts=2 sts=2 sw=2 let s:skip_symbol = '…' diff --git a/sources_non_forked/vim-airline/autoload/airline/extensions/tagbar.vim b/sources_non_forked/vim-airline/autoload/airline/extensions/tagbar.vim index 061a47f21a..eb158ac410 100644 --- a/sources_non_forked/vim-airline/autoload/airline/extensions/tagbar.vim +++ b/sources_non_forked/vim-airline/autoload/airline/extensions/tagbar.vim @@ -1,4 +1,4 @@ -" MIT License. Copyright (c) 2013 Bailey Ling. +" MIT License. Copyright (c) 2013-2014 Bailey Ling. " vim: et ts=2 sts=2 sw=2 if !exists(':TagbarToggle') diff --git a/sources_non_forked/vim-airline/autoload/airline/extensions/tmuxline.vim b/sources_non_forked/vim-airline/autoload/airline/extensions/tmuxline.vim index 4bc0a5f928..363709bc4c 100644 --- a/sources_non_forked/vim-airline/autoload/airline/extensions/tmuxline.vim +++ b/sources_non_forked/vim-airline/autoload/airline/extensions/tmuxline.vim @@ -1,4 +1,4 @@ -" MIT License. Copyright (c) 2013 Bailey Ling. +" MIT License. Copyright (c) 2013-2014 Bailey Ling. " vim: et ts=2 sts=2 sw=2 if !exists(':Tmuxline') diff --git a/sources_non_forked/vim-airline/autoload/airline/extensions/undotree.vim b/sources_non_forked/vim-airline/autoload/airline/extensions/undotree.vim index d897f04183..f577ffd8d6 100644 --- a/sources_non_forked/vim-airline/autoload/airline/extensions/undotree.vim +++ b/sources_non_forked/vim-airline/autoload/airline/extensions/undotree.vim @@ -1,4 +1,4 @@ -" MIT License. Copyright (c) 2013 Bailey Ling. +" MIT License. Copyright (c) 2013-2014 Bailey Ling. " vim: et ts=2 sts=2 sw=2 if !exists(':UndotreeToggle') diff --git a/sources_non_forked/vim-airline/autoload/airline/extensions/unite.vim b/sources_non_forked/vim-airline/autoload/airline/extensions/unite.vim index 4db38584b0..d230b6fb27 100644 --- a/sources_non_forked/vim-airline/autoload/airline/extensions/unite.vim +++ b/sources_non_forked/vim-airline/autoload/airline/extensions/unite.vim @@ -1,4 +1,4 @@ -" MIT License. Copyright (c) 2013 Bailey Ling. +" MIT License. Copyright (c) 2013-2014 Bailey Ling. " vim: et ts=2 sts=2 sw=2 if !get(g:, 'loaded_unite', 0) diff --git a/sources_non_forked/vim-airline/autoload/airline/extensions/virtualenv.vim b/sources_non_forked/vim-airline/autoload/airline/extensions/virtualenv.vim index c052282c45..f070c47254 100644 --- a/sources_non_forked/vim-airline/autoload/airline/extensions/virtualenv.vim +++ b/sources_non_forked/vim-airline/autoload/airline/extensions/virtualenv.vim @@ -1,4 +1,4 @@ -" MIT License. Copyright (c) 2013 Bailey Ling. +" MIT License. Copyright (c) 2013-2014 Bailey Ling. " vim: et ts=2 sts=2 sw=2 if !get(g:, 'virtualenv_loaded', 0) diff --git a/sources_non_forked/vim-airline/autoload/airline/extensions/whitespace.vim b/sources_non_forked/vim-airline/autoload/airline/extensions/whitespace.vim index 002fba1d6f..ba98b71eb0 100644 --- a/sources_non_forked/vim-airline/autoload/airline/extensions/whitespace.vim +++ b/sources_non_forked/vim-airline/autoload/airline/extensions/whitespace.vim @@ -1,4 +1,4 @@ -" MIT License. Copyright (c) 2013 Bailey Ling. +" MIT License. Copyright (c) 2013-2014 Bailey Ling. " vim: et ts=2 sts=2 sw=2 " http://got-ravings.blogspot.com/2008/10/vim-pr0n-statusline-whitespace-flags.html diff --git a/sources_non_forked/vim-airline/autoload/airline/highlighter.vim b/sources_non_forked/vim-airline/autoload/airline/highlighter.vim index f5e68465ec..65a95cc988 100644 --- a/sources_non_forked/vim-airline/autoload/airline/highlighter.vim +++ b/sources_non_forked/vim-airline/autoload/airline/highlighter.vim @@ -1,4 +1,4 @@ -" MIT License. Copyright (c) 2013 Bailey Ling. +" MIT License. Copyright (c) 2013-2014 Bailey Ling. " vim: et ts=2 sts=2 sw=2 let s:is_win32term = (has('win32') || has('win64')) && !has('gui_running') diff --git a/sources_non_forked/vim-airline/autoload/airline/init.vim b/sources_non_forked/vim-airline/autoload/airline/init.vim index 558b3f23b6..a60774d81c 100644 --- a/sources_non_forked/vim-airline/autoload/airline/init.vim +++ b/sources_non_forked/vim-airline/autoload/airline/init.vim @@ -1,4 +1,4 @@ -" MIT License. Copyright (c) 2013 Bailey Ling. +" MIT License. Copyright (c) 2013-2014 Bailey Ling. " vim: et ts=2 sts=2 sw=2 function! s:check_defined(variable, default) diff --git a/sources_non_forked/vim-airline/autoload/airline/parts.vim b/sources_non_forked/vim-airline/autoload/airline/parts.vim index bec4504f5c..b0356b1de6 100644 --- a/sources_non_forked/vim-airline/autoload/airline/parts.vim +++ b/sources_non_forked/vim-airline/autoload/airline/parts.vim @@ -1,4 +1,4 @@ -" MIT License. Copyright (c) 2013 Bailey Ling. +" MIT License. Copyright (c) 2013-2014 Bailey Ling. " vim: et ts=2 sts=2 sw=2 let s:parts = {} diff --git a/sources_non_forked/vim-airline/autoload/airline/section.vim b/sources_non_forked/vim-airline/autoload/airline/section.vim index 4562bacd69..0baf07798e 100644 --- a/sources_non_forked/vim-airline/autoload/airline/section.vim +++ b/sources_non_forked/vim-airline/autoload/airline/section.vim @@ -1,4 +1,4 @@ -" MIT License. Copyright (c) 2013 Bailey Ling. +" MIT License. Copyright (c) 2013-2014 Bailey Ling. " vim: et ts=2 sts=2 sw=2 call airline#init#bootstrap() diff --git a/sources_non_forked/vim-airline/autoload/airline/themes.vim b/sources_non_forked/vim-airline/autoload/airline/themes.vim index 110a9dc3b4..07e032412d 100644 --- a/sources_non_forked/vim-airline/autoload/airline/themes.vim +++ b/sources_non_forked/vim-airline/autoload/airline/themes.vim @@ -1,4 +1,4 @@ -" MIT License. Copyright (c) 2013 Bailey Ling. +" MIT License. Copyright (c) 2013-2014 Bailey Ling. " vim: et ts=2 sts=2 sw=2 " generates a dictionary which defines the colors for each highlight group diff --git a/sources_non_forked/vim-airline/autoload/airline/themes/kalisi.vim b/sources_non_forked/vim-airline/autoload/airline/themes/kalisi.vim new file mode 100644 index 0000000000..4ff94f57fb --- /dev/null +++ b/sources_non_forked/vim-airline/autoload/airline/themes/kalisi.vim @@ -0,0 +1,57 @@ +" +" Colorscheme: Kalisi for airline. Inspired by powerline. +" 06.02.2014 Arthur Jaron +" hifreeo@gmail.com +" + +" Insert mode +let s:I1 = [ '#ffffff' , '#e80000' , 23 , 231 ] +let s:I2 = [ '#c5c5c5' , '#901010' , 74 , 31 ] +let s:I3 = [ '#c5c5c5' , '#500000' , 117 , 24 ] + +" Visual mode +let s:V1 = [ '#005f5f' , '#ffffff' , 23 , 231 ] +let s:V2 = [ '#5fafd7' , '#0087af' , 74 , 31 ] +let s:V3 = [ '#87d7ff' , '#005f87' , 117 , 24 ] + +" Replace mode +let s:R1 = [ '#8e00da' , '#ffffff' , 23 , 231 ] +let s:R2 = [ '#8e00da' , '#ce99ff' , 74 , 31 ] +let s:R3 = [ '#ce99ff' , '#8e00da' , 117 , 24 ] + +let g:airline#themes#kalisi#palette = {} + +function! airline#themes#kalisi#refresh() + + " Normal mode + let s:N1 = [ '#005f00' , '#afd700' , 22 , 148 ] + let s:N2 = [ '#afd700' , '#005f00' , 247 , 236 ] + let s:N3 = airline#themes#get_highlight('StatusLine') + + " Tabline Plugin + let g:airline#themes#kalisi#palette.tabline = { + \ 'airline_tab': ['#A6DB29', '#005f00', 231, 29, ''], + \ 'airline_tabsel': ['#404042', '#A6DB29', 231, 36, ''], + \ 'airline_tabtype': ['#afd700', '#005f00', 231, 36, ''], + \ 'airline_tabfill': ['#ffffff', '#000000', 231, 23, ''], + \ 'airline_tabhid': ['#c5c5c5', '#404042', 231, 88, ''], + \ 'airline_tabmod': ['#ffffff', '#F1266F', 231, 88, ''], + \ } + + let g:airline#themes#kalisi#palette.normal = airline#themes#generate_color_map(s:N1, s:N2, s:N3) + let g:airline#themes#kalisi#palette.visual = airline#themes#generate_color_map(s:V1, s:V2, s:V3) + let g:airline#themes#kalisi#palette.insert = airline#themes#generate_color_map(s:I1, s:I2, s:I3) + let g:airline#themes#kalisi#palette.replace = airline#themes#generate_color_map(s:R1, s:R2, s:R3) + + " Inactive Mode + " let s:IA = [ '#c5c5c5' , '#505052' , 239 , 234 , '' ] + let s:IA = airline#themes#get_highlight('StatusLineNC') + let g:airline#themes#kalisi#palette.inactive = airline#themes#generate_color_map(s:IA, s:IA, s:IA) + let g:airline#themes#kalisi#palette.inactive_modified = { + \ 'statusline': [ '#F1266F' , '' , '53' , '' , '' ] , + \ } + +endfunction + +call airline#themes#kalisi#refresh() + diff --git a/sources_non_forked/vim-airline/autoload/airline/util.vim b/sources_non_forked/vim-airline/autoload/airline/util.vim index b97c086686..a04bd0bf61 100644 --- a/sources_non_forked/vim-airline/autoload/airline/util.vim +++ b/sources_non_forked/vim-airline/autoload/airline/util.vim @@ -1,4 +1,4 @@ -" MIT License. Copyright (c) 2013 Bailey Ling. +" MIT License. Copyright (c) 2013-2014 Bailey Ling. " vim: et ts=2 sts=2 sw=2 call airline#init#bootstrap() diff --git a/sources_non_forked/vim-airline/doc/airline.txt b/sources_non_forked/vim-airline/doc/airline.txt index 8b8da8bdce..d5407b91a8 100644 --- a/sources_non_forked/vim-airline/doc/airline.txt +++ b/sources_non_forked/vim-airline/doc/airline.txt @@ -433,7 +433,7 @@ eclim < Note: Enabling this extension will modify 'showtabline' and 'guioptions'. -------------------------------------- *airline-tmuxline* +------------------------------------- *airline-tmuxline* tmuxline * enable/disable tmuxline integration > @@ -450,6 +450,26 @@ tmuxline startup > airline#extensions#tmuxline#snapshot_file = "~/.tmux-statusline-colors.conf" < +------------------------------------- *airline-promptline* +promptline + +* configure the path to the snapshot .sh file. Mandatory option. The created + file should be sourced by the shell on login > + " in .vimrc + airline#extensions#promptline#snapshot_file = "~/.shell_prompt.sh" + + " in .bashrc/.zshrc + [ -f ~/.shell_prompt.sh ] && source ~/.shell_prompt.sh +< +* enable/disable promptline integration > + let g:airline#extensions#promptline#enabled = 0 +< +* configure which mode colors should be used in prompt > + let airline#extensions#promptline#color_template = 'normal' (default) + let airline#extensions#promptline#color_template = 'insert' + let airline#extensions#promptline#color_template = 'visual' + let airline#extensions#promptline#color_template = 'replace' +< ============================================================================== ADVANCED CUSTOMIZATION *airline-advanced-customization* @@ -699,7 +719,7 @@ Contributions and pull requests are welcome. ============================================================================== LICENSE *airline-license* -MIT License. Copyright © 2013 Bailey Ling. +MIT License. Copyright © 2013-2014 Bailey Ling. vim:tw=78:ts=8:ft=help:norl: diff --git a/sources_non_forked/vim-airline/plugin/airline.vim b/sources_non_forked/vim-airline/plugin/airline.vim index f1d3d386bc..e75535fede 100644 --- a/sources_non_forked/vim-airline/plugin/airline.vim +++ b/sources_non_forked/vim-airline/plugin/airline.vim @@ -1,4 +1,4 @@ -" MIT License. Copyright (c) 2013 Bailey Ling. +" MIT License. Copyright (c) 2013-2014 Bailey Ling. " vim: et ts=2 sts=2 sw=2 if &cp || v:version < 702 || (exists('g:loaded_airline') && g:loaded_airline) diff --git a/sources_non_forked/vim-fugitive/plugin/fugitive.vim b/sources_non_forked/vim-fugitive/plugin/fugitive.vim index dbbc754d2f..8ddb28dabd 100644 --- a/sources_non_forked/vim-fugitive/plugin/fugitive.vim +++ b/sources_non_forked/vim-fugitive/plugin/fugitive.vim @@ -136,6 +136,9 @@ function! fugitive#extract_git_dir(path) abort " checking for them since such checks are extremely slow. break endif + if index(split($GIT_CEILING_DIRECTORIES, ':'), root) >= 0 + break + endif let dir = s:sub(root, '[\/]$', '') . '/.git' let type = getftype(dir) if type ==# 'dir' && fugitive#is_git_dir(dir) diff --git a/sources_non_forked/vim-snipmate/Contributors.md b/sources_non_forked/vim-snipmate/Contributors.md index 117ea62bce..6333cf5788 100644 --- a/sources_non_forked/vim-snipmate/Contributors.md +++ b/sources_non_forked/vim-snipmate/Contributors.md @@ -14,6 +14,7 @@ additional contributions from: * [bpugh](https://github.com/bpugh) * [bruno-](https://github.com/bruno-) * [darkwise](https://github.com/darkwise) +* [fish-face](https://github.com/fish-face) * [henrik](https://github.com/henrik) * [holizz](https://github.com/holizz) * [honza](https://github.com/honza) diff --git a/sources_non_forked/vim-snipmate/README.md b/sources_non_forked/vim-snipmate/README.md index 5fdf73ac54..4ddeecbe5d 100644 --- a/sources_non_forked/vim-snipmate/README.md +++ b/sources_non_forked/vim-snipmate/README.md @@ -22,6 +22,8 @@ dependencies. SnipMate depends on [vim-addon-mw-utils][mw-utils] and [tlib][tlib]. Since SnipMate does not ship with any snippets, we suggest looking at the [vim-snippets][vim-snippets] repository. +* Using [VAM][vam], add `vim-snippets` to the list of packages to be installed. + * Using [Pathogen][pathogen], run the following commands: % cd ~/.vim/bundle @@ -32,8 +34,6 @@ looking at the [vim-snippets][vim-snippets] repository. # Optional: % git clone https://github.com/honza/vim-snippets.git -* Using [VAM][vam], add `vim-snippets` to the list of packages to be installed. - * Using [Vundle][vundle], add the following to your `vimrc` then run `:BundleInstall` @@ -46,6 +46,11 @@ looking at the [vim-snippets][vim-snippets] repository. ## Release Notes ## +### Master ### + +* Fix bug with mirrors in the first column +* Fix bug with tabs in indents ([#143][143]) + ### 0.87 - 2014-01-04 ### * Stop indenting empty lines when expanding snippets @@ -68,3 +73,5 @@ looking at the [vim-snippets][vim-snippets] repository. [vam]: https://github.com/marcweber/vim-addon-manager [pathogen]: https://github.com/tpope/vim-pathogen [vundle]: https://github.com/gmarik/vundle + +[143]: https://github.com/garbas/vim-snipmate/issues/143 diff --git a/sources_non_forked/vim-snipmate/autoload/snipMate.vim b/sources_non_forked/vim-snipmate/autoload/snipMate.vim index 19304995e8..b4dc394939 100644 --- a/sources_non_forked/vim-snipmate/autoload/snipMate.vim +++ b/sources_non_forked/vim-snipmate/autoload/snipMate.vim @@ -79,7 +79,7 @@ fun! snipMate#expandSnip(snip, col) endif " Insert snippet with proper indentation - let indent = indent(lnum) + 1 + let indent = match(line, '\S\|$') + 1 call setline(lnum, line . snipLines[0]) call append(lnum, map(snipLines[1:], "empty(v:val) ? v:val : '" . strpart(line, 0, indent - 1) . "' . v:val")) @@ -375,10 +375,14 @@ function! s:state_proto.update_vars(change) let i += 1 endif + " Split the line into three parts: the mirror, what's before it, and + " what's after it. Then combine them using the new mirror string. + " Subtract one to go from column index to byte index let theline = getline(lnum) - " subtract -1 to go from column byte index to string byte index - " subtract another -1 to exclude the col'th element - call setline(lnum, theline[0:(col-2)] . newWord . theline[(col+self.end_col-self.start_col-a:change-1):]) + let update = strpart(theline, 0, col - 1) + let update .= newWord + let update .= strpart(theline, col + self.end_col - self.start_col - a:change - 1) + call setline(lnum, update) endfor " Reposition the cursor in case a var updates on the same line but before diff --git a/sources_non_forked/vim-snippets/README.md b/sources_non_forked/vim-snippets/README.md index 27592c73cc..da03e6610e 100644 --- a/sources_non_forked/vim-snippets/README.md +++ b/sources_non_forked/vim-snippets/README.md @@ -51,6 +51,32 @@ If you have VimL only (vim without python support) your best option is using garbas/vim-snipmate and cope with the minor bugs found in the engine. +Installation +============ +First be aware that there are many options, see "Snippet engines" above. +Second be aware than there are [tons of plugin managers](http://vim-wiki.mawercer.de/wiki/topic/vim%20plugin%20managment.html) +which is why Marc Weber thinks that it doesn't make sense to repeat the same +repetitive information everywhere. + +*Recommended way:* +[vim-addon-manager](vim-addon-manager) (because Marc Weber wrote it for exactly +this reason, it supports simple dependency management). Eg you're done by this +line in your .vimrc: + +``` +" assuming you want to use snipmate snippet engine +ActivateAddons vim-snippets snipmate +``` + +[vim-pi](https://bitbucket.org/vimcommunity/vim-pi/issue/90/we-really-need-a-web-interface) +Is the place to discuss plugin managers and repository resources. + +About how to install snipate see [snipmate@garbas](https://github.com/garbas/vim-snipmate) + +(Bundle, Pathogen, git clone - keywords to make people find this link by ctrl-f search) +I know that I should be reading the docs of the snippet engine, just let me copy paste into my .vmirc: +(See this pull request)[https://github.com/honza/vim-snippets/pull/307/files]. + Policies / for contributors =========================== Some snippets are useful for almost all languages, so let's try to have the same diff --git a/sources_non_forked/vim-snippets/snippets/puppet.snippets b/sources_non_forked/vim-snippets/snippets/puppet.snippets index 2e451e4142..a4fdf19fc1 100644 --- a/sources_non_forked/vim-snippets/snippets/puppet.snippets +++ b/sources_non_forked/vim-snippets/snippets/puppet.snippets @@ -90,7 +90,7 @@ snippet class ${0} } snippet node - node "${1:`vim_snippets#Filename('', 'fqdn')`}" { + node '${1:`vim_snippets#Filename('', 'fqdn')`}' { ${0} } snippet case @@ -122,99 +122,99 @@ snippet [ snippet > ${1} => ${0} snippet p: - "puppet://puppet/${1:module name}/${0:file name}" + 'puppet://puppet/${1:module name}/${0:file name}' # # Functions snippet alert - alert("${1:message}") + alert('${1:message}') snippet crit - crit("${1:message}") + crit('${1:message}') snippet debug - debug("${1:message}") + debug('${1:message}') snippet defined - defined(${1:Resource}["${2:name}"]) + defined(${1:Resource}['${2:name}']) snippet emerg - emerg("${1:message}") + emerg('${1:message}') snippet extlookup Simple extlookup - extlookup("${1:variable}") + extlookup('${1:variable}') snippet extlookup Extlookup with defaults - extlookup("${1:variable}", "${2:default}") + extlookup('${1:variable}', '${2:default}') snippet extlookup Extlookup with defaults and custom data file - extlookup("${1:variable}", "${2:default}", "${3:data source}") + extlookup('${1:variable}', '${2:default}', '${3:data source}') snippet fail - fail("${1:message}") + fail('${1:message}') snippet info - info("${1:message}") + info('${1:message}') snippet inline_template - inline_template("<%= ${1} %>") + inline_template('<%= ${1} %>') snippet notice - notice("${1:message}") + notice('${1:message}') snippet realize realize(${1:Resource}[${2:name}]) snippet regsubst - regsubst(${1:hay stack}, ${2:needle}, "${3:replacement}") + regsubst(${1:hay stack}, ${2:needle}, '${3:replacement}') snippet inc include ${1:classname} snippet split - split(${1:hay stack}, "${2:patten}") + split(${1:hay stack}, '${2:patten}') snippet versioncmp - versioncmp("${1:version}", "${2:version}") + versioncmp('${1:version}', '${2:version}') snippet warning - warning("${1:message}") + warning('${1:message}') # # Types snippet cron - cron{ "${1:name}": - command => "${2}", - user => "${3:root}", - ${4} => ${0} + cron { '${1:name}': + command => '${2}', + user => '${3:root}', + ${4} => ${0}, } snippet exec - exec{ "${1:name}": - command => "${2:$1}", - user => "${3:root}", - ${4} => ${0} + exec { '${1:name}': + command => '${2:$1}', + user => '${3:root}', + ${4} => ${0}, } snippet user - user{ "${1:user}": - comment => "${2:$1}", - ensure => present, - managehome => true, - home => "${0:/home/$1}" + user { '${1:user}': + ensure => present, + comment => '${2:$1}', + managehome => true, + home => '${0:/home/$1}', } snippet group - group{ "${1:group}": - ensure => ${0:present} + group { '${1:group}': + ensure => ${0:present}, } snippet host - host{ "${1:hostname}": - ip => ${0:127.0.0.1} + host { '${1:hostname}': + ip => ${0:127.0.0.1}, } snippet mailalias - mailalias{ "${1:localpart}": - recipient => "${0:recipient}" + mailalias { '${1:localpart}': + recipient => '${0:recipient}', } snippet mount - mount{ "${1:destination path}": + mount { '${1:destination path}': ensure => ${2:mounted}, - device => "${0:device name or path}" + device => '${0:device name or path}', } snippet package - package{ "${1:package name}": - ensure => ${0:present} + package { '${1:package name}': + ensure => ${0:present}, } snippet yumrepo - yumrepo{ "${1:repo name}": - descr => "${2:$1}", - enabled => ${0:1} + yumrepo { '${1:repo name}': + Descr => '${2:$1}', + enabled => ${0:1}, } snippet define @@ -227,7 +227,7 @@ snippet service ensure => running, enable => true, require => [ Package['${2:package}'], File['${3:file}'], ], - subscribe => [ File['${4:configfile1}'], File['${5:configfile2}'], Package['${6:package}'], ] + subscribe => [ File['${4:configfile1}'], File['${5:configfile2}'], Package['${6:package}'], ], } snippet file diff --git a/update_plugins.py b/update_plugins.py index 946f0b743a..ad474860d1 100644 --- a/update_plugins.py +++ b/update_plugins.py @@ -35,6 +35,7 @@ vim-airline https://github.com/bling/vim-airline goyo.vim https://github.com/junegunn/goyo.vim vim-zenroom2 https://github.com/amix/vim-zenroom2 +pyflakes-pathogen https://github.com/mitechie/pyflakes-pathogen """.strip() GITHUB_ZIP = '%s/archive/master.zip' diff --git a/vimrcs/basic.vim b/vimrcs/basic.vim index 6cbbc3a203..68b79b824f 100644 --- a/vimrcs/basic.vim +++ b/vimrcs/basic.vim @@ -293,23 +293,21 @@ autocmd BufWrite *.coffee :call DeleteTrailingWS() """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" -" => vimgrep searching and cope displaying +" => Ack searching and cope displaying +" requires ack.vim - it's much better than vimgrep/grep """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" -" When you press gv you vimgrep after the selected text +" When you press gv you Ack after the selected text vnoremap gv :call VisualSelection('gv', '') -" Open vimgrep and put the cursor in the right position -map g :vimgrep // **/*. - -" Vimgreps in the current file -map :vimgrep // % +" Open Ack and put the cursor in the right position +map g :Ack " When you press r you can search and replace the selected text vnoremap r :call VisualSelection('replace', '') " Do :help cope if you are unsure what cope is. It's super useful! " -" When you search with vimgrep, display your results in cope by doing: +" When you search with Ack, display your results in cope by doing: " cc " " To go to the next search result do: @@ -373,7 +371,7 @@ function! VisualSelection(direction, extra_filter) range if a:direction == 'b' execute "normal ?" . l:pattern . "^M" elseif a:direction == 'gv' - call CmdLine("vimgrep " . '/'. l:pattern . '/' . ' **/*.' . a:extra_filter) + call CmdLine("Ack \"" . l:pattern . "\" " ) elseif a:direction == 'replace' call CmdLine("%s" . '/'. l:pattern . '/') elseif a:direction == 'f'