]> git.madduck.net Git - etc/vim.git/commitdiff

madduck's git repository

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

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

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

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

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

Add '.vim/bundle/vim-python-pep8-indent/' from commit '60ba5e11a61618c0344e2db1902101...
authormartin f. krafft <madduck@madduck.net>
Thu, 14 Oct 2021 02:01:27 +0000 (15:01 +1300)
committermartin f. krafft <madduck@madduck.net>
Thu, 14 Oct 2021 02:01:27 +0000 (15:01 +1300)
git-subtree-dir: .vim/bundle/vim-python-pep8-indent
git-subtree-mainline: 2de20d9c659d6350a6408dc1ec4aa6e0b1dea6ac
git-subtree-split: 60ba5e11a61618c0344e2db190210145083c91f8

19 files changed:
1  2 
.vim/bundle/vim-python-pep8-indent/.circleci/config.yml
.vim/bundle/vim-python-pep8-indent/.coveragerc
.vim/bundle/vim-python-pep8-indent/.dockerignore
.vim/bundle/vim-python-pep8-indent/.gitignore
.vim/bundle/vim-python-pep8-indent/CONTRIBUTING.rst
.vim/bundle/vim-python-pep8-indent/COPYING.txt
.vim/bundle/vim-python-pep8-indent/Dockerfile
.vim/bundle/vim-python-pep8-indent/Gemfile
.vim/bundle/vim-python-pep8-indent/Makefile
.vim/bundle/vim-python-pep8-indent/README.rst
.vim/bundle/vim-python-pep8-indent/docker-compose.yml
.vim/bundle/vim-python-pep8-indent/indent/cython.vim
.vim/bundle/vim-python-pep8-indent/indent/python.vim
.vim/bundle/vim-python-pep8-indent/spec/indent/bytes_spec.rb
.vim/bundle/vim-python-pep8-indent/spec/indent/cython_spec.rb
.vim/bundle/vim-python-pep8-indent/spec/indent/indent_spec.rb
.vim/bundle/vim-python-pep8-indent/spec/make-coverage
.vim/bundle/vim-python-pep8-indent/spec/spec_helper.rb
.vim/bundle/vim-python-pep8-indent/spec/vimrc

