pax_global_header00006660000000000000000000000064135613376520014525gustar00rootroot0000000000000052 comment=ad716f1df4f89589c0b13b9a39e68a10adba5e13 vim-airline-0.11/000077500000000000000000000000001356133765200136625ustar00rootroot00000000000000vim-airline-0.11/.gitignore000066400000000000000000000000421356133765200156460ustar00rootroot00000000000000doc/tags *.lock .vim-flavor *.swp vim-airline-0.11/.travis.yml000066400000000000000000000010201356133765200157640ustar00rootroot00000000000000language: ruby before_install: - curl -f -L "https://raw.githubusercontent.com/vim-airline/vim-airline-themes/master/autoload/airline/themes/simple.vim" -o autoload/airline/themes/simple.vim - curl -f -L "https://raw.githubusercontent.com/vim-airline/vim-airline-themes/master/autoload/airline/themes/molokai.vim" -o autoload/airline/themes/molokai.vim - mkdir colors && curl -f -L 'https://raw.githubusercontent.com/tomasr/molokai/master/colors/molokai.vim' -o colors/molokai.vim #rvm: # - 1.9.3 script: rake ci vim-airline-0.11/CHANGELOG.md000066400000000000000000000266141356133765200155040ustar00rootroot00000000000000# Change Log This is the Changelog for the vim-airline project. ## [0.12] - Unreleased ## [0.11] - 2019-11-10 - New features - Extensions: - [Coc](https://github.com/neoclide/coc.nvim) support - [Defx](https://github.com/Shougo/defx.nvim) support - [gina](https://github.com/lambdalisue/gina.vim) support - [vim-bookmark](https://github.com/MattesGroeger/vim-bookmarks) support - [vista.vim](https://github.com/liuchengxu/vista.vim) support - [tabws](https://github.com/s1341/vim-tabws) support for the tabline - Improvements - The statusline can be configured to be shown on top (in the tabline) Set the `g:airline_statusline_ontop` to enable this experimental feature. - If `buffer_idx_mode=2`, up to 89 mappings will be exposed to access more buffers directly (issue [#1823](https://github.com/vim-airline/vim-airline/issues/1823)) - Allow to use `random` as special theme name, which will switch to a random airline theme (at least if a random number can be generated :() - The branch extensions now also displays whether the repository is in a clean state (will append a ! or ⚡if the repository is considered dirty). - The whitespace extensions will also check for conflict markers - `:AirlineRefresh` command now takes an additional `!` attribute, that **skips** recreating the highlighting groups (which might have a serious performance impact if done very often, as might be the case when the configuration variable `airline_skip_empty_sections` is active). - airline can now also detect multiple cursor mode (issue [#1933](https://github.com/vim-airline/vim-airline/issues/1933)) - expose hunks output using the function `airline#extensions#hunks#get_raw_hunks()` to the outside [#1877](https://github.com/vim-airline/vim-airline/pull/1877) - expose wordcount affected filetype list to the public using the `airline#extensions#wordcount#filetypes` variable [#1887](https://github.com/vim-airline/vim-airline/pull/1887) - for the `:AirlineExtension` command, indicate whether the extension has been loaded from an external source [#1890](https://github.com/vim-airline/vim-airline/issues/1890) - correctly load custom wordcount formatters [#1896](https://github.com/vim-airline/vim-airline/issues/1896) - add a new short_path formatter for the tabline [#1898](https://github.com/vim-airline/vim-airline/pull/1898) - several improvements to the branch, denite and tabline extension, as well as the async code for Vim and Neovim - the term extension supports [neoterm](https://github.com/kassio/neoterm) vim plugin ## [0.10] - 2018-12-15 - New features - Extensions: - [LanguageClient](https://github.com/autozimu/LanguageClient-neovim) - [vim-gutentags](https://github.com/ludovicchabant/vim-gutentags) - [vim-localsearch](https://github.com/mox-mox/vim-localsearch) - [xtabline](https://github.com/mg979/vim-xtabline) - [vim-grepper](https://github.com/mhinz/vim-grepper) - Add custom AirlineModeChanged autocommand, allowing to call user defined commands whenever airline displays a different mode - New :AirlineExtensions command, to show which extensions have been loaded - Detect several new modes (e.g. completion, virtual replace, etc) - Improvements - Various performance improvements, should Vim keep responsive, even when many highlighting groups need to be re-created - Rework tabline extension - Refactor [vim-ctrlspace](https://github.com/szw/vim-ctrlspace) extension - Refactor the wordcount extension - Reworked the po extension - Allow to disable line numbers for the [Ale Extension](https://github.com/w0rp/ale) - [fugitive](https://github.com/tpope/vim-fugitive) plugin has been refactored causing adjustments for vim-airline, also uses Fugitives new API calls - some improvements to Vims terminal mode - Allow to use alternative seperators for inactive windows ([#1236](https://github.com/vim-airline/vim-airline/issues/1236)) - Statusline can be set to inactive, whenever Vim loses focus (using FocusLost autocommand) ## [0.9] - 2018-01-15 - Changes - Look of default Airline Symbols has been improved [#1397](https://github.com/vim-airline/vim-airline/issues/1397) - Airline does now set `laststatus=2` if needed - Syntastic extension now displays warnings and errors separately - Updates on Resize and SessionLoad events - Add `maxlinenr` symbol to `airline_section_z` - Add quickfix title to inactive windows - Improvements - Many performance improvements (using caching and async feature when possible) - Cache changes to highlighting groups if `g:airline_highlighting_cache = 1` is set - Allow to skip empty sections by setting `g:airline_skip_empty_sections` variable - Make use of improved Vim Script API, if available (e.g. getwininfo()) - Support for Vims terminal feature (very experimental since it hasn't been stabilized yet) - More configuration for the tabline extension (with clickable buffers for Neovim) - Works better on smaller window sizes - Make airline aware of git worktrees - Improvements to the fugitive extension [#1603](https://github.com/vim-airline/vim-airline/issues/1603) - Allows for configurable fileformat output if `g:airline#parts#ffenc#skip_expected_string` is set - Improvements to the documentation - New features - Full async support for Vim 8 and Neovim - Extensions: - [vim-bufmru](https://github.com/mildred/vim-bufmru) - [xkb-switch](https://github.com/ierton/xkb-switch) - [input-source-switcher](https://github.com/vovkasm/input-source-switcher) - [vimagit](https://github.com/jreybert/vimagit) - [denite](https://github.com/Shougo/denite.nvim) - [dein](https://github.com/Shougo/dein.vim) - [vimtex](https://github.com/lervag/vimtex) - [minpac](https://github.com/k-takata/minpac/) - [vim-cursormode](https://github.com/vheon/vim-cursormode) - [Neomake](https://github.com/neomake/neomake) - [Ale](https://github.com/w0rp/ale) - [vim-obsession](https://github.com/tpope/vim-obsession) - spell (can also display Spell language) - keymap - Formatters: - Formatters for JavaScript [#1617](https://github.com/vim-airline/vim-airline/issues/1617) - Tabline: Allow for custom formatter for `tab_nr_type` [#1418](https://github.com/vim-airline/vim-airline/issues/1418) - Customizable wordcount formatter [#1584](https://github.com/vim-airline/vim-airline/issues/1584) - Add User autocommand for Theme changing [#1226](https://github.com/vim-airline/vim-airline/issues/1226) - Shows mercurial mq status if hg mq extension is enabled ## [0.8] - 2016-03-09 - Changes - Airline converted to an organization and moved to new [repository](https://github.com/vim-airline/vim-airline) - Themes have been split into an separate repository [vim-airline-themes](https://github.com/vim-airline/vim-airline-themes) - Improvements - Extensions - branch: support Git and Mercurial simultaneously, untracked files - whitespace: new mixed-indent rule - Windows support - Many bug fixes - Support for Neovim - New features - Many new themes - Extensions/integration - [taboo](https://github.com/gcmt/taboo.vim) - [vim-ctrlspace](https://github.com/szw/vim-ctrlspace) - [quickfixsigns](https://github.com/tomtom/quickfixsigns_vim) - [YouCompleteMe](https://github.com/Valloric/YouCompleteMe) - [po.vim](http://www.vim.org/scripts/script.php?script_id=695) - [unicode.vim](https://github.com/chrisbra/unicode.vim) - wordcount - crypt indicator - byte order mark indicator - Tabline's tab mode can display splits simultaneously ## [0.7] - 2014-12-10 - New features - accents support; allowing multiple colors/styles in the same section - extensions: eclim - themes: understated, monochrome, murmur, sol, lucius - Improvements - solarized theme; support for 8 color terminals - tabline resizes dynamically based on number of open buffers - miscellaneous bug fixes ## [0.6] - 2013-10-08 - New features - accents support; allowing multiple colors/styles in the same section - extensions: eclim - themes: understated, monochrome, murmur, sol, lucius - Improvements - solarized theme; support for 8 color terminals - tabline resizes dynamically based on number of open buffers - miscellaneous bug fixes ## [0.5] - 2013-09-13 - New features - smart tabline extension which displays all buffers when only one tab is visible - automatic section truncation when the window resizes - support for a declarative style of configuration, allowing parts to contain metadata such as minimum window width or conditional visibility - themes: zenburn, serene - Other - a sizable chunk of vim-airline is now running through a unit testing suite, automated via Travis CI ## [0.4] - 2013-08-26 - New features - integration with csv.vim and vim-virtualenv - hunks extension for vim-gitgutter and vim-signify - automatic theme switching with matching colorschemes - commands: AirlineToggle - themes: base16 (all variants) - Improvements - integration with undotree, tagbar, and unite - Other - refactored core and exposed statusline builder and pipeline - all extension related g:airline_variables have been deprecated in favor of g:airline#extensions# variables - extensions found in the runtimepath outside of the default distribution will be automatically loaded ## [0.3] - 2013-08-12 - New features - first-class integration with tagbar - white space detection for trailing spaces and mixed indentation - introduced warning section for syntastic and white space detection - improved ctrlp integration: colors are automatically selected based on the current airline theme - new themes: molokai, bubblegum, jellybeans, tomorrow - Bug fixes - improved handling of eventignore used by other plugins - Other - code cleaned up for clearer separation between core functionality and extensions - introduced color extraction from highlight groups, allowing themes to be generated off of the active colorscheme (e.g. jellybeans and tomorrow) - License changed to MIT ## [0.2] - 2013-07-28 - New features - iminsert detection - integration with vimshell, vimfiler, commandt, lawrencium - enhanced bufferline theming - support for ctrlp theming - support for custom window excludes - New themes - luna and wombat - Bug fixes - refresh branch name after switching with a shell command ## [0.1] - 2013-07-17 - Initial release - integration with other plugins: netrw, unite, nerdtree, undotree, gundo, tagbar, minibufexplr, ctrlp - support for themes: 8 included [0.12]: https://github.com/vim-airline/vim-airline/compare/v0.11...HEAD [0.11]: https://github.com/vim-airline/vim-airline/compare/v0.10...v.11 [0.10]: https://github.com/vim-airline/vim-airline/compare/v0.9...v0.10 [0.9]: https://github.com/vim-airline/vim-airline/compare/v0.8...v0.9 [0.8]: https://github.com/vim-airline/vim-airline/compare/v0.7...v0.8 [0.7]: https://github.com/vim-airline/vim-airline/compare/v0.6...v0.7 [0.6]: https://github.com/vim-airline/vim-airline/compare/v0.5...v0.6 [0.5]: https://github.com/vim-airline/vim-airline/compare/v0.4...v0.5 [0.4]: https://github.com/vim-airline/vim-airline/compare/v0.3...v0.4 [0.3]: https://github.com/vim-airline/vim-airline/compare/v0.2...v0.3 [0.2]: https://github.com/vim-airline/vim-airline/compare/v0.1...v0.2 [0.1]: https://github.com/vim-airline/vim-airline/releases/tag/v0.1 vim-airline-0.11/CONTRIBUTING.md000066400000000000000000000036231356133765200161170ustar00rootroot00000000000000# Contributions Contributions and pull requests are welcome. Please take note of the following guidelines: * Adhere to the existing style as much as possible; notably, 2 space indents and long-form keywords. * Keep the history clean! Squash your branches before you submit a pull request. `pull --rebase` is your friend. * Any changes to the core should be tested against Vim 7.2. # Bugs Tracking down bugs can take a very long time due to different configurations, versions, and operating systems. To ensure a timely response, please help me out by doing the following: * Reproduce it with this [minivimrc][7] repository to rule out any configuration conflicts. Even better, create a `gist` of your vimrc that is compatible with [pathogen][11]. * And to make it easier to reproduce, please supply the following: * the `:version` of vim * the commit of vim-airline you're using * the OS that you're using, including terminal emulator, GUI vs non-GUI # Themes * If you submit a theme, please create a screenshot so it can be added to the [Wiki][14]. * In the majority of cases, modifications to colors of existing themes will likely be rejected. Themes are a subjective thing, so while you may prefer that a particular color be darker, another user will prefer it to be lighter, or something entirely different. The more popular the theme, the more unlikely the change will be accepted. However, it's pretty simple to create your own theme; copy the theme to `~/.vim/autoload/airline/themes` under a new name with your modifications, and it can be used. # Maintenance If you would like to take a more active role in improving vim-airline, please consider [becoming a maintainer][43]. [7]: https://github.com/bling/minivimrc [11]: https://github.com/tpope/vim-pathogen [14]: https://github.com/vim-airline/vim-airline/wiki/Screenshots [43]: https://github.com/vim-airline/vim-airline/wiki/Becoming-a-Maintainer vim-airline-0.11/Gemfile000066400000000000000000000000711356133765200151530ustar00rootroot00000000000000source 'https://rubygems.org' gem 'vim-flavor', '~> 1.1' vim-airline-0.11/ISSUE_TEMPLATE.md000066400000000000000000000005551356133765200163740ustar00rootroot00000000000000#### environment - vim: ???? - vim-airline: ???? - OS: ???? - Have you reproduced with a minimal vimrc: ??? - What is your airline configuration: ??? if you are using terminal: - terminal: ???? - $TERM variable: ??? - color configuration (:set t_Co?): if you are using Neovim: - does it happen in Vim: ??? #### actual behavior ???? #### expected behavior ???? vim-airline-0.11/LICENSE000066400000000000000000000021271356133765200146710ustar00rootroot00000000000000The MIT License (MIT) Copyright (C) 2013-2019 Bailey Ling, Christian Brabandt, et al. 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. vim-airline-0.11/README.md000066400000000000000000000415461356133765200151530ustar00rootroot00000000000000# vim-airline [![Build Status](https://travis-ci.org/vim-airline/vim-airline.png)](https://travis-ci.org/vim-airline/vim-airline)[![Say Thanks!](https://img.shields.io/badge/Say%20Thanks-!-1EAEDB.svg)](https://saythanks.io/to/chrisbra) Lean & mean status/tabline for vim that's light as air. ![img](https://github.com/vim-airline/vim-airline/wiki/screenshots/demo.gif) When the plugin is correctly loaded, Vim will draw a nice statusline at the bottom of each window. That line consists of several sections, each one displaying some piece of information. By default (without configuration) this line will look like this: ``` +-----------------------------------------------------------------------------+ |~ | |~ | |~ VIM - Vi IMproved | |~ | |~ version 8.0 | |~ by Bram Moolenaar et al. | |~ Vim is open source and freely distributable | |~ | |~ type :h :q to exit | |~ type :help or for on-line help | |~ type :help version8 for version info | |~ | |~ | +-----------------------------------------------------------------------------+ | A | B | C X | Y | Z | [...] | +-----------------------------------------------------------------------------+ ``` The statusline is the colored line at the bottom, which contains the sections (possibly in different colors): section|meaning (example) -------|------------------ A | displays the mode + additional flags like crypt/spell/paste (INSERT) B | VCS information (branch, hunk summary) (master) C | filename + read-only flag (~/.vim/vimrc RO) X | filetype (vim) Y | file encoding[fileformat] (utf-8[unix]) Z | current position in the file [...] | additional sections (warning/errors/statistics) from external plugins (e.g. YCM, syntastic, ...) The information in Section Z looks like this: `10% ☰ 10/100 ln : 20` This means: ``` 10% - 10 percent down the top of the file ☰ 10 - current line 10 /100 ln - of 100 lines : 20 - current column 20 ``` For a better look, those sections can be colored differently, depending on various conditions (e.g. the mode or whether the current file is 'modified') # Features * Tiny core written with extensibility in mind ([open/closed principle][8]). * 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], [quickfixsigns][39], [syntastic][5], [eclim][34], [lawrencium][21], [virtualenv][31], [tmuxline][35], [taboo.vim][37], [ctrlspace][38], [vim-bufmru][47], [vimagit][50], [denite][51] and more. * 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 color schemes including [solarized][23] (dark and light), [tomorrow][24] (all variants), [base16][32] (all variants), [molokai][25], [jellybeans][26] and others. Note these are now external to this plugin. See [below][46] for detail. * 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. ## Straightforward customization If you don't like the defaults, you can replace all sections with standard `statusline` syntax. Give your statusline that you've built over the years a face lift. ![image](https://f.cloud.github.com/assets/306502/1009429/d69306da-0b38-11e3-94bf-7c6e3eef41e9.png) ## Themes Themes have moved to another repository as of [this commit][45]. Install the themes as you would this plugin (Vundle example): ```vim Plugin 'vim-airline/vim-airline' Plugin 'vim-airline/vim-airline-themes' ``` See https://github.com/vim-airline/vim-airline-themes for more. ## Automatic truncation Sections and parts within sections can be configured to automatically hide when the window size shrinks. ![image](https://f.cloud.github.com/assets/306502/1060831/05c08aac-11bc-11e3-8470-a506a3037f45.png) ## Smarter tab line Automatically displays all buffers when there's only one tab open. ![tabline](https://f.cloud.github.com/assets/306502/1072623/44c292a0-1495-11e3-9ce6-dcada3f1c536.gif) This is disabled by default; add the following to your vimrc to enable the extension: let g:airline#extensions#tabline#enabled = 1 Separators can be configured independently for the tabline, so here is how you can define "straight" tabs: let g:airline#extensions#tabline#left_sep = ' ' let g:airline#extensions#tabline#left_alt_sep = '|' In addition, you can also choose which path formatter airline uses. This affects how file paths are displayed in each individual tab as well as the current buffer indicator in the upper right. To do so, set the `formatter` field with: let g:airline#extensions#tabline#formatter = 'default' Here is a complete list of formatters with screenshots: #### `default` ![image](https://user-images.githubusercontent.com/2652762/34422844-1d005efa-ebe6-11e7-8053-c784c0da7ba7.png) #### `jsformatter` ![image](https://user-images.githubusercontent.com/2652762/34422843-1cf6a4d2-ebe6-11e7-810a-07e6eb08de24.png) #### `unique_tail` ![image](https://user-images.githubusercontent.com/2652762/34422841-1ce5b4ec-ebe6-11e7-86e9-3d45c876068b.png) #### `unique_tail_improved` ![image](https://user-images.githubusercontent.com/2652762/34422842-1cee23f2-ebe6-11e7-962d-97e068873077.png) ## Seamless integration vim-airline integrates with a variety of plugins out of the box. These extensions will be lazily loaded if and only if you have the other plugins installed (and of course you can turn them off). #### [ctrlp.vim][10] ![image](https://f.cloud.github.com/assets/306502/962258/7345a224-04ec-11e3-8b5a-f11724a47437.png) #### [unite.vim][9] ![image](https://f.cloud.github.com/assets/306502/962319/4d7d3a7e-04ed-11e3-9d59-ab29cb310ff8.png) #### [denite.nvim][51] ![image](https://cloud.githubusercontent.com/assets/246230/23939717/f65bce6e-099c-11e7-85c3-918dbc839392.png) #### [tagbar][19] ![image](https://f.cloud.github.com/assets/306502/962150/7e7bfae6-04ea-11e3-9e28-32af206aed80.png) #### [csv.vim][28] ![image](https://f.cloud.github.com/assets/306502/962204/cfc1210a-04eb-11e3-8a93-42e6bcd21efa.png) #### [syntastic][5] ![image](https://f.cloud.github.com/assets/306502/962864/9824c484-04f7-11e3-9928-da94f8c7da5a.png) #### hunks ([vim-gitgutter][29] & [vim-signify][30]) ![image](https://f.cloud.github.com/assets/306502/995185/73fc7054-09b9-11e3-9d45-618406c6ed98.png) #### [vimagit][50] ![vim-airline-vimagit-demo](https://cloud.githubusercontent.com/assets/533068/22107273/2ea85ba0-de4d-11e6-9fa8-331103b88df4.gif) #### [virtualenv][31] ![image](https://f.cloud.github.com/assets/390964/1022566/cf81f830-0d98-11e3-904f-cf4fe3ce201e.png) #### [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) #### [ctrlspace][38] ![papercolor_with_ctrlspace](https://cloud.githubusercontent.com/assets/493242/12912041/7fc3c6ec-cf16-11e5-8775-8492b9c64ebf.png) #### [xkb-switch][48]/[xkb-layout][49] ![image](https://cloud.githubusercontent.com/assets/5715281/22061422/347e7842-ddb8-11e6-8bdb-7abbd418653c.gif) #### [vimtex][53] ![image](https://cloud.githubusercontent.com/assets/1798172/25799740/e77d5c2e-33ee-11e7-8660-d34ce4c5f13f.png) #### [localsearch][54] ![image](https://raw.githubusercontent.com/mox-mox/vim-localsearch/master/vim-airline-localsearch-indicator.png) #### [LanguageClient][57] ![image](https://user-images.githubusercontent.com/9622/45275524-52f45c00-b48b-11e8-8b83-a66240b10747.gif) ## Extras vim-airline also supplies some supplementary stand-alone extensions. In addition to the tabline extension mentioned earlier, there is also: #### whitespace ![image](https://f.cloud.github.com/assets/306502/962401/2a75385e-04ef-11e3-935c-e3b9f0e954cc.png) ### statusline on top The statusline can alternatively by drawn on top, making room for other plugins to use the statusline: The example shows a custom statusline setting, that imitates Vims default statusline, while allowing to call custom functions. Use `:let g:airline_statusline_ontop=1` to enable it. ![image](https://i.imgur.com/tW1lMRU.png) ## Configurable and extensible #### Fine-tuned configuration Every section is composed of parts, and you can reorder and reconfigure them at will. ![image](https://f.cloud.github.com/assets/306502/1073278/f291dd4c-14a3-11e3-8a83-268e2753f97d.png) Sections can contain accents, which allows for very granular control of visuals (see configuration [here](https://github.com/vim-airline/vim-airline/issues/299#issuecomment-25772886)). ![image](https://f.cloud.github.com/assets/306502/1195815/4bfa38d0-249d-11e3-823e-773cfc2ca894.png) #### Extensible pipeline Completely transform the statusline to your liking. Build out the statusline as you see fit by extracting colors from the current colorscheme's highlight groups. ![allyourbase](https://f.cloud.github.com/assets/306502/1022714/e150034a-0da7-11e3-94a5-ca9d58a297e8.png) # Rationale There's already [powerline][2], why yet another statusline? * 100% vimscript; no python needed. What about [vim-powerline][1]? * vim-powerline has been deprecated in favor of the newer, unifying powerline, which is under active development; the new version is written in python at the core and exposes various bindings such that it can style statuslines not only in vim, but also tmux, bash, zsh, and others. # Where did the name come from? I wrote the initial version on an airplane, and since it's light as air it turned out to be a good name. Thanks for flying vim! # Installation This plugin follows the standard runtime path structure, and as such it can be installed with a variety of plugin managers: | Plugin Manager | Install with... | | ------------- | ------------- | | [Pathogen][11] | `git clone https://github.com/vim-airline/vim-airline ~/.vim/bundle/vim-airline`
Remember to run `:Helptags` to generate help tags | | [NeoBundle][12] | `NeoBundle 'vim-airline/vim-airline'` | | [Vundle][13] | `Plugin 'vim-airline/vim-airline'` | | [Plug][40] | `Plug 'vim-airline/vim-airline'` | | [VAM][22] | `call vam#ActivateAddons([ 'vim-airline' ])` | | [Dein][52] | `call dein#add('vim-airline/vim-airline')` | | [minpac][55] | `call minpac#add('vim-airline/vim-airline')` | | pack feature (native Vim 8 package feature)| `git clone https://github.com/vim-airline/vim-airline ~/.vim/pack/dist/start/vim-airline`
Remember to run `:helptags` to generate help tags | | manual | copy all of the files into your `~/.vim` directory | # Documentation `:help airline` # Integrating with powerline fonts For the nice looking powerline symbols to appear, you will need to install a patched font. Instructions can be found in the official powerline [documentation][20]. Prepatched fonts can be found in the [powerline-fonts][3] repository. Finally, you can add the convenience variable `let g:airline_powerline_fonts = 1` to your vimrc which will automatically populate the `g:airline_symbols` dictionary with the powerline symbols. # FAQ Solutions to common problems can be found in the [Wiki][27]. # Performance Whoa! Everything got slow all of a sudden... vim-airline strives to make it easy to use out of the box, which means that by default it will look for all compatible plugins that you have installed and enable the relevant extension. Many optimizations have been made such that the majority of users will not see any performance degradation, but it can still happen. For example, users who routinely open very large files may want to disable the `tagbar` extension, as it can be very expensive to scan for the name of the current function. The [minivimrc][7] project has some helper mappings to troubleshoot performance related issues. If you don't want all the bells and whistles enabled by default, you can define a value for `g:airline_extensions`. When this variable is defined, only the extensions listed will be loaded; an empty array would effectively disable all extensions (e.g. `:let g:airline_extensions = []`). Also, you can enable caching of the various syntax highlighting groups. This will try to prevent some of the more expensive `:hi` calls in Vim, which seem to be expensive in the Vim core at the expense of possibly not being one hundred percent correct all the time (especially if you often change highlighting groups yourself using `:hi` commands). To set this up do `:let g:airline_highlighting_cache = 1`. A `:AirlineRefresh` will however clear the cache. In addition you might want to check out the [dark_minimal theme][56], which does not change highlighting groups once they are defined. Also please check the [FAQ][27] for more information on how to diagnose and fix the problem. # Screenshots A full list of screenshots for various themes can be found in the [Wiki][14]. # Maintainers The project is currently being maintained by [Bailey Ling][41], [Christian Brabandt][42], and [Mike Hartington][44]. If you are interested in becoming a maintainer (we always welcome more maintainers), please [go here][43]. # License [MIT License][58]. Copyright (c) 2013-2019 Bailey Ling & Contributors. [1]: https://github.com/Lokaltog/vim-powerline [2]: https://github.com/Lokaltog/powerline [3]: https://github.com/Lokaltog/powerline-fonts [4]: https://github.com/tpope/vim-fugitive [5]: https://github.com/scrooloose/syntastic [6]: https://github.com/bling/vim-bufferline [7]: https://github.com/bling/minivimrc [8]: http://en.wikipedia.org/wiki/Open/closed_principle [9]: https://github.com/Shougo/unite.vim [10]: https://github.com/ctrlpvim/ctrlp.vim [11]: https://github.com/tpope/vim-pathogen [12]: https://github.com/Shougo/neobundle.vim [13]: https://github.com/VundleVim/Vundle.vim [14]: https://github.com/vim-airline/vim-airline/wiki/Screenshots [15]: https://github.com/techlivezheng/vim-plugin-minibufexpl [16]: https://github.com/sjl/gundo.vim [17]: https://github.com/mbbill/undotree [18]: https://github.com/scrooloose/nerdtree [19]: https://github.com/majutsushi/tagbar [20]: https://powerline.readthedocs.org/en/master/installation.html#patched-fonts [21]: https://bitbucket.org/ludovicchabant/vim-lawrencium [22]: https://github.com/MarcWeber/vim-addon-manager [23]: https://github.com/altercation/solarized [24]: https://github.com/chriskempson/tomorrow-theme [25]: https://github.com/tomasr/molokai [26]: https://github.com/nanotech/jellybeans.vim [27]: https://github.com/vim-airline/vim-airline/wiki/FAQ [28]: https://github.com/chrisbra/csv.vim [29]: https://github.com/airblade/vim-gitgutter [30]: https://github.com/mhinz/vim-signify [31]: https://github.com/jmcantrell/vim-virtualenv [32]: https://github.com/chriskempson/base16-vim [33]: https://github.com/vim-airline/vim-airline/wiki/Test-Plan [34]: http://eclim.org [35]: https://github.com/edkolev/tmuxline.vim [36]: https://github.com/edkolev/promptline.vim [37]: https://github.com/gcmt/taboo.vim [38]: https://github.com/vim-ctrlspace/vim-ctrlspace [39]: https://github.com/tomtom/quickfixsigns_vim [40]: https://github.com/junegunn/vim-plug [41]: https://github.com/bling [42]: https://github.com/chrisbra [43]: https://github.com/vim-airline/vim-airline/wiki/Becoming-a-Maintainer [44]: https://github.com/mhartington [45]: https://github.com/vim-airline/vim-airline/commit/d7fd8ca649e441b3865551a325b10504cdf0711b [46]: https://github.com/vim-airline/vim-airline#themes [47]: https://github.com/mildred/vim-bufmru [48]: https://github.com/ierton/xkb-switch [49]: https://github.com/vovkasm/input-source-switcher [50]: https://github.com/jreybert/vimagit [51]: https://github.com/Shougo/denite.nvim [52]: https://github.com/Shougo/dein.vim [53]: https://github.com/lervag/vimtex [54]: https://github.com/mox-mox/vim-localsearch [55]: https://github.com/k-takata/minpac/ [56]: https://github.com/vim-airline/vim-airline-themes/blob/master/autoload/airline/themes/dark_minimal.vim [57]: https://github.com/autozimu/LanguageClient-neovim [58]: https://github.com/vim-airline/vim-airline/blob/master/LICENSE vim-airline-0.11/Rakefile000066400000000000000000000002511356133765200153250ustar00rootroot00000000000000#!/usr/bin/env rake task :default => [:test] task :ci => [:dump, :test] task :dump do sh 'vim --version' end task :test do sh 'bundle exec vim-flavor test' end vim-airline-0.11/autoload/000077500000000000000000000000001356133765200154725ustar00rootroot00000000000000vim-airline-0.11/autoload/airline.vim000066400000000000000000000205611356133765200176360ustar00rootroot00000000000000" MIT License. Copyright (c) 2013-2019 Bailey Ling et al. " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 let g:airline_statusline_funcrefs = get(g:, 'airline_statusline_funcrefs', []) let s:sections = ['a','b','c','gutter','x','y','z', 'error', 'warning'] let s:inactive_funcrefs = [] let s:contexts = {} let s:core_funcrefs = [ \ function('airline#extensions#apply'), \ function('airline#extensions#default#apply') ] function! airline#add_statusline_func(name) call airline#add_statusline_funcref(function(a:name)) endfunction function! airline#add_statusline_funcref(function) if index(g:airline_statusline_funcrefs, a:function) >= 0 call airline#util#warning(printf('The airline statusline funcref "%s" has already been added.', string(a:function))) return endif call add(g:airline_statusline_funcrefs, a:function) endfunction function! airline#remove_statusline_func(name) let i = index(g:airline_statusline_funcrefs, function(a:name)) if i > -1 call remove(g:airline_statusline_funcrefs, i) endif endfunction function! airline#add_inactive_statusline_func(name) call add(s:inactive_funcrefs, function(a:name)) endfunction function! airline#load_theme() let g:airline_theme = get(g:, 'airline_theme', 'dark') if exists('*airline#themes#{g:airline_theme}#refresh') call airline#themes#{g:airline_theme}#refresh() endif let palette = g:airline#themes#{g:airline_theme}#palette call airline#themes#patch(palette) if exists('g:airline_theme_patch_func') let Fn = function(g:airline_theme_patch_func) call Fn(palette) endif call airline#highlighter#load_theme() call airline#extensions#load_theme() call airline#update_statusline() endfunction " Load an airline theme function! airline#switch_theme(name, ...) let silent = get(a:000, '0', 0) " get all available themes let themes = airline#util#themes('') let err = 0 try if index(themes, a:name) == -1 " Theme not available if !silent call airline#util#warning(printf('The specified theme "%s" cannot be found.', a:name)) endif throw "not-found" let err = 1 else exe "ru autoload/airline/themes/". a:name. ".vim" let g:airline_theme = a:name endif catch /^Vim/ " catch only Vim errors, not "not-found" call airline#util#warning(printf('There is an error in theme "%s".', a:name)) if &vbs call airline#util#warning(v:exception) endif let err = 1 endtry if err if exists('g:airline_theme') return else let g:airline_theme = 'dark' endif endif unlet! w:airline_lastmode call airline#load_theme() call airline#util#doautocmd('AirlineAfterTheme') " this is required to prevent clobbering the startup info message, i don't know why... call airline#check_mode(winnr()) endfunction " Try to load the right theme for the current colorscheme function! airline#switch_matching_theme() if exists('g:colors_name') let existing = g:airline_theme let theme = tr(tolower(g:colors_name), '-', '_') try call airline#switch_theme(theme, 1) return 1 catch for map in items(g:airline_theme_map) if match(g:colors_name, map[0]) > -1 try call airline#switch_theme(map[1], 1) catch call airline#switch_theme(existing) endtry return 1 endif endfor endtry endif return 0 endfunction " Update the statusline function! airline#update_statusline() if airline#util#getwinvar(winnr(), 'airline_disabled', 0) return endif let range = filter(range(1, winnr('$')), 'v:val != winnr()') " create inactive statusline call airline#update_statusline_inactive(range) unlet! w:airline_render_left w:airline_render_right exe 'unlet! ' 'w:airline_section_'. join(s:sections, ' w:airline_section_') " Now create the active statusline let w:airline_active = 1 let context = { 'winnr': winnr(), 'active': 1, 'bufnr': winbufnr(winnr()) } call s:invoke_funcrefs(context, g:airline_statusline_funcrefs) endfunction " Function to be called to make all statuslines inactive " Triggered on FocusLost autocommand function! airline#update_statusline_focuslost() if get(g:, 'airline_focuslost_inactive', 0) let bufnr=bufnr('%') call airline#highlighter#highlight_modified_inactive(bufnr) call airline#highlighter#highlight(['inactive'], bufnr) call airline#update_statusline_inactive(range(1, winnr('$'))) endif endfunction " Function to draw inactive statuslines for inactive windows function! airline#update_statusline_inactive(range) if airline#util#getwinvar(winnr(), 'airline_disabled', 0) return endif for nr in a:range if airline#util#getwinvar(nr, 'airline_disabled', 0) continue endif call setwinvar(nr, 'airline_active', 0) let context = { 'winnr': nr, 'active': 0, 'bufnr': winbufnr(nr) } if get(g:, 'airline_inactive_alt_sep', 0) call extend(context, { \ 'left_sep': g:airline_left_alt_sep, \ 'right_sep': g:airline_right_alt_sep }, 'keep') endif call s:invoke_funcrefs(context, s:inactive_funcrefs) endfor endfunction " Gather output from all funcrefs which will later be returned by the " airline#statusline() function function! s:invoke_funcrefs(context, funcrefs) let builder = airline#builder#new(a:context) let err = airline#util#exec_funcrefs(a:funcrefs + s:core_funcrefs, builder, a:context) if err == 1 let a:context.line = builder.build() let s:contexts[a:context.winnr] = a:context let option = get(g:, 'airline_statusline_ontop', 0) ? '&tabline' : '&statusline' call setwinvar(a:context.winnr, option, '%!airline#statusline('.a:context.winnr.')') endif endfunction " Main statusline function per window " will be set to the statusline option function! airline#statusline(winnr) if has_key(s:contexts, a:winnr) return '%{airline#check_mode('.a:winnr.')}'.s:contexts[a:winnr].line endif " in rare circumstances this happens...see #276 return '' endfunction " Check if mode has changed function! airline#check_mode(winnr) if !has_key(s:contexts, a:winnr) return '' endif let context = s:contexts[a:winnr] if get(w:, 'airline_active', 1) let l:m = mode(1) if l:m ==# "i" let l:mode = ['insert'] elseif l:m[0] ==# "i" let l:mode = ['insert'] elseif l:m ==# "Rv" let l:mode =['replace'] elseif l:m[0] ==# "R" let l:mode = ['replace'] elseif l:m[0] =~# '\v(v|V||s|S|)' let l:mode = ['visual'] elseif l:m ==# "t" let l:mode = ['terminal'] elseif l:m[0] ==# "c" let l:mode = ['commandline'] elseif l:m ==# "no" " does not work, most likely, Vim does not refresh the statusline in OP mode let l:mode = ['normal'] elseif l:m[0:1] ==# 'ni' let l:mode = ['normal'] let l:m = 'ni' else let l:mode = ['normal'] endif if exists("*VMInfos") && !empty(VMInfos()) " Vim plugin Multiple Cursors https://github.com/mg979/vim-visual-multi let l:m = 'multi' endif if index(['Rv', 'no', 'ni', 'ix', 'ic', 'multi'], l:m) == -1 let l:m = l:m[0] endif let w:airline_current_mode = get(g:airline_mode_map, l:m, l:m) else let l:mode = ['inactive'] let w:airline_current_mode = get(g:airline_mode_map, '__') endif if g:airline_detect_modified && &modified call add(l:mode, 'modified') endif if g:airline_detect_paste && &paste call add(l:mode, 'paste') endif if g:airline_detect_crypt && exists("+key") && !empty(&key) call add(l:mode, 'crypt') endif if g:airline_detect_spell && &spell call add(l:mode, 'spell') endif if &readonly || ! &modifiable call add(l:mode, 'readonly') endif let mode_string = join(l:mode) if get(w:, 'airline_lastmode', '') != mode_string call airline#highlighter#highlight_modified_inactive(context.bufnr) call airline#highlighter#highlight(l:mode, context.bufnr) call airline#util#doautocmd('AirlineModeChanged') let w:airline_lastmode = mode_string endif return '' endfunction function! airline#update_tabline() if get(g:, 'airline_statusline_ontop', 0) call airline#extensions#tabline#redraw() endif endfunction function! airline#mode_changed() " airline#visual_active " Boolean: for when to get visual wordcount " needed for the wordcount extension let g:airline#visual_active = (mode() =~? '[vs]') call airline#update_tabline() endfunction vim-airline-0.11/autoload/airline/000077500000000000000000000000001356133765200171155ustar00rootroot00000000000000vim-airline-0.11/autoload/airline/async.vim000066400000000000000000000255531356133765200207610ustar00rootroot00000000000000" MIT License. Copyright (c) 2013-2019 Christian Brabandt et al. " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 let s:untracked_jobs = {} let s:mq_jobs = {} let s:po_jobs = {} let s:clean_jobs = {} " Generic functions handling on exit event of the various async functions function! s:untracked_output(dict, buf) if a:buf =~? ('^'. a:dict.cfg['untracked_mark']) let a:dict.cfg.untracked[a:dict.file] = get(g:, 'airline#extensions#branch#notexists', g:airline_symbols.notexists) else let a:dict.cfg.untracked[a:dict.file] = '' endif endfunction " also called from branch extension (for non-async vims) function! airline#async#mq_output(buf, file) let buf=a:buf if !empty(a:buf) if a:buf =~# 'no patches applied' || \ a:buf =~# "unknown command 'qtop'" || \ a:buf =~# "abort" let buf = '' elseif exists("b:mq") && b:mq isnot# buf " make sure, statusline is updated unlet! b:airline_head endif let b:mq = buf endif if has_key(s:mq_jobs, a:file) call remove(s:mq_jobs, a:file) endif endfunction function! s:po_output(buf, file) if !empty(a:buf) let b:airline_po_stats = printf("%s", a:buf) else let b:airline_po_stats = '' endif if has_key(s:po_jobs, a:file) call remove(s:po_jobs, a:file) endif endfunction function! s:valid_dir(dir) if empty(a:dir) || !isdirectory(a:dir) return getcwd() endif return a:dir endfunction function! airline#async#vcs_untracked(config, file, vcs) if g:airline#init#vim_async " Vim 8 with async support noa call airline#async#vim_vcs_untracked(a:config, a:file) else " nvim async or vim without job-feature noa call airline#async#nvim_vcs_untracked(a:config, a:file, a:vcs) endif endfunction function! s:set_clean_variables(file, vcs, val) let var=getbufvar(fnameescape(a:file), 'buffer_vcs_config', {}) if has_key(var, a:vcs) && has_key(var[a:vcs], 'dirty') && \ type(getbufvar(fnameescape(a:file), 'buffer_vcs_config')) == type({}) let var[a:vcs].dirty=a:val try call setbufvar(fnameescape(a:file), 'buffer_vcs_config', var) unlet! b:airline_head catch endtry endif endfunction function! s:set_clean_jobs_variable(vcs, file, id) if !has_key(s:clean_jobs, a:vcs) let s:clean_jobs[a:vcs] = {} endif let s:clean_jobs[a:vcs][a:file]=a:id endfunction function! s:on_exit_clean(...) dict abort let buf=self.buf call s:set_clean_variables(self.file, self.vcs, !empty(buf)) if has_key(get(s:clean_jobs, self.vcs, {}), self.file) call remove(s:clean_jobs[self.vcs], self.file) endif endfunction function! airline#async#vcs_clean(cmd, file, vcs) if g:airline#init#vim_async " Vim 8 with async support noa call airline#async#vim_vcs_clean(a:cmd, a:file, a:vcs) elseif has("nvim") " nvim async noa call airline#async#nvim_vcs_clean(a:cmd, a:file, a:vcs) else " Vim pre 8 using system() call airline#async#vim7_vcs_clean(a:cmd, a:file, a:vcs) endif endfunction if v:version >= 800 && has("job") " Vim 8.0 with Job feature " TODO: Check if we need the cwd option for the job_start() functions " (only works starting with Vim 8.0.0902) function! s:on_stdout(channel, msg) dict abort let self.buf .= a:msg endfunction function! s:on_exit_mq(channel) dict abort call airline#async#mq_output(self.buf, self.file) endfunction function! s:on_exit_untracked(channel) dict abort call s:untracked_output(self, self.buf) if has_key(s:untracked_jobs, self.file) call remove(s:untracked_jobs, self.file) endif endfunction function! s:on_exit_po(channel) dict abort call s:po_output(self.buf, self.file) call airline#extensions#po#shorten() endfunction function! airline#async#get_mq_async(cmd, file) if g:airline#init#is_windows && &shell =~ 'cmd' let cmd = a:cmd else let cmd = ['sh', '-c', a:cmd] endif let options = {'cmd': a:cmd, 'buf': '', 'file': a:file} if has_key(s:mq_jobs, a:file) if job_status(get(s:mq_jobs, a:file)) == 'run' return elseif has_key(s:mq_jobs, a:file) call remove(s:mq_jobs, a:file) endif endif let id = job_start(cmd, { \ 'err_io': 'out', \ 'out_cb': function('s:on_stdout', options), \ 'close_cb': function('s:on_exit_mq', options)}) let s:mq_jobs[a:file] = id endfunction function! airline#async#get_msgfmt_stat(cmd, file) if g:airline#init#is_windows || !executable('msgfmt') " no msgfmt on windows? return else let cmd = ['sh', '-c', a:cmd. shellescape(a:file)] endif let options = {'buf': '', 'file': a:file} if has_key(s:po_jobs, a:file) if job_status(get(s:po_jobs, a:file)) == 'run' return elseif has_key(s:po_jobs, a:file) call remove(s:po_jobs, a:file) endif endif let id = job_start(cmd, { \ 'err_io': 'out', \ 'out_cb': function('s:on_stdout', options), \ 'close_cb': function('s:on_exit_po', options)}) let s:po_jobs[a:file] = id endfunction function! airline#async#vim_vcs_clean(cmd, file, vcs) if g:airline#init#is_windows && &shell =~ 'cmd' let cmd = a:cmd else let cmd = ['sh', '-c', a:cmd] endif let options = {'buf': '', 'vcs': a:vcs, 'file': a:file} let jobs = get(s:clean_jobs, a:vcs, {}) if has_key(jobs, a:file) if job_status(get(jobs, a:file)) == 'run' return elseif has_key(jobs, a:file) " still running return " jobs dict should be cleaned on exit, so not needed here " call remove(jobs, a:file) endif endif let id = job_start(cmd, { \ 'err_io': 'null', \ 'out_cb': function('s:on_stdout', options), \ 'close_cb': function('s:on_exit_clean', options)}) call s:set_clean_jobs_variable(a:vcs, a:file, id) endfunction function! airline#async#vim_vcs_untracked(config, file) if g:airline#init#is_windows && &shell =~ 'cmd' let cmd = a:config['cmd'] . shellescape(a:file) else let cmd = ['sh', '-c', a:config['cmd'] . shellescape(a:file)] endif let options = {'cfg': a:config, 'buf': '', 'file': a:file} if has_key(s:untracked_jobs, a:file) if job_status(get(s:untracked_jobs, a:file)) == 'run' return elseif has_key(s:untracked_jobs, a:file) call remove(s:untracked_jobs, a:file) endif endif let id = job_start(cmd, { \ 'err_io': 'out', \ 'out_cb': function('s:on_stdout', options), \ 'close_cb': function('s:on_exit_untracked', options)}) let s:untracked_jobs[a:file] = id endfunction elseif has("nvim") " NVim specific functions function! s:nvim_output_handler(job_id, data, event) dict if a:event == 'stdout' || a:event == 'stderr' let self.buf .= join(a:data) endif endfunction function! s:nvim_untracked_job_handler(job_id, data, event) dict if a:event == 'exit' call s:untracked_output(self, self.buf) if has_key(s:untracked_jobs, self.file) call remove(s:untracked_jobs, self.file) endif endif endfunction function! s:nvim_mq_job_handler(job_id, data, event) dict if a:event == 'exit' call airline#async#mq_output(self.buf, self.file) endif endfunction function! s:nvim_po_job_handler(job_id, data, event) dict if a:event == 'exit' call s:po_output(self.buf, self.file) call airline#extensions#po#shorten() endif endfunction function! airline#async#nvim_get_mq_async(cmd, file) let config = { \ 'buf': '', \ 'file': a:file, \ 'cwd': s:valid_dir(fnamemodify(a:file, ':p:h')), \ 'on_stdout': function('s:nvim_output_handler'), \ 'on_stderr': function('s:nvim_output_handler'), \ 'on_exit': function('s:nvim_mq_job_handler') \ } if g:airline#init#is_windows && &shell =~ 'cmd' let cmd = a:cmd else let cmd = ['sh', '-c', a:cmd] endif if has_key(s:mq_jobs, a:file) call remove(s:mq_jobs, a:file) endif let id = jobstart(cmd, config) let s:mq_jobs[a:file] = id endfunction function! airline#async#nvim_get_msgfmt_stat(cmd, file) let config = { \ 'buf': '', \ 'file': a:file, \ 'cwd': s:valid_dir(fnamemodify(a:file, ':p:h')), \ 'on_stdout': function('s:nvim_output_handler'), \ 'on_stderr': function('s:nvim_output_handler'), \ 'on_exit': function('s:nvim_po_job_handler') \ } if g:airline#init#is_windows && &shell =~ 'cmd' " no msgfmt on windows? return else let cmd = ['sh', '-c', a:cmd. shellescape(a:file)] endif if has_key(s:po_jobs, a:file) call remove(s:po_jobs, a:file) endif let id = jobstart(cmd, config) let s:po_jobs[a:file] = id endfunction function! airline#async#nvim_vcs_clean(cmd, file, vcs) let config = { \ 'buf': '', \ 'vcs': a:vcs, \ 'file': a:file, \ 'cwd': s:valid_dir(fnamemodify(a:file, ':p:h')), \ 'on_stdout': function('s:nvim_output_handler'), \ 'on_stderr': function('s:nvim_output_handler'), \ 'on_exit': function('s:on_exit_clean')} if g:airline#init#is_windows && &shell =~ 'cmd' let cmd = a:cmd else let cmd = ['sh', '-c', a:cmd] endif if !has_key(s:clean_jobs, a:vcs) let s:clean_jobs[a:vcs] = {} endif if has_key(s:clean_jobs[a:vcs], a:file) " still running return " jobs dict should be cleaned on exit, so not needed here " call remove(s:clean_jobs[a:vcs], a:file) endif let id = jobstart(cmd, config) call s:set_clean_jobs_variable(a:vcs, a:file, id) endfunction endif " Should work in either Vim pre 8 or Nvim function! airline#async#nvim_vcs_untracked(cfg, file, vcs) let cmd = a:cfg.cmd . shellescape(a:file) let id = -1 let config = { \ 'buf': '', \ 'vcs': a:vcs, \ 'cfg': a:cfg, \ 'file': a:file, \ 'cwd': s:valid_dir(fnamemodify(a:file, ':p:h')) \ } if has("nvim") call extend(config, { \ 'on_stdout': function('s:nvim_output_handler'), \ 'on_exit': function('s:nvim_untracked_job_handler')}) if has_key(s:untracked_jobs, config.file) " still running return endif try let id = jobstart(cmd, config) catch " catch-all, jobstart() failed, fall back to system() let id=-1 endtry let s:untracked_jobs[a:file] = id endif " vim without job feature or nvim jobstart failed if id < 1 let output=system(cmd) call s:untracked_output(config, output) call airline#extensions#branch#update_untracked_config(a:file, a:vcs) endif endfunction function! airline#async#vim7_vcs_clean(cmd, file, vcs) " Vim pre 8, fallback using system() " don't want to to see error messages if g:airline#init#is_windows && &shell =~ 'cmd' let cmd = a:cmd .' 2>nul' else let cmd = a:cmd .' 2>/dev/null' endif let output=system(cmd) call s:set_clean_variables(a:file, a:vcs, !empty(output)) endfunction vim-airline-0.11/autoload/airline/builder.vim000066400000000000000000000156261356133765200212720ustar00rootroot00000000000000" MIT License. Copyright (c) 2013-2019 Bailey Ling et al. " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 let s:prototype = {} function! s:prototype.split(...) dict call add(self._sections, ['|', a:0 ? a:1 : '%=']) endfunction function! s:prototype.add_section_spaced(group, contents) dict let spc = empty(a:contents) ? '' : g:airline_symbols.space call self.add_section(a:group, spc.a:contents.spc) endfunction function! s:prototype.add_section(group, contents) dict call add(self._sections, [a:group, a:contents]) endfunction function! s:prototype.add_raw(text) dict call add(self._sections, ['', a:text]) endfunction function! s:prototype.insert_section(group, contents, position) dict call insert(self._sections, [a:group, a:contents], a:position) endfunction function! s:prototype.insert_raw(text, position) dict call insert(self._sections, ['', a:text], a:position) endfunction function! s:prototype.get_position() dict return len(self._sections) endfunction function! airline#builder#get_prev_group(sections, i) let x = a:i - 1 while x >= 0 let group = a:sections[x][0] if group != '' && group != '|' return group endif let x = x - 1 endwhile return '' endfunction function! airline#builder#get_next_group(sections, i) let x = a:i + 1 let l = len(a:sections) while x < l let group = a:sections[x][0] if group != '' && group != '|' return group endif let x = x + 1 endwhile return '' endfunction function! s:prototype.build() dict let side = 1 let line = '' let i = 0 let length = len(self._sections) let split = 0 let is_empty = 0 let prev_group = '' while i < length let section = self._sections[i] let group = section[0] let contents = section[1] let pgroup = prev_group let prev_group = airline#builder#get_prev_group(self._sections, i) if group ==# 'airline_c' && &buftype ==# 'terminal' && self._context.active let group = 'airline_term' elseif group ==# 'airline_c' && !self._context.active && has_key(self._context, 'bufnr') let group = 'airline_c'. self._context.bufnr elseif prev_group ==# 'airline_c' && !self._context.active && has_key(self._context, 'bufnr') let prev_group = 'airline_c'. self._context.bufnr endif if is_empty let prev_group = pgroup endif let is_empty = s:section_is_empty(self, contents) if is_empty " need to fix highlighting groups, since we " have skipped a section, we actually need " the previous previous group and so the " seperator goes from the previous previous group " to the current group let pgroup = group endif if group == '' let line .= contents elseif group == '|' let side = 0 let line .= contents let split = 1 else if prev_group == '' let line .= '%#'.group.'#' elseif split if !is_empty let line .= s:get_transitioned_seperator(self, prev_group, group, side) endif let split = 0 else if !is_empty let line .= s:get_seperator(self, prev_group, group, side) endif endif let line .= is_empty ? '' : s:get_accented_line(self, group, contents) endif let i = i + 1 endwhile if !self._context.active "let line = substitute(line, '%#airline_c#', '%#airline_c'.self._context.bufnr.'#', '') let line = substitute(line, '%#.\{-}\ze#', '\0_inactive', 'g') endif return line endfunction function! airline#builder#should_change_group(group1, group2) if a:group1 == a:group2 return 0 endif let color1 = airline#highlighter#get_highlight(a:group1) let color2 = airline#highlighter#get_highlight(a:group2) if g:airline_gui_mode ==# 'gui' return color1[1] != color2[1] || color1[0] != color2[0] else return color1[3] != color2[3] || color1[2] != color2[2] endif endfunction function! s:get_transitioned_seperator(self, prev_group, group, side) let line = '' if get(a:self._context, 'tabline', 0) && get(g:, 'airline#extensions#tabline#alt_sep', 0) && a:group ==# 'airline_tabsel' && a:side call airline#highlighter#add_separator(a:prev_group, a:group, 0) let line .= '%#'.a:prev_group.'_to_'.a:group.'#' let line .= a:self._context.right_sep.'%#'.a:group.'#' else call airline#highlighter#add_separator(a:prev_group, a:group, a:side) let line .= '%#'.a:prev_group.'_to_'.a:group.'#' let line .= a:side ? a:self._context.left_sep : a:self._context.right_sep let line .= '%#'.a:group.'#' endif return line endfunction function! s:get_seperator(self, prev_group, group, side) if airline#builder#should_change_group(a:prev_group, a:group) return s:get_transitioned_seperator(a:self, a:prev_group, a:group, a:side) else return a:side ? a:self._context.left_alt_sep : a:self._context.right_alt_sep endif endfunction function! s:get_accented_line(self, group, contents) if a:self._context.active " active window let contents = [] let content_parts = split(a:contents, '__accent') for cpart in content_parts let accent = matchstr(cpart, '_\zs[^#]*\ze') call add(contents, cpart) endfor let line = join(contents, a:group) let line = substitute(line, '__restore__', a:group, 'g') else " inactive window let line = substitute(a:contents, '%#__accent[^#]*#', '', 'g') let line = substitute(line, '%#__restore__#', '', 'g') endif return line endfunction function! s:section_is_empty(self, content) let start=1 " do not check for inactive windows or the tabline if a:self._context.active == 0 return 0 elseif get(a:self._context, 'tabline', 0) return 0 endif " only check, if airline#skip_empty_sections == 1 if get(g:, 'airline_skip_empty_sections', 0) == 0 return 0 endif " only check, if airline#skip_empty_sections == 1 if get(w:, 'airline_skip_empty_sections', -1) == 0 return 0 endif " assume accents sections to be never empty " (avoides, that on startup the mode message becomes empty) if match(a:content, '%#__accent_[^#]*#.*__restore__#') > -1 return 0 endif if empty(a:content) return 1 endif let list=matchlist(a:content, '%{\zs.\{-}\ze}', 1, start) if empty(list) return 0 " no function in statusline text endif while len(list) > 0 let expr = list[0] try " catch all exceptions, just in case if !empty(eval(expr)) return 0 endif catch return 0 endtry let start += 1 let list=matchlist(a:content, '%{\zs.\{-}\ze}', 1, start) endw return 1 endfunction function! airline#builder#new(context) let builder = copy(s:prototype) let builder._context = a:context let builder._sections = [] call extend(builder._context, { \ 'left_sep': g:airline_left_sep, \ 'left_alt_sep': g:airline_left_alt_sep, \ 'right_sep': g:airline_right_sep, \ 'right_alt_sep': g:airline_right_alt_sep, \ }, 'keep') return builder endfunction vim-airline-0.11/autoload/airline/debug.vim000066400000000000000000000020211356133765200207130ustar00rootroot00000000000000" MIT License. Copyright (c) 2013-2019 Bailey Ling et al. " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 function! airline#debug#profile1() profile start airline-profile-switch.log profile func * profile file * split for i in range(1, 1000) wincmd w redrawstatus endfor profile pause noautocmd qall! endfunction function! airline#debug#profile2() profile start airline-profile-cursor.log profile func * profile file * edit blank call setline(1, 'all your base are belong to us') call setline(2, 'all your base are belong to us') let positions = [[1,2], [2,2], [1,2], [1,1]] for i in range(1, 1000) for pos in positions call cursor(pos[0], pos[1]) redrawstatus endfor endfor profile pause noautocmd qall! endfunction function! airline#debug#profile3() profile start airline-profile-mode.log profile func * profile file * for i in range(1000) startinsert redrawstatus stopinsert redrawstatus endfor profile pause noautocmd qall! endfunction vim-airline-0.11/autoload/airline/extensions.vim000066400000000000000000000327651356133765200220460ustar00rootroot00000000000000" MIT License. Copyright (c) 2013-2019 Bailey Ling et al. " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 let s:loaded_ext = [] let s:ext = {} let s:ext._theme_funcrefs = [] function! s:ext.add_statusline_func(name) dict call airline#add_statusline_func(a:name) endfunction function! s:ext.add_statusline_funcref(function) dict call airline#add_statusline_funcref(a:function) endfunction function! s:ext.add_inactive_statusline_func(name) dict call airline#add_inactive_statusline_func(a:name) endfunction function! s:ext.add_theme_func(name) dict call add(self._theme_funcrefs, function(a:name)) endfunction let s:script_path = tolower(resolve(expand(':p:h'))) let s:filetype_overrides = { \ 'defx': ['defx', '%{b:defx.paths[0]}'], \ 'fugitive': ['fugitive', '%{airline#util#wrap(airline#extensions#branch#get_head(),80)}'], \ 'gundo': [ 'Gundo', '' ], \ 'help': [ 'Help', '%f' ], \ 'minibufexpl': [ 'MiniBufExplorer', '' ], \ 'nerdtree': [ get(g:, 'NERDTreeStatusline', 'NERD'), '' ], \ 'startify': [ 'startify', '' ], \ 'vim-plug': [ 'Plugins', '' ], \ 'vimfiler': [ 'vimfiler', '%{vimfiler#get_status_string()}' ], \ 'vimshell': ['vimshell','%{vimshell#get_status_string()}'], \ } if exists(':Gina') && (v:version > 704 || (v:version == 704 && has("patch1898"))) " Gina needs the Vim 7.4.1898, which introduce the flag for custom commands let s:filetype_overrides['gina-status'] = ['gina', '%{gina#component#repo#preset()}' ] let s:filetype_overrides['diff'] = ['gina', '%{gina#component#repo#preset()}' ] let s:filetype_overrides['gina-log'] = ['gina', '%{gina#component#repo#preset()}' ] let s:filetype_overrides['gina-tag'] = ['gina', '%{gina#component#repo#preset()}' ] endif let s:filetype_regex_overrides = {} function! s:check_defined_section(name) if !exists('w:airline_section_{a:name}') let w:airline_section_{a:name} = g:airline_section_{a:name} endif endfunction function! airline#extensions#append_to_section(name, value) call check_defined_section(a:name) let w:airline_section_{a:name} .= a:value endfunction function! airline#extensions#prepend_to_section(name, value) call check_defined_section(a:name) let w:airline_section_{a:name} = a:value . w:airline_section_{a:name} endfunction function! airline#extensions#apply_left_override(section1, section2) let w:airline_section_a = a:section1 let w:airline_section_b = a:section2 let w:airline_section_c = airline#section#create(['readonly']) let w:airline_render_left = 1 let w:airline_render_right = 0 endfunction function! airline#extensions#apply(...) let filetype_overrides = get(s:, 'filetype_overrides', {}) call extend(filetype_overrides, get(g:, 'airline_filetype_overrides', {}), 'force') if s:is_excluded_window() return -1 endif if &buftype == 'terminal' let w:airline_section_x = '' let w:airline_section_y = '' endif if &previewwindow let w:airline_section_a = 'Preview' let w:airline_section_b = '' let w:airline_section_c = bufname(winbufnr(winnr())) endif if has_key(filetype_overrides, &ft) && \ ((&filetype == 'help' && &buftype == 'help') || &filetype !~ 'help') " for help files only override it, if the buftype is also of type 'help', " else it would trigger when editing Vim help files let args = filetype_overrides[&ft] call airline#extensions#apply_left_override(args[0], args[1]) endif if &buftype == 'help' let w:airline_section_x = '' let w:airline_section_y = '' let w:airline_render_right = 1 endif for item in items(s:filetype_regex_overrides) if match(&ft, item[0]) >= 0 call airline#extensions#apply_left_override(item[1][0], item[1][1]) endif endfor endfunction function! s:is_excluded_window() for matchft in g:airline_exclude_filetypes if matchft ==# &ft return 1 endif endfor for matchw in g:airline_exclude_filenames if matchstr(expand('%'), matchw) ==# matchw return 1 endif endfor if g:airline_exclude_preview && &previewwindow return 1 endif return 0 endfunction function! airline#extensions#load_theme() call airline#util#exec_funcrefs(s:ext._theme_funcrefs, g:airline#themes#{g:airline_theme}#palette) endfunction function! airline#extensions#load() let s:loaded_ext = [] if exists('g:airline_extensions') for ext in g:airline_extensions try call airline#extensions#{ext}#init(s:ext) catch /^Vim\%((\a\+)\)\=:E117/ " E117, function does not exist call airline#util#warning("Extension '".ext."' not installed, ignoring!") endtry endfor return endif call airline#extensions#quickfix#init(s:ext) call add(s:loaded_ext, 'quickfix') if get(g:, 'loaded_unite', 0) call airline#extensions#unite#init(s:ext) call add(s:loaded_ext, 'unite') endif if get(g:, 'loaded_denite', 0) call airline#extensions#denite#init(s:ext) call add(s:loaded_ext, 'denite') endif if exists(':NetrwSettings') call airline#extensions#netrw#init(s:ext) call add(s:loaded_ext, 'netrw') endif if (has("terminal") || has('nvim')) && \ get(g:, 'airline#extensions#term#enabled', 1) call airline#extensions#term#init(s:ext) call add(s:loaded_ext, 'term') endif if get(g:, 'airline#extensions#ycm#enabled', 0) call airline#extensions#ycm#init(s:ext) call add(s:loaded_ext, 'ycm') endif if get(g:, 'loaded_vimfiler', 0) let g:vimfiler_force_overwrite_statusline = 0 endif if get(g:, 'loaded_ctrlp', 0) call airline#extensions#ctrlp#init(s:ext) call add(s:loaded_ext, 'ctrlp') endif if get(g:, 'loaded_localsearch', 0) call airline#extensions#localsearch#init(s:ext) call add(s:loaded_ext, 'localsearch') endif if get(g:, 'CtrlSpaceLoaded', 0) call airline#extensions#ctrlspace#init(s:ext) call add(s:loaded_ext, 'ctrlspace') endif if get(g:, 'command_t_loaded', 0) call airline#extensions#commandt#init(s:ext) call add(s:loaded_ext, 'commandt') endif if exists(':UndotreeToggle') call airline#extensions#undotree#init(s:ext) call add(s:loaded_ext, 'undotree') endif if get(g:, 'airline#extensions#hunks#enabled', 1) \ && (exists('g:loaded_signify') || exists('g:loaded_gitgutter') || exists('g:loaded_changes') || exists('g:loaded_quickfixsigns')) call airline#extensions#hunks#init(s:ext) call add(s:loaded_ext, 'hunks') endif if get(g:, 'airline#extensions#vimagit#enabled', 1) \ && (exists('g:loaded_magit')) call airline#extensions#vimagit#init(s:ext) call add(s:loaded_ext, 'vimagit') endif if get(g:, 'airline#extensions#tagbar#enabled', 1) \ && exists(':TagbarToggle') call airline#extensions#tagbar#init(s:ext) call add(s:loaded_ext, 'tagbar') endif if get(g:, 'airline#extensions#vista#enabled', 1) call airline#extensions#vista#init(s:ext) call add(s:loaded_ext, 'vista') endif if get(g:, 'airline#extensions#bookmark#enabled', 1) \ && exists(':BookmarkToggle') call airline#extensions#bookmark#init(s:ext) call add(s:loaded_ext, 'bookmark') endif if get(g:, 'airline#extensions#csv#enabled', 1) \ && (get(g:, 'loaded_csv', 0) || exists(':Table')) call airline#extensions#csv#init(s:ext) call add(s:loaded_ext, 'csv') endif if exists(':VimShell') let s:filetype_regex_overrides['^int-'] = ['vimshell','%{substitute(&ft, "int-", "", "")}'] endif if get(g:, 'airline#extensions#branch#enabled', 1) && ( \ airline#util#has_fugitive() || \ airline#util#has_lawrencium() || \ airline#util#has_vcscommand() || \ airline#util#has_custom_scm()) call airline#extensions#branch#init(s:ext) call add(s:loaded_ext, 'branch') endif if get(g:, 'airline#extensions#bufferline#enabled', 1) \ && exists('*bufferline#get_status_string') call airline#extensions#bufferline#init(s:ext) call add(s:loaded_ext, 'bufferline') endif if get(g:, 'airline#extensions#fugitiveline#enabled', 1) \ && airline#util#has_fugitive() \ && index(s:loaded_ext, 'bufferline') == -1 call airline#extensions#fugitiveline#init(s:ext) call add(s:loaded_ext, 'fugitiveline') endif if (get(g:, 'airline#extensions#virtualenv#enabled', 1) && (exists(':VirtualEnvList') || isdirectory($VIRTUAL_ENV))) call airline#extensions#virtualenv#init(s:ext) call add(s:loaded_ext, 'virtualenv') endif if (get(g:, 'airline#extensions#eclim#enabled', 1) && exists(':ProjectCreate')) call airline#extensions#eclim#init(s:ext) call add(s:loaded_ext, 'eclim') endif if get(g:, 'airline#extensions#syntastic#enabled', 1) \ && exists(':SyntasticCheck') call airline#extensions#syntastic#init(s:ext) call add(s:loaded_ext, 'syntastic') endif if (get(g:, 'airline#extensions#ale#enabled', 1) && exists(':ALELint')) call airline#extensions#ale#init(s:ext) call add(s:loaded_ext, 'ale') endif if (get(g:, 'airline#extensions#coc#enabled', 1) && exists(':CocCommand')) call airline#extensions#coc#init(s:ext) call add(s:loaded_ext, 'coc') endif if (get(g:, 'airline#extensions#languageclient#enabled', 1) && exists(':LanguageClientStart')) call airline#extensions#languageclient#init(s:ext) call add(s:loaded_ext, 'languageclient') endif if get(g:, 'airline#extensions#whitespace#enabled', 1) call airline#extensions#whitespace#init(s:ext) call add(s:loaded_ext, 'whitespace') endif if (get(g:, 'airline#extensions#neomake#enabled', 1) && exists(':Neomake')) call airline#extensions#neomake#init(s:ext) call add(s:loaded_ext, 'neomake') endif if get(g:, 'airline#extensions#po#enabled', 1) && executable('msgfmt') call airline#extensions#po#init(s:ext) call add(s:loaded_ext, 'po') endif if get(g:, 'airline#extensions#wordcount#enabled', 1) call airline#extensions#wordcount#init(s:ext) call add(s:loaded_ext, 'wordcount') endif if get(g:, 'airline#extensions#tabline#enabled', 0) call airline#extensions#tabline#init(s:ext) call add(s:loaded_ext, 'tabline') endif if get(g:, 'airline#extensions#tmuxline#enabled', 1) && exists(':Tmuxline') call airline#extensions#tmuxline#init(s:ext) call add(s:loaded_ext, 'tmuxline') 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) call add(s:loaded_ext, 'promptline') endif if get(g:, 'airline#extensions#nrrwrgn#enabled', 1) && exists(':NR') == 2 call airline#extensions#nrrwrgn#init(s:ext) call add(s:loaded_ext, 'nrrwrgn') endif if get(g:, 'airline#extensions#unicode#enabled', 1) && exists(':UnicodeTable') == 2 call airline#extensions#unicode#init(s:ext) call add(s:loaded_ext, 'unicode') endif if (get(g:, 'airline#extensions#capslock#enabled', 1) && exists('*CapsLockStatusline')) call airline#extensions#capslock#init(s:ext) call add(s:loaded_ext, 'capslock') endif if (get(g:, 'airline#extensions#gutentags#enabled', 1) && get(g:, 'loaded_gutentags', 0)) call airline#extensions#gutentags#init(s:ext) call add(s:loaded_ext, 'gutentags') endif if (get(g:, 'airline#extensions#grepper#enabled', 1) && get(g:, 'loaded_grepper', 0)) call airline#extensions#grepper#init(s:ext) call add(s:loaded_ext, 'grepper') endif if (get(g:, 'airline#extensions#xkblayout#enabled', 1) && exists('g:XkbSwitchLib')) call airline#extensions#xkblayout#init(s:ext) call add(s:loaded_ext, 'xkblayout') endif if (get(g:, 'airline#extensions#keymap#enabled', 1) && has('keymap')) call airline#extensions#keymap#init(s:ext) call add(s:loaded_ext, 'keymap') endif if (get(g:, 'airline#extensions#windowswap#enabled', 1) && get(g:, 'loaded_windowswap', 0)) call airline#extensions#windowswap#init(s:ext) call add(s:loaded_ext, 'windowswap') endif if (get(g:, 'airline#extensions#obsession#enabled', 1) && exists('*ObsessionStatus')) call airline#extensions#obsession#init(s:ext) call add(s:loaded_ext, 'obsession') endif if get(g:, 'airline#extensions#vimtex#enabled', 1) runtime autoload/vimtex.vim if exists('*vimtex#init') call airline#extensions#vimtex#init(s:ext) call add(s:loaded_ext, 'vimtex') endif endif if (get(g:, 'airline#extensions#cursormode#enabled', 0)) call airline#extensions#cursormode#init(s:ext) call add(s:loaded_ext, 'cursormode') endif if !get(g:, 'airline#extensions#disable_rtp_load', 0) " load all other extensions, which are not part of the default distribution. " (autoload/airline/extensions/*.vim outside of our s:script_path). for file in split(globpath(&rtp, "autoload/airline/extensions/*.vim"), "\n") " we have to check both resolved and unresolved paths, since it's possible " that they might not get resolved properly (see #187) if stridx(tolower(resolve(fnamemodify(file, ':p'))), s:script_path) < 0 \ && stridx(tolower(fnamemodify(file, ':p')), s:script_path) < 0 let name = fnamemodify(file, ':t:r') if !get(g:, 'airline#extensions#'.name.'#enabled', 1) || \ index(s:loaded_ext, name) > -1 continue endif try call airline#extensions#{name}#init(s:ext) " mark as external call add(s:loaded_ext, name.'*') catch endtry endif endfor endif endfunction function! airline#extensions#get_loaded_extensions() return s:loaded_ext endfunction vim-airline-0.11/autoload/airline/extensions/000077500000000000000000000000001356133765200213145ustar00rootroot00000000000000vim-airline-0.11/autoload/airline/extensions/ale.vim000066400000000000000000000101621356133765200225720ustar00rootroot00000000000000" MIT License. Copyright (c) 2013-2019 Bjorn Neergaard, w0rp et al. " Plugin: https://github.com/dense-analysis/ale " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 function! s:airline_ale_count(cnt, symbol) return a:cnt ? a:symbol. a:cnt : '' endfunction function! s:legacy_airline_ale_get_line_number(cnt, type) abort " Before ALE introduced the FirstProblem API function, this is how " airline would get the line numbers: " 1. Get the whole loclist; 2. Filter it for the desired problem type. " 3. Return the line number of the first element in the filtered list. if a:cnt == 0 return '' endif let buffer = bufnr('') let problem_type = (a:type ==# 'error') ? 'E' : 'W' let problems = copy(ale#engine#GetLoclist(buffer)) call filter(problems, 'v:val.bufnr is buffer && v:val.type is# problem_type') if empty(problems) return '' endif let open_lnum_symbol = get(g:, 'airline#extensions#ale#open_lnum_symbol', '(L') let close_lnum_symbol = get(g:, 'airline#extensions#ale#close_lnum_symbol', ')') return open_lnum_symbol . problems[0].lnum . close_lnum_symbol endfunction function! s:new_airline_ale_get_line_number(cnt, type) abort " The FirstProblem call in ALE is a far more efficient way " of obtaining line number data. If the installed ALE supports " it, we should use this method of getting line data. if a:cnt == 0 return '' endif let l:buffer = bufnr('') " Try to get the first error from ALE. let l:result = ale#statusline#FirstProblem(l:buffer, a:type) if empty(l:result) " If there are no errors then try and check for style errors. let l:result = ale#statusline#FirstProblem(l:buffer, 'style_' . a:type) endif if empty(l:result) return '' endif let l:open_lnum_symbol = \ get(g:, 'airline#extensions#ale#open_lnum_symbol', '(L') let l:close_lnum_symbol = \ get(g:, 'airline#extensions#ale#close_lnum_symbol', ')') return open_lnum_symbol . l:result.lnum . close_lnum_symbol endfunction function! s:airline_ale_get_line_number(cnt, type) abort " Use the new ALE statusline API function if it is available. if exists("*ale#statusline#FirstProblem") return s:new_airline_ale_get_line_number(a:cnt, a:type) endif return s:legacy_airline_ale_get_line_number(a:cnt, a:type) endfunction function! airline#extensions#ale#get(type) if !exists(':ALELint') return '' endif let error_symbol = get(g:, 'airline#extensions#ale#error_symbol', 'E:') let warning_symbol = get(g:, 'airline#extensions#ale#warning_symbol', 'W:') let checking_symbol = get(g:, 'airline#extensions#ale#checking_symbol', '...') let show_line_numbers = get(g:, 'airline#extensions#ale#show_line_numbers', 1) let is_err = a:type ==# 'error' if ale#engine#IsCheckingBuffer(bufnr('')) == 1 return is_err ? '' : checking_symbol endif let symbol = is_err ? error_symbol : warning_symbol let counts = ale#statusline#Count(bufnr('')) if type(counts) == type({}) && has_key(counts, 'error') " Use the current Dictionary format. let errors = counts.error + counts.style_error let num = is_err ? errors : counts.total - errors else " Use the old List format. let num = is_err ? counts[0] : counts[1] endif if show_line_numbers == 1 return s:airline_ale_count(num, symbol) . airline_ale_get_line_number(num, a:type) else return s:airline_ale_count(num, symbol) endif endfunction function! airline#extensions#ale#get_warning() return airline#extensions#ale#get('warning') endfunction function! airline#extensions#ale#get_error() return airline#extensions#ale#get('error') endfunction function! airline#extensions#ale#init(ext) call airline#parts#define_function('ale_error_count', 'airline#extensions#ale#get_error') call airline#parts#define_function('ale_warning_count', 'airline#extensions#ale#get_warning') augroup airline_ale autocmd! autocmd CursorHold,BufWritePost * call ale_refresh() autocmd User ALEJobStarted,ALELintPost call ale_refresh() augroup END endfunction function! s:ale_refresh() if get(g:, 'airline_skip_empty_sections', 0) exe ':AirlineRefresh!' endif endfunction vim-airline-0.11/autoload/airline/extensions/bookmark.vim000066400000000000000000000014231356133765200236360ustar00rootroot00000000000000" MIT License. Copyright (c) 2019 Bjoern Petri " Plugin: https://github.com/MattesGroeger/vim-bookmarks " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 if !exists(':BookmarkToggle') finish endif function! airline#extensions#bookmark#currentbookmark() if get(w:, 'airline_active', 0) let file = expand("%:p") if file ==# "" return endif let current_line = line('.') let has_bm = bm#has_bookmark_at_line(file, current_line) let bm = has_bm ? bm#get_bookmark_by_line(file, current_line) : 0 let annotation = has_bm ? bm['annotation'] : "" return annotation endif return '' endfunction function! airline#extensions#bookmark#init(ext) call airline#parts#define_function('bookmark', 'airline#extensions#bookmark#currentbookmark') endfunction vim-airline-0.11/autoload/airline/extensions/branch.vim000066400000000000000000000254631356133765200233000ustar00rootroot00000000000000" MIT License. Copyright (c) 2013-2019 Bailey Ling et al. " Plugin: fugitive, lawrencium and vcscommand " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 " s:vcs_config contains static configuration of VCSes and their status relative " to the active file. " 'branch' - The name of currently active branch. This field is empty iff it " has not been initialized yet or the current file is not in " an active branch. " 'untracked' - Cache of untracked files represented as a dictionary with files " as keys. A file has a not exists symbol set as its value if it " is untracked. A file is present in this dictionary iff its " status is considered up to date. " 'untracked_mark' - used as regexp to test against the output of 'cmd' let s:vcs_config = { \ 'git': { \ 'exe': 'git', \ 'cmd': 'git status --porcelain -- ', \ 'dirty': 'git status -uno --porcelain --ignore-submodules', \ 'untracked_mark': '??', \ 'exclude': '\.git', \ 'update_branch': 's:update_git_branch', \ 'display_branch': 's:display_git_branch', \ 'branch': '', \ 'untracked': {}, \ }, \ 'mercurial': { \ 'exe': 'hg', \ 'cmd': 'hg status -u -- ', \ 'dirty': 'hg status -mard', \ 'untracked_mark': '?', \ 'exclude': '\.hg', \ 'update_branch': 's:update_hg_branch', \ 'display_branch': 's:display_hg_branch', \ 'branch': '', \ 'untracked': {}, \ }, \} " Initializes b:buffer_vcs_config. b:buffer_vcs_config caches the branch and " untracked status of the file in the buffer. Caching those fields is necessary, " because s:vcs_config may be updated asynchronously and s:vcs_config fields may " be invalid during those updates. b:buffer_vcs_config fields are updated " whenever corresponding fields in s:vcs_config are updated or an inconsistency " is detected during update_* operation. " " b:airline_head caches the head string it is empty iff it needs to be " recalculated. b:airline_head is recalculated based on b:buffer_vcs_config. function! s:init_buffer() let b:buffer_vcs_config = {} for vcs in keys(s:vcs_config) let b:buffer_vcs_config[vcs] = { \ 'branch': '', \ 'untracked': '', \ 'dirty': 0, \ } endfor unlet! b:airline_head endfunction let s:head_format = get(g:, 'airline#extensions#branch#format', 0) if s:head_format == 1 function! s:format_name(name) return fnamemodify(a:name, ':t') endfunction elseif s:head_format == 2 function! s:format_name(name) return pathshorten(a:name) endfunction elseif type(s:head_format) == type('') function! s:format_name(name) return call(s:head_format, [a:name]) endfunction else function! s:format_name(name) return a:name endfunction endif " Fugitive special revisions. call '0' "staging" ? let s:names = {'0': 'index', '1': 'orig', '2':'fetch', '3':'merge'} let s:sha1size = get(g:, 'airline#extensions#branch#sha1_len', 7) function! s:update_git_branch() if !airline#util#has_fugitive() let s:vcs_config['git'].branch = '' return endif let s:vcs_config['git'].branch = exists("*FugitiveHead") ? \ FugitiveHead(s:sha1size) : fugitive#head(s:sha1size) if s:vcs_config['git'].branch is# 'master' && \ airline#util#winwidth() < 81 " Shorten default a bit let s:vcs_config['git'].branch='mas' endif endfunction function! s:display_git_branch() let name = b:buffer_vcs_config['git'].branch try let commit = matchstr(FugitiveParse()[0], '^\x\+') if has_key(s:names, commit) let name = get(s:names, commit)."(".name.")" elseif !empty(commit) let ref = fugitive#repo().git_chomp('describe', '--all', '--exact-match', commit) if ref !~ "^fatal: no tag exactly matches" let name = s:format_name(substitute(ref, '\v\C^%(heads/|remotes/|tags/)=','',''))."(".name.")" else let name = matchstr(commit, '.\{'.s:sha1size.'}')."(".name.")" endif endif catch endtry return name endfunction function! s:update_hg_branch() if airline#util#has_lawrencium() let cmd='LC_ALL=C hg qtop' let stl=lawrencium#statusline() let file=expand('%:p') if !empty(stl) && get(b:, 'airline_do_mq_check', 1) if g:airline#init#vim_async noa call airline#async#get_mq_async(cmd, file) elseif has("nvim") noa call airline#async#nvim_get_mq_async(cmd, file) else " remove \n at the end of the command let output=system(cmd)[0:-2] noa call airline#async#mq_output(output, file) endif endif " do not do mq check anymore let b:airline_do_mq_check = 0 if exists("b:mq") && !empty(b:mq) if stl is# 'default' " Shorten default a bit let stl='def' endif let stl.=' ['.b:mq.']' endif let s:vcs_config['mercurial'].branch = stl else let s:vcs_config['mercurial'].branch = '' endif endfunction function! s:display_hg_branch() return b:buffer_vcs_config['mercurial'].branch endfunction function! s:update_branch() for vcs in keys(s:vcs_config) call {s:vcs_config[vcs].update_branch}() if b:buffer_vcs_config[vcs].branch != s:vcs_config[vcs].branch let b:buffer_vcs_config[vcs].branch = s:vcs_config[vcs].branch unlet! b:airline_head endif endfor endfunction function! airline#extensions#branch#update_untracked_config(file, vcs) if !has_key(s:vcs_config[a:vcs].untracked, a:file) return elseif s:vcs_config[a:vcs].untracked[a:file] != b:buffer_vcs_config[a:vcs].untracked let b:buffer_vcs_config[a:vcs].untracked = s:vcs_config[a:vcs].untracked[a:file] unlet! b:airline_head endif endfunction function! s:update_untracked() let file = expand("%:p") if empty(file) || isdirectory(file) || !empty(&buftype) return endif let needs_update = 1 let vcs_checks = get(g:, "airline#extensions#branch#vcs_checks", ["untracked", "dirty"]) for vcs in keys(s:vcs_config) if file =~ s:vcs_config[vcs].exclude " Skip check for files that live in the exclude directory let needs_update = 0 endif if has_key(s:vcs_config[vcs].untracked, file) let needs_update = 0 call airline#extensions#branch#update_untracked_config(file, vcs) endif endfor if !needs_update return endif for vcs in keys(s:vcs_config) " only check, for git, if fugitive is installed " and for 'hg' if lawrencium is installed, else skip if vcs is# 'git' && !airline#util#has_fugitive() continue elseif vcs is# 'mercurial' && !airline#util#has_lawrencium() continue endif let config = s:vcs_config[vcs] " Note that asynchronous update updates s:vcs_config only, and only " s:update_untracked updates b:buffer_vcs_config. If s:vcs_config is " invalidated again before s:update_untracked is called, then we lose the " result of the previous call, i.e. the head string is not updated. It " doesn't happen often in practice, so we let it be. if index(vcs_checks, 'untracked') > -1 call airline#async#vcs_untracked(config, file, vcs) endif " Check clean state of repo if index(vcs_checks, 'dirty') > -1 call airline#async#vcs_clean(config.dirty, file, vcs) endif endfor endfunction function! airline#extensions#branch#head() if !exists('b:buffer_vcs_config') call s:init_buffer() endif call s:update_branch() call s:update_untracked() if exists('b:airline_head') && !empty(b:airline_head) return b:airline_head endif let b:airline_head = '' let vcs_priority = get(g:, "airline#extensions#branch#vcs_priority", ["git", "mercurial"]) let heads = [] for vcs in vcs_priority if !empty(b:buffer_vcs_config[vcs].branch) let heads += [vcs] endif endfor for vcs in heads if !empty(b:airline_head) let b:airline_head .= ' | ' endif if len(heads) > 1 let b:airline_head .= s:vcs_config[vcs].exe .':' endif let b:airline_head .= s:format_name({s:vcs_config[vcs].display_branch}()) let additional = b:buffer_vcs_config[vcs].untracked if empty(additional) && \ has_key(b:buffer_vcs_config[vcs], 'dirty') && \ b:buffer_vcs_config[vcs].dirty let additional = g:airline_symbols['dirty'] endif let b:airline_head .= additional endfor if empty(heads) if airline#util#has_vcscommand() noa call VCSCommandEnableBufferSetup() if exists('b:VCSCommandBufferInfo') let b:airline_head = s:format_name(get(b:VCSCommandBufferInfo, 0, '')) endif endif endif if empty(heads) if airline#util#has_custom_scm() try let Fn = function(g:airline#extensions#branch#custom_head) let b:airline_head = Fn() endtry endif endif if exists("g:airline#extensions#branch#displayed_head_limit") let w:displayed_head_limit = g:airline#extensions#branch#displayed_head_limit if strwidth(b:airline_head) > w:displayed_head_limit - 1 let b:airline_head = \ airline#util#strcharpart(b:airline_head, 0, w:displayed_head_limit - 1) \ . (&encoding ==? 'utf-8' ? '…' : '.') endif endif return b:airline_head endfunction function! airline#extensions#branch#get_head() let head = airline#extensions#branch#head() let winwidth = get(airline#parts#get('branch'), 'minwidth', 120) let minwidth = empty(get(b:, 'airline_hunks', '')) ? 14 : 7 let head = airline#util#shorten(head, winwidth, minwidth) let symbol = get(g:, 'airline#extensions#branch#symbol', g:airline_symbols.branch) return empty(head) \ ? get(g:, 'airline#extensions#branch#empty_message', '') \ : printf('%s%s', empty(symbol) ? '' : symbol.(g:airline_symbols.space), head) endfunction function! s:reset_untracked_cache(shellcmdpost) " shellcmdpost - whether function was called as a result of ShellCmdPost hook if !g:airline#init#vim_async && !has('nvim') if a:shellcmdpost " Clear cache only if there was no error or the script uses an " asynchronous interface. Otherwise, cache clearing would overwrite " v:shell_error with a system() call inside get_*_untracked. if v:shell_error return endif endif endif let file = expand("%:p") for vcs in keys(s:vcs_config) " Dump the value of the cache for the current file. Partially mitigates the " issue of cache invalidation happening before a call to " s:update_untracked() call airline#extensions#branch#update_untracked_config(file, vcs) let s:vcs_config[vcs].untracked = {} endfor endfunction function! airline#extensions#branch#init(ext) call airline#parts#define_function('branch', 'airline#extensions#branch#get_head') autocmd ShellCmdPost,CmdwinLeave * unlet! b:airline_head b:airline_do_mq_check autocmd User AirlineBeforeRefresh unlet! b:airline_head b:airline_do_mq_check autocmd BufWritePost * call s:reset_untracked_cache(0) autocmd ShellCmdPost * call s:reset_untracked_cache(1) endfunction vim-airline-0.11/autoload/airline/extensions/bufferline.vim000066400000000000000000000021451356133765200241540ustar00rootroot00000000000000" MIT License. Copyright (c) 2013-2019 Bailey Ling et al. " Plugin: https://github.com/bling/vim-bufferline " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 if !exists('*bufferline#get_status_string') finish endif function! airline#extensions#bufferline#init(ext) if get(g:, 'airline#extensions#bufferline#overwrite_variables', 1) highlight bufferline_selected gui=bold cterm=bold term=bold highlight link bufferline_selected_inactive airline_c_inactive let g:bufferline_inactive_highlight = 'airline_c' let g:bufferline_active_highlight = 'bufferline_selected' let g:bufferline_active_buffer_left = '' let g:bufferline_active_buffer_right = '' let g:bufferline_separator = g:airline_symbols.space endif if exists("+autochdir") && &autochdir == 1 " if 'acd' is set, vim-airline uses the path section, so we need ot redefine this here as well call airline#parts#define_raw('path', '%{bufferline#refresh_status()}'.bufferline#get_status_string()) else call airline#parts#define_raw('file', '%{bufferline#refresh_status()}'.bufferline#get_status_string()) endif endfunction vim-airline-0.11/autoload/airline/extensions/capslock.vim000066400000000000000000000007431356133765200236340ustar00rootroot00000000000000" MIT License. Copyright (c) 2014-2019 Mathias Andersson et al. " Plugin: https://github.com/tpope/vim-capslock " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 if !exists('*CapsLockStatusline') finish endif function! airline#extensions#capslock#status() return tolower(CapsLockStatusline()) == '[caps]' ? 'CAPS' : '' endfunction function! airline#extensions#capslock#init(ext) call airline#parts#define_function('capslock', 'airline#extensions#capslock#status') endfunction vim-airline-0.11/autoload/airline/extensions/coc.vim000066400000000000000000000026461356133765200226050ustar00rootroot00000000000000" MIT License. Copyright (c) 2019 Peng Guanwen et al. " vim: et ts=2 sts=2 sw=2 " Plugin: https://github.com/neoclide/coc scriptencoding utf-8 let s:error_symbol = get(g:, 'airline#extensions#coc#error_symbol', 'E:') let s:warning_symbol = get(g:, 'airline#extensions#coc#warning_symbol', 'W:') function! airline#extensions#coc#get_warning() return airline#extensions#coc#get('warning') endfunction function! airline#extensions#coc#get_error() return airline#extensions#coc#get('error') endfunction function! airline#extensions#coc#get(type) if !exists(":CocCommand") return '' endif let _backup = get(g:, 'coc_stl_format', '') let is_err = (a:type is# 'error') if is_err let g:coc_stl_format = get(g:, 'airline#extensions#coc#stl_format_err', '%E{[%e(#%fe)]}') else let g:coc_stl_format = get(g:, 'airline#extensions#coc#stl_format_warn', '%W{[%w(#%fw)]}') endif let info = get(b:, 'coc_diagnostic_info', {}) if empty(info) | return '' | endif let cnt = get(info, a:type, 0) if !empty(_backup) let g:coc_stl_format = _backup endif if empty(cnt) return '' else return (is_err ? s:error_symbol : s:warning_symbol).cnt endif endfunction function! airline#extensions#coc#init(ext) call airline#parts#define_function('coc_error_count', 'airline#extensions#coc#get_error') call airline#parts#define_function('coc_warning_count', 'airline#extensions#coc#get_warning') endfunction vim-airline-0.11/autoload/airline/extensions/commandt.vim000066400000000000000000000007661356133765200236440ustar00rootroot00000000000000" MIT License. Copyright (c) 2013-2019 Bailey Ling et al. " Plugin: https://github.com/wincent/command-t " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 if !get(g:, 'command_t_loaded', 0) finish endif function! airline#extensions#commandt#apply(...) if bufname('%') ==# 'GoToFile' call airline#extensions#apply_left_override('CommandT', '') endif endfunction function! airline#extensions#commandt#init(ext) call a:ext.add_statusline_func('airline#extensions#commandt#apply') endfunction vim-airline-0.11/autoload/airline/extensions/csv.vim000066400000000000000000000016041356133765200226250ustar00rootroot00000000000000" MIT License. Copyright (c) 2013-2019 Bailey Ling, Christian Brabandt et al. " Plugin: https://github.com/chrisbra/csv.vim " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 if !get(g:, 'loaded_csv', 0) && !exists(':Table') finish endif let s:column_display = get(g:, 'airline#extensions#csv#column_display', 'Number') function! airline#extensions#csv#get_column() if exists('*CSV_WCol') if s:column_display ==# 'Name' return '['.CSV_WCol('Name').CSV_WCol().']' else return '['.CSV_WCol().']' endif endif return '' endfunction function! airline#extensions#csv#apply(...) if &ft ==# "csv" call airline#extensions#prepend_to_section('gutter', \ g:airline_left_alt_sep.' %{airline#extensions#csv#get_column()}') endif endfunction function! airline#extensions#csv#init(ext) call a:ext.add_statusline_func('airline#extensions#csv#apply') endfunction vim-airline-0.11/autoload/airline/extensions/ctrlp.vim000066400000000000000000000055351356133765200231650ustar00rootroot00000000000000" MIT License. Copyright (c) 2013-2019 Bailey Ling et al. " Plugin: https://github.com/ctrlpvim/ctrlp.vim " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 if !get(g:, 'loaded_ctrlp', 0) finish endif let s:color_template = get(g:, 'airline#extensions#ctrlp#color_template', 'insert') function! airline#extensions#ctrlp#generate_color_map(dark, light, white) return { \ 'CtrlPdark' : a:dark, \ 'CtrlPlight' : a:light, \ 'CtrlPwhite' : a:white, \ 'CtrlParrow1' : [ a:light[1] , a:white[1] , a:light[3] , a:white[3] , '' ] , \ 'CtrlParrow2' : [ a:white[1] , a:light[1] , a:white[3] , a:light[3] , '' ] , \ 'CtrlParrow3' : [ a:light[1] , a:dark[1] , a:light[3] , a:dark[3] , '' ] , \ } endfunction function! airline#extensions#ctrlp#load_theme(palette) if exists('a:palette.ctrlp') let theme = a:palette.ctrlp else let s:color_template = has_key(a:palette, s:color_template) ? s:color_template : 'insert' let theme = airline#extensions#ctrlp#generate_color_map( \ a:palette[s:color_template]['airline_c'], \ a:palette[s:color_template]['airline_b'], \ a:palette[s:color_template]['airline_a']) endif for key in keys(theme) call airline#highlighter#exec(key, theme[key]) endfor endfunction " Arguments: focus, byfname, regexp, prv, item, nxt, marked function! airline#extensions#ctrlp#ctrlp_airline(...) let b = airline#builder#new({'active': 1}) if a:2 == 'file' call b.add_section_spaced('CtrlPlight', 'by fname') endif if a:3 call b.add_section_spaced('CtrlPlight', 'regex') endif if get(g:, 'airline#extensions#ctrlp#show_adjacent_modes', 1) call b.add_section_spaced('CtrlPlight', a:4) call b.add_section_spaced('CtrlPwhite', a:5) call b.add_section_spaced('CtrlPlight', a:6) else call b.add_section_spaced('CtrlPwhite', a:5) endif call b.add_section_spaced('CtrlPdark', a:7) call b.split() call b.add_section_spaced('CtrlPdark', a:1) call b.add_section_spaced('CtrlPdark', a:2) call b.add_section_spaced('CtrlPlight', '%{getcwd()}') return b.build() endfunction " Argument: len function! airline#extensions#ctrlp#ctrlp_airline_status(...) let len = '%#CtrlPdark# '.a:1 let dir = '%=%<%#CtrlParrow3#'.g:airline_right_sep.'%#CtrlPlight# '.getcwd().' %*' return len.dir endfunction function! airline#extensions#ctrlp#apply(...) " disable statusline overwrite if ctrlp already did it return match(&statusline, 'CtrlPwhite') >= 0 ? -1 : 0 endfunction function! airline#extensions#ctrlp#init(ext) let g:ctrlp_status_func = { \ 'main': 'airline#extensions#ctrlp#ctrlp_airline', \ 'prog': 'airline#extensions#ctrlp#ctrlp_airline_status', \ } call a:ext.add_statusline_func('airline#extensions#ctrlp#apply') call a:ext.add_theme_func('airline#extensions#ctrlp#load_theme') endfunction vim-airline-0.11/autoload/airline/extensions/ctrlspace.vim000066400000000000000000000013621356133765200240130ustar00rootroot00000000000000" MIT License. Copyright (c) 2013-2019 Bailey Ling et al. " Plugin: https://github.com/szw/vim-ctrlspace " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 function! airline#extensions#ctrlspace#statusline(...) let spc = g:airline_symbols.space let padding = spc . spc . spc let cs = ctrlspace#context#Configuration().Symbols.CS let b = airline#builder#new({ 'active': 1 }) call b.add_section('airline_b', cs . padding . ctrlspace#api#StatuslineModeSegment(s:padding)) call b.split() call b.add_section('airline_x', spc . ctrlspace#api#StatuslineTabSegment() . spc) return b.build() endfunction function! airline#extensions#ctrlspace#init(ext) let g:CtrlSpaceStatuslineFunction = "airline#extensions#ctrlspace#statusline()" endfunction vim-airline-0.11/autoload/airline/extensions/cursormode.vim000066400000000000000000000064131356133765200242170ustar00rootroot00000000000000" MIT Licsense. " Plugin: https://github.com/vheon/vim-cursormode " Copyright (C) 2014 Andrea Cedraro , " Copyright (C) 2017 Eduardo Suarez-Santana scriptencoding utf-8 let s:is_win = has('win32') || has('win64') let s:is_iTerm = exists('$TERM_PROGRAM') && $TERM_PROGRAM =~# 'iTerm.app' let s:is_AppleTerminal = exists('$TERM_PROGRAM') && $TERM_PROGRAM =~# 'Apple_Terminal' let s:is_good = !has('gui_running') && !s:is_win && !s:is_AppleTerminal let s:last_mode = '' if !exists('g:cursormode_exit_mode') let g:cursormode_exit_mode='n' endif function! airline#extensions#cursormode#tmux_escape(escape) return '\033Ptmux;'.substitute(a:escape, '\\033', '\\033\\033', 'g').'\033\\' endfunction let s:iTerm_escape_template = '\033]Pl%s\033\\' let s:xterm_escape_template = '\033]12;%s\007' function! s:get_mode() return call(get(g:, 'cursormode_mode_func', 'mode'), []) endfunction function! airline#extensions#cursormode#set(...) let mode = s:get_mode() if mode !=# s:last_mode let s:last_mode = mode call s:set_cursor_color_for(mode) endif return '' endfunction function! s:set_cursor_color_for(mode) let mode = a:mode for mode in [a:mode, a:mode.&background] if has_key(s:color_map, mode) try let save_eventignore = &eventignore set eventignore=all let save_shelltemp = &shelltemp set noshelltemp silent call system(s:build_command(s:color_map[mode])) return finally let &shelltemp = save_shelltemp let &eventignore = save_eventignore endtry endif endfor endfunction function! s:build_command(color) if s:is_iTerm let color = substitute(a:color, '^#', '', '') let escape_template = s:iTerm_escape_template else let color = a:color let escape_template = s:xterm_escape_template endif let escape = printf(escape_template, color) if exists('$TMUX') let escape = airline#extensions#cursormode#tmux_escape(escape) endif return "printf '".escape."' > /dev/tty" endfunction function! s:get_color_map() if exists('g:cursormode_color_map') return g:cursormode_color_map endif try let map = g:cursormode#{g:colors_name}#color_map return map catch return { \ "nlight": "#000000", \ "ndark": "#BBBBBB", \ "i": "#0000BB", \ "v": "#FF5555", \ "V": "#BBBB00", \ "\": "#BB00BB", \ } endtry endfunction augroup airline#extensions#cursormode autocmd! autocmd VimLeave * nested call s:set_cursor_color_for(g:cursormode_exit_mode) " autocmd VimEnter * call airline#extensions#cursormode#activate() autocmd Colorscheme * call airline#extensions#cursormode#activate() augroup END function! airline#extensions#cursormode#activate() let s:color_map = s:get_color_map() call airline#extensions#cursormode#set() endfunction function! airline#extensions#cursormode#apply(...) let w:airline_section_a = get(w:, 'airline_section_a', g:airline_section_a) let w:airline_section_a .= '%{airline#extensions#cursormode#set()}' endfunction function! airline#extensions#cursormode#init(ext) let s:color_map = s:get_color_map() call a:ext.add_statusline_func('airline#extensions#cursormode#apply') endfunction vim-airline-0.11/autoload/airline/extensions/default.vim000066400000000000000000000066001356133765200234570ustar00rootroot00000000000000" MIT License. Copyright (c) 2013-2019 Bailey Ling et al. " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 let s:section_use_groups = get(g:, 'airline#extensions#default#section_use_groupitems', 1) let s:section_truncate_width = get(g:, 'airline#extensions#default#section_truncate_width', { \ 'b': 79, \ 'x': 60, \ 'y': 88, \ 'z': 45, \ 'warning': 80, \ 'error': 80, \ }) let s:layout = get(g:, 'airline#extensions#default#layout', [ \ [ 'a', 'b', 'c' ], \ [ 'x', 'y', 'z', 'warning', 'error' ] \ ]) function! s:get_section(winnr, key, ...) if has_key(s:section_truncate_width, a:key) if airline#util#winwidth(a:winnr) < s:section_truncate_width[a:key] return '' endif endif let spc = g:airline_symbols.space if !exists('g:airline_section_{a:key}') return '' endif let text = airline#util#getwinvar(a:winnr, 'airline_section_'.a:key, g:airline_section_{a:key}) let [prefix, suffix] = [get(a:000, 0, '%('.spc), get(a:000, 1, spc.'%)')] return empty(text) ? '' : prefix.text.suffix endfunction function! s:build_sections(builder, context, keys) for key in a:keys if (key == 'warning' || key == 'error') && !a:context.active continue endif call s:add_section(a:builder, a:context, key) endfor endfunction " There still is a highlighting bug when using groups %(%) in the statusline, " deactivate it, unless it is fixed (7.4.1511) if s:section_use_groups && (v:version >= 704 || (v:version >= 703 && has('patch81'))) function! s:add_section(builder, context, key) let condition = (a:key is# "warning" || a:key is# "error") && \ (v:version == 704 && !has("patch1511")) " i have no idea why the warning section needs special treatment, but it's " needed to prevent separators from showing up if ((a:key == 'error' || a:key == 'warning') && empty(s:get_section(a:context.winnr, a:key))) return endif if condition call a:builder.add_raw('%(') endif call a:builder.add_section('airline_'.a:key, s:get_section(a:context.winnr, a:key)) if condition call a:builder.add_raw('%)') endif endfunction else " older version don't like the use of %(%) function! s:add_section(builder, context, key) if ((a:key == 'error' || a:key == 'warning') && empty(s:get_section(a:context.winnr, a:key))) return endif if a:key == 'warning' call a:builder.add_raw('%#airline_warning#'.s:get_section(a:context.winnr, a:key)) elseif a:key == 'error' call a:builder.add_raw('%#airline_error#'.s:get_section(a:context.winnr, a:key)) else call a:builder.add_section('airline_'.a:key, s:get_section(a:context.winnr, a:key)) endif endfunction endif function! airline#extensions#default#apply(builder, context) let winnr = a:context.winnr let active = a:context.active if airline#util#getwinvar(winnr, 'airline_render_left', active || (!active && !g:airline_inactive_collapse)) call s:build_sections(a:builder, a:context, s:layout[0]) else let text = s:get_section(winnr, 'c') if empty(text) let text = ' %f%m ' endif call a:builder.add_section('airline_c'.(a:context.bufnr), text) endif call a:builder.split(s:get_section(winnr, 'gutter', '', '')) if airline#util#getwinvar(winnr, 'airline_render_right', 1) call s:build_sections(a:builder, a:context, s:layout[1]) endif return 1 endfunction vim-airline-0.11/autoload/airline/extensions/denite.vim000066400000000000000000000036511356133765200233060ustar00rootroot00000000000000" MIT License. Copyright (c) 2017-2019 Thomas Dy et al. " Plugin: https://github.com/Shougo/denite.nvim " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 if !get(g:, 'loaded_denite', 0) finish endif let s:denite_ver = (exists('*denite#get_status_mode') ? 2 : 3) " Denite does not use vim's built-in modal editing but has a custom prompt " that implements its own insert/normal mode so we have to handle changing the " highlight function! airline#extensions#denite#check_denite_mode(bufnr) if &filetype !=# 'denite' || &filetype !=# 'denite-filter' return '' endif if s:denite_ver == 3 let mode = split(denite#get_status("mode"), ' ') else let mode = split(denite#get_status_mode(), ' ') endif let mode = tolower(get(mode, 1, '')) if !exists('b:denite_mode_cache') || mode != b:denite_mode_cache call airline#highlighter#highlight([mode], a:bufnr) let b:denite_mode_cache = mode endif return '' endfunction function! airline#extensions#denite#apply(...) if &filetype ==# 'denite' || &filetype ==# 'denite-filter' let w:airline_skip_empty_sections = 0 call a:1.add_section('airline_a', ' Denite %{airline#extensions#denite#check_denite_mode('.a:2['bufnr'].')}') if s:denite_ver == 3 call a:1.add_section('airline_c', ' %{denite#get_status("sources")}') call a:1.split() call a:1.add_section('airline_y', ' %{denite#get_status("path")} ') call a:1.add_section('airline_z', ' %{denite#get_status("linenr")} ') else call a:1.add_section('airline_c', ' %{denite#get_status_sources()}') call a:1.split() call a:1.add_section('airline_y', ' %{denite#get_status_path()} ') call a:1.add_section('airline_z', ' %{denite#get_status_linenr()} ') endif return 1 endif endfunction function! airline#extensions#denite#init(ext) call denite#custom#option('_', 'statusline', 0) call a:ext.add_statusline_func('airline#extensions#denite#apply') endfunction vim-airline-0.11/autoload/airline/extensions/eclim.vim000066400000000000000000000036561356133765200231340ustar00rootroot00000000000000" MIT License. Copyright (c) 2013-2019 Bailey Ling et al. " PLugin: https://eclim.org " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 if !exists(':ProjectCreate') finish endif function! airline#extensions#eclim#creat_line(...) if &filetype == "tree" let builder = a:1 call builder.add_section('airline_a', ' Project ') call builder.add_section('airline_b', ' %f ') call builder.add_section('airline_c', '') return 1 endif endfunction function! airline#extensions#eclim#get_warnings() " Cache vavlues, so that it isn't called too often if exists("s:eclim_errors") && \ get(b:, 'airline_changenr', 0) == changenr() return s:eclim_errors endif let eclimList = eclim#display#signs#GetExisting() let s:eclim_errors = '' if !empty(eclimList) " Remove any non-eclim signs (see eclim#display#signs#Update) " First check for just errors since they are more important. " If there are no errors, then check for warnings. let errorList = filter(copy(eclimList), 'v:val.name =~ "^\\(qf_\\)\\?\\(error\\)$"') if (empty(errorList)) " use the warnings call filter(eclimList, 'v:val.name =~ "^\\(qf_\\)\\?\\(warning\\)$"') let type = 'W' else " Use the errors let eclimList = errorList let type = 'E' endif if !empty(eclimList) let errorsLine = eclimList[0]['line'] let errorsNumber = len(eclimList) let errors = "[Eclim:" . type . " line:".string(errorsLine)." (".string(errorsNumber).")]" if !exists(':SyntasticCheck') || SyntasticStatuslineFlag() == '' let s:eclim_errors = errors.(g:airline_symbols.space) endif endif endif let b:airline_changenr = changenr() return s:eclim_errors endfunction function! airline#extensions#eclim#init(ext) call airline#parts#define_function('eclim', 'airline#extensions#eclim#get_warnings') call a:ext.add_statusline_func('airline#extensions#eclim#creat_line') endfunction vim-airline-0.11/autoload/airline/extensions/example.vim000066400000000000000000000037621356133765200234740ustar00rootroot00000000000000" MIT License. Copyright (c) 2013-2019 Bailey Ling et al. " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 " we don't actually want this loaded :P finish " Due to some potential rendering issues, the use of the `space` variable is " recommended. let s:spc = g:airline_symbols.space " Extension specific variables can be defined the usual fashion. if !exists('g:airline#extensions#example#number_of_cats') let g:airline#extensions#example#number_of_cats = 42 endif " First we define an init function that will be invoked from extensions.vim function! airline#extensions#example#init(ext) " Here we define a new part for the plugin. This allows users to place this " extension in arbitrary locations. call airline#parts#define_raw('cats', '%{airline#extensions#example#get_cats()}') " Next up we add a funcref so that we can run some code prior to the " statusline getting modifed. call a:ext.add_statusline_func('airline#extensions#example#apply') " You can also add a funcref for inactive statuslines. " call a:ext.add_inactive_statusline_func('airline#extensions#example#unapply') endfunction " This function will be invoked just prior to the statusline getting modified. function! airline#extensions#example#apply(...) " First we check for the filetype. if &filetype == "nyancat" " Let's say we want to append to section_c, first we check if there's " already a window-local override, and if not, create it off of the global " section_c. let w:airline_section_c = get(w:, 'airline_section_c', g:airline_section_c) " Then we just append this extenion to it, optionally using separators. let w:airline_section_c .= s:spc.g:airline_left_alt_sep.s:spc.'%{airline#extensions#example#get_cats()}' endif endfunction " Finally, this function will be invoked from the statusline. function! airline#extensions#example#get_cats() let cats = '' for i in range(1, g:airline#extensions#example#number_of_cats) let cats .= ' (,,,)=(^.^)=(,,,) ' endfor return cats endfunction vim-airline-0.11/autoload/airline/extensions/fugitiveline.vim000066400000000000000000000032721356133765200245270ustar00rootroot00000000000000" MIT License. Copyright (c) 2017-2019 Cimbali et al " Plugin: https://github.com/tpope/vim-fugitive " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 if !airline#util#has_fugitive() finish endif function! s:ModifierFlags() return (exists("+autochdir") && &autochdir) ? ':p' : ':.' endfunction function! airline#extensions#fugitiveline#bufname() if !exists('b:fugitive_name') let b:fugitive_name = '' try if bufname('%') =~? '^fugitive:' && exists('*FugitiveReal') let b:fugitive_name = FugitiveReal(bufname('%')) elseif exists('b:git_dir') && exists('*fugitive#repo') if get(b:, 'fugitive_type', '') is# 'blob' let b:fugitive_name = fugitive#repo().translate(FugitivePath(@%, '')) endif elseif exists('b:git_dir') && !exists('*fugitive#repo') let buffer = fugitive#buffer() if buffer.type('blob') let b:fugitive_name = buffer.repo().translate(buffer.path('/')) endif endif catch endtry endif let fmod = s:ModifierFlags() if empty(b:fugitive_name) return fnamemodify(bufname('%'), fmod) else return fnamemodify(b:fugitive_name, fmod). " [git]" endif endfunction function! airline#extensions#fugitiveline#init(ext) if exists("+autochdir") && &autochdir " if 'acd' is set, vim-airline uses the path section, so we need to redefine this here as well call airline#parts#define_raw('path', '%<%{airline#extensions#fugitiveline#bufname()}%m') else call airline#parts#define_raw('file', '%<%{airline#extensions#fugitiveline#bufname()}%m') endif autocmd ShellCmdPost,CmdwinLeave * unlet! b:fugitive_name autocmd User AirlineBeforeRefresh unlet! b:fugitive_name endfunction vim-airline-0.11/autoload/airline/extensions/grepper.vim000066400000000000000000000007421356133765200235000ustar00rootroot00000000000000" MIT License. Copyright (c) 2014-2019 Mathias Andersson et al. " Plugin: https://github.com/mhinz/vim-grepper " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 if !get(g:, 'loaded_grepper', 0) finish endif function! airline#extensions#grepper#status() let msg = grepper#statusline() return empty(msg) ? '' : 'grepper' endfunction function! airline#extensions#grepper#init(ext) call airline#parts#define_function('grepper', 'airline#extensions#grepper#status') endfunction vim-airline-0.11/autoload/airline/extensions/gutentags.vim000066400000000000000000000007761356133765200240440ustar00rootroot00000000000000" MIT License. Copyright (c) 2014-2019 Mathias Andersson et al. " Plugin: https://github.com/ludovicchabant/vim-gutentags " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 if !get(g:, 'loaded_gutentags', 0) finish endif function! airline#extensions#gutentags#status() let msg = gutentags#statusline() return empty(msg) ? '' : 'Gen. ' . msg endfunction function! airline#extensions#gutentags#init(ext) call airline#parts#define_function('gutentags', 'airline#extensions#gutentags#status') endfunction vim-airline-0.11/autoload/airline/extensions/hunks.vim000066400000000000000000000060611356133765200231640ustar00rootroot00000000000000" MIT License. Copyright (c) 2013-2019 Bailey Ling et al. " Plugin: vim-gitgutter, vim-signify, changesPlugin, quickfixsigns " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 if !get(g:, 'loaded_signify', 0) && !get(g:, 'loaded_gitgutter', 0) && !get(g:, 'loaded_changes', 0) && !get(g:, 'loaded_quickfixsigns', 0) finish endif let s:non_zero_only = get(g:, 'airline#extensions#hunks#non_zero_only', 0) let s:hunk_symbols = get(g:, 'airline#extensions#hunks#hunk_symbols', ['+', '~', '-']) function! s:get_hunks_signify() let hunks = sy#repo#get_stats() if hunks[0] >= 0 return hunks endif return [] endfunction function! s:is_branch_empty() return exists('*airline#extensions#branch#head') && \ empty(get(b:, 'airline_head', '')) endfunction function! s:get_hunks_gitgutter() if !get(g:, 'gitgutter_enabled', 0) || s:is_branch_empty() return '' endif return GitGutterGetHunkSummary() endfunction function! s:get_hunks_changes() if !get(b:, 'changes_view_enabled', 0) || s:is_branch_empty() return [] endif let hunks = changes#GetStats() return hunks == [0, 0, 0] ? [] : hunks endfunction function! s:get_hunks_empty() return '' endfunction function! airline#extensions#hunks#get_raw_hunks() if !exists('b:source_func') || get(b:, 'source_func', '') is# 's:get_hunks_empty' if get(g:, 'loaded_signify') && sy#buffer_is_active() let b:source_func = 's:get_hunks_signify' elseif exists('*GitGutterGetHunkSummary') let b:source_func = 's:get_hunks_gitgutter' elseif exists('*changes#GetStats') let b:source_func = 's:get_hunks_changes' elseif exists('*quickfixsigns#vcsdiff#GetHunkSummary') let b:source_func = 'quickfixsigns#vcsdiff#GetHunkSummary' else let b:source_func = 's:get_hunks_empty' endif endif return {b:source_func}() endfunction function! airline#extensions#hunks#get_hunks() if !get(w:, 'airline_active', 0) return '' endif " Cache values, so that it isn't called too often if exists("b:airline_hunks") && \ get(b:, 'airline_changenr', 0) == b:changedtick && \ airline#util#winwidth() == get(s:, 'airline_winwidth', 0) && \ get(b:, 'source_func', '') isnot# 's:get_hunks_signify' && \ get(b:, 'source_func', '') isnot# 's:get_hunks_gitgutter' && \ get(b:, 'source_func', '') isnot# 's:get_hunks_empty' && \ get(b:, 'source_func', '') isnot# 's:get_hunks_changes' return b:airline_hunks endif let hunks = airline#extensions#hunks#get_raw_hunks() let string = '' let winwidth = get(airline#parts#get('hunks'), 'minwidth', 100) if !empty(hunks) for i in [0, 1, 2] if (s:non_zero_only == 0 && airline#util#winwidth() > winwidth) || hunks[i] > 0 let string .= printf('%s%s ', s:hunk_symbols[i], hunks[i]) endif endfor endif let b:airline_hunks = string let b:airline_changenr = b:changedtick let s:airline_winwidth = airline#util#winwidth() return string endfunction function! airline#extensions#hunks#init(ext) call airline#parts#define_function('hunks', 'airline#extensions#hunks#get_hunks') endfunction vim-airline-0.11/autoload/airline/extensions/keymap.vim000066400000000000000000000010411356133765200233130ustar00rootroot00000000000000" MIT License. Copyright (c) 2013-2019 Doron Behar, C.Brabandt et al. " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 if !has('keymap') finish endif function! airline#extensions#keymap#status() if (get(g:, 'airline#extensions#keymap#enabled', 1) && has('keymap')) return printf('%s', (!empty(&keymap) ? (g:airline_symbols.keymap . ' '. &keymap) : '')) else return '' endif endfunction function! airline#extensions#keymap#init(ext) call airline#parts#define_function('keymap', 'airline#extensions#keymap#status') endfunction vim-airline-0.11/autoload/airline/extensions/languageclient.vim000066400000000000000000000064651356133765200250260ustar00rootroot00000000000000" MIT License. Copyright (c) 2013-2019 Bjorn Neergaard, hallettj et al. " Plugin: https://github.com/autozimu/LanguageClient-neovim " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 let s:error_symbol = get(g:, 'airline#extensions#languageclient#error_symbol', 'E:') let s:warning_symbol = get(g:, 'airline#extensions#languageclient#warning_symbol', 'W:') let s:show_line_numbers = get(g:, 'airline#extensions#languageclient#show_line_numbers', 1) " Severity codes from the LSP spec let s:severity_error = 1 let s:severity_warning = 2 let s:severity_info = 3 let s:severity_hint = 4 " After each LanguageClient state change `s:diagnostics` will be populated with " a map from file names to lists of errors, warnings, informational messages, " and hints. let s:diagnostics = {} function! s:languageclient_refresh() if get(g:, 'airline_skip_empty_sections', 0) exe ':AirlineRefresh!' endif endfunction function! s:record_diagnostics(state) " The returned message might not have the 'result' key if has_key(a:state, 'result') let result = json_decode(a:state.result) let s:diagnostics = result.diagnostics endif call s:languageclient_refresh() endfunction function! s:get_diagnostics() call LanguageClient#getState(function("s:record_diagnostics")) endfunction function! s:diagnostics_for_buffer() return get(s:diagnostics, expand('%:p'), []) endfunction function! s:airline_languageclient_count(cnt, symbol) return a:cnt ? a:symbol. a:cnt : '' endfunction function! s:airline_languageclient_get_line_number(type) abort let linenumber_of_first_problem = 0 for d in s:diagnostics_for_buffer() if has_key(d, 'severity') && d.severity == a:type let linenumber_of_first_problem = d.range.start.line break endif endfor if linenumber_of_first_problem == 0 return '' endif let open_lnum_symbol = get(g:, 'airline#extensions#languageclient#open_lnum_symbol', '(L') let close_lnum_symbol = get(g:, 'airline#extensions#languageclient#close_lnum_symbol', ')') return open_lnum_symbol . linenumber_of_first_problem . close_lnum_symbol endfunction function! airline#extensions#languageclient#get(type) let is_err = a:type == s:severity_error let symbol = is_err ? s:error_symbol : s:warning_symbol let cnt = 0 for d in s:diagnostics_for_buffer() if has_key(d, 'severity') && d.severity == a:type let cnt += 1 endif endfor if cnt == 0 return '' endif if s:show_line_numbers == 1 return s:airline_languageclient_count(cnt, symbol) . airline_languageclient_get_line_number(a:type) else return s:airline_languageclient_count(cnt, symbol) endif endfunction function! airline#extensions#languageclient#get_warning() return airline#extensions#languageclient#get(s:severity_warning) endfunction function! airline#extensions#languageclient#get_error() return airline#extensions#languageclient#get(s:severity_error) endfunction function! airline#extensions#languageclient#init(ext) call airline#parts#define_function('languageclient_error_count', 'airline#extensions#languageclient#get_error') call airline#parts#define_function('languageclient_warning_count', 'airline#extensions#languageclient#get_warning') augroup airline_languageclient autocmd! autocmd User LanguageClientDiagnosticsChanged call get_diagnostics() augroup END endfunction vim-airline-0.11/autoload/airline/extensions/localsearch.vim000066400000000000000000000022431356133765200243120ustar00rootroot00000000000000" MIT License. Copyright (c) 2018-2019 mox et al. " Plugin: https://github.com/mox-mox/localsearch " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 let s:enabled = get(g:, 'airline#extensions#localsearch#enabled', 1) if !get(g:, 'loaded_localsearch', 0) || !s:enabled || get(g:, 'airline#extensions#localsearch#loaded', 0) finish endif let g:airline#extensions#localsearch#loaded = 001 let s:spc = g:airline_symbols.space function! airline#extensions#localsearch#load_theme(palette) call airline#highlighter#exec('localsearch_dark', [ '#ffffff' , '#000000' , 15 , 1 , '']) endfunction function! airline#extensions#localsearch#init(ext) call a:ext.add_theme_func('airline#extensions#localsearch#load_theme') call a:ext.add_statusline_func('airline#extensions#localsearch#apply') endfunction function! airline#extensions#localsearch#apply(...) " first variable is the statusline builder let builder = a:1 """"" WARNING: the API for the builder is not finalized and may change if exists('#localsearch#WinEnter') " If localsearch mode is enabled call builder.add_section('localsearch_dark', s:spc.airline#section#create('LS').s:spc) endif return 0 endfunction vim-airline-0.11/autoload/airline/extensions/neomake.vim000066400000000000000000000021671356133765200234560ustar00rootroot00000000000000" MIT License. Copyright (c) 2013-2019 Bailey Ling et al. " Plugin: https://github.com/neomake/neomake " vim: et ts=2 sts=2 sw=2 if !exists(':Neomake') finish endif let s:error_symbol = get(g:, 'airline#extensions#neomake#error_symbol', 'E:') let s:warning_symbol = get(g:, 'airline#extensions#neomake#warning_symbol', 'W:') function! s:get_counts() let l:counts = neomake#statusline#LoclistCounts() if empty(l:counts) return neomake#statusline#QflistCounts() else return l:counts endif endfunction function! airline#extensions#neomake#get_warnings() let counts = s:get_counts() let warnings = get(counts, 'W', 0) return warnings ? s:warning_symbol.warnings : '' endfunction function! airline#extensions#neomake#get_errors() let counts = s:get_counts() let errors = get(counts, 'E', 0) return errors ? s:error_symbol.errors : '' endfunction function! airline#extensions#neomake#init(ext) call airline#parts#define_function('neomake_warning_count', 'airline#extensions#neomake#get_warnings') call airline#parts#define_function('neomake_error_count', 'airline#extensions#neomake#get_errors') endfunction vim-airline-0.11/autoload/airline/extensions/netrw.vim000066400000000000000000000021041356133765200231650ustar00rootroot00000000000000" MIT License. Copyright (c) 2013-2019 Bailey Ling et al. " Plugin: http://www.drchip.org/astronaut/vim/#NETRW " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 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 = (get(g:, 'netrw_sort_direction', 'n') =~ 'n') ? '+' : '-' return g:netrw_sort_by . (g:airline_symbols.space) . '[' . order . ']' endfunction vim-airline-0.11/autoload/airline/extensions/nrrwrgn.vim000066400000000000000000000044121356133765200235310ustar00rootroot00000000000000" MIT License. Copyright (c) 2013-2019 Bailey Ling, Christian Brabandt et al. " Plugin: https://github.com/chrisbra/NrrwRgn " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 if !get(g:, 'loaded_nrrw_rgn', 0) finish endif function! airline#extensions#nrrwrgn#apply(...) if exists(":WidenRegion") == 2 let spc = g:airline_symbols.space if !exists("*nrrwrgn#NrrwRgnStatus()") || empty(nrrwrgn#NrrwRgnStatus()) call a:1.add_section('airline_a', printf('%s[Narrowed%s#%d]', spc, spc, b:nrrw_instn)) let bufname=(get(b:, 'orig_buf', 0) ? bufname(b:orig_buf) : substitute(bufname('%'), '^Nrrwrgn_\zs.*\ze_\d\+$', submatch(0), '')) call a:1.add_section('airline_c', spc.bufname.spc) call a:1.split() else let dict=nrrwrgn#NrrwRgnStatus() let vmode = { 'v': 'Char ', 'V': 'Line ', '': 'Block '} let mode = dict.visual ? vmode[dict.visual] : vmode['V'] let winwidth = airline#util#winwidth() if winwidth < 80 let mode = mode[0] endif let title = (winwidth < 80 ? "Nrrw" : "Narrowed ") let multi = (winwidth < 80 ? 'M' : 'Multi') call a:1.add_section('airline_a', printf('[%s%s%s#%d]%s', (dict.multi ? multi : ""), \ title, mode, b:nrrw_instn, spc)) let name = dict.fullname if name !=# '[No Name]' if winwidth > 100 " need some space let name = fnamemodify(dict.fullname, ':~') if strlen(name) > 8 " shorten name let name = substitute(name, '\(.\)[^/\\]*\([/\\]\)', '\1\2', 'g') endif else let name = fnamemodify(dict.fullname, ':t') endif endif let range=(dict.multi ? '' : printf("[%d-%d]", dict.start[1], dict.end[1])) call a:1.add_section('airline_c', printf("%s %s %s", name, range, \ dict.enabled ? (&encoding ==? 'utf-8' ? "\u2713" : '') : '!')) call a:1.split() call a:1.add_section('airline_x', get(g:, 'airline_section_x').spc) call a:1.add_section('airline_y', spc.get(g:, 'airline_section_y').spc) call a:1.add_section('airline_z', spc.get(g:, 'airline_section_z')) endif return 1 endif endfunction function! airline#extensions#nrrwrgn#init(ext) call a:ext.add_statusline_func('airline#extensions#nrrwrgn#apply') endfunction vim-airline-0.11/autoload/airline/extensions/obsession.vim000066400000000000000000000012361356133765200240370ustar00rootroot00000000000000" MIT License. Copyright (c) 2013-2019 Bailey Ling et al. " Plugin: https://github.com/tpope/vim-obsession " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 if !exists('*ObsessionStatus') finish endif let s:spc = g:airline_symbols.space if !exists('g:airline#extensions#obsession#indicator_text') let g:airline#extensions#obsession#indicator_text = '$' endif function! airline#extensions#obsession#init(ext) call airline#parts#define_function('obsession', 'airline#extensions#obsession#get_status') endfunction function! airline#extensions#obsession#get_status() return ObsessionStatus((g:airline#extensions#obsession#indicator_text . s:spc), '') endfunction vim-airline-0.11/autoload/airline/extensions/po.vim000066400000000000000000000063501356133765200224530ustar00rootroot00000000000000" MIT License. Copyright (c) 2013-2019 Bailey Ling, Christian Brabandt et al. " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 function! airline#extensions#po#shorten() " Format and shorte the output of msgfmt let b:airline_po_stats = substitute(get(b:, 'airline_po_stats', ''), ' \(message\|translation\)s*\.*', '', 'g') let b:airline_po_stats = substitute(b:airline_po_stats, ', ', '/', 'g') if exists("g:airline#extensions#po#displayed_limit") let w:displayed_po_limit = g:airline#extensions#po#displayed_limit if len(b:airline_po_stats) > w:displayed_po_limit - 1 let b:airline_po_stats = b:airline_po_stats[0:(w:displayed_po_limit - 2)].(&encoding==?'utf-8' ? '…' : '.'). ']' endif endif if strlen(get(b:, 'airline_po_stats', '')) >= 30 && airline#util#winwidth() < 150 let fuzzy = '' let untranslated = '' let messages = '' " Shorten [120 translated, 50 fuzzy, 4 untranslated] to [120T/50F/4U] if b:airline_po_stats =~ 'fuzzy' let fuzzy = substitute(b:airline_po_stats, '.*\(\d\+\) fuzzy.*', '\1F', '') if fuzzy == '0F' let fuzzy = '' endif endif if b:airline_po_stats =~ 'untranslated' let untranslated = substitute(b:airline_po_stats, '.*\(\d\+\) untranslated.*', '\1U', '') if untranslated == '0U' let untranslated = '' endif endif let messages = substitute(b:airline_po_stats, '\(\d\+\) translated.*', '\1T', '') let b:airline_po_stats = printf('%s%s%s', fuzzy, (empty(fuzzy) || empty(untranslated) ? '' : '/'), untranslated) if strlen(b:airline_po_stats) < 8 let b:airline_po_stats = messages. (!empty(b:airline_po_stats) ? '/':''). b:airline_po_stats endif endif let b:airline_po_stats = '['.b:airline_po_stats. ']' endfunction function! airline#extensions#po#on_winenter() " only reset cache, if the window size changed if get(b:, 'airline_winwidth', 0) != airline#util#winwidth() let b:airline_winwidth = airline#util#winwidth() " needs re-formatting unlet! b:airline_po_stats endif endfunction function! airline#extensions#po#apply(...) if &ft ==# 'po' call airline#extensions#prepend_to_section('z', '%{airline#extensions#po#stats()}') " Also reset the cache variable, if a window has been split, e.g. the winwidth changed autocmd airline BufWritePost * unlet! b:airline_po_stats autocmd airline WinEnter * call airline#extensions#po#on_winenter() endif endfunction function! airline#extensions#po#stats() if exists('b:airline_po_stats') && !empty(b:airline_po_stats) return b:airline_po_stats endif let cmd = 'msgfmt --statistics -o /dev/null -- ' if g:airline#init#vim_async call airline#async#get_msgfmt_stat(cmd, expand('%:p')) elseif has("nvim") call airline#async#nvim_get_msgfmt_stat(cmd, expand('%:p')) else let airline_po_stats = system(cmd. shellescape(expand('%:p'))) if v:shell_error return '' endif try let b:airline_po_stats = split(airline_po_stats, '\n')[0] catch let b:airline_po_stats = '' endtry call airline#extensions#po#shorten() endif return get(b:, 'airline_po_stats', '') endfunction function! airline#extensions#po#init(ext) call a:ext.add_statusline_func('airline#extensions#po#apply') endfunction vim-airline-0.11/autoload/airline/extensions/promptline.vim000066400000000000000000000024761356133765200242330ustar00rootroot00000000000000" MIT License. Copyright (c) 2013-2019 Bailey Ling et al. " Plugin: https://github.com/edkolev/promptline.vim " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 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 vim-airline-0.11/autoload/airline/extensions/quickfix.vim000066400000000000000000000036701356133765200236620ustar00rootroot00000000000000" MIT License. Copyright (c) 2013-2019 Bailey Ling et al. " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 if !exists('g:airline#extensions#quickfix#quickfix_text') let g:airline#extensions#quickfix#quickfix_text = 'Quickfix' endif if !exists('g:airline#extensions#quickfix#location_text') let g:airline#extensions#quickfix#location_text = 'Location' endif function! airline#extensions#quickfix#apply(...) if &buftype == 'quickfix' let w:airline_section_a = airline#extensions#quickfix#get_type() let w:airline_section_b = '%{get(w:, "quickfix_title", "")}' let w:airline_section_c = '' let w:airline_section_x = '' endif endfunction function! airline#extensions#quickfix#init(ext) call a:ext.add_statusline_func('airline#extensions#quickfix#apply') call a:ext.add_inactive_statusline_func('airline#extensions#quickfix#inactive_qf_window') endfunction function! airline#extensions#quickfix#inactive_qf_window(...) if getbufvar(a:2.bufnr, '&filetype') is# 'qf' && !empty(airline#util#getwinvar(a:2.winnr, 'quickfix_title', '')) call setwinvar(a:2.winnr, 'airline_section_c', '[%{get(w:, "quickfix_title", "")}] %f %m') endif endfunction function! airline#extensions#quickfix#get_type() if exists("*win_getid") && exists("*getwininfo") let dict = getwininfo(win_getid()) if len(dict) > 0 && get(dict[0], 'quickfix', 0) && !get(dict[0], 'loclist', 0) return g:airline#extensions#quickfix#quickfix_text elseif len(dict) > 0 && get(dict[0], 'quickfix', 0) && get(dict[0], 'loclist', 0) return g:airline#extensions#quickfix#location_text endif endif redir => buffers silent ls redir END let nr = bufnr('%') for buf in split(buffers, '\n') if match(buf, '\v^\s*'.nr) > -1 if match(buf, '\cQuickfix') > -1 return g:airline#extensions#quickfix#quickfix_text else return g:airline#extensions#quickfix#location_text endif endif endfor return '' endfunction vim-airline-0.11/autoload/airline/extensions/syntastic.vim000066400000000000000000000026711356133765200240600ustar00rootroot00000000000000" MIT License. Copyright (c) 2013-2019 Bailey Ling et al. " Plugin: https://github.com/vim-syntastic/syntastic " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 if !exists(':SyntasticCheck') finish endif let s:error_symbol = get(g:, 'airline#extensions#syntastic#error_symbol', 'E:') let s:warning_symbol = get(g:, 'airline#extensions#syntastic#warning_symbol', 'W:') function! airline#extensions#syntastic#get_warning() return airline#extensions#syntastic#get('warning') endfunction function! airline#extensions#syntastic#get_error() return airline#extensions#syntastic#get('error') endfunction function! airline#extensions#syntastic#get(type) let _backup = get(g:, 'syntastic_stl_format', '') let is_err = (a:type is# 'error') if is_err let g:syntastic_stl_format = get(g:, 'airline#extensions#syntastic#stl_format_err', '%E{[%fe(#%e)]}') else let g:syntastic_stl_format = get(g:, 'airline#extensions#syntastic#stl_format_warn', '%W{[%fw(#%w)]}') endif let cnt = SyntasticStatuslineFlag() if !empty(_backup) let g:syntastic_stl_format = _backup endif if empty(cnt) return '' else return (is_err ? s:error_symbol : s:warning_symbol).cnt endif endfunction function! airline#extensions#syntastic#init(ext) call airline#parts#define_function('syntastic-warn', 'airline#extensions#syntastic#get_warning') call airline#parts#define_function('syntastic-err', 'airline#extensions#syntastic#get_error') endfunction vim-airline-0.11/autoload/airline/extensions/tabline.vim000066400000000000000000000220251356133765200234500ustar00rootroot00000000000000" MIT License. Copyright (c) 2013-2019 Bailey Ling et al. " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 let s:taboo = get(g:, 'airline#extensions#taboo#enabled', 1) && get(g:, 'loaded_taboo', 0) if s:taboo let g:taboo_tabline = 0 endif let s:ctrlspace = get(g:, 'CtrlSpaceLoaded', 0) let s:tabws = get(g:, 'tabws_loaded', 0) function! airline#extensions#tabline#init(ext) if has('gui_running') set guioptions-=e endif autocmd User AirlineToggledOn call s:toggle_on() autocmd User AirlineToggledOff call s:toggle_off() call s:toggle_on() call a:ext.add_theme_func('airline#extensions#tabline#load_theme') endfunction function! s:toggle_off() call airline#extensions#tabline#autoshow#off() call airline#extensions#tabline#tabs#off() call airline#extensions#tabline#buffers#off() if s:ctrlspace call airline#extensions#tabline#ctrlspace#off() endif if s:tabws call airline#extensions#tabline#tabws#off() endif endfunction function! s:toggle_on() if get(g:, 'airline_statusline_ontop', 0) call airline#extensions#tabline#enable() let &tabline='%!airline#statusline('.winnr().')' return endif call airline#extensions#tabline#autoshow#on() call airline#extensions#tabline#tabs#on() call airline#extensions#tabline#buffers#on() if s:ctrlspace call airline#extensions#tabline#ctrlspace#on() endif if s:tabws call airline#extensions#tabline#tabws#on() endif set tabline=%!airline#extensions#tabline#get() endfunction function! s:update_tabline() if get(g:, 'airline#extensions#tabline#disable_refresh', 0) return endif let match = expand('') if pumvisible() return elseif !get(g:, 'airline#extensions#tabline#enabled', 0) return " return, if buffer matches ignore pattern or is directory (netrw) elseif empty(match) || airline#util#ignore_buf(match) \ || isdirectory(expand("")) return endif call airline#util#doautocmd('BufMRUChange') call airline#extensions#tabline#redraw() endfunction function! airline#extensions#tabline#redraw() " sometimes, the tabline is not correctly updated see #1580 " so force redraw here if exists(":redrawtabline") == 2 redrawtabline else " Have to set a property equal to itself to get airline to re-eval. " Setting `let &tabline=&tabline` destroys the cursor position so we " need something less invasive. let &ro = &ro endif endfunction function! airline#extensions#tabline#enable() if &lines > 3 set showtabline=2 endif endfunction function! airline#extensions#tabline#load_theme(palette) if pumvisible() return endif let colors = get(a:palette, 'tabline', {}) let tablabel = get(colors, 'airline_tablabel', a:palette.normal.airline_b) " Theme for tabs on the left let tab = get(colors, 'airline_tab', a:palette.normal.airline_b) let tabsel = get(colors, 'airline_tabsel', a:palette.normal.airline_a) let tabtype = get(colors, 'airline_tabtype', a:palette.visual.airline_a) let tabfill = get(colors, 'airline_tabfill', a:palette.normal.airline_c) let tabmod = get(colors, 'airline_tabmod', a:palette.insert.airline_a) let tabhid = get(colors, 'airline_tabhid', a:palette.normal.airline_c) if has_key(a:palette, 'normal_modified') && has_key(a:palette.normal_modified, 'airline_c') let tabmodu = get(colors, 'airline_tabmod_unsel', a:palette.normal_modified.airline_c) else "Fall back to normal airline_c if modified airline_c isn't present let tabmodu = get(colors, 'airline_tabmod_unsel', a:palette.normal.airline_c) endif call airline#highlighter#exec('airline_tablabel', tablabel) call airline#highlighter#exec('airline_tab', tab) call airline#highlighter#exec('airline_tabsel', tabsel) call airline#highlighter#exec('airline_tabtype', tabtype) call airline#highlighter#exec('airline_tabfill', tabfill) call airline#highlighter#exec('airline_tabmod', tabmod) call airline#highlighter#exec('airline_tabmod_unsel', tabmodu) call airline#highlighter#exec('airline_tabhid', tabhid) " Theme for tabs on the right " label on the right let tablabel_r = get(colors, 'airline_tablabel', a:palette.normal.airline_b) let tabsel_right = get(colors, 'airline_tabsel_right', a:palette.normal.airline_a) let tab_right = get(colors, 'airline_tab_right', a:palette.inactive.airline_c) let tabmod_right = get(colors, 'airline_tabmod_right', a:palette.insert.airline_a) let tabhid_right = get(colors, 'airline_tabhid_right', a:palette.normal.airline_c) if has_key(a:palette, 'normal_modified') && has_key(a:palette.normal_modified, 'airline_c') let tabmodu_right = get(colors, 'airline_tabmod_unsel_right', a:palette.normal_modified.airline_c) else "Fall back to normal airline_c if modified airline_c isn't present let tabmodu_right = get(colors, 'airline_tabmod_unsel_right', a:palette.normal.airline_c) endif call airline#highlighter#exec('airline_tablabel_right', tablabel_r) call airline#highlighter#exec('airline_tab_right', tab_right) call airline#highlighter#exec('airline_tabsel_right', tabsel_right) call airline#highlighter#exec('airline_tabmod_right', tabmod_right) call airline#highlighter#exec('airline_tabhid_right', tabhid_right) call airline#highlighter#exec('airline_tabmod_unsel_right', tabmodu_right) endfunction let s:current_tabcnt = -1 function! airline#extensions#tabline#get() let show_buffers = get(g:, 'airline#extensions#tabline#show_buffers', 1) let show_tabs = get(g:, 'airline#extensions#tabline#show_tabs', 1) let curtabcnt = tabpagenr('$') if curtabcnt != s:current_tabcnt let s:current_tabcnt = curtabcnt call airline#extensions#tabline#tabs#invalidate() call airline#extensions#tabline#buffers#invalidate() call airline#extensions#tabline#ctrlspace#invalidate() call airline#extensions#tabline#tabws#invalidate() endif if !exists('#airline#BufAdd#*') autocmd airline BufAdd * call update_tabline() endif if s:ctrlspace return airline#extensions#tabline#ctrlspace#get() elseif s:tabws return airline#extensions#tabline#tabws#get() elseif show_buffers && curtabcnt == 1 || !show_tabs return airline#extensions#tabline#buffers#get() else return airline#extensions#tabline#tabs#get() endif endfunction function! airline#extensions#tabline#title(n) let title = '' if s:taboo let title = TabooTabTitle(a:n) endif if empty(title) && exists('*gettabvar') let title = gettabvar(a:n, 'title') endif if empty(title) let buflist = tabpagebuflist(a:n) let winnr = tabpagewinnr(a:n) let all_buffers = airline#extensions#tabline#buflist#list() return airline#extensions#tabline#get_buffer_name( \ buflist[winnr - 1], \ filter(buflist, 'index(all_buffers, v:val) != -1')) endif return title endfunction function! airline#extensions#tabline#get_buffer_name(nr, ...) let buffers = a:0 ? a:1 : airline#extensions#tabline#buflist#list() let formatter = get(g:, 'airline#extensions#tabline#formatter', 'default') return airline#extensions#tabline#formatters#{formatter}#format(a:nr, buffers) endfunction function! airline#extensions#tabline#new_builder() let builder_context = { \ 'active' : 1, \ 'tabline' : 1, \ 'right_sep' : get(g:, 'airline#extensions#tabline#right_sep' , g:airline_right_sep), \ 'right_alt_sep' : get(g:, 'airline#extensions#tabline#right_alt_sep', g:airline_right_alt_sep), \ } if get(g:, 'airline_powerline_fonts', 0) let builder_context.left_sep = get(g:, 'airline#extensions#tabline#left_sep' , g:airline_left_sep) let builder_context.left_alt_sep = get(g:, 'airline#extensions#tabline#left_alt_sep' , g:airline_left_alt_sep) else let builder_context.left_sep = get(g:, 'airline#extensions#tabline#left_sep' , ' ') let builder_context.left_alt_sep = get(g:, 'airline#extensions#tabline#left_alt_sep' , '|') endif return airline#extensions#tabline#builder#new(builder_context) endfunction function! airline#extensions#tabline#group_of_bufnr(tab_bufs, bufnr) let cur = bufnr('%') if cur == a:bufnr if g:airline_detect_modified && getbufvar(a:bufnr, '&modified') let group = 'airline_tabmod' else let group = 'airline_tabsel' endif else if g:airline_detect_modified && getbufvar(a:bufnr, '&modified') let group = 'airline_tabmod_unsel' elseif index(a:tab_bufs, a:bufnr) > -1 let group = 'airline_tab' else let group = 'airline_tabhid' endif endif return group endfunction function! airline#extensions#tabline#add_label(dict, type, right) if get(g:, 'airline#extensions#tabline#show_tab_type', 1) call a:dict.add_section_spaced('airline_tablabel'. \ (a:right ? '_right' : ''), \ get(g:, 'airline#extensions#tabline#'.a:type.'_label', a:type)) endif endfunction function! airline#extensions#tabline#add_tab_label(dict) if get(g:, 'airline#extensions#tabline#show_tab_count', 1) && tabpagenr('$') > 1 call a:dict.add_section_spaced('airline_tabmod', printf('%s %d/%d', "tab", tabpagenr(), tabpagenr('$'))) endif endfunction vim-airline-0.11/autoload/airline/extensions/tabline/000077500000000000000000000000001356133765200227325ustar00rootroot00000000000000vim-airline-0.11/autoload/airline/extensions/tabline/autoshow.vim000066400000000000000000000033331356133765200253220ustar00rootroot00000000000000" MIT License. Copyright (c) 2013-2019 Bailey Ling et al. " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 let s:show_buffers = get(g:, 'airline#extensions#tabline#show_buffers', 1) let s:buf_min_count = get(g:, 'airline#extensions#tabline#buffer_min_count', 0) let s:tab_min_count = get(g:, 'airline#extensions#tabline#tab_min_count', 0) function! airline#extensions#tabline#autoshow#off() if exists('s:original_tabline') let &tabline = s:original_tabline let &showtabline = s:original_showtabline endif augroup airline_tabline_autoshow autocmd! augroup END endfunction function! airline#extensions#tabline#autoshow#on() let [ s:original_tabline, s:original_showtabline ] = [ &tabline, &showtabline ] augroup airline_tabline_autoshow autocmd! if s:buf_min_count <= 0 && s:tab_min_count <= 1 call airline#extensions#tabline#enable() else if s:show_buffers == 1 autocmd BufEnter * call show_tabline(s:buf_min_count, len(airline#extensions#tabline#buflist#list())) autocmd BufUnload * call show_tabline(s:buf_min_count, len(airline#extensions#tabline#buflist#list()) - 1) else autocmd TabEnter * call show_tabline(s:tab_min_count, tabpagenr('$')) endif endif " Invalidate cache. This has to come after the BufUnload for " s:show_buffers, to invalidate the cache for BufEnter. autocmd BufLeave,BufAdd,BufUnload * call airline#extensions#tabline#buflist#invalidate() augroup END endfunction function! s:show_tabline(min_count, total_count) if a:total_count >= a:min_count if &showtabline != 2 && &lines > 3 set showtabline=2 endif else if &showtabline != 0 set showtabline=0 endif endif endfunction vim-airline-0.11/autoload/airline/extensions/tabline/buffers.vim000066400000000000000000000206761356133765200251160ustar00rootroot00000000000000" MIT License. Copyright (c) 2013-2019 Bailey Ling et al. " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 let s:spc = g:airline_symbols.space let s:current_bufnr = -1 let s:current_modified = 0 let s:current_tabline = '' let s:current_visible_buffers = [] let s:number_map = { \ '0': '⁰', \ '1': '¹', \ '2': '²', \ '3': '³', \ '4': '⁴', \ '5': '⁵', \ '6': '⁶', \ '7': '⁷', \ '8': '⁸', \ '9': '⁹' \ } let s:number_map = &encoding == 'utf-8' \ ? get(g:, 'airline#extensions#tabline#buffer_idx_format', s:number_map) \ : {} function! airline#extensions#tabline#buffers#off() augroup airline_tabline_buffers autocmd! augroup END endfunction function! airline#extensions#tabline#buffers#on() let terminal_event = has("nvim") ? 'TermOpen' : 'TerminalOpen' augroup airline_tabline_buffers autocmd! autocmd BufDelete * call airline#extensions#tabline#buflist#clean() if exists("##".terminal_event) exe 'autocmd '. terminal_event. ' * call airline#extensions#tabline#buflist#clean()' endif autocmd User BufMRUChange call airline#extensions#tabline#buflist#clean() augroup END endfunction function! airline#extensions#tabline#buffers#invalidate() let s:current_bufnr = -1 endfunction function! airline#extensions#tabline#buffers#get() try call map_keys() catch " no-op endtry let cur = bufnr('%') if cur == s:current_bufnr && &columns == s:column_width if !g:airline_detect_modified || getbufvar(cur, '&modified') == s:current_modified return s:current_tabline endif endif let b = airline#extensions#tabline#new_builder() let tab_bufs = tabpagebuflist(tabpagenr()) let show_buf_label_first = 0 if get(g:, 'airline#extensions#tabline#buf_label_first', 0) let show_buf_label_first = 1 endif if show_buf_label_first call airline#extensions#tabline#add_label(b, 'buffers', 0) endif let b.tab_bufs = tabpagebuflist(tabpagenr()) let b.overflow_group = 'airline_tabhid' let b.buffers = airline#extensions#tabline#buflist#list() if get(g:, 'airline#extensions#tabline#current_first', 0) if index(b.buffers, cur) > -1 call remove(b.buffers, index(b.buffers, cur)) endif let b.buffers = [cur] + b.buffers endif function! b.get_group(i) dict let bufnum = get(self.buffers, a:i, -1) if bufnum == -1 return '' endif let group = airline#extensions#tabline#group_of_bufnr(self.tab_bufs, bufnum) if bufnum == bufnr('%') let s:current_modified = (group == 'airline_tabmod') ? 1 : 0 endif return group endfunction if has("tablineat") function! b.get_pretitle(i) dict let bufnum = get(self.buffers, a:i, -1) return '%'.bufnum.'@airline#extensions#tabline#buffers#clickbuf@' endfunction function! b.get_posttitle(i) dict return '%X' endfunction endif function! b.get_title(i) dict let bufnum = get(self.buffers, a:i, -1) let group = self.get_group(a:i) let pgroup = self.get_group(a:i - 1) " always add a space when powerline_fonts are used " or for the very first item if get(g:, 'airline_powerline_fonts', 0) || a:i == 0 let space = s:spc else let space= (pgroup == group ? s:spc : '') endif if get(g:, 'airline#extensions#tabline#buffer_idx_mode', 0) if len(s:number_map) > 0 return space. s:get_number(a:i) . '%(%{airline#extensions#tabline#get_buffer_name('.bufnum.')}%)' . s:spc else return '['.(a:i+1).s:spc.'%(%{airline#extensions#tabline#get_buffer_name('.bufnum.')}%)'.']' endif else return space.'%(%{airline#extensions#tabline#get_buffer_name('.bufnum.')}%)'.s:spc endif endfunction let current_buffer = max([index(b.buffers, cur), 0]) let last_buffer = len(b.buffers) - 1 call b.insert_titles(current_buffer, 0, last_buffer) call b.add_section('airline_tabfill', '') call b.split() call b.add_section('airline_tabfill', '') if !show_buf_label_first call airline#extensions#tabline#add_label(b, 'buffers', 1) endif call airline#extensions#tabline#add_tab_label(b) let s:current_bufnr = cur let s:column_width = &columns let s:current_tabline = b.build() let s:current_visible_buffers = copy(b.buffers) " Do not remove from s:current_visible_buffers, this breaks s:select_tab() "if b._right_title <= last_buffer " call remove(s:current_visible_buffers, b._right_title, last_buffer) "endif "if b._left_title > 0 " call remove(s:current_visible_buffers, 0, b._left_title) "endif return s:current_tabline endfunction function! s:get_number(index) if len(s:number_map) == 0 return a:index endif let bidx_mode = get(g:, 'airline#extensions#tabline#buffer_idx_mode', 0) if bidx_mode > 1 return join(map(split(a:index+11, '\zs'), 'get(s:number_map, v:val, "")'), '') else return get(s:number_map, a:index+1, '') endif endfunction function! s:select_tab(buf_index) " no-op when called in 'keymap_ignored_filetypes' if count(get(g:, 'airline#extensions#tabline#keymap_ignored_filetypes', \ ['vimfiler', 'nerdtree']), &ft) return endif let idx = a:buf_index if s:current_visible_buffers[0] == -1 let idx = idx + 1 endif let buf = get(s:current_visible_buffers, idx, 0) if buf != 0 exec 'b!' . buf endif endfunction function! s:jump_to_tab(offset) let l = airline#extensions#tabline#buflist#list() let i = index(l, bufnr('%')) if i > -1 exec 'b!' . l[(i + a:offset) % len(l)] endif endfunction function! s:map_keys() let bidx_mode = get(g:, 'airline#extensions#tabline#buffer_idx_mode', 1) if bidx_mode > 0 if bidx_mode == 1 for i in range(1, 9) exe printf('noremap AirlineSelectTab%d :call select_tab(%d)', i, i-1) endfor else for i in range(11, 99) exe printf('noremap AirlineSelectTab%d :call select_tab(%d)', i, i-11) endfor endif noremap AirlineSelectPrevTab :call jump_to_tab(-v:count1) noremap AirlineSelectNextTab :call jump_to_tab(v:count1) " Enable this for debugging " com! AirlineBufferList :echo map(copy(s:current_visible_buffers), {i,k -> k.": ".bufname(k)}) endif endfunction function! airline#extensions#tabline#buffers#clickbuf(minwid, clicks, button, modifiers) abort " Clickable buffers " works only in recent NeoVim with has('tablineat') " single mouse button click without modifiers pressed if a:clicks == 1 && a:modifiers !~# '[^ ]' if a:button is# 'l' " left button - switch to buffer silent execute 'buffer' a:minwid elseif a:button is# 'm' " middle button - delete buffer if get(g:, 'airline#extensions#tabline#middle_click_preserves_windows', 0) == 0 || winnr('$') == 1 " just simply delete the clicked buffer. This will cause windows " associated with the clicked buffer to be closed. silent execute 'bdelete' a:minwid else " find windows displaying the clicked buffer and open an new " buffer in them. let current_window = bufwinnr("%") let window_number = bufwinnr(a:minwid) let last_window_visited = -1 " Set to 1 if the clicked buffer was open in any windows. let buffer_in_window = 0 " Find the next window with the clicked buffer open. If bufwinnr() " returns the same window number, this is because we clicked a new " buffer, and then tried editing a new buffer. Vim won't create a " new empty buffer for the same window, so we get the same window " number from bufwinnr(). In this case we just give up and don't " delete the buffer. " This could be made cleaner if we could check if the clicked buffer " is a new buffer, but I don't know if there is a way to do that. while window_number != -1 && window_number != last_window_visited let buffer_in_window = 1 silent execute window_number . 'wincmd w' silent execute 'enew' let last_window_visited = window_number let window_number = bufwinnr(a:minwid) endwhile silent execute current_window . 'wincmd w' if window_number != last_window_visited || buffer_in_window == 0 silent execute 'bdelete' a:minwid endif endif endif endif endfunction vim-airline-0.11/autoload/airline/extensions/tabline/buflist.vim000066400000000000000000000050421356133765200251200ustar00rootroot00000000000000" MIT License. Copyright (c) 2013-2019 Bailey Ling et al. " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 function! airline#extensions#tabline#buflist#invalidate() unlet! s:current_buffer_list endfunction function! airline#extensions#tabline#buflist#clean() call airline#extensions#tabline#buflist#invalidate() call airline#extensions#tabline#buffers#invalidate() endfunction " paths in excludes list function! s:ExcludePaths(nr, exclude_paths) let bname = bufname(a:nr) if empty(bname) return 0 endif let bpath = fnamemodify(bname, ":p") for f in a:exclude_paths if bpath =~# f | return 1 | endif endfor endfunction " other types to exclude function! s:ExcludeOther(nr, exclude_preview) if (getbufvar(a:nr, 'current_syntax') == 'qf') || \ (a:exclude_preview && getbufvar(a:nr, '&bufhidden') == 'wipe' \ && getbufvar(a:nr, '&buftype') == 'nofile') return 1 | endif endfunction function! airline#extensions#tabline#buflist#list() if exists('s:current_buffer_list') return s:current_buffer_list endif let exclude_buffers = get(g:, 'airline#extensions#tabline#exclude_buffers', []) let exclude_paths = get(g:, 'airline#extensions#tabline#excludes', []) let exclude_preview = get(g:, 'airline#extensions#tabline#exclude_preview', 1) let list = (exists('g:did_bufmru') && g:did_bufmru) ? BufMRUList() : range(1, bufnr("$")) let buffers = [] " If this is too slow, we can switch to a different algorithm. " Basically branch 535 already does it, but since it relies on " BufAdd autocommand, I'd like to avoid this if possible. for nr in list if buflisted(nr) " Do not add to the bufferlist, if either " 1) bufnr is exclude_buffers list " 2) buffername matches one of exclude_paths patterns " 3) buffer is a quickfix buffer " 4) when excluding preview windows: " 'bufhidden' == wipe " 'buftype' == nofile " 5) ignore buffers matching airline#extensions#tabline#ignore_bufadd_pat " check buffer numbers first if index(exclude_buffers, nr) >= 0 continue " check paths second elseif !empty(exclude_paths) && s:ExcludePaths(nr, exclude_paths) continue " ignore buffers matching airline#extensions#tabline#ignore_bufadd_pat elseif airline#util#ignore_buf(bufname(nr)) continue " check other types last elseif s:ExcludeOther(nr, exclude_preview) continue endif call add(buffers, nr) endif endfor let s:current_buffer_list = buffers return buffers endfunction vim-airline-0.11/autoload/airline/extensions/tabline/builder.vim000066400000000000000000000235061356133765200251030ustar00rootroot00000000000000" MIT License. Copyright (c) 2013-2019 Bailey Ling et al. " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 let s:prototype = {} " Set the point in the tabline where the builder should insert the titles. " " Subsequent calls will overwrite the previous ones, so only the last call " determines to location to insert titles. " " NOTE: The titles are not inserted until |build| is called, so that the " remaining contents of the tabline can be taken into account. " " Callers should define at least |get_title| and |get_group| on the host " object before calling |build|. function! s:prototype.insert_titles(current, first, last) dict let self._first_title = a:first " lowest index let self._last_title = a:last " highest index let self._left_title = a:current " next index to add on the left let self._right_title = a:current + 1 " next index to add on the right let self._left_position = self.get_position() " left end of titles let self._right_position = self._left_position " right end of the titles endfunction " Insert a title for entry number |index|, of group |group| at position |pos|, " if there is space for it. Returns 1 if it is inserted, 0 otherwise " " |force| inserts the title even if there isn't enough space left for it. " |sep_size| adjusts the size change that the title is considered to take up, " to account for changes to the separators " " The title is defined by |get_title| on the hosting object, called with " |index| as its only argument. " |get_pretitle| and |get_posttitle| may be defined on the host object to " insert some formatting before or after the title. These should be 0-width. " " This method updates |_right_position| and |_remaining_space| on the host " object, if the title is inserted. function! s:prototype.try_insert_title(index, group, pos, sep_size, force) dict let title = self.get_title(a:index) let title_size = s:tabline_evaluated_length(title) + a:sep_size if a:force || self._remaining_space >= title_size let pos = a:pos if has_key(self, "get_pretitle") call self.insert_raw(self.get_pretitle(a:index), pos) let self._right_position += 1 let pos += 1 endif call self.insert_section(a:group, title, pos) let self._right_position += 1 let pos += 1 if has_key(self, "get_posttitle") call self.insert_raw(self.get_posttitle(a:index), pos) let self._right_position += 1 let pos += 1 endif let self._remaining_space -= title_size return 1 endif return 0 endfunction function! s:get_separator_change(new_group, old_group, end_group, sep_size, alt_sep_size) return s:get_separator_change_with_end(a:new_group, a:old_group, a:end_group, a:end_group, a:sep_size, a:alt_sep_size) endfunction " Compute the change in size of the tabline caused by separators " " This should be kept up-to-date with |s:get_transitioned_seperator| and " |s:get_separator| in autoload/airline/builder.vim function! s:get_separator_change_with_end(new_group, old_group, new_end_group, old_end_group, sep_size, alt_sep_size) let sep_change = 0 if !empty(a:new_end_group) " Separator between title and the end let sep_change += airline#builder#should_change_group(a:new_group, a:new_end_group) ? a:sep_size : a:alt_sep_size endif if !empty(a:old_group) " Separator between the title and the one adjacent let sep_change += airline#builder#should_change_group(a:new_group, a:old_group) ? a:sep_size : a:alt_sep_size if !empty(a:old_end_group) " Remove mis-predicted separator let sep_change -= airline#builder#should_change_group(a:old_group, a:old_end_group) ? a:sep_size : a:alt_sep_size endif endif return sep_change endfunction " This replaces the build function of the |airline#builder#new| object, to " insert titles as specified by the last call to |insert_titles| before " passing to the original build function. " " Callers should define at least |get_title| and |get_group| on the host " object if |insert_titles| has been called on it. function! s:prototype.build() dict if has_key(self, '_left_position') && self._first_title <= self._last_title let self._remaining_space = &columns - s:tabline_evaluated_length(self._build()) let center_active = get(g:, 'airline#extensions#tabline#center_active', 0) let sep_size = s:tabline_evaluated_length(self._context.left_sep) let alt_sep_size = s:tabline_evaluated_length(self._context.left_alt_sep) let outer_left_group = airline#builder#get_prev_group(self._sections, self._left_position) let outer_right_group = airline#builder#get_next_group(self._sections, self._right_position) let overflow_marker = get(g:, 'airline#extensions#tabline#overflow_marker', g:airline_symbols.ellipsis) let overflow_marker_size = s:tabline_evaluated_length(overflow_marker) " Allow space for the markers before we begin filling in titles. if self._left_title > self._first_title let self._remaining_space -= overflow_marker_size + \ s:get_separator_change(self.overflow_group, "", outer_left_group, sep_size, alt_sep_size) endif if self._left_title < self._last_title let self._remaining_space -= overflow_marker_size + \ s:get_separator_change(self.overflow_group, "", outer_right_group, sep_size, alt_sep_size) endif " Add the current title let group = self.get_group(self._left_title) if self._left_title == self._first_title let sep_change = s:get_separator_change(group, "", outer_left_group, sep_size, alt_sep_size) else let sep_change = s:get_separator_change(group, "", self.overflow_group, sep_size, alt_sep_size) endif if self._left_title == self._last_title let sep_change += s:get_separator_change(group, "", outer_right_group, sep_size, alt_sep_size) else let sep_change += s:get_separator_change(group, "", self.overflow_group, sep_size, alt_sep_size) endif let left_group = group let right_group = group let self._left_title -= \ self.try_insert_title(self._left_title, group, self._left_position, sep_change, 1) if get(g:, 'airline#extensions#tabline#current_first', 0) " always have current title first let self._left_position += 1 endif if !center_active && self._right_title <= self._last_title " Add the title to the right let group = self.get_group(self._right_title) if self._right_title == self._last_title let sep_change = s:get_separator_change_with_end(group, right_group, outer_right_group, self.overflow_group, sep_size, alt_sep_size) - overflow_marker_size else let sep_change = s:get_separator_change(group, right_group, self.overflow_group, sep_size, alt_sep_size) endif let right_group = group let self._right_title += \ self.try_insert_title(self._right_title, group, self._right_position, sep_change, 1) endif while self._remaining_space > 0 let done = 0 if self._left_title >= self._first_title " Insert next title to the left let group = self.get_group(self._left_title) if self._left_title == self._first_title let sep_change = s:get_separator_change_with_end(group, left_group, outer_left_group, self.overflow_group, sep_size, alt_sep_size) - overflow_marker_size else let sep_change = s:get_separator_change(group, left_group, self.overflow_group, sep_size, alt_sep_size) endif let left_group = group let done = self.try_insert_title(self._left_title, group, self._left_position, sep_change, 0) let self._left_title -= done endif " If center_active is set, this |if| operates as an independent |if|, " otherwise as an |elif|. if self._right_title <= self._last_title && (center_active || !done) " Insert next title to the right let group = self.get_group(self._right_title) if self._right_title == self._last_title let sep_change = s:get_separator_change_with_end(group, right_group, outer_right_group, self.overflow_group, sep_size, alt_sep_size) - overflow_marker_size else let sep_change = s:get_separator_change(group, right_group, self.overflow_group, sep_size, alt_sep_size) endif let right_group = group let done = self.try_insert_title(self._right_title, group, self._right_position, sep_change, 0) let self._right_title += done endif if !done break endif endwhile if self._left_title >= self._first_title if get(g:, 'airline#extensions#tabline#current_first', 0) let self._left_position -= 1 endif call self.insert_section(self.overflow_group, overflow_marker, self._left_position) let self._right_position += 1 endif if self._right_title <= self._last_title call self.insert_section(self.overflow_group, overflow_marker, self._right_position) endif endif return self._build() endfunction let s:prototype.overflow_group = 'airline_tab' " Extract the text content a tabline will render. (Incomplete). " " See :help 'statusline' for the list of fields. function! s:evaluate_tabline(tabline) let tabline = a:tabline let tabline = substitute(tabline, '%{\([^}]\+\)}', '\=eval(submatch(1))', 'g') let tabline = substitute(tabline, '%#[^#]\+#', '', 'g') let tabline = substitute(tabline, '%(\([^)]\+\)%)', '\1', 'g') let tabline = substitute(tabline, '%\d\+[TX]', '', 'g') let tabline = substitute(tabline, '%=', '', 'g') let tabline = substitute(tabline, '%\d*\*', '', 'g') if has('tablineat') let tabline = substitute(tabline, '%@[^@]\+@', '', 'g') endif return tabline endfunction function! s:tabline_evaluated_length(tabline) return airline#util#strchars(s:evaluate_tabline(a:tabline)) endfunction function! airline#extensions#tabline#builder#new(context) let builder = airline#builder#new(a:context) let builder._build = builder.build call extend(builder, s:prototype, 'force') return builder endfunction vim-airline-0.11/autoload/airline/extensions/tabline/ctrlspace.vim000066400000000000000000000122601356133765200254300ustar00rootroot00000000000000" MIT License. Copyright (c) 2016-2019 Kevin Sapper et al. " Plugin: https://github.com/szw/vim-ctrlspace " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 let s:current_bufnr = -1 let s:current_modified = 0 let s:current_tabnr = -1 let s:current_tabline = '' let s:highlight_groups = ['hid', 0, '', 'sel', 'mod_unsel', 0, 'mod_unsel', 'mod'] function! airline#extensions#tabline#ctrlspace#off() augroup airline_tabline_ctrlspace autocmd! augroup END endfunction function! airline#extensions#tabline#ctrlspace#on() augroup airline_tabline_ctrlspace autocmd! autocmd BufDelete * call airline#extensions#tabline#ctrlspace#invalidate() augroup END endfunction function! airline#extensions#tabline#ctrlspace#invalidate() let s:current_bufnr = -1 let s:current_tabnr = -1 endfunction function! airline#extensions#tabline#ctrlspace#add_buffer_section(builder, cur_tab, cur_buf, pull_right) let pos_extension = (a:pull_right ? '_right' : '') let buffer_list = ctrlspace#api#BufferList(a:cur_tab) " add by tenfy(tenfyzhong@qq.com) " if the current buffer no in the buffer list " return false and no redraw tabline. " Fixes #1515. if there a BufEnter autocmd execute redraw. The tabline may no update. let bufnr_list = map(copy(buffer_list), 'v:val["index"]') if index(bufnr_list, a:cur_buf) == -1 && a:cur_tab == s:current_tabnr return 0 endif let s:current_modified = getbufvar(a:cur_buf, '&modified') for buffer in buffer_list let group = 'airline_tab' \ .s:highlight_groups[(4 * buffer.modified) + (2 * buffer.visible) + (a:cur_buf == buffer.index)] \ .pos_extension let buf_name = '%(%{airline#extensions#tabline#get_buffer_name('.buffer.index.')}%)' if has("tablineat") let buf_name = '%'.buffer.index.'@airline#extensions#tabline#buffers#clickbuf@'.buf_name.'%X' endif call a:builder.add_section_spaced(group, buf_name) endfor " add by tenfy(tenfyzhong@qq.com) " if the selected buffer was updated " return true return 1 endfunction function! airline#extensions#tabline#ctrlspace#add_tab_section(builder, pull_right) let pos_extension = (a:pull_right ? '_right' : '') let tab_list = ctrlspace#api#TabList() for tab in tab_list let group = 'airline_tab' \ .s:highlight_groups[(4 * tab.modified) + (3 * tab.current)] \ .pos_extension if get(g:, 'airline#extensions#tabline#ctrlspace_show_tab_nr', 0) == 0 call a:builder.add_section_spaced(group, '%'.tab.index.'T'.tab.title.ctrlspace#api#TabBuffersNumber(tab.index).'%T') else call a:builder.add_section_spaced(group, '%'.(tab.index).'T'.(tab.index).(g:airline_symbols.space).(tab.title).ctrlspace#api#TabBuffersNumber(tab.index).'%T') endif endfor endfunction function! airline#extensions#tabline#ctrlspace#get() let cur_buf = bufnr('%') let buffer_label = get(g:, 'airline#extensions#tabline#buffers_label', 'buffers') let tab_label = get(g:, 'airline#extensions#tabline#tabs_label', 'tabs') let switch_buffers_and_tabs = get(g:, 'airline#extensions#tabline#switch_buffers_and_tabs', 0) try call airline#extensions#tabline#tabs#map_keys() endtry let cur_tab = tabpagenr() if cur_buf == s:current_bufnr && cur_tab == s:current_tabnr if !g:airline_detect_modified || getbufvar(cur_buf, '&modified') == s:current_modified return s:current_tabline endif endif let builder = airline#extensions#tabline#new_builder() let show_buffers = get(g:, 'airline#extensions#tabline#show_buffers', 1) let show_tabs = get(g:, 'airline#extensions#tabline#show_tabs', 1) let AppendBuffers = function('airline#extensions#tabline#ctrlspace#add_buffer_section', [builder, cur_tab, cur_buf]) let AppendTabs = function('airline#extensions#tabline#ctrlspace#add_tab_section', [builder]) let AppendLabel = function(builder.add_section_spaced, ['airline_tabtype'], builder) " <= 1: |{Tabs} {Buffers} {Tabs} s:fnametruncate let _ = strpart(_, 0, s:fnametruncate) endif endif return airline#extensions#tabline#formatters#default#wrap_name(a:bufnr, _) endfunction function! airline#extensions#tabline#formatters#default#wrap_name(bufnr, buffer_name) let _ = s:buf_nr_show ? printf(s:buf_nr_format, a:bufnr) : '' let _ .= substitute(a:buffer_name, '\\', '/', 'g') if getbufvar(a:bufnr, '&modified') == 1 let _ .= s:buf_modified_symbol endif return _ endfunction vim-airline-0.11/autoload/airline/extensions/tabline/formatters/jsformatter.vim000066400000000000000000000010311356133765200301700ustar00rootroot00000000000000" MIT License. Copyright (c) 2013-2019 Bailey Ling et al. " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 function! airline#extensions#tabline#formatters#jsformatter#format(bufnr, buffers) let buf = bufname(a:bufnr) let filename = fnamemodify(buf, ':t') if filename == 'index.js' || filename == 'index.jsx' || filename == 'index.ts' || filename == 'index.tsx' return fnamemodify(buf, ':p:h:t') . '/i' else return airline#extensions#tabline#formatters#unique_tail_improved#format(a:bufnr, a:buffers) endif endfunction vim-airline-0.11/autoload/airline/extensions/tabline/formatters/short_path.vim000066400000000000000000000010231356133765200300040ustar00rootroot00000000000000" MIT License. Copyright (c) 2013-2019 Bailey Ling et al. " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 let s:fnamecollapse = get(g:, 'airline#extensions#tabline#fnamecollapse', 1) function! airline#extensions#tabline#formatters#short_path#format(bufnr, buffers) let _ = '' let name = bufname(a:bufnr) if empty(name) let _ .= '[No Name]' else let _ .= fnamemodify(name, ':p:h:t') . '/' . fnamemodify(name, ':t') endif return airline#extensions#tabline#formatters#default#wrap_name(a:bufnr, _) endfunction vim-airline-0.11/autoload/airline/extensions/tabline/formatters/tabnr.vim000066400000000000000000000007531356133765200267500ustar00rootroot00000000000000" MIT License. Copyright (c) 2017-2019 Christian Brabandt et al. " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 function! airline#extensions#tabline#formatters#tabnr#format(tab_nr_type, nr) let spc=g:airline_symbols.space if a:tab_nr_type == 0 " nr of splits return spc. '%{len(tabpagebuflist('.a:nr.'))}' elseif a:tab_nr_type == 1 " tab number return spc. a:nr else "== 2 splits and tab number return spc. a:nr. '.%{len(tabpagebuflist('.a:nr.'))}' endif endfunction vim-airline-0.11/autoload/airline/extensions/tabline/formatters/unique_tail.vim000066400000000000000000000026371356133765200301640ustar00rootroot00000000000000" MIT License. Copyright (c) 2013-2019 Bailey Ling et al. " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 function! airline#extensions#tabline#formatters#unique_tail#format(bufnr, buffers) let duplicates = {} let tails = {} let map = {} for nr in a:buffers let name = bufname(nr) if empty(name) let map[nr] = airline#extensions#tabline#formatters#default#wrap_name(nr, '[No Name]') else let tail = fnamemodify(name, ':s?/\+$??:t') if has_key(tails, tail) let duplicates[nr] = nr endif let tails[tail] = 1 let map[nr] = airline#extensions#tabline#formatters#default#wrap_name(nr, tail) endif endfor let fmod = get(g:, 'airline#extensions#tabline#fnamemod', ':p:.') for nr in values(duplicates) let name = bufname(nr) let fnamecollapse = get(g:, 'airline#extensions#tabline#fnamecollapse', 1) if fnamecollapse let map[nr] = airline#extensions#tabline#formatters#default#wrap_name(nr, substitute(fnamemodify(name, fmod), '\v\w\zs.{-}\ze(\\|/)', '', 'g')) else let map[nr] = airline#extensions#tabline#formatters#default#wrap_name(nr, fnamemodify(name, fmod)) endif endfor if has_key(map, a:bufnr) return map[a:bufnr] endif " if we get here, the buffer list isn't in sync with the selected buffer yet, fall back to the default return airline#extensions#tabline#formatters#default#format(a:bufnr, a:buffers) endfunction vim-airline-0.11/autoload/airline/extensions/tabline/formatters/unique_tail_improved.vim000066400000000000000000000054221356133765200320640ustar00rootroot00000000000000" MIT License. Copyright (c) 2013-2019 Bailey Ling et al. " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 let s:skip_symbol = '…' function! airline#extensions#tabline#formatters#unique_tail_improved#format(bufnr, buffers) if len(a:buffers) <= 1 " don't need to compare bufnames if has less than one buffer opened return airline#extensions#tabline#formatters#default#format(a:bufnr, a:buffers) endif let curbuf_tail = fnamemodify(bufname(a:bufnr), ':t') let do_deduplicate = 0 let path_tokens = {} for nr in a:buffers let name = bufname(nr) if !empty(name) && nr != a:bufnr && fnamemodify(name, ':t') == curbuf_tail " only perform actions if curbuf_tail isn't unique let do_deduplicate = 1 let tokens = reverse(split(substitute(fnamemodify(name, ':p:h'), '\\', '/', 'g'), '/')) let token_index = 0 for token in tokens if token == '' | continue | endif if token == '.' | break | endif if !has_key(path_tokens, token_index) let path_tokens[token_index] = {} endif let path_tokens[token_index][token] = 1 let token_index += 1 endfor endif endfor if do_deduplicate == 1 let path = [] let token_index = 0 for token in reverse(split(substitute(fnamemodify(bufname(a:bufnr), ':p:h'), '\\', '/', 'g'), '/')) if token == '.' | break | endif let duplicated = 0 let uniq = 1 let single = 1 if has_key(path_tokens, token_index) let duplicated = 1 if len(keys(path_tokens[token_index])) > 1 | let single = 0 | endif if has_key(path_tokens[token_index], token) | let uniq = 0 | endif endif call insert(path, {'token': token, 'duplicated': duplicated, 'uniq': uniq, 'single': single}) let token_index += 1 endfor let buf_name = [curbuf_tail] let has_uniq = 0 let has_skipped = 0 for token1 in reverse(path) if !token1['duplicated'] && len(buf_name) > 1 call insert(buf_name, s:skip_symbol) let has_skipped = 0 break endif if has_uniq == 1 call insert(buf_name, s:skip_symbol) let has_skipped = 0 break endif if token1['uniq'] == 0 && token1['single'] == 1 let has_skipped = 1 else if has_skipped == 1 call insert(buf_name, s:skip_symbol) let has_skipped = 0 endif call insert(buf_name, token1['token']) endif if token1['uniq'] == 1 let has_uniq = 1 endif endfor if has_skipped == 1 call insert(buf_name, s:skip_symbol) endif return airline#extensions#tabline#formatters#default#wrap_name(a:bufnr, join(buf_name, '/')) else return airline#extensions#tabline#formatters#default#format(a:bufnr, a:buffers) endif endfunction vim-airline-0.11/autoload/airline/extensions/tabline/tabs.vim000066400000000000000000000101511356133765200243760ustar00rootroot00000000000000" MIT License. Copyright (c) 2013-2019 Bailey Ling et al. " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 let s:spc = g:airline_symbols.space let s:current_bufnr = -1 let s:current_tabnr = -1 let s:current_modified = 0 function! airline#extensions#tabline#tabs#off() augroup airline_tabline_tabs autocmd! augroup END endfunction function! airline#extensions#tabline#tabs#on() augroup airline_tabline_tabs autocmd! autocmd BufDelete * call airline#extensions#tabline#tabs#invalidate() augroup END endfunction function! airline#extensions#tabline#tabs#invalidate() let s:current_bufnr = -1 endfunction function! airline#extensions#tabline#tabs#get() let curbuf = bufnr('%') let curtab = tabpagenr() try call airline#extensions#tabline#tabs#map_keys() catch " no-op endtry if curbuf == s:current_bufnr && curtab == s:current_tabnr && &columns == s:column_width if !g:airline_detect_modified || getbufvar(curbuf, '&modified') == s:current_modified return s:current_tabline endif endif let b = airline#extensions#tabline#new_builder() call airline#extensions#tabline#add_label(b, 'tabs', 0) function! b.get_group(i) dict let curtab = tabpagenr() let group = 'airline_tab' if a:i == curtab let group = 'airline_tabsel' if g:airline_detect_modified for bi in tabpagebuflist(curtab) if getbufvar(bi, '&modified') let group = 'airline_tabmod' endif endfor endif let s:current_modified = (group == 'airline_tabmod') ? 1 : 0 endif return group endfunction function! b.get_title(i) dict let val = '%(' if get(g:, 'airline#extensions#tabline#show_tab_nr', 1) let tab_nr_type = get(g:, 'airline#extensions#tabline#tab_nr_type', 0) let val .= airline#extensions#tabline#tabs#tabnr_formatter(tab_nr_type, a:i) endif return val.'%'.a:i.'T %{airline#extensions#tabline#title('.a:i.')} %)' endfunction call b.insert_titles(curtab, 1, tabpagenr('$')) call b.add_section('airline_tabfill', '') call b.split() call b.add_section('airline_tabfill', '') if get(g:, 'airline#extensions#tabline#show_close_button', 1) call b.add_section('airline_tab_right', ' %999X'. \ get(g:, 'airline#extensions#tabline#close_symbol', 'X').' ') endif if get(g:, 'airline#extensions#tabline#show_splits', 1) == 1 let buffers = tabpagebuflist(curtab) for nr in buffers let group = airline#extensions#tabline#group_of_bufnr(buffers, nr) . "_right" call b.add_section_spaced(group, '%(%{airline#extensions#tabline#get_buffer_name('.nr.')}%)') endfor if get(g:, 'airline#extensions#tabline#show_buffers', 1) call airline#extensions#tabline#add_label(b, 'buffers', 1) endif endif call airline#extensions#tabline#add_tab_label(b) let s:current_bufnr = curbuf let s:current_tabnr = curtab let s:column_width = &columns let s:current_tabline = b.build() return s:current_tabline endfunction function! airline#extensions#tabline#tabs#map_keys() if maparg('AirlineSelectTab1', 'n') is# ':1tabn' return endif let bidx_mode = get(g:, 'airline#extensions#tabline#buffer_idx_mode', 1) if bidx_mode == 1 for i in range(1, 9) exe printf('noremap AirlineSelectTab%d :%dtabn', i, i) endfor else for i in range(11, 99) exe printf('noremap AirlineSelectTab%d :%dtabn', i, i-10) endfor endif noremap AirlineSelectPrevTab gT " tabn {count} goes to count tab does not go {count} tab pages forward! noremap AirlineSelectNextTab :exe repeat(':tabn\|', v:count1) endfunction function! airline#extensions#tabline#tabs#tabnr_formatter(nr, i) abort let formatter = get(g:, 'airline#extensions#tabline#tabnr_formatter', 'tabnr') try return airline#extensions#tabline#formatters#{formatter}#format(a:nr, a:i) catch /^Vim\%((\a\+)\)\=:E117/ " catch E117, unknown function " Function not found return call(formatter, [a:nr, a:i]) catch " something went wrong, return an empty string return "" endtry endfunction vim-airline-0.11/autoload/airline/extensions/tabline/tabws.vim000066400000000000000000000115121356133765200245670ustar00rootroot00000000000000" MIT License. Copyright (c) 2016-2019 Kevin Sapper et al. " PLugin: https://github.com/s1341/vim-tabws " vim: et ts=2 sts=2 sw=2 scriptencoding utf-8 let s:current_bufnr = -1 let s:current_modified = 0 let s:current_tabnr = -1 let s:current_tabline = '' let s:highlight_groups = ['hid', 0, '', 'sel', 'mod_unsel', 0, 'mod_unsel', 'mod'] function! airline#extensions#tabline#tabws#off() augroup airline_tabline_tabws autocmd! augroup END endfunction function! airline#extensions#tabline#tabws#on() augroup airline_tabline_tabws autocmd! autocmd BufDelete * call airline#extensions#tabline#tabws#invalidate() augroup END endfunction function! airline#extensions#tabline#tabws#invalidate() let s:current_bufnr = -1 let s:current_tabnr = -1 endfunction function! airline#extensions#tabline#tabws#add_buffer_section(builder, cur_tab, cur_buf, pull_right) let pos_extension = (a:pull_right ? '_right' : '') let bufnr_list = tabws#getbuffersfortab(a:cur_tab) if index(bufnr_list, a:cur_buf) == -1 && a:cur_tab == s:current_tabnr return 0 endif let s:current_modified = getbufvar(a:cur_buf, '&modified') let visible_list = tabpagebuflist(a:cur_tab) for buffer in bufnr_list let group = 'airline_tab' \ .s:highlight_groups[(4 * getbufvar(buffer, '&modified')) + (2 * (index(visible_list, buffer) != -1)) + (a:cur_buf == buffer)] \ .pos_extension let buf_name = '%(%{airline#extensions#tabline#get_buffer_name('.buffer.')}%)' if has("tablineat") let buf_name = '%'.buffer.'@airline#extensions#tabline#buffers#clickbuf@'.buf_name.'%X' endif call a:builder.add_section_spaced(group, buf_name) endfor " add by tenfy(tenfyzhong@qq.com) " if the selected buffer was updated " return true return 1 endfunction function! airline#extensions#tabline#tabws#add_tab_section(builder, pull_right) let pos_extension = (a:pull_right ? '_right' : '') for tab in range(1, tabpagenr('$')) let current = tab == tabpagenr() let group = 'airline_tab' \ .s:highlight_groups[(3 * current)] \ .pos_extension if get(g:, 'airline#extensions#tabline#tabws_show_tab_nr', 0) == 0 call a:builder.add_section_spaced(group, '%'.tab.'T'.tabws#gettabname(tab).'%T') else call a:builder.add_section_spaced(group, '%'.tab.'T'.tab.(g:airline_symbols.space).tabws#gettabname(tab).'%T') endif endfor endfunction function! airline#extensions#tabline#tabws#get() let cur_buf = bufnr('%') let buffer_label = get(g:, 'airline#extensions#tabline#buffers_label', 'buffers') let tab_label = get(g:, 'airline#extensions#tabline#tabs_label', 'tabs') let switch_buffers_and_tabs = get(g:, 'airline#extensions#tabline#switch_buffers_and_tabs', 0) try call airline#extensions#tabline#tabs#map_keys() endtry let cur_tab = tabpagenr() if cur_buf == s:current_bufnr && cur_tab == s:current_tabnr if !g:airline_detect_modified || getbufvar(cur_buf, '&modified') == s:current_modified return s:current_tabline endif endif let builder = airline#extensions#tabline#new_builder() let show_buffers = get(g:, 'airline#extensions#tabline#show_buffers', 1) let show_tabs = get(g:, 'airline#extensions#tabline#show_tabs', 1) let AppendBuffers = function('airline#extensions#tabline#tabws#add_buffer_section', [builder, cur_tab, cur_buf]) let AppendTabs = function('airline#extensions#tabline#tabws#add_tab_section', [builder]) let AppendLabel = function(builder.add_section_spaced, ['airline_tabtype'], builder) " <= 1: |{Tabs} {Buffers} {Tabs} " tabpagecd: " expanded version by mg979 " MIT License Copyright (C) 2012-2013 Kana Natsuno " MIT License Copyright (C) 2018-2019 Gianmaria Bajo """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" function! airline#extensions#tabline#xtabline#init() let s:state = 0 " initialize mappings call airline#extensions#tabline#xtabline#maps() """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" " Variables """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" let g:loaded_xtabline = 1 let s:most_recent = -1 let s:xtabline_filtering = 1 let t:xtl_excluded = get(g:, 'airline#extensions#tabline#exclude_buffers', []) let t:xtl_accepted = [] let g:xtabline_include_previews = get(g:, 'xtabline_include_previews', 1) let g:xtabline_alt_action = get(g:, 'xtabline_alt_action', "buffer #") """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" " Autocommands """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" augroup plugin-xtabline autocmd! autocmd TabNew * call s:Do('new') autocmd TabEnter * call s:Do('enter') autocmd TabLeave * call s:Do('leave') autocmd TabClosed * call s:Do('close') autocmd BufEnter * let g:xtabline_changing_buffer = 0 autocmd BufAdd,BufDelete,BufWrite * call airline#extensions#tabline#xtabline#filter_buffers() augroup END """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" " Commands """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" com! XTabReopen call airline#extensions#tabline#xtabline#reopen_last_tab() endfunction """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" " Mappings """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" function! airline#extensions#tabline#xtabline#maps() if !exists('g:xtabline_disable_keybindings') fun! s:mapkeys(keys, plug) if empty(mapcheck(a:keys)) && !hasmapto(a:plug) silent! execute 'nmap '.a:keys.' '.a:plug endif endfun call s:mapkeys('','XTablineToggleTabs') call s:mapkeys('','XTablineToggleFiltering') call s:mapkeys('','XTablineSelectBuffer') call s:mapkeys(']l','XTablineNextBuffer') call s:mapkeys('[l','XTablinePrevBuffer') call s:mapkeys('tr','XTablineReopen') endif nnoremap