index 0000000000000000000000000000000000000000,8d54439bda3bb4a6dcf7a415f12e3ad2b24c861d..8d54439bda3bb4a6dcf7a415f12e3ad2b24c861d
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,37 +1,37 @@@
+ version: 2
+ common: &common
+   working_directory: ~/repo
+   docker:
+     - image: blueyed/vim-python-pep8-indent-vims-for-test:3@sha256:e7e3c4f4b021954a40f2f1d88dc470f119dc65603c63724d1c58cbe437fdc2d4
+ jobs:
+   test:
+     <<: *common
+     steps:
+       - checkout
+       - run:
+           name: Run tests
+           command: |
+             spec/make-coverage
+       - run:
+           name: Report coverage
+           command: |
+             covimerage xml
+             codecov -X search gcov pycov -f coverage.xml
+   checkqa:
+     <<: *common
+     steps:
+       - checkout
+       - run:
+           name: Lint
+           command: |
+             vint **/*.vim
+ workflows:
+   version: 2
+   test:
+     jobs:
+       - test
+       - checkqa
index 0000000000000000000000000000000000000000,74cc24e8d2570ea7e20c9ed28f23ba25c7ca50b7..74cc24e8d2570ea7e20c9ed28f23ba25c7ca50b7
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,7 +1,7 @@@
+ [run]
+ plugins = covimerage
+ data_file = .coverage_covimerage
+ source = indent/python.vim
+ [report]
+ include = indent/python.vim
index 0000000000000000000000000000000000000000,1a99a797612cc211504f982a0d6961f97266a6d8..1a99a797612cc211504f982a0d6961f97266a6d8
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,2 +1,2 @@@
+ *
+ !Gemfile
index 0000000000000000000000000000000000000000,e8035f64e5288064c880140340364f5bda8a5afb..e8035f64e5288064c880140340364f5bda8a5afb
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,3 +1,3 @@@
+ .*.swp
+ .coverage_covimerage
+ Gemfile.lock
index 0000000000000000000000000000000000000000,094f20ada26cae12073b1b2ed32d7090c05649ef..094f20ada26cae12073b1b2ed32d7090c05649ef
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,37 +1,37 @@@
+ How To Contribute
+ =================
+ ``vim-python-pep8-indent`` is always open for suggestions and contributions by generous developers.
+ I’ve collected a few tips to get you started.
+ Please:
+ - *Always* add tests for your code.
+ - Write `good commit messages`_.
+ Running Tests
+ -------------
+ - They are written in Ruby_ (sorry :() using vimrunner_ which requires rspec_.
+ - The tests go into ``spec/indent/indent_spec.rb``.
+   Look at the ``describe`` blocks to get the hang of it.
+ - Run the tests with the command::
+    $ rspec spec
+ - Alternatively you can use Docker::
+    $ make test_docker
+ - You can select tests based on line numbers, e.g.::
+    $ rspec ./spec/indent/indent_spec.rb:385
+    $ make test_docker RSPEC_ARGS=./spec/indent/indent_spec.rb:385
+ Thank you for considering to contribute!
+ .. _Ruby: https://www.ruby-lang.org/
+ .. _`good commit messages`: http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html
+ .. _vimrunner: https://github.com/AndrewRadev/vimrunner
+ .. _rspec: https://github.com/rspec/rspec
index 0000000000000000000000000000000000000000,0e259d42c996742e9e3cba14c677129b2c1b6311..0e259d42c996742e9e3cba14c677129b2c1b6311
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,121 +1,121 @@@
+ Creative Commons Legal Code
+ CC0 1.0 Universal
+     CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
+     LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
+     ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
+     INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
+     REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
+     PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
+     THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
+     HEREUNDER.
+ Statement of Purpose
+ The laws of most jurisdictions throughout the world automatically confer
+ exclusive Copyright and Related Rights (defined below) upon the creator
+ and subsequent owner(s) (each and all, an "owner") of an original work of
+ authorship and/or a database (each, a "Work").
+ Certain owners wish to permanently relinquish those rights to a Work for
+ the purpose of contributing to a commons of creative, cultural and
+ scientific works ("Commons") that the public can reliably and without fear
+ of later claims of infringement build upon, modify, incorporate in other
+ works, reuse and redistribute as freely as possible in any form whatsoever
+ and for any purposes, including without limitation commercial purposes.
+ These owners may contribute to the Commons to promote the ideal of a free
+ culture and the further production of creative, cultural and scientific
+ works, or to gain reputation or greater distribution for their Work in
+ part through the use and efforts of others.
+ For these and/or other purposes and motivations, and without any
+ expectation of additional consideration or compensation, the person
+ associating CC0 with a Work (the "Affirmer"), to the extent that he or she
+ is an owner of Copyright and Related Rights in the Work, voluntarily
+ elects to apply CC0 to the Work and publicly distribute the Work under its
+ terms, with knowledge of his or her Copyright and Related Rights in the
+ Work and the meaning and intended legal effect of CC0 on those rights.
+ 1. Copyright and Related Rights. A Work made available under CC0 may be
+ protected by copyright and related or neighboring rights ("Copyright and
+ Related Rights"). Copyright and Related Rights include, but are not
+ limited to, the following:
+   i. the right to reproduce, adapt, distribute, perform, display,
+      communicate, and translate a Work;
+  ii. moral rights retained by the original author(s) and/or performer(s);
+ iii. publicity and privacy rights pertaining to a person's image or
+      likeness depicted in a Work;
+  iv. rights protecting against unfair competition in regards to a Work,
+      subject to the limitations in paragraph 4(a), below;
+   v. rights protecting the extraction, dissemination, use and reuse of data
+      in a Work;
+  vi. database rights (such as those arising under Directive 96/9/EC of the
+      European Parliament and of the Council of 11 March 1996 on the legal
+      protection of databases, and under any national implementation
+      thereof, including any amended or successor version of such
+      directive); and
+ vii. other similar, equivalent or corresponding rights throughout the
+      world based on applicable law or treaty, and any national
+      implementations thereof.
+ 2. Waiver. To the greatest extent permitted by, but not in contravention
+ of, applicable law, Affirmer hereby overtly, fully, permanently,
+ irrevocably and unconditionally waives, abandons, and surrenders all of
+ Affirmer's Copyright and Related Rights and associated claims and causes
+ of action, whether now known or unknown (including existing as well as
+ future claims and causes of action), in the Work (i) in all territories
+ worldwide, (ii) for the maximum duration provided by applicable law or
+ treaty (including future time extensions), (iii) in any current or future
+ medium and for any number of copies, and (iv) for any purpose whatsoever,
+ including without limitation commercial, advertising or promotional
+ purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
+ member of the public at large and to the detriment of Affirmer's heirs and
+ successors, fully intending that such Waiver shall not be subject to
+ revocation, rescission, cancellation, termination, or any other legal or
+ equitable action to disrupt the quiet enjoyment of the Work by the public
+ as contemplated by Affirmer's express Statement of Purpose.
+ 3. Public License Fallback. Should any part of the Waiver for any reason
+ be judged legally invalid or ineffective under applicable law, then the
+ Waiver shall be preserved to the maximum extent permitted taking into
+ account Affirmer's express Statement of Purpose. In addition, to the
+ extent the Waiver is so judged Affirmer hereby grants to each affected
+ person a royalty-free, non transferable, non sublicensable, non exclusive,
+ irrevocable and unconditional license to exercise Affirmer's Copyright and
+ Related Rights in the Work (i) in all territories worldwide, (ii) for the
+ maximum duration provided by applicable law or treaty (including future
+ time extensions), (iii) in any current or future medium and for any number
+ of copies, and (iv) for any purpose whatsoever, including without
+ limitation commercial, advertising or promotional purposes (the
+ "License"). The License shall be deemed effective as of the date CC0 was
+ applied by Affirmer to the Work. Should any part of the License for any
+ reason be judged legally invalid or ineffective under applicable law, such
+ partial invalidity or ineffectiveness shall not invalidate the remainder
+ of the License, and in such case Affirmer hereby affirms that he or she
+ will not (i) exercise any of his or her remaining Copyright and Related
+ Rights in the Work or (ii) assert any associated claims and causes of
+ action with respect to the Work, in either case contrary to Affirmer's
+ express Statement of Purpose.
+ 4. Limitations and Disclaimers.
+  a. No trademark or patent rights held by Affirmer are waived, abandoned,
+     surrendered, licensed or otherwise affected by this document.
+  b. Affirmer offers the Work as-is and makes no representations or
+     warranties of any kind concerning the Work, express, implied,
+     statutory or otherwise, including without limitation warranties of
+     title, merchantability, fitness for a particular purpose, non
+     infringement, or the absence of latent or other defects, accuracy, or
+     the present or absence of errors, whether or not discoverable, all to
+     the greatest extent permissible under applicable law.
+  c. Affirmer disclaims responsibility for clearing rights of other persons
+     that may apply to the Work or any use thereof, including without
+     limitation any person's Copyright and Related Rights in the Work.
+     Further, Affirmer disclaims responsibility for obtaining any necessary
+     consents, permissions or other rights required for any use of the
+     Work.
+  d. Affirmer understands and acknowledges that Creative Commons is not a
+     party to this document and has no duty or obligation with respect to
+     this CC0 or use of the Work.
index 0000000000000000000000000000000000000000,14e39ea133a6da381f8f51a3d32184143ca3765d..14e39ea133a6da381f8f51a3d32184143ca3765d
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,24 +1,24 @@@
+ FROM testbed/vim:latest
+ RUN apk --no-cache add gtk+2.0-dev libx11-dev libxt-dev mcookie xauth xvfb
+ # NOTE: +profile needs huge features.
+ RUN install_vim -tag v8.1.0129 -name vim --with-features=huge \
+   --disable-channel --disable-netbeans --disable-xim \
+   --enable-gui=gtk2 --with-x -build
+ RUN ln -s /vim-build/bin/vim /usr/bin/gvim
+ RUN gvim --version
+ # Install covimerage and vint.
+ # NOTE: we have py2 already via gtk+2.0-dev.
+ # NOTE: enum34+pathlib+typing gets installed as workaround for broken vim-vint wheel.
+ RUN apk --no-cache add py2-pip \
+   && pip install --no-cache-dir codecov covimerage==0.0.9 vim-vint enum34 pathlib typing \
+   && rm -rf /usr/include /usr/lib/python*/turtle* /usr/lib/python*/tkinter
+ WORKDIR /vim-python-pep8-indent
+ ADD Gemfile .
+ RUN apk --no-cache add coreutils ruby-bundler
+ RUN bundle install
+ ENTRYPOINT ["rspec", "spec"]
index 0000000000000000000000000000000000000000,9bbf59689951d8881663447c0532cf98a70e6c90..9bbf59689951d8881663447c0532cf98a70e6c90
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,3 +1,3 @@@
+ source 'https://rubygems.org'
+ gem "vimrunner", "0.3.4"
+ gem "rspec"
index 0000000000000000000000000000000000000000,2566d411dc911a7a4aea9153cd0581122ccd4f7b..2566d411dc911a7a4aea9153cd0581122ccd4f7b
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,25 +1,25 @@@
+ test:
+       VIMRUNNER_REUSE_SERVER=1 xvfb-run bundle exec rspec
+ # Run tests in dockerized Vims.
+ DOCKER_REPO:=blueyed/vim-python-pep8-indent-vims-for-test
+ DOCKER_TAG:=3
+ DOCKER_IMAGE:=$(DOCKER_REPO):$(DOCKER_TAG)
+ docker_image:
+       docker build -t $(DOCKER_REPO):$(DOCKER_TAG) .
+ docker_push:
+       docker push $(DOCKER_REPO):$(DOCKER_TAG)
+ docker_update_latest:
+       docker tag $(DOCKER_REPO):$(DOCKER_TAG) $(DOCKER_REPO):latest
+       docker push $(DOCKER_REPO):latest
+ test_docker: XVFB_ERRORFILE:=/dev/null
+ test_docker:
+       @set -x; export DISPLAY=$(if $(VIMRUNNER_TEST_DISPLAY),$(VIMRUNNER_TEST_DISPLAY),172.17.0.1:99; Xvfb -ac -listen tcp :99 >$(XVFB_ERRORFILE) 2>&1 & XVFB_PID=$$!); \
+         docker run --rm -ti -e DISPLAY -e VIMRUNNER_REUSE_SERVER=1 \
+         -v $(CURDIR):/vim-python-pep8-indent $(DOCKER_IMAGE) $(RSPEC_ARGS) \
+         $(if $(VIMRUNNER_TEST_DISPLAY),,; ret=$$?; kill $$XVFB_PID; exit $$ret)
+ test_coverage:
+       spec/make-coverage
index 0000000000000000000000000000000000000000,77be58ccc58d48498300cf3845e2f780c7c042be..77be58ccc58d48498300cf3845e2f780c7c042be
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,169 +1,169 @@@
+ vim-python-pep8-indent
+ ======================
+ .. image:: https://circleci.com/gh/Vimjas/vim-python-pep8-indent.svg?style=svg
+   :target: https://circleci.com/gh/Vimjas/vim-python-pep8-indent
+ .. image:: https://codecov.io/gh/Vimjas/vim-python-pep8-indent/branch/master/graph/badge.svg
+   :target: https://codecov.io/gh/Vimjas/vim-python-pep8-indent
+ This small script modifies Vim_’s indentation behavior to comply with PEP8_ and my aesthetic preferences.
+ Most importantly::
+    foobar(foo,
+           bar)
+ and::
+    foobar(
+       foo,
+       bar
+    )
+ Installation
+ ------------
+ Install the plugin using your favorite plugin manager / method, a few examples
+ follow:
+ Pathogen
+ ^^^^^^^^
+ Follow the instructions on installing Pathogen_ and then:
+ .. code-block:: shell-session
+    $ cd ~/.vim/bundle
+    $ git clone https://github.com/Vimjas/vim-python-pep8-indent.git
+ Vundle
+ ^^^^^^
+ Follow the instructions on installing Vundle_ and add the appropriate plugin line into your ``.vimrc``:
+ .. code-block:: vim
+    Plugin 'Vimjas/vim-python-pep8-indent'
+ NeoBundle
+ ^^^^^^^^^
+ Follow the instructions on installing NeoBundle_ and add the appropriate NeoBundle line into your ``.vimrc``:
+ .. code-block:: vim
+    NeoBundle 'Vimjas/vim-python-pep8-indent'
+ Configuration
+ -------------
+ g:python_pep8_indent_multiline_string
+ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ You can configure the initial indentation of multiline strings using ``g:python_pep8_indent_multiline_string`` (which can also be set per buffer).
+ This defaults to ``0``, which means that multiline strings are not indented.
+ ``-1`` and positive values will be used as-is, where ``-1`` is a special value for Vim's ``indentexpr``, and will keep the existing indent (using Vim's ``autoindent`` setting).
+ ``-2`` is meant to be used for strings that are wrapped with ``textwrap.dedent`` etc.  It will add a level of indentation if the multiline string started in the previous line, without any content in it already::
+    testdir.makeconftest("""
+        _
+ With content already, it will be aligned to the opening parenthesis::
+    testdir.makeconftest("""def pytest_addoption(parser):
+                         _
+ Existing indentation (including ``0``) in multiline strings will be kept, so this setting only applies to the indentation of new/empty lines.
+ g:python_pep8_indent_hang_closing
+ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ Control closing bracket indentation with ``python_pep8_indent_hang_closing``, set globally or per buffer.
+ By default (set to ``0``), closing brackets line up with the opening line::
+    my_list = [
+        1, 2, 3,
+        4, 5, 6,
+    ]
+    result = some_function_that_takes_arguments(
+        'a', 'b', 'c',
+        'd', 'e', 'f',
+    )
+ With ``python_pep8_indent_hang_closing = 1``, closing brackets line up with the items::
+    my_list = [
+        1, 2, 3,
+        4, 5, 6,
+        ]
+    result = some_function_that_takes_arguments(
+        'a', 'b', 'c',
+        'd', 'e', 'f',
+        )
+ Troubleshooting
+ ---------------
+ In case it is not working, please make sure your Vim is configured to load
+ indent files (``filetype indent on``).
+ This is typically the case when using a plugin manager, but check its docs.
+ Check ``:verbose set indentexpr?`` in a Python file, which should show
+ something like the following:
+   indentexpr=GetPythonPEPIndent(v:lnum)
+         Last set from ~/…/plugged/vim-python-pep8-indent/indent/python.vim
+ Notes
+ -----
+ Please note that Kirill Klenov’s python-mode_ ships its own version of this bundle.
+ Therefore, if you want to use this version specifically, you’ll have to disable python-mode’s using:
+ .. code-block:: vim
+    let g:pymode_indent = 0
+ License and Authorship
+ ----------------------
+ This script is based on one from Vim’s official `script repo`_  that was *not* originally written by me.
+ Unfortunately the indentation was off by one character in one case and the script hasn’t been updated since 2005.
+ Even more unfortunately, I wasn’t able to reach any of the original authors/maintainers:
+ **David Bustos** and **Eric Mc Sween**.
+ So I fixed the annoyance with the help of `Steve Losh`_ and am putting it out here so you don’t have to patch the original yourself.
+ The original patch is still available here_.
+ Over the time a lot more improvements have been contributed_ by `generous people`_.
+ I’d like to thank the original authors here for their work and release it hereby to the *Public Domain* (using the CC0_ licence) since I hope that would be in their spirit.
+ If anyone with a say in this objects, please let me_ know immediately.
+ Also, if someone is in contact with one of them, I would appreciate being introduced.
+ While my Vimscript_ skills are still feeble, I intend to maintain it for now.
+ This mainly means that I’ll triage through bugs and pull requests but won’t be fixing much myself.
+ .. _Vim: http://www.vim.org/
+ .. _PEP8: http://www.python.org/dev/peps/pep-0008/
+ .. _`script repo`: http://www.vim.org/scripts/script.php?script_id=974
+ .. _`Steve Losh`: http://stevelosh.com/
+ .. _here: https://gist.github.com/2965846
+ .. _Neobundle: https://github.com/Shougo/neobundle.vim
+ .. _Pathogen: https://github.com/tpope/vim-pathogen
+ .. _python-mode: https://github.com/klen/python-mode
+ .. _`Vimscript`: http://learnvimscriptthehardway.stevelosh.com/
+ .. _vundle: https://github.com/gmarik/Vundle.vim
+ .. _me: https://hynek.me/
+ .. _CC0: http://creativecommons.org/publicdomain/zero/1.0/
+ .. _contributed: https://github.com/hynek/vim-python-pep8-indent/blob/master/CONTRIBUTING.rst
+ .. _`generous people`: https://github.com/hynek/vim-python-pep8-indent/graphs/contributors
index 0000000000000000000000000000000000000000,71760c2d5f3a34817477ad5372600df703ed2a56..71760c2d5f3a34817477ad5372600df703ed2a56
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,6 +1,6 @@@
+ version: '2'
+ services:
+   rspec:
+     build: .
+     volumes:
+     - .:/vim-python-pep8-indent
index 0000000000000000000000000000000000000000,4407bc185851258cf1fe8d298386e3db45e209fc..4407bc185851258cf1fe8d298386e3db45e209fc
mode 000000,120000..120000
--- /dev/null
@@@ -1,0 -1,1 +1,1 @@@
+ python.vim
index 0000000000000000000000000000000000000000,047ae3d7bad1ec3157ceffabcc1479598ae7a783..047ae3d7bad1ec3157ceffabcc1479598ae7a783
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,454 +1,454 @@@
+ " PEP8 compatible Python indent file
+ " Language:         Python
+ " Maintainer:       Daniel Hahler <https://daniel.hahler.de/>
+ " Prev Maintainer:  Hynek Schlawack <hs@ox.cx>
+ " Prev Maintainer:  Eric Mc Sween <em@tomcom.de> (address invalid)
+ " Original Author:  David Bustos <bustos@caltech.edu> (address invalid)
+ " License:          CC0
+ "
+ " vim-python-pep8-indent - A nicer Python indentation style for vim.
+ " Written in 2004 by David Bustos <bustos@caltech.edu>
+ " Maintained from 2004-2005 by Eric Mc Sween <em@tomcom.de>
+ " Maintained from 2013 by Hynek Schlawack <hs@ox.cx>
+ " Maintained from 2017 by Daniel Hahler <https://daniel.hahler.de/>
+ "
+ " To the extent possible under law, the author(s) have dedicated all copyright
+ " and related and neighboring rights to this software to the public domain
+ " worldwide. This software is distributed without any warranty.
+ " You should have received a copy of the CC0 Public Domain Dedication along
+ " with this software. If not, see
+ " <http://creativecommons.org/publicdomain/zero/1.0/>.
+ " Only load this indent file when no other was loaded.
+ if exists('b:did_indent')
+     finish
+ endif
+ let b:did_indent = 1
+ setlocal nolisp
+ setlocal autoindent
+ setlocal indentexpr=GetPythonPEPIndent(v:lnum)
+ setlocal indentkeys=!^F,o,O,<:>,0),0],0},=elif,=except
+ if !exists('g:python_pep8_indent_multiline_string')
+     let g:python_pep8_indent_multiline_string = 0
+ endif
+ if !exists('g:python_pep8_indent_hang_closing')
+     let g:python_pep8_indent_hang_closing = 0
+ endif
+ " TODO: check required patch for timeout argument, likely lower than 7.3.429 though.
+ if !exists('g:python_pep8_indent_searchpair_timeout')
+     if has('patch-8.0.1483')
+         let g:python_pep8_indent_searchpair_timeout = 150
+     else
+         let g:python_pep8_indent_searchpair_timeout = 0
+     endif
+ endif
+ let s:block_rules = {
+       \ '^\s*elif\>': [['if', 'elif'], ['else']],
+       \ '^\s*except\>': [['try', 'except'], []],
+       \ '^\s*finally\>': [['try', 'except', 'else'], []]
+       \ }
+ let s:block_rules_multiple = {
+       \ '^\s*else\>': [['if', 'elif', 'for', 'try', 'except'], []]
+       \ }
+ " Pairs to look for when searching for opening parenthesis.
+ " The value is the maximum offset in lines.
+ let s:paren_pairs = {'()': 50, '[]': 100, '{}': 1000}
+ if &filetype ==# 'pyrex' || &filetype ==# 'cython'
+     let b:control_statement = '\v^\s*(class|def|if|while|with|for|except|cdef|cpdef)>'
+ else
+     let b:control_statement = '\v^\s*(class|def|if|while|with|for|except)>'
+ endif
+ let s:stop_statement = '^\s*\(break\|continue\|raise\|return\|pass\)\>'
+ let s:skip_after_opening_paren = 'synIDattr(synID(line("."), col("."), 0), "name") ' .
+             \ '=~? "\\vcomment|jedi\\S"'
+ let s:special_chars_syn_pattern = "\\vstring|comment|^pythonbytes%(contents)=$|pythonTodo|jedi\\S"
+ if !get(g:, 'python_pep8_indent_skip_concealed', 0) || !has('conceal')
+     " Skip strings and comments. Return 1 for chars to skip.
+     " jedi* refers to syntax definitions from jedi-vim for call signatures, which
+     " are inserted temporarily into the buffer.
+     function! s:_skip_special_chars(line, col)
+         return synIDattr(synID(a:line, a:col, 0), 'name')
+               \ =~? s:special_chars_syn_pattern
+     endfunction
+ else
+     " Also ignore anything concealed.
+     " TODO: doc; likely only necessary with jedi-vim, where a better version is
+     " planned (https://github.com/Vimjas/vim-python-pep8-indent/pull/98).
+     " Wrapper around synconcealed for older Vim (7.3.429, used on Travis CI).
+     function! s:is_concealed(line, col)
+         let concealed = synconcealed(a:line, a:col)
+         return len(concealed) && concealed[0]
+     endfunction
+     function! s:_skip_special_chars(line, col)
+         return synIDattr(synID(a:line, a:col, 0), 'name')
+               \ =~? s:special_chars_syn_pattern
+               \ || s:is_concealed(a:line, a:col)
+     endfunction
+ endif
+ " Use 'shiftwidth()' instead of '&sw'.
+ " (Since Vim patch 7.3.629, 'shiftwidth' can be set to 0 to follow 'tabstop').
+ if exists('*shiftwidth')
+     function! s:sw()
+         return shiftwidth()
+     endfunction
+ else
+     function! s:sw()
+         return &shiftwidth
+     endfunction
+ endif
+ " Find backwards the closest open parenthesis/bracket/brace.
+ function! s:find_opening_paren(lnum, col)
+     " Return if cursor is in a comment.
+     if synIDattr(synID(a:lnum, a:col, 0), 'name') =~? 'comment'
+         return [0, 0]
+     endif
+     call cursor(a:lnum, a:col)
+     let nearest = [0, 0]
+     let timeout = g:python_pep8_indent_searchpair_timeout
+     let skip_special_chars = 's:_skip_special_chars(line("."), col("."))'
+     for [p, maxoff] in items(s:paren_pairs)
+         let stopline = max([0, line('.') - maxoff, nearest[0]])
+         let next = searchpairpos(
+            \ '\V'.p[0], '', '\V'.p[1], 'bnW', skip_special_chars, stopline, timeout)
+         if next[0] && (next[0] > nearest[0] || (next[0] == nearest[0] && next[1] > nearest[1]))
+             let nearest = next
+         endif
+     endfor
+     return nearest
+ endfunction
+ " Find the start of a multi-line statement
+ function! s:find_start_of_multiline_statement(lnum)
+     let lnum = a:lnum
+     while lnum > 0
+         if getline(lnum - 1) =~# '\\$'
+             let lnum = prevnonblank(lnum - 1)
+         else
+             let [paren_lnum, _] = s:find_opening_paren(lnum, 1)
+             if paren_lnum < 1
+                 return lnum
+             else
+                 let lnum = paren_lnum
+             endif
+         endif
+     endwhile
+ endfunction
+ " Find possible indent(s) of the block starter that matches the current line.
+ function! s:find_start_of_block(lnum, types, skip, multiple) abort
+     let r = []
+     let re = '\V\^\s\*\('.join(a:types, '\|').'\)\>'
+     if !empty(a:skip)
+       let re_skip = '\V\^\s\*\('.join(a:skip, '\|').'\)\>'
+     else
+       let re_skip = ''
+     endif
+     let last_indent = indent(a:lnum) + 1
+     let lnum = a:lnum - 1
+     while lnum > 0 && last_indent > 0
+         let indent = indent(lnum)
+         if indent < last_indent
+             let line = getline(lnum)
+             if !empty(re_skip) && line =~# re_skip
+                 let last_indent = indent
+             elseif line =~# re
+                 if !a:multiple
+                     return [indent]
+                 endif
+                 if index(r, indent) == -1
+                     let r += [indent]
+                 endif
+                 let last_indent = indent
+             endif
+         endif
+         let lnum = prevnonblank(lnum - 1)
+     endwhile
+     return r
+ endfunction
+ " Is "expr" true for every position in "lnum", beginning at "start"?
+ " (optionally up to a:1 / 4th argument)
+ function! s:match_expr_on_line(expr, lnum, start, ...)
+     let text = getline(a:lnum)
+     let end = a:0 ? a:1 : len(text)
+     if a:start > end
+         return 1
+     endif
+     let save_pos = getpos('.')
+     let r = 1
+     for i in range(a:start, end)
+         call cursor(a:lnum, i)
+         if !(eval(a:expr) || text[i-1] =~# '\s')
+             let r = 0
+             break
+         endif
+     endfor
+     call setpos('.', save_pos)
+     return r
+ endfunction
+ " Line up with open parenthesis/bracket/brace.
+ function! s:indent_like_opening_paren(lnum)
+     let [paren_lnum, paren_col] = s:find_opening_paren(a:lnum, 1)
+     if paren_lnum <= 0
+         return -2
+     endif
+     let text = getline(paren_lnum)
+     let base = indent(paren_lnum)
+     let nothing_after_opening_paren = s:match_expr_on_line(
+                 \ s:skip_after_opening_paren, paren_lnum, paren_col+1)
+     let starts_with_closing_paren = getline(a:lnum) =~# '^\s*[])}]'
+     let hang_closing = get(b:, 'python_pep8_indent_hang_closing',
+                 \ get(g:, 'python_pep8_indent_hang_closing', 0))
+     if nothing_after_opening_paren
+         if starts_with_closing_paren && !hang_closing
+             let res = base
+         else
+             let res = base + s:sw()
+             " Special case for parenthesis.
+             if text[paren_col-1] ==# '(' && getline(a:lnum) !~# '\v\)\s*:?\s*$'
+                 return res
+             endif
+         endif
+     else
+         " Indent to match position of opening paren.
+         let res = paren_col
+     endif
+     " If this line is the continuation of a control statement
+     " indent further to distinguish the continuation line
+     " from the next logical line.
+     if text =~# b:control_statement && res == base + s:sw()
+         " But only if not inside parens itself (Flake's E127).
+         let [paren_lnum, _] = s:find_opening_paren(paren_lnum, 1)
+         if paren_lnum <= 0
+             return res + s:sw()
+         endif
+     endif
+     return res
+ endfunction
+ " Match indent of first block of this type.
+ function! s:indent_like_block(lnum)
+     let text = getline(a:lnum)
+     for [multiple, block_rules] in [
+                 \ [0, s:block_rules],
+                 \ [1, s:block_rules_multiple],
+                 \ ]
+         for [line_re, blocks_ignore] in items(block_rules)
+             if text !~# line_re
+                 continue
+             endif
+             let [blocks, skip] = blocks_ignore
+             let indents = s:find_start_of_block(a:lnum, blocks, skip, multiple)
+             if empty(indents)
+                 return -1
+             endif
+             if len(indents) == 1
+                 return indents[0]
+             endif
+             " Multiple valid indents, e.g. for 'else' with both try and if.
+             let indent = indent(a:lnum)
+             if index(indents, indent) != -1
+                 " The indent is valid, keep it.
+                 return indent
+             endif
+             " Fallback to the first/nearest one.
+             return indents[0]
+         endfor
+     endfor
+     return -2
+ endfunction
+ function! s:indent_like_previous_line(lnum)
+     let lnum = prevnonblank(a:lnum - 1)
+     " No previous line, keep current indent.
+     if lnum < 1
+       return -1
+     endif
+     let text = getline(lnum)
+     let start = s:find_start_of_multiline_statement(lnum)
+     let base = indent(start)
+     let current = indent(a:lnum)
+     " Ignore last character in previous line?
+     let lastcol = len(text)
+     let col = lastcol
+     " Search for final colon that is not inside something to be ignored.
+     while 1
+         if col == 1 | break | endif
+         if text[col-1] =~# '\s' || s:_skip_special_chars(lnum, col)
+             let col = col - 1
+             continue
+         elseif text[col-1] ==# ':'
+             return base + s:sw()
+         endif
+         break
+     endwhile
+     if text =~# '\\$' && !s:_skip_special_chars(lnum, lastcol)
+         " If this line is the continuation of a control statement
+         " indent further to distinguish the continuation line
+         " from the next logical line.
+         if getline(start) =~# b:control_statement
+             return base + s:sw() * 2
+         endif
+         " Nest (other) explicit continuations only one level deeper.
+         return base + s:sw()
+     endif
+     let empty = getline(a:lnum) =~# '^\s*$'
+     " Current and prev line are empty, next is not -> indent like next.
+     if empty && a:lnum > 1 &&
+           \ (getline(a:lnum - 1) =~# '^\s*$') &&
+           \ !(getline(a:lnum + 1) =~# '^\s*$')
+       return indent(a:lnum + 1)
+     endif
+     " If the previous statement was a stop-execution statement or a pass
+     if getline(start) =~# s:stop_statement
+         " Remove one level of indentation if the user hasn't already dedented
+         if empty || current > base - s:sw()
+             return base - s:sw()
+         endif
+         " Otherwise, trust the user
+         return -1
+     endif
+     if (current || !empty) && s:is_dedented_already(current, base)
+         return -1
+     endif
+     " In all other cases, line up with the start of the previous statement.
+     return base
+ endfunction
+ " If this line is dedented and the number of indent spaces is valid
+ " (multiple of the indentation size), trust the user.
+ function! s:is_dedented_already(current, base)
+     let dedent_size = a:current - a:base
+     return (dedent_size < 0 && a:current % s:sw() == 0) ? 1 : 0
+ endfunction
+ " Is the syntax at lnum (and optionally cnum) a python string?
+ function! s:is_python_string(lnum, ...)
+     let line = getline(a:lnum)
+     if a:0
+       let cols = type(a:1) != type([]) ? [a:1] : a:1
+     else
+       let cols = range(1, max([1, len(line)]))
+     endif
+     for cnum in cols
+         if match(map(synstack(a:lnum, cnum),
+                     \ "synIDattr(v:val, 'name')"), 'python\S*String') == -1
+             return 0
+         end
+     endfor
+     return 1
+ endfunction
+ function! GetPythonPEPIndent(lnum)
+     " First line has indent 0
+     if a:lnum == 1
+         return 0
+     endif
+     let line = getline(a:lnum)
+     let prevline = getline(a:lnum-1)
+     " Multilinestrings: continous, docstring or starting.
+     if s:is_python_string(a:lnum-1, max([1, len(prevline)]))
+                 \ && (s:is_python_string(a:lnum, 1)
+                 \     || match(line, '^\%("""\|''''''\)') != -1)
+         " Indent closing quotes as the line with the opening ones.
+         let match_quotes = match(line, '^\s*\zs\%("""\|''''''\)')
+         if match_quotes != -1
+             " closing multiline string
+             let quotes = line[match_quotes:(match_quotes+2)]
+             call cursor(a:lnum, 1)
+             let pairpos = searchpairpos(quotes, '', quotes, 'bW', '', 0, g:python_pep8_indent_searchpair_timeout)
+             if pairpos[0] != 0
+                 return indent(pairpos[0])
+             else
+                 return -1
+             endif
+         endif
+         if s:is_python_string(a:lnum-1)
+             " Previous line is (completely) a string: keep current indent.
+             return -1
+         endif
+         if match(prevline, '^\s*\%("""\|''''''\)') != -1
+             " docstring.
+             return indent(a:lnum-1)
+         endif
+         let indent_multi = get(b:, 'python_pep8_indent_multiline_string',
+                     \ get(g:, 'python_pep8_indent_multiline_string', 0))
+         if match(prevline, '\v%("""|'''''')$') != -1
+             " Opening multiline string, started in previous line.
+             if (&autoindent && indent(a:lnum) == indent(a:lnum-1))
+                         \ || match(line, '\v^\s+$') != -1
+                 " <CR> with empty line or to split up 'foo("""bar' into
+                 " 'foo("""' and 'bar'.
+                 if indent_multi == -2
+                     return indent(a:lnum-1) + s:sw()
+                 endif
+                 return indent_multi
+             endif
+         endif
+         " Keep existing indent.
+         if match(line, '\v^\s*\S') != -1
+             return -1
+         endif
+         if indent_multi != -2
+             return indent_multi
+         endif
+         return s:indent_like_opening_paren(a:lnum)
+     endif
+     " Parens: If we can find an open parenthesis/bracket/brace, line up with it.
+     let indent = s:indent_like_opening_paren(a:lnum)
+     if indent >= -1
+         return indent
+     endif
+     " Blocks: Match indent of first block of this type.
+     let indent = s:indent_like_block(a:lnum)
+     if indent >= -1
+         return indent
+     endif
+     return s:indent_like_previous_line(a:lnum)
+ endfunction
index 0000000000000000000000000000000000000000,3d6744e8f299b73b0f16560bd48a9f1b4a98da9e..3d6744e8f299b73b0f16560bd48a9f1b4a98da9e
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,36 +1,36 @@@
+ require "spec_helper"
+ describe "handles byte strings" do
+   before(:all) {
+       vim.command 'syn region pythonBytes start=+[bB]"+ skip=+\\\\\|\\"\|\\$+ excludenl end=+"+ end=+$+ keepend contains=pythonBytesError,pythonBytesContent,@Spell'
+       vim.command "syn match pythonBytesEscape       '\\\\$'"
+   }
+   before(:each) {
+     # clear buffer
+     vim.normal 'gg"_dG'
+     # Insert two blank lines.
+     # The first line is a corner case in this plugin that would shadow the
+     # correct behaviour of other tests. Thus we explicitly jump to the first
+     # line when we require so.
+     vim.feedkeys 'i\<CR>\<CR>\<ESC>'
+   }
+   it "it does not indent to bracket in byte string" do
+     vim.feedkeys 'ireg = b"["\<Esc>'
+     vim.echo('map(synstack(line("."), col(".")), "synIDattr(v:val, \"name\")")'
+             ).should == "['pythonBytes']"
+     vim.feedkeys 'o'
+     indent.should == 0
+   end
+   it "it indents backslash continuation correctly" do
+     vim.feedkeys 'iwith foo, \<Bslash>\<Esc>'
+     vim.echo('getline(".")').should == "with foo, \\"
+     vim.echo('map(synstack(line("."), col(".")), "synIDattr(v:val, \"name\")")'
+             ).should == "['pythonBytesEscape']"
+     vim.feedkeys 'o'
+     indent.should == 8
+   end
+ end
index 0000000000000000000000000000000000000000,03dcbb2ac02d3a79a6490575f9838dee28652963..03dcbb2ac02d3a79a6490575f9838dee28652963
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,36 +1,36 @@@
+ require "spec_helper"
+ describe "vim for cython" do
+   before(:all) {
+     vim.command "new"
+     vim.command "set ft=cython"
+     vim.command("set indentexpr?").should include "GetPythonPEPIndent("
+   }
+   before(:each) {
+     # clear buffer
+     vim.normal 'gg"_dG'
+     # Insert two blank lines.
+     # The first line is a corner case in this plugin that would shadow the
+     # correct behaviour of other tests. Thus we explicitly jump to the first
+     # line when we require so.
+     vim.feedkeys 'i\<CR>\<CR>\<ESC>'
+   }
+   after(:all) {
+     vim.command "bwipe!"
+   }
+   describe "when using a cdef function definition" do
+       it "indents shiftwidth spaces" do
+           vim.feedkeys 'icdef long_function_name(\<CR>arg'
+           indent.should == shiftwidth
+       end
+   end
+   describe "when using a cpdef function definition" do
+       it "indents shiftwidth spaces" do
+           vim.feedkeys 'icpdef long_function_name(\<CR>arg'
+           indent.should == shiftwidth
+       end
+   end
+ end
index 0000000000000000000000000000000000000000,745e939d65894c48d01da9341c298c076cb17fe8..745e939d65894c48d01da9341c298c076cb17fe8
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,796 +1,796 @@@
+ require "spec_helper"
+ shared_examples_for "vim" do
+   before(:each) {
+     # clear buffer
+     vim.normal 'gg"_dG'
+     # Insert two blank lines.
+     # The first line is a corner case in this plugin that would shadow the
+     # correct behaviour of other tests. Thus we explicitly jump to the first
+     # line when we require so.
+     vim.feedkeys 'i\<CR>\<CR>\<ESC>'
+   }
+   describe "when using the indent plugin" do
+     it "sets the indentexpr and indentkeys options" do
+       vim.command("set indentexpr?").should include "GetPythonPEPIndent("
+       vim.command("set indentkeys?").should include "=elif"
+     end
+     it "sets autoindent and expandtab" do
+       vim.command("set autoindent?").should match(/\s*autoindent/)
+       vim.command("set expandtab?").should match(/\s*expandtab/)
+     end
+   end
+   describe "when entering the first line" do
+     before { vim.feedkeys '0ggipass' }
+     it "does not indent" do
+       indent.should == 0
+       proposed_indent.should == 0
+     end
+     it "does not indent when using '=='" do
+       vim.normal "=="
+       indent.should == 0
+     end
+   end
+   describe "when after a '(' that is at the end of its line" do
+     before { vim.feedkeys 'itest(\<CR>' }
+     it "indents by one level" do
+       proposed_indent.should == shiftwidth
+       vim.feedkeys 'something'
+       indent.should == shiftwidth
+       vim.normal '=='
+       indent.should == shiftwidth
+     end
+     it "puts the closing parenthesis at the same level" do
+       vim.feedkeys ')'
+       indent.should == (hang_closing ? shiftwidth : 0)
+     end
+   end
+   describe "when after an '(' that is followed by something" do
+     before { vim.feedkeys 'itest(something,\<CR>' }
+     it "lines up on following lines" do
+       indent.should == 5
+       vim.feedkeys 'more,\<CR>'
+       indent.should == 5
+     end
+     it "lines up the closing parenthesis" do
+       vim.feedkeys ')'
+       indent.should == 5
+     end
+     it "does not touch the closing parenthesis if it is already indented further" do
+       vim.feedkeys '  )'
+       indent.should == 7
+     end
+   end
+   describe "when after an '{' that is followed by a comment" do
+     before { vim.feedkeys 'imydict = {  # comment\<CR>' }
+     it "indent by one level" do
+       indent.should == shiftwidth
+       vim.feedkeys '1: 1,\<CR>'
+       indent.should == shiftwidth
+     end
+     it "lines up the closing parenthesis" do
+       vim.feedkeys '}'
+       indent.should == (hang_closing ? shiftwidth : 0)
+     end
+   end
+   describe "when using gq to reindent a '(' that is" do
+     before { vim.feedkeys 'itest(' }
+     it "something and has a string without spaces at the end" do
+       vim.feedkeys 'something_very_long_blaaaaaaaaa, "some_very_long_string_blaaaaaaaaaaaaaaaaaaaa"\<esc>gqq'
+       indent.should == 5
+     end
+   end
+   describe "when after multiple parens of different types" do
+     it "indents by one level" do
+       vim.feedkeys 'if({\<CR>'
+       indent.should == shiftwidth
+     end
+     it "lines up with the last paren" do
+       vim.feedkeys 'ifff({123: 456,\<CR>'
+       indent.should == 5
+     end
+   end
+   describe "when '#' is contained in a string that is followed by a colon" do
+     it "indents by one level" do
+         vim.feedkeys 'iif "some#thing" == "test":#test\<CR>pass'
+         indent.should == shiftwidth
+     end
+   end
+   describe "when '#' is not contained in a string and is followed by a colon" do
+     it "does not indent" do
+         vim.feedkeys 'iif "some#thing" == "test"#:test\<CR>'
+         indent.should == 0
+     end
+   end
+   describe "when inside an unfinished string" do
+     it "does not indent" do
+       vim.feedkeys 'i"test:\<ESC>'
+       vim.echo('synIDattr(synID(line("."), col("."), 0), "name")'
+               ).downcase.should include 'string'
+       vim.feedkeys 'a\<CR>'
+       proposed_indent.should == -1
+       indent.should == 0
+     end
+     it "does not dedent" do
+       vim.feedkeys 'iif True:\<CR>"test:\<ESC>'
+       vim.echo('synIDattr(synID(line("."), col("."), 0), "name")'
+               ).downcase.should include 'string'
+       proposed_indent.should == shiftwidth
+       indent.should == shiftwidth
+     end
+   end
+   describe "when the previous line has a colon in a string" do
+     before { vim.feedkeys 'itest(":".join(["1","2"]))\<CR>' }
+     it "does not indent" do
+       vim.feedkeys 'if True:'
+       indent.should == 0
+       proposed_indent.should == 0
+     end
+   end
+   describe "when the previous line has a list slice" do
+     it "does not indent" do
+       vim.feedkeys 'ib = a[2:]\<CR>'
+       indent.should == 0
+       proposed_indent.should == 0
+     end
+   end
+   describe "when line is empty inside a block" do
+     it "is indented like the previous line" do
+       vim.feedkeys 'idef a():\<CR>1\<CR>\<CR>2\<ESC>kcc'
+       indent.should == shiftwidth
+     end
+   end
+   describe "when an empty line is after empty line / before non-empty" do
+     it "is indented like the next line" do
+       vim.feedkeys 'idef a():\<CR>1\<CR>\<CR>\<CR>2\<ESC><<kcc'
+       indent.should == 0
+     end
+   end
+   describe "when an empty line is after empty line / before non-empty (nested)" do
+     it "is indented like the next line" do
+       vim.feedkeys 'idef a():\<CR>1\<CR>\<CR>\<CR>\<ESC>0i\<TAB>2\<ESC>kcc'
+       indent.should == shiftwidth
+     end
+   end
+   describe "when line is empty inside a block following multi-line statement" do
+     it "is indented like the previous line" do
+       vim.feedkeys 'idef a():\<CR>x = (1 +\<CR>2)\<CR>\<CR>y\<ESC>kcc'
+       indent.should == shiftwidth
+     end
+   end
+   describe "when line is empty inside a block following stop statement" do
+     it "is indented like the previous line minus shiftwidth" do
+       vim.feedkeys 'iif x:\<CR>if y:\<CR>pass\<CR>\<CR>z\<ESC>kcc'
+       indent.should == shiftwidth
+     end
+   end
+   describe "when using simple control structures" do
+       it "indents shiftwidth spaces" do
+           vim.feedkeys 'iwhile True:\<CR>pass'
+           indent.should == shiftwidth
+       end
+   end
+   describe "when using a function definition" do
+       it "handles indent with closing parenthesis on same line" do
+           vim.feedkeys 'idef long_function_name(\<CR>arg'
+           indent.should == shiftwidth
+           vim.feedkeys '):'
+           indent.should == shiftwidth * 2
+       end
+       it "handles indent with closing parenthesis on new line" do
+           vim.feedkeys 'idef long_function_name(\<CR>arg'
+           indent.should == shiftwidth
+           vim.feedkeys '\<CR>'
+           indent.should == shiftwidth
+           vim.feedkeys ')'
+           indent.should == (hang_closing ? shiftwidth * 2 : 0)
+           vim.feedkeys ':'
+           indent.should == (hang_closing ? shiftwidth * 2 : 0)
+           vim.feedkeys '\<Esc>k'
+           indent.should == shiftwidth
+       end
+   end
+   describe "when using a class definition" do
+       it "indents shiftwidth spaces" do
+           vim.feedkeys 'iclass Foo(\<CR>'
+           indent.should == shiftwidth
+       end
+   end
+   describe "when writing an 'else' block" do
+     it "aligns to the preceeding 'for' block" do
+       vim.feedkeys 'ifor x in "abc":\<CR>pass\<CR>else:'
+       indent.should == 0
+     end
+     it "aligns to the preceeding 'if' block" do
+       vim.feedkeys 'ifor x in "abc":\<CR>if True:\<CR>pass\<CR>else:'
+       indent.should == shiftwidth
+     end
+   end
+   describe "when using parens and control statements" do
+     it "avoids ambiguity by using extra indentation" do
+       vim.feedkeys 'iif (111 and\<CR>'
+       if shiftwidth == 4
+         indent.should == shiftwidth * 2
+       else
+         indent.should == 4
+       end
+       vim.feedkeys '222):\<CR>'
+       indent.should == shiftwidth
+       vim.feedkeys 'pass\<CR>'
+       indent.should == 0
+     end
+     it "still aligns parens properly if not ambiguous" do
+       vim.feedkeys 'iwhile (111 and\<CR>'
+       indent.should == 7
+       vim.feedkeys '222):\<CR>'
+       indent.should == shiftwidth
+       vim.feedkeys 'pass\<CR>'
+       indent.should == 0
+     end
+     it "handles nested expressions (Flake8's E127)" do
+       vim.feedkeys 'i[\<CR>x for x in foo\<CR>if (\<CR>'
+       indent.should == shiftwidth * 2
+     end
+     it "still handles multiple parens correctly" do
+       vim.feedkeys 'iif (111 and (222 and 333\<CR>'
+       indent.should == 13
+       vim.feedkeys 'and 444\<CR>'
+       indent.should == 13
+       vim.feedkeys ')\<CR>'
+       if shiftwidth == 4
+         indent.should == shiftwidth * 2
+       else
+         indent.should == 4
+       end
+       vim.feedkeys 'and 555):\<CR>'
+       indent.should == shiftwidth
+       vim.feedkeys 'pass\<CR>'
+       indent.should == 0
+     end
+   end
+   describe "when a line breaks with a manual '\\'" do
+     it "indents shiftwidth spaces on normal line" do
+         vim.feedkeys 'ivalue = test + \\\\\<CR>'
+         indent.should == shiftwidth
+     end
+     it "indents 2x shiftwidth spaces for control structures" do
+         vim.feedkeys 'iif somevalue == xyz and \\\\\<CR>'
+         indent.should == shiftwidth * 2
+     end
+     it "indents relative to line above" do
+         vim.feedkeys 'i\<TAB>value = test + \\\\\<CR>'
+         indent.should == shiftwidth * 2
+     end
+   end
+   describe "when current line is dedented compared to previous line" do
+      before { vim.feedkeys 'i\<TAB>\<TAB>if x:\<CR>y = True\<CR>\<ESC>' }
+      it "and current line has a valid indentation (Part 1)" do
+         vim.feedkeys '0i\<TAB>if y:'
+         proposed_indent.should == -1
+      end
+      it "and current line has a valid indentation (Part 2)" do
+         vim.feedkeys '0i\<TAB>\<TAB>if y:'
+         proposed_indent.should == -1
+      end
+      it "and current line has an invalid indentation" do
+         vim.feedkeys 'i    while True:\<CR>'
+         indent.should == previous_indent + shiftwidth
+      end
+   end
+   describe "when current line is dedented compared to the last non-empty line" do
+      before { vim.feedkeys 'i\<TAB>\<TAB>if x:\<CR>y = True\<CR>\<CR>\<ESC>' }
+      it "and current line has a valid indentation" do
+         vim.feedkeys '0i\<TAB>if y:'
+         proposed_indent.should == -1
+      end
+   end
+   describe "when an 'if' is followed by" do
+      before { vim.feedkeys 'i\<TAB>\<TAB>if x:\<CR>' }
+      it "an elif, it lines up with the 'if'" do
+         vim.feedkeys 'elif y:'
+         indent.should == shiftwidth * 2
+      end
+      it "an 'else', it lines up with the 'if'" do
+         vim.feedkeys 'else:'
+         indent.should == shiftwidth * 2
+      end
+   end
+   describe "when an 'if' contains a try-except" do
+      before {
+        vim.feedkeys 'iif x:\<CR>try:\<CR>pass\<CR>except:\<CR>pass\<CR>'
+        indent.should == shiftwidth
+      }
+      it "an 'else' should be indented to the try" do
+        vim.feedkeys 'else:'
+        indent.should == shiftwidth
+        proposed_indent.should == shiftwidth
+      end
+      it "an 'else' should keep the indent of the 'if'" do
+        vim.feedkeys 'else:\<ESC><<'
+        indent.should == 0
+        proposed_indent.should == 0
+      end
+   end
+   describe "when a 'for' is followed by" do
+      before { vim.feedkeys 'i\<TAB>\<TAB>for x in y:\<CR>' }
+      it "an 'else', it lines up with the 'for'" do
+         vim.feedkeys 'else:'
+         indent.should == shiftwidth * 2
+      end
+   end
+   describe "when an 'else' is followed by" do
+      before { vim.feedkeys 'i\<TAB>\<TAB>else:\<CR>XXX\<CR>' }
+      it "a 'finally', it lines up with the 'else'" do
+         vim.feedkeys 'finally:'
+         indent.should == shiftwidth * 2
+      end
+   end
+   describe "when a 'try' is followed by" do
+      before { vim.feedkeys 'i\<TAB>\<TAB>try:\<CR>' }
+      it "an 'except', it lines up with the 'try'" do
+         vim.feedkeys 'except:'
+         indent.should == shiftwidth * 2
+      end
+      it "an 'else', it lines up with the 'try'" do
+         vim.feedkeys 'else:'
+         indent.should == shiftwidth * 2
+      end
+      it "a 'finally', it lines up with the 'try'" do
+         vim.feedkeys 'finally:'
+         indent.should == shiftwidth * 2
+      end
+   end
+   describe "when an 'except' is followed by" do
+      before { vim.feedkeys 'i\<TAB>\<TAB>except:\<CR>' }
+      it "an 'else', it lines up with the 'except'" do
+         vim.feedkeys 'else:'
+         indent.should == shiftwidth * 2
+      end
+      it "another 'except', it lines up with the previous 'except'" do
+         vim.feedkeys 'except:'
+         indent.should == shiftwidth * 2
+      end
+      it "a 'finally', it lines up with the 'except'" do
+         vim.feedkeys 'finally:'
+         indent.should == shiftwidth * 2
+      end
+   end
+   describe "when an else is used inside of a nested if" do
+     before { vim.feedkeys 'iif foo:\<CR>if bar:\<CR>pass\<CR>' }
+     it "indents the else to the inner if" do
+       vim.feedkeys 'else:'
+       indent.should == shiftwidth
+     end
+   end
+   describe "when an else is used outside of a nested if" do
+     before { vim.feedkeys 'iif True:\<CR>if True:\<CR>pass\<CR>\<Esc>0' }
+     it "indents the else to the outer if" do
+       indent.should == 0
+       proposed_indent.should == shiftwidth
+       vim.feedkeys 'ielse:'
+       indent.should == 0
+       proposed_indent.should == 0
+     end
+   end
+   describe "when jedi-vim call signatures are used" do
+     before { vim.command 'syn match jediFunction "JEDI_CALL_SIGNATURE" keepend extend' }
+     it "ignores the call signature after a colon" do
+       vim.feedkeys 'iif True:  JEDI_CALL_SIGNATURE\<CR>'
+       indent.should == shiftwidth
+     end
+     it "ignores the call signature after a function" do
+       vim.feedkeys 'idef f(  JEDI_CALL_SIGNATURE\<CR>'
+       indent.should == shiftwidth
+     end
+   end
+ end
+ shared_examples_for "multiline strings" do
+   before(:each) {
+     # clear buffer
+     vim.normal 'gg"_dG'
+     # Insert two blank lines.
+     # The first line is a corner case in this plugin that would shadow the
+     # correct behaviour of other tests. Thus we explicitly jump to the first
+     # line when we require so.
+     vim.feedkeys 'i\<CR>\<CR>\<ESC>'
+   }
+   describe "when after an '(' that is followed by an unfinished string" do
+     before { vim.feedkeys 'itest("""' }
+     it "it indents the next line" do
+       vim.feedkeys '\<CR>'
+       expected_proposed, expected_indent = multiline_indent(0, shiftwidth)
+       proposed_indent.should == expected_proposed
+       indent.should == expected_indent
+     end
+     it "with contents it indents the second line to the parenthesis" do
+       vim.feedkeys 'second line\<CR>'
+       expected_proposed, expected_indent = multiline_indent(0, 5)
+       proposed_indent.should == expected_proposed
+       indent.should == expected_indent
+     end
+   end
+   describe "when after assigning an unfinished string" do
+     before { vim.feedkeys 'itest = """' }
+     it "it indents the next line" do
+       vim.feedkeys '\<CR>'
+       expected_proposed, expected_indent = multiline_indent(0, shiftwidth)
+       proposed_indent.should == expected_proposed
+       indent.should == expected_indent
+     end
+   end
+   describe "when after assigning an indented unfinished string" do
+     before { vim.feedkeys 'i    test = """' }
+     it "it indents the next line" do
+       vim.feedkeys '\<CR>'
+       expected_proposed, expected_indent = multiline_indent(4, shiftwidth + 4)
+       proposed_indent.should == expected_proposed
+       indent.should == expected_indent
+     end
+   end
+   describe "when after assigning an indented finished string" do
+     before { vim.feedkeys 'i    test = ""' }
+     it "it does indent the next line" do
+       vim.feedkeys '\<CR>'
+       indent.should == 4
+     end
+     it "and writing a new string, it does indent the next line" do
+       vim.feedkeys '\<CR>""'
+       indent.should == 4
+     end
+   end
+   describe "when after a docstring" do
+     it "it does indent the next line to the docstring" do
+       vim.feedkeys 'i    """\<CR>'
+       indent.should == 4
+       proposed_indent.should == 4
+     end
+     it "indents the closing docstring quotes" do
+       vim.feedkeys 'i    """\<CR>\<CR>"""'
+       indent.should == 4
+       proposed_indent.should == 4
+       vim.echo('getline(3)').should == '    """'
+     end
+     it "indents non-matching docstring quotes" do
+       vim.feedkeys 'i    """\<CR>\<Esc>'
+       vim.feedkeys "0C'''"
+       vim.echo('line(".")').should == "4"
+       vim.echo('getline(".")').should == "'''"
+       indent.should == 0
+       proposed_indent.should == -1
+     end
+   end
+   describe "when after a docstring with contents" do
+     before { vim.feedkeys 'i    """First line' }
+     it "it does indent the next line to the docstring" do
+       vim.feedkeys '\<CR>'
+       indent.should == 4
+       proposed_indent.should == 4
+     end
+   end
+   describe "when breaking a string after opening parenthesis" do
+     before { vim.feedkeys 'i    foo("""bar\<Left>\<Left>\<Left>' }
+     it "it does indent the next line as after an opening multistring" do
+       vim.feedkeys '\<CR>'
+       _, expected_indent = multiline_indent(4, 4 + shiftwidth)
+       indent.should == expected_indent
+       proposed_indent.should == -1
+       # it keeps the indent after an empty line
+       vim.feedkeys '\<CR>'
+       proposed_indent, expected_indent = multiline_indent(4, 4 + shiftwidth)
+       indent.should == expected_indent
+       proposed_indent.should == proposed_indent
+       # it keeps the indent of nonblank above
+       vim.feedkeys '\<End>\<CR>'
+       proposed_indent, expected_indent = multiline_indent(4, 4 + shiftwidth)
+       indent.should == expected_indent
+       proposed_indent.should == proposed_indent
+       # it keeps the indent of nonblank above before an empty line
+       vim.feedkeys '\<CR>'
+       proposed_indent, expected_indent = multiline_indent(4, 4 + shiftwidth)
+       indent.should == expected_indent
+       proposed_indent.should == proposed_indent
+     end
+   end
+ end
+ SUITE_SHIFTWIDTHS = [4, 3]
+ SUITE_HANG_CLOSINGS = [false, true]
+ SUITE_SHIFTWIDTHS.each do |sw|
+   describe "vim when using width of #{sw}" do
+     before {
+       vim.command("set sw=#{sw} ts=#{sw} sts=#{sw} et")
+     }
+     it "sets shiftwidth to #{sw}" do
+       shiftwidth.should == sw
+     end
+     SUITE_HANG_CLOSINGS.each do |hc|
+       describe "vim when hang_closing is set to #{hc}" do
+         before {
+           set_hang_closing hc
+         }
+         it "sets hang_closing to #{hc}" do
+           hang_closing.should == !!hc
+         end
+         it_behaves_like "vim"
+       end
+     end
+   end
+ end
+ describe "vim when not using python_pep8_indent_multiline_string" do
+   before {
+     vim.command("set sw=4 ts=4 sts=4 et")
+     vim.command("unlet! g:python_pep8_indent_multiline_string")
+   }
+   it_behaves_like "multiline strings"
+ end
+ describe "vim when using python_pep8_indent_multiline_first=0" do
+   before {
+     vim.command("set sw=4 ts=4 sts=4 et")
+     vim.command("let g:python_pep8_indent_multiline_string=0")
+   }
+   it_behaves_like "multiline strings"
+ end
+ describe "vim when using python_pep8_indent_multiline_string=-1" do
+   before {
+     vim.command("set sw=4 ts=4 sts=4 et")
+     vim.command("let g:python_pep8_indent_multiline_string=-1")
+   }
+   it_behaves_like "multiline strings"
+ end
+ describe "vim when using python_pep8_indent_multiline_string=-2" do
+   before {
+     vim.command("set sw=4 ts=4 sts=4 et")
+     vim.command("let g:python_pep8_indent_multiline_string=-2")
+   }
+   it_behaves_like "multiline strings"
+ end
+ describe "Handles far away opening parens" do
+   before { vim.feedkeys '\<ESC>ggdGifrom foo import (' }
+   it "indents by one level" do
+     vim.feedkeys '\<CR>'
+     proposed_indent.should == shiftwidth
+   end
+   it "indents by one level for 10 lines" do
+     vim.command('set paste | exe "norm 9o" | set nopaste')
+     vim.feedkeys '\<Esc>o'
+     indent.should == shiftwidth
+   end
+   it "indents by one level for 50 lines" do
+     vim.command('set paste | exe "norm 49o" | set nopaste')
+     vim.feedkeys '\<Esc>o'
+     indent.should == shiftwidth
+   end
+ end
+ describe "Handles far away opening square brackets" do
+   before { vim.feedkeys '\<ESC>ggdGibar = [' }
+   it "indents by one level" do
+     vim.feedkeys '\<CR>'
+     proposed_indent.should == shiftwidth
+   end
+   it "indents by one level for 10 lines" do
+     vim.command('set paste | exe "norm 9o" | set nopaste')
+     vim.feedkeys '\<Esc>o'
+     indent.should == shiftwidth
+   end
+   it "indents by one level for 100 lines" do
+     vim.command('set paste | exe "norm 99o" | set nopaste')
+     vim.feedkeys '\<Esc>o'
+     indent.should == shiftwidth
+   end
+ end
+ describe "Handles far away opening curly brackets" do
+   before { vim.feedkeys '\<ESC>ggdGijson = {' }
+   it "indents by one level" do
+     vim.feedkeys '\<CR>'
+     vim.feedkeys '\<Esc>o'
+     proposed_indent.should == shiftwidth
+   end
+   it "indents by one level for 10 lines" do
+     vim.command('set paste | exe "norm 9o" | set nopaste')
+     vim.feedkeys '\<Esc>o'
+     indent.should == shiftwidth
+   end
+   it "indents by one level for 1000 lines" do
+     vim.command('set paste | exe "norm 999o" | set nopaste')
+     vim.feedkeys '\<Esc>o'
+     indent.should == shiftwidth
+   end
+ end
+ describe "Compact multiline dict" do
+   before { vim.feedkeys '\<ESC>ggdGid = {"one": 1,' }
+   it "gets indented correctly" do
+     vim.feedkeys '\<CR>'
+     proposed_indent.should == 5
+     vim.feedkeys '"two": 2}'
+     proposed_indent.should == 5
+     vim.feedkeys '\<CR>'
+     proposed_indent.should == 0
+   end
+ end
+ describe "Using O" do
+   before {
+     vim.feedkeys '\<ESC>ggdG'
+     vim.feedkeys 'iif foo:\<CR>'
+   }
+   it "respects autoindent" do
+     vim.feedkeys '1\<CR>\<CR>'
+     indent.should == shiftwidth
+     vim.feedkeys '\<Esc>ko'
+     indent.should == shiftwidth
+     vim.feedkeys '\<Esc>kO'
+     indent.should == shiftwidth
+     # Uses/keeps indent from line above
+     vim.feedkeys '\<Esc>i2\<Esc>O'
+     indent.should == shiftwidth
+     # Uses/keeps indent from line above
+     vim.feedkeys '\<Esc>j\<Esc>O'
+     indent.should == 0
+   end
+ end
+ describe "searchpairpos" do
+   before { vim.feedkeys '\<ESC>ggdG' }
+   it "handles nested parenthesis" do
+     vim.feedkeys 'iif foo.startswith("("):\<CR>'
+     indent.should == shiftwidth
+   end
+ end
+ describe "o within TODO" do
+   before {
+     vim.feedkeys '\<ESC>ggdG'
+     vim.feedkeys 'iif 1:  # TODO\<Esc>'
+     # Assertion that we have a pythonTodo here.
+     vim.echo('synIDattr(synID(line("."), col("."), 0), "name")').should match 'pythonTodo'
+   }
+   it "respects autoindent" do
+     vim.feedkeys 'o'
+     indent.should == shiftwidth
+   end
+ end
+ describe "elif after else" do
+   before {
+     vim.feedkeys '\<ESC>ggdG'
+   }
+   it "is indented to the outer if" do
+     vim.feedkeys 'iif 1:\<CR>if 2:\<CR>pass\<CR>else:\<CR>pass\<CR>elif 3:\<Esc>'
+     indent.should == 0
+     vim.feedkeys '\<ESC>ggdG'
+     vim.feedkeys 'i    if 1:\<CR>if 2:\<CR>pass\<CR>else:\<CR>pass\<CR>elif 3:\<Esc>'
+     indent.should == 4
+   end
+ end
+ describe "elif after two ifs" do
+   before {
+     vim.feedkeys '\<ESC>ggdG'
+   }
+   it "keeps its indent to the outer if" do
+     vim.feedkeys 'iif 1:\<CR>if 2:\<CR>pass\<CR>elif 3:\<CR>pass\<CR>'
+     indent.should == 4
+     vim.feedkeys '\<Esc>'
+     indent.should == 0
+     proposed_indent.should == shiftwidth
+     vim.feedkeys 'ielif 4:'
+     indent.should == 0
+     proposed_indent.should == 0
+     vim.feedkeys '\<CR>'
+     indent.should == 4
+     proposed_indent.should == 4
+   end
+ end
index 0000000000000000000000000000000000000000,f425496aa2d27f68af73a6f4946cbf12c151bd2e..f425496aa2d27f68af73a6f4946cbf12c151bd2e
mode 000000,100755..100755
--- /dev/null
@@@ -1,0 -1,24 +1,24 @@@
+ #!/bin/sh
+ set -ex
+ rm -f .coverage_covimerage
+ export PYTHON_PEP8_INDENT_TEST_PROFILE_BASE=/tmp/vim-python-pep8-profile
+ Xvfb :99 2>/dev/null >&2 &
+ export DISPLAY=:99
+ export VIMRUNNER_REUSE_SERVER=1
+ ret=0
+ for file in ./spec/indent/*_spec.rb; do
+   # shellcheck disable=SC2086
+   bundle exec rspec "$file" $RSPEC_OPTIONS || ret=1
+   for p in "${PYTHON_PEP8_INDENT_TEST_PROFILE_BASE}".*; do
+     covimerage write_coverage --append "$p"
+     rm "$p"
+     covimerage report -m
+   done
+ done
+ exit $ret
index 0000000000000000000000000000000000000000,c6cc517499d01a33c790071ea63d7f8254064441..c6cc517499d01a33c790071ea63d7f8254064441
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,70 +1,70 @@@
+ require 'vimrunner'
+ require 'vimrunner/rspec'
+ require 'vimrunner/server'
+ # Explicitly enable usage of "should".
+ RSpec.configure do |config|
+     config.expect_with(:rspec) { |c| c.syntax = :should }
+ end
+ Vimrunner::RSpec.configure do |config|
+   # Use a single Vim instance for the test suite. Set to false to use an
+   # instance per test (slower, but can be easier to manage).
+   # This requires using gvim, otherwise it hangs after a few tests.
+   config.reuse_server = ENV['VIMRUNNER_REUSE_SERVER'] == '1' ? true : false
+   config.start_vim do
+     exe = config.reuse_server ? Vimrunner::Platform.gvim : Vimrunner::Platform.vim
+     vimrc = File.expand_path("../vimrc", __FILE__)
+     vim = Vimrunner::Server.new(:executable => exe,
+                                 :vimrc => vimrc).start
+     # More friendly killing.
+     # Otherwise profiling information might not be written.
+     def vim.kill
+       normal(':qall!<CR>')
+       Timeout.timeout(5) do
+         sleep 0.1 while server.running?
+       end
+     end
+     plugin_path = File.expand_path('../..', __FILE__)
+     vim.command "set rtp^=#{plugin_path}"
+     vim.command "set filetype=python"
+     def shiftwidth
+       @shiftwidth ||= vim.echo("exists('*shiftwidth') ? shiftwidth() : &sw").to_i
+     end
+     def tabstop
+       @tabstop ||= vim.echo("&tabstop").to_i
+     end
+     def indent
+       vim.echo("indent('.')").to_i
+     end
+     def previous_indent
+       pline = vim.echo("line('.')").to_i - 1
+       vim.echo("indent('#{pline}')").to_i
+     end
+     def proposed_indent
+       line = vim.echo("line('.')")
+       col = vim.echo("col('.')")
+       indent_value = vim.echo("GetPythonPEPIndent(#{line})").to_i
+       vim.command("call cursor(#{line}, #{col})")
+       return indent_value
+     end
+     def multiline_indent(prev, default)
+       i = vim.echo("get(g:, 'python_pep8_indent_multiline_string', 0)").to_i
+       return (i == -2 ? default : i), i < 0 ? (i == -1 ? prev : default) : i
+     end
+     def hang_closing
+       i = vim.echo("get(g:, 'python_pep8_indent_hang_closing', 0)").to_i
+       return (i != 0)
+     end
+     def set_hang_closing(value)
+       i = value ? 1 : 0
+       vim.command("let g:python_pep8_indent_hang_closing=#{i}")
+     end
+     vim
+   end
+ end
index 0000000000000000000000000000000000000000,e549f80edfc5e83cefe4103f29b67bf20a71b255..e549f80edfc5e83cefe4103f29b67bf20a71b255
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,22 +1,22 @@@
+ " vint: -ProhibitSetNoCompatible
+ set nocompatible
+ filetype plugin on
+ filetype indent on
+ syntax on
+ set noswapfile nobackup
+ " remove default ~/.vim directories to avoid loading plugins
+ set runtimepath-=~/.vim
+ set runtimepath-=~/.vim/after
+ let sfile = expand('<sfile>')
+ let plugin_path = fnamemodify(sfile, ':p:h:h')
+ exe 'set runtimepath^='.plugin_path
+ if !empty($PYTHON_PEP8_INDENT_TEST_PROFILE_BASE)
+   execute printf('profile start %s.%s',
+         \ $PYTHON_PEP8_INDENT_TEST_PROFILE_BASE, getpid())
+   execute 'profile! file '. plugin_path . '/indent/python.vim'
+ endif