Showing preview only (5,740K chars total). Download the full file or copy to clipboard to get everything.
Repository: Integralist/ProVim
Branch: master
Commit: 2eb07bb58720
Files: 759
Total size: 5.3 MB
Directory structure:
gitextract_v4dsqjfv/
├── .tmux.conf
├── .vim/
│ ├── autoload/
│ │ └── pathogen.vim
│ ├── bundle/
│ │ ├── CSApprox/
│ │ │ ├── README
│ │ │ ├── after/
│ │ │ │ └── plugin/
│ │ │ │ └── CSApprox.vim
│ │ │ ├── autoload/
│ │ │ │ ├── csapprox/
│ │ │ │ │ ├── common.vim
│ │ │ │ │ └── per_component.vim
│ │ │ │ └── csapprox.vim
│ │ │ ├── doc/
│ │ │ │ └── CSApprox.txt
│ │ │ └── plugin/
│ │ │ └── CSApprox.vim
│ │ ├── Gist.vim/
│ │ │ ├── README
│ │ │ ├── README.mkd
│ │ │ ├── autoload/
│ │ │ │ └── gist.vim
│ │ │ ├── doc/
│ │ │ │ └── gist-vim.txt
│ │ │ └── plugin/
│ │ │ └── gist.vim
│ │ ├── Tabmerge/
│ │ │ ├── README
│ │ │ └── plugin/
│ │ │ └── Tabmerge.vim
│ │ ├── ZoomWin/
│ │ │ ├── autoload/
│ │ │ │ └── ZoomWin.vim
│ │ │ ├── doc/
│ │ │ │ └── ZoomWin.txt
│ │ │ └── plugin/
│ │ │ └── ZoomWinPlugin.vim
│ │ ├── ack.vim/
│ │ │ ├── README.md
│ │ │ ├── Rakefile
│ │ │ ├── doc/
│ │ │ │ └── ack.txt
│ │ │ └── plugin/
│ │ │ └── ack.vim
│ │ ├── camelcasemotion/
│ │ │ ├── README
│ │ │ ├── autoload/
│ │ │ │ └── camelcasemotion.vim
│ │ │ ├── doc/
│ │ │ │ └── camelcasemotion.txt
│ │ │ └── plugin/
│ │ │ └── camelcasemotion.vim
│ │ ├── ctrlp.vim/
│ │ │ ├── autoload/
│ │ │ │ ├── ctrlp/
│ │ │ │ │ ├── bookmarkdir.vim
│ │ │ │ │ ├── buffertag.vim
│ │ │ │ │ ├── changes.vim
│ │ │ │ │ ├── dir.vim
│ │ │ │ │ ├── line.vim
│ │ │ │ │ ├── mixed.vim
│ │ │ │ │ ├── mrufiles.vim
│ │ │ │ │ ├── quickfix.vim
│ │ │ │ │ ├── rtscript.vim
│ │ │ │ │ ├── tag.vim
│ │ │ │ │ ├── undo.vim
│ │ │ │ │ └── utils.vim
│ │ │ │ └── ctrlp.vim
│ │ │ ├── doc/
│ │ │ │ └── ctrlp.txt
│ │ │ ├── plugin/
│ │ │ │ └── ctrlp.vim
│ │ │ └── readme.md
│ │ ├── emmet-vim/
│ │ │ ├── Makefile
│ │ │ ├── README.mkd
│ │ │ ├── TODO
│ │ │ ├── TUTORIAL
│ │ │ ├── autoload/
│ │ │ │ ├── emmet/
│ │ │ │ │ ├── lang/
│ │ │ │ │ │ ├── css.vim
│ │ │ │ │ │ ├── haml.vim
│ │ │ │ │ │ ├── html.vim
│ │ │ │ │ │ ├── less.vim
│ │ │ │ │ │ ├── sass.vim
│ │ │ │ │ │ ├── scss.vim
│ │ │ │ │ │ └── slim.vim
│ │ │ │ │ ├── lang.vim
│ │ │ │ │ ├── lorem/
│ │ │ │ │ │ ├── en.vim
│ │ │ │ │ │ └── ja.vim
│ │ │ │ │ └── util.vim
│ │ │ │ └── emmet.vim
│ │ │ ├── doc/
│ │ │ │ └── emmet.txt
│ │ │ ├── emmet.vim.vimup
│ │ │ ├── plugin/
│ │ │ │ └── emmet.vim
│ │ │ └── unittest.vim
│ │ ├── gruvbox/
│ │ │ ├── README.md
│ │ │ ├── autoload/
│ │ │ │ └── gruvbox.vim
│ │ │ ├── colors/
│ │ │ │ └── gruvbox.vim
│ │ │ ├── gruvbox_256palette.sh
│ │ │ └── gruvbox_256palette_osx.sh
│ │ ├── html5.vim/
│ │ │ ├── CHANGES.markdown
│ │ │ ├── Makefile
│ │ │ ├── README.md
│ │ │ ├── autoload/
│ │ │ │ ├── htmlcomplete.vim
│ │ │ │ └── xml/
│ │ │ │ ├── aria.vim
│ │ │ │ └── html5.vim
│ │ │ ├── config.mk
│ │ │ ├── indent/
│ │ │ │ └── html.vim
│ │ │ └── syntax/
│ │ │ ├── html/
│ │ │ │ ├── aria.vim
│ │ │ │ └── rdfa.vim
│ │ │ ├── html.vim
│ │ │ └── javascript/
│ │ │ └── html5.vim
│ │ ├── nerdtree/
│ │ │ ├── README.markdown
│ │ │ ├── autoload/
│ │ │ │ └── nerdtree.vim
│ │ │ ├── doc/
│ │ │ │ └── NERD_tree.txt
│ │ │ ├── lib/
│ │ │ │ └── nerdtree/
│ │ │ │ ├── bookmark.vim
│ │ │ │ ├── creator.vim
│ │ │ │ ├── key_map.vim
│ │ │ │ ├── menu_controller.vim
│ │ │ │ ├── menu_item.vim
│ │ │ │ ├── opener.vim
│ │ │ │ ├── path.vim
│ │ │ │ ├── tree_dir_node.vim
│ │ │ │ └── tree_file_node.vim
│ │ │ ├── nerdtree_plugin/
│ │ │ │ ├── exec_menuitem.vim
│ │ │ │ └── fs_menu.vim
│ │ │ ├── plugin/
│ │ │ │ └── NERD_tree.vim
│ │ │ └── syntax/
│ │ │ └── nerdtree.vim
│ │ ├── paredit.vim/
│ │ │ ├── README
│ │ │ ├── doc/
│ │ │ │ └── paredit.txt
│ │ │ └── plugin/
│ │ │ └── paredit.vim
│ │ ├── rainbow_parentheses.vim/
│ │ │ ├── autoload/
│ │ │ │ └── rainbow_parentheses.vim
│ │ │ ├── plugin/
│ │ │ │ └── rainbow_parentheses.vim
│ │ │ └── readme.md
│ │ ├── supertab/
│ │ │ ├── Makefile
│ │ │ ├── README.rst
│ │ │ ├── doc/
│ │ │ │ └── supertab.txt
│ │ │ └── plugin/
│ │ │ └── supertab.vim
│ │ ├── syntastic/
│ │ │ ├── CONTRIBUTING.md
│ │ │ ├── LICENCE
│ │ │ ├── README.markdown
│ │ │ ├── autoload/
│ │ │ │ └── syntastic/
│ │ │ │ ├── c.vim
│ │ │ │ ├── log.vim
│ │ │ │ ├── postprocess.vim
│ │ │ │ ├── preprocess.vim
│ │ │ │ └── util.vim
│ │ │ ├── doc/
│ │ │ │ └── syntastic.txt
│ │ │ ├── plugin/
│ │ │ │ ├── syntastic/
│ │ │ │ │ ├── autoloclist.vim
│ │ │ │ │ ├── balloons.vim
│ │ │ │ │ ├── checker.vim
│ │ │ │ │ ├── cursor.vim
│ │ │ │ │ ├── highlighting.vim
│ │ │ │ │ ├── loclist.vim
│ │ │ │ │ ├── modemap.vim
│ │ │ │ │ ├── notifiers.vim
│ │ │ │ │ ├── registry.vim
│ │ │ │ │ └── signs.vim
│ │ │ │ └── syntastic.vim
│ │ │ └── syntax_checkers/
│ │ │ ├── actionscript/
│ │ │ │ └── mxmlc.vim
│ │ │ ├── ada/
│ │ │ │ └── gcc.vim
│ │ │ ├── applescript/
│ │ │ │ └── osacompile.vim
│ │ │ ├── asciidoc/
│ │ │ │ └── asciidoc.vim
│ │ │ ├── asm/
│ │ │ │ └── gcc.vim
│ │ │ ├── bemhtml/
│ │ │ │ └── bemhtmllint.vim
│ │ │ ├── c/
│ │ │ │ ├── avrgcc.vim
│ │ │ │ ├── checkpatch.vim
│ │ │ │ ├── cppcheck.vim
│ │ │ │ ├── gcc.vim
│ │ │ │ ├── make.vim
│ │ │ │ ├── oclint.vim
│ │ │ │ ├── sparse.vim
│ │ │ │ └── splint.vim
│ │ │ ├── chef/
│ │ │ │ └── foodcritic.vim
│ │ │ ├── co/
│ │ │ │ └── coco.vim
│ │ │ ├── cobol/
│ │ │ │ └── cobc.vim
│ │ │ ├── coffee/
│ │ │ │ ├── coffee.vim
│ │ │ │ └── coffeelint.vim
│ │ │ ├── coq/
│ │ │ │ └── coqtop.vim
│ │ │ ├── cpp/
│ │ │ │ ├── cppcheck.vim
│ │ │ │ ├── cpplint.vim
│ │ │ │ ├── gcc.vim
│ │ │ │ └── oclint.vim
│ │ │ ├── cs/
│ │ │ │ └── mcs.vim
│ │ │ ├── css/
│ │ │ │ ├── csslint.vim
│ │ │ │ ├── phpcs.vim
│ │ │ │ └── prettycss.vim
│ │ │ ├── cucumber/
│ │ │ │ └── cucumber.vim
│ │ │ ├── cuda/
│ │ │ │ └── nvcc.vim
│ │ │ ├── d/
│ │ │ │ └── dmd.vim
│ │ │ ├── dart/
│ │ │ │ └── dartanalyzer.vim
│ │ │ ├── docbk/
│ │ │ │ └── xmllint.vim
│ │ │ ├── dustjs/
│ │ │ │ └── swiffer.vim
│ │ │ ├── elixir/
│ │ │ │ └── elixir.vim
│ │ │ ├── erlang/
│ │ │ │ ├── erlang_check_file.erl
│ │ │ │ ├── escript.vim
│ │ │ │ └── syntaxerl.vim
│ │ │ ├── eruby/
│ │ │ │ └── ruby.vim
│ │ │ ├── fortran/
│ │ │ │ └── gfortran.vim
│ │ │ ├── glsl/
│ │ │ │ └── cgc.vim
│ │ │ ├── go/
│ │ │ │ ├── go.vim
│ │ │ │ ├── gofmt.vim
│ │ │ │ ├── golint.vim
│ │ │ │ ├── gotype.vim
│ │ │ │ └── govet.vim
│ │ │ ├── haml/
│ │ │ │ ├── haml.vim
│ │ │ │ └── haml_lint.vim
│ │ │ ├── handlebars/
│ │ │ │ └── handlebars.vim
│ │ │ ├── haskell/
│ │ │ │ ├── ghc-mod.vim
│ │ │ │ ├── hdevtools.vim
│ │ │ │ └── hlint.vim
│ │ │ ├── haxe/
│ │ │ │ └── haxe.vim
│ │ │ ├── hss/
│ │ │ │ └── hss.vim
│ │ │ ├── html/
│ │ │ │ ├── jshint.vim
│ │ │ │ ├── tidy.vim
│ │ │ │ ├── validator.vim
│ │ │ │ └── w3.vim
│ │ │ ├── java/
│ │ │ │ ├── checkstyle.vim
│ │ │ │ └── javac.vim
│ │ │ ├── javascript/
│ │ │ │ ├── closurecompiler.vim
│ │ │ │ ├── eslint.vim
│ │ │ │ ├── gjslint.vim
│ │ │ │ ├── jscs.vim
│ │ │ │ ├── jshint.vim
│ │ │ │ ├── jsl.vim
│ │ │ │ ├── jslint.vim
│ │ │ │ └── jsxhint.vim
│ │ │ ├── json/
│ │ │ │ ├── jsonlint.vim
│ │ │ │ └── jsonval.vim
│ │ │ ├── less/
│ │ │ │ ├── less-lint.coffee
│ │ │ │ ├── less-lint.js
│ │ │ │ └── lessc.vim
│ │ │ ├── lex/
│ │ │ │ └── flex.vim
│ │ │ ├── limbo/
│ │ │ │ └── limbo.vim
│ │ │ ├── lisp/
│ │ │ │ └── clisp.vim
│ │ │ ├── llvm/
│ │ │ │ └── llvm.vim
│ │ │ ├── lua/
│ │ │ │ └── luac.vim
│ │ │ ├── matlab/
│ │ │ │ └── mlint.vim
│ │ │ ├── nasm/
│ │ │ │ └── nasm.vim
│ │ │ ├── nroff/
│ │ │ │ └── mandoc.vim
│ │ │ ├── objc/
│ │ │ │ ├── gcc.vim
│ │ │ │ └── oclint.vim
│ │ │ ├── objcpp/
│ │ │ │ ├── gcc.vim
│ │ │ │ └── oclint.vim
│ │ │ ├── ocaml/
│ │ │ │ └── camlp4o.vim
│ │ │ ├── perl/
│ │ │ │ ├── perl.vim
│ │ │ │ ├── perlcritic.vim
│ │ │ │ └── podchecker.vim
│ │ │ ├── php/
│ │ │ │ ├── php.vim
│ │ │ │ ├── phpcs.vim
│ │ │ │ └── phpmd.vim
│ │ │ ├── po/
│ │ │ │ └── msgfmt.vim
│ │ │ ├── pod/
│ │ │ │ └── podchecker.vim
│ │ │ ├── puppet/
│ │ │ │ ├── puppet.vim
│ │ │ │ └── puppetlint.vim
│ │ │ ├── python/
│ │ │ │ ├── compile.py
│ │ │ │ ├── flake8.vim
│ │ │ │ ├── frosted.vim
│ │ │ │ ├── pep257.vim
│ │ │ │ ├── pep8.vim
│ │ │ │ ├── py3kwarn.vim
│ │ │ │ ├── pyflakes.vim
│ │ │ │ ├── pylama.vim
│ │ │ │ ├── pylint.vim
│ │ │ │ └── python.vim
│ │ │ ├── racket/
│ │ │ │ ├── code-ayatollah.vim
│ │ │ │ └── racket.vim
│ │ │ ├── rst/
│ │ │ │ ├── rst2pseudoxml.vim
│ │ │ │ └── rstcheck.vim
│ │ │ ├── ruby/
│ │ │ │ ├── jruby.vim
│ │ │ │ ├── macruby.vim
│ │ │ │ ├── mri.vim
│ │ │ │ ├── rubocop.vim
│ │ │ │ └── rubylint.vim
│ │ │ ├── rust/
│ │ │ │ └── rustc.vim
│ │ │ ├── sass/
│ │ │ │ └── sass.vim
│ │ │ ├── scala/
│ │ │ │ ├── fsc.vim
│ │ │ │ └── scalac.vim
│ │ │ ├── scss/
│ │ │ │ ├── sass.vim
│ │ │ │ └── scss_lint.vim
│ │ │ ├── sh/
│ │ │ │ ├── checkbashisms.vim
│ │ │ │ ├── sh.vim
│ │ │ │ └── shellcheck.vim
│ │ │ ├── slim/
│ │ │ │ └── slimrb.vim
│ │ │ ├── tcl/
│ │ │ │ └── nagelfar.vim
│ │ │ ├── tex/
│ │ │ │ ├── chktex.vim
│ │ │ │ └── lacheck.vim
│ │ │ ├── texinfo/
│ │ │ │ └── makeinfo.vim
│ │ │ ├── text/
│ │ │ │ ├── atdtool.vim
│ │ │ │ └── language_check.vim
│ │ │ ├── twig/
│ │ │ │ └── twiglint.vim
│ │ │ ├── typescript/
│ │ │ │ └── tsc.vim
│ │ │ ├── vala/
│ │ │ │ └── valac.vim
│ │ │ ├── verilog/
│ │ │ │ └── verilator.vim
│ │ │ ├── vhdl/
│ │ │ │ └── ghdl.vim
│ │ │ ├── vim/
│ │ │ │ └── vimlint.vim
│ │ │ ├── xhtml/
│ │ │ │ ├── jshint.vim
│ │ │ │ └── tidy.vim
│ │ │ ├── xml/
│ │ │ │ └── xmllint.vim
│ │ │ ├── xslt/
│ │ │ │ └── xmllint.vim
│ │ │ ├── yacc/
│ │ │ │ └── bison.vim
│ │ │ ├── yaml/
│ │ │ │ ├── jsyaml.vim
│ │ │ │ └── yamlxs.vim
│ │ │ ├── z80/
│ │ │ │ └── z80syntaxchecker.vim
│ │ │ ├── zpt/
│ │ │ │ └── zptlint.vim
│ │ │ └── zsh/
│ │ │ ├── shellcheck.vim
│ │ │ └── zsh.vim
│ │ ├── tabular/
│ │ │ ├── README.md
│ │ │ ├── after/
│ │ │ │ └── plugin/
│ │ │ │ └── TabularMaps.vim
│ │ │ ├── autoload/
│ │ │ │ └── tabular.vim
│ │ │ ├── doc/
│ │ │ │ └── Tabular.txt
│ │ │ └── plugin/
│ │ │ └── Tabular.vim
│ │ ├── targets.vim/
│ │ │ ├── LICENSE
│ │ │ ├── README.md
│ │ │ ├── autoload/
│ │ │ │ └── targets.vim
│ │ │ ├── cheatsheet.md
│ │ │ ├── doc/
│ │ │ │ └── targets.txt
│ │ │ ├── plugin/
│ │ │ │ └── targets.vim
│ │ │ └── test/
│ │ │ ├── Makefile
│ │ │ ├── test.vim
│ │ │ ├── test1.in
│ │ │ ├── test1.ok
│ │ │ ├── test1.out
│ │ │ ├── test2.in
│ │ │ ├── test2.ok
│ │ │ ├── test2.out
│ │ │ ├── test3.in
│ │ │ ├── test3.ok
│ │ │ ├── test3.out
│ │ │ ├── test4.in
│ │ │ ├── test4.ok
│ │ │ └── test4.out
│ │ ├── textutil.vim/
│ │ │ ├── README
│ │ │ └── plugin/
│ │ │ └── textutil.vim
│ │ ├── tomorrow-night-vim/
│ │ │ └── colors/
│ │ │ ├── Tomorrow-Night-Blue.vim
│ │ │ ├── Tomorrow-Night-Bright.vim
│ │ │ ├── Tomorrow-Night-Eighties.vim
│ │ │ ├── Tomorrow-Night.vim
│ │ │ └── Tomorrow.vim
│ │ ├── vim-airline/
│ │ │ ├── .travis.yml
│ │ │ ├── Gemfile
│ │ │ ├── LICENSE
│ │ │ ├── README.md
│ │ │ ├── Rakefile
│ │ │ ├── autoload/
│ │ │ │ ├── airline/
│ │ │ │ │ ├── builder.vim
│ │ │ │ │ ├── debug.vim
│ │ │ │ │ ├── deprecation.vim
│ │ │ │ │ ├── extensions/
│ │ │ │ │ │ ├── branch.vim
│ │ │ │ │ │ ├── bufferline.vim
│ │ │ │ │ │ ├── commandt.vim
│ │ │ │ │ │ ├── csv.vim
│ │ │ │ │ │ ├── ctrlp.vim
│ │ │ │ │ │ ├── default.vim
│ │ │ │ │ │ ├── eclim.vim
│ │ │ │ │ │ ├── example.vim
│ │ │ │ │ │ ├── hunks.vim
│ │ │ │ │ │ ├── netrw.vim
│ │ │ │ │ │ ├── promptline.vim
│ │ │ │ │ │ ├── quickfix.vim
│ │ │ │ │ │ ├── syntastic.vim
│ │ │ │ │ │ ├── tabline/
│ │ │ │ │ │ │ ├── default.vim
│ │ │ │ │ │ │ ├── unique_tail.vim
│ │ │ │ │ │ │ └── unique_tail_improved.vim
│ │ │ │ │ │ ├── tabline.vim
│ │ │ │ │ │ ├── tagbar.vim
│ │ │ │ │ │ ├── tmuxline.vim
│ │ │ │ │ │ ├── undotree.vim
│ │ │ │ │ │ ├── unite.vim
│ │ │ │ │ │ ├── virtualenv.vim
│ │ │ │ │ │ └── whitespace.vim
│ │ │ │ │ ├── extensions.vim
│ │ │ │ │ ├── highlighter.vim
│ │ │ │ │ ├── init.vim
│ │ │ │ │ ├── parts.vim
│ │ │ │ │ ├── section.vim
│ │ │ │ │ ├── themes/
│ │ │ │ │ │ ├── badwolf.vim
│ │ │ │ │ │ ├── base16.vim
│ │ │ │ │ │ ├── bubblegum.vim
│ │ │ │ │ │ ├── dark.vim
│ │ │ │ │ │ ├── hybrid.vim
│ │ │ │ │ │ ├── jellybeans.vim
│ │ │ │ │ │ ├── kalisi.vim
│ │ │ │ │ │ ├── kolor.vim
│ │ │ │ │ │ ├── laederon.vim
│ │ │ │ │ │ ├── light.vim
│ │ │ │ │ │ ├── lucius.vim
│ │ │ │ │ │ ├── luna.vim
│ │ │ │ │ │ ├── molokai.vim
│ │ │ │ │ │ ├── monochrome.vim
│ │ │ │ │ │ ├── murmur.vim
│ │ │ │ │ │ ├── powerlineish.vim
│ │ │ │ │ │ ├── serene.vim
│ │ │ │ │ │ ├── simple.vim
│ │ │ │ │ │ ├── sol.vim
│ │ │ │ │ │ ├── solarized.vim
│ │ │ │ │ │ ├── tomorrow.vim
│ │ │ │ │ │ ├── ubaryd.vim
│ │ │ │ │ │ ├── understated.vim
│ │ │ │ │ │ ├── wombat.vim
│ │ │ │ │ │ └── zenburn.vim
│ │ │ │ │ ├── themes.vim
│ │ │ │ │ └── util.vim
│ │ │ │ └── airline.vim
│ │ │ ├── doc/
│ │ │ │ └── airline.txt
│ │ │ ├── plugin/
│ │ │ │ └── airline.vim
│ │ │ └── t/
│ │ │ ├── airline.vim
│ │ │ ├── builder.vim
│ │ │ ├── commands.vim
│ │ │ ├── extensions_default.vim
│ │ │ ├── highlighter.vim
│ │ │ ├── init.vim
│ │ │ ├── parts.vim
│ │ │ ├── section.vim
│ │ │ ├── themes.vim
│ │ │ └── util.vim
│ │ ├── vim-bookmarks/
│ │ │ ├── .travis.yml
│ │ │ ├── CONTRIBUTING.md
│ │ │ ├── Gemfile
│ │ │ ├── Guardfile
│ │ │ ├── LICENSE
│ │ │ ├── README.md
│ │ │ ├── Rakefile
│ │ │ ├── autoload/
│ │ │ │ ├── bm.vim
│ │ │ │ ├── bm_sign.vim
│ │ │ │ └── util.vim
│ │ │ ├── doc/
│ │ │ │ └── bookmarks.txt
│ │ │ ├── plugin/
│ │ │ │ └── bookmark.vim
│ │ │ └── t/
│ │ │ ├── bm_sign_spec.vim
│ │ │ ├── bm_spec.vim
│ │ │ └── util_spec.vim
│ │ ├── vim-choosewin/
│ │ │ ├── README-JP.md
│ │ │ ├── README.md
│ │ │ ├── Rakefile
│ │ │ ├── VERSION
│ │ │ ├── autoload/
│ │ │ │ ├── choosewin/
│ │ │ │ │ ├── data/
│ │ │ │ │ │ ├── _sample
│ │ │ │ │ │ ├── large
│ │ │ │ │ │ ├── small
│ │ │ │ │ │ └── small_horizontal
│ │ │ │ │ ├── font.vim
│ │ │ │ │ ├── highlighter.vim
│ │ │ │ │ ├── hlmanager.vim
│ │ │ │ │ └── overlay.vim
│ │ │ │ └── choosewin.vim
│ │ │ ├── doc/
│ │ │ │ └── choosewin.txt
│ │ │ ├── misc/
│ │ │ │ └── work.vim
│ │ │ ├── plugin/
│ │ │ │ └── choosewin.vim
│ │ │ └── test/
│ │ │ └── font.vim
│ │ ├── vim-classpath/
│ │ │ ├── README.markdown
│ │ │ ├── autoload/
│ │ │ │ └── classpath.vim
│ │ │ ├── doc/
│ │ │ │ └── classpath.txt
│ │ │ └── plugin/
│ │ │ └── classpath.vim
│ │ ├── vim-clojure-static/
│ │ │ ├── LICENSE.txt
│ │ │ ├── README.markdown
│ │ │ ├── autoload/
│ │ │ │ └── clojurecomplete.vim
│ │ │ ├── clj/
│ │ │ │ ├── project.clj
│ │ │ │ ├── src/
│ │ │ │ │ └── vim_clojure_static/
│ │ │ │ │ ├── generate.clj
│ │ │ │ │ ├── test.clj
│ │ │ │ │ └── update.clj
│ │ │ │ ├── test/
│ │ │ │ │ └── vim_clojure_static/
│ │ │ │ │ └── syntax_test.clj
│ │ │ │ └── vim/
│ │ │ │ └── test-runtime.vim
│ │ │ ├── doc/
│ │ │ │ └── clojure.txt
│ │ │ ├── ftdetect/
│ │ │ │ └── clojure.vim
│ │ │ ├── ftplugin/
│ │ │ │ └── clojure.vim
│ │ │ ├── indent/
│ │ │ │ └── clojure.vim
│ │ │ └── syntax/
│ │ │ └── clojure.vim
│ │ ├── vim-colors-solarized/
│ │ │ ├── README.mkd
│ │ │ ├── autoload/
│ │ │ │ └── togglebg.vim
│ │ │ ├── colors/
│ │ │ │ └── solarized.vim
│ │ │ └── doc/
│ │ │ └── solarized.txt
│ │ ├── vim-commentary/
│ │ │ ├── README.markdown
│ │ │ ├── doc/
│ │ │ │ └── commentary.txt
│ │ │ └── plugin/
│ │ │ └── commentary.vim
│ │ ├── vim-css-color/
│ │ │ ├── README.md
│ │ │ ├── after/
│ │ │ │ └── syntax/
│ │ │ │ ├── css.vim
│ │ │ │ ├── html.vim
│ │ │ │ ├── less.vim
│ │ │ │ ├── sass.vim
│ │ │ │ ├── stylus.vim
│ │ │ │ └── vim.vim
│ │ │ ├── autoload/
│ │ │ │ └── css_color.vim
│ │ │ └── tests/
│ │ │ ├── bench
│ │ │ ├── example.less
│ │ │ ├── example.sass
│ │ │ ├── example.stylus
│ │ │ └── torture.css
│ │ ├── vim-cucumber/
│ │ │ ├── compiler/
│ │ │ │ └── cucumber.vim
│ │ │ ├── ftdetect/
│ │ │ │ └── cucumber.vim
│ │ │ ├── ftplugin/
│ │ │ │ └── cucumber.vim
│ │ │ ├── indent/
│ │ │ │ └── cucumber.vim
│ │ │ └── syntax/
│ │ │ └── cucumber.vim
│ │ ├── vim-dispatch/
│ │ │ ├── CONTRIBUTING.markdown
│ │ │ ├── README.markdown
│ │ │ ├── autoload/
│ │ │ │ ├── dispatch/
│ │ │ │ │ ├── headless.vim
│ │ │ │ │ ├── iterm.vim
│ │ │ │ │ ├── screen.vim
│ │ │ │ │ ├── tmux.vim
│ │ │ │ │ ├── windows.vim
│ │ │ │ │ └── x11.vim
│ │ │ │ └── dispatch.vim
│ │ │ ├── doc/
│ │ │ │ └── dispatch.txt
│ │ │ └── plugin/
│ │ │ └── dispatch.vim
│ │ ├── vim-endwise/
│ │ │ ├── README.markdown
│ │ │ └── plugin/
│ │ │ └── endwise.vim
│ │ ├── vim-fireplace/
│ │ │ ├── CONTRIBUTING.markdown
│ │ │ ├── README.markdown
│ │ │ ├── autoload/
│ │ │ │ ├── fireplace/
│ │ │ │ │ └── nrepl.vim
│ │ │ │ └── nrepl/
│ │ │ │ └── fireplace_connection.vim
│ │ │ ├── compiler/
│ │ │ │ └── lein.vim
│ │ │ ├── doc/
│ │ │ │ └── fireplace.txt
│ │ │ ├── plugin/
│ │ │ │ ├── fireplace/
│ │ │ │ │ └── zip.vim
│ │ │ │ └── fireplace.vim
│ │ │ └── python/
│ │ │ └── nrepl_fireplace.py
│ │ ├── vim-fugitive/
│ │ │ ├── CONTRIBUTING.markdown
│ │ │ ├── README.markdown
│ │ │ ├── doc/
│ │ │ │ └── fugitive.txt
│ │ │ └── plugin/
│ │ │ └── fugitive.vim
│ │ ├── vim-gitgutter/
│ │ │ ├── README.mkd
│ │ │ ├── autoload/
│ │ │ │ ├── debug.vim
│ │ │ │ ├── diff.vim
│ │ │ │ ├── highlight.vim
│ │ │ │ ├── hunk.vim
│ │ │ │ ├── sign.vim
│ │ │ │ └── utility.vim
│ │ │ ├── doc/
│ │ │ │ └── gitgutter.txt
│ │ │ └── plugin/
│ │ │ └── gitgutter.vim
│ │ ├── vim-haml/
│ │ │ ├── compiler/
│ │ │ │ ├── haml.vim
│ │ │ │ └── sass.vim
│ │ │ ├── ftdetect/
│ │ │ │ └── haml.vim
│ │ │ ├── ftplugin/
│ │ │ │ ├── haml.vim
│ │ │ │ ├── sass.vim
│ │ │ │ └── scss.vim
│ │ │ ├── indent/
│ │ │ │ ├── haml.vim
│ │ │ │ ├── sass.vim
│ │ │ │ └── scss.vim
│ │ │ └── syntax/
│ │ │ ├── haml.vim
│ │ │ ├── sass.vim
│ │ │ └── scss.vim
│ │ ├── vim-localrc/
│ │ │ ├── autoload/
│ │ │ │ └── localrc.vim
│ │ │ ├── doc/
│ │ │ │ └── localrc.txt
│ │ │ └── plugin/
│ │ │ └── localrc.vim
│ │ ├── vim-markdown/
│ │ │ ├── ftdetect/
│ │ │ │ └── markdown.vim
│ │ │ ├── ftplugin/
│ │ │ │ └── markdown.vim
│ │ │ └── syntax/
│ │ │ └── markdown.vim
│ │ ├── vim-polyglot/
│ │ │ ├── .travis.yml
│ │ │ ├── Gemfile
│ │ │ ├── README.md
│ │ │ ├── after/
│ │ │ │ ├── ftdetect/
│ │ │ │ │ └── rspec.vim
│ │ │ │ ├── ftplugin/
│ │ │ │ │ └── haskell.vim
│ │ │ │ ├── indent/
│ │ │ │ │ └── html.vim
│ │ │ │ └── syntax/
│ │ │ │ ├── coffee.vim
│ │ │ │ ├── cpp.vim
│ │ │ │ ├── css/
│ │ │ │ │ └── vim-coloresque.vim
│ │ │ │ ├── haml.vim
│ │ │ │ ├── help.vim
│ │ │ │ ├── html.vim
│ │ │ │ ├── less.vim
│ │ │ │ ├── rspec.vim
│ │ │ │ ├── ruby.vim
│ │ │ │ ├── rust.vim
│ │ │ │ ├── sass.vim
│ │ │ │ ├── scss.vim
│ │ │ │ ├── stylus.vim
│ │ │ │ ├── tex.vim
│ │ │ │ └── vim.vim
│ │ │ ├── autoload/
│ │ │ │ ├── clojurecomplete.vim
│ │ │ │ ├── coffee.vim
│ │ │ │ ├── erlangcomplete.vim
│ │ │ │ ├── go/
│ │ │ │ │ └── complete.vim
│ │ │ │ ├── htmlcomplete.vim
│ │ │ │ ├── rubycomplete.vim
│ │ │ │ └── xml/
│ │ │ │ ├── aria.vim
│ │ │ │ └── html5.vim
│ │ │ ├── build
│ │ │ ├── compiler/
│ │ │ │ ├── cake.vim
│ │ │ │ ├── coffee.vim
│ │ │ │ ├── cucumber.vim
│ │ │ │ ├── erlang.vim
│ │ │ │ ├── eruby.vim
│ │ │ │ ├── exunit.vim
│ │ │ │ ├── go.vim
│ │ │ │ ├── haml.vim
│ │ │ │ ├── rake.vim
│ │ │ │ ├── rspec.vim
│ │ │ │ ├── ruby.vim
│ │ │ │ ├── rubyunit.vim
│ │ │ │ ├── rustc.vim
│ │ │ │ ├── sass.vim
│ │ │ │ └── typescript.vim
│ │ │ ├── ftdetect/
│ │ │ │ └── polyglot.vim
│ │ │ ├── ftplugin/
│ │ │ │ ├── clojure.vim
│ │ │ │ ├── coffee.vim
│ │ │ │ ├── csv.vim
│ │ │ │ ├── cucumber.vim
│ │ │ │ ├── elixir.vim
│ │ │ │ ├── erlang.vim
│ │ │ │ ├── erlang_refactor.vim
│ │ │ │ ├── eruby.vim
│ │ │ │ ├── git.vim
│ │ │ │ ├── gitcommit.vim
│ │ │ │ ├── gitconfig.vim
│ │ │ │ ├── gitrebase.vim
│ │ │ │ ├── gitsendemail.vim
│ │ │ │ ├── go/
│ │ │ │ │ ├── fmt.vim
│ │ │ │ │ └── import.vim
│ │ │ │ ├── go.vim
│ │ │ │ ├── haml.vim
│ │ │ │ ├── jade.vim
│ │ │ │ ├── latex-box/
│ │ │ │ │ ├── common.vim
│ │ │ │ │ ├── complete.vim
│ │ │ │ │ ├── findmain.vim
│ │ │ │ │ ├── folding.vim
│ │ │ │ │ ├── latexmk.vim
│ │ │ │ │ ├── mappings.vim
│ │ │ │ │ └── motion.vim
│ │ │ │ ├── latextoc.vim
│ │ │ │ ├── less.vim
│ │ │ │ ├── markdown.vim
│ │ │ │ ├── mustache.vim
│ │ │ │ ├── ocaml.vim
│ │ │ │ ├── opencl.vim
│ │ │ │ ├── perl.vim
│ │ │ │ ├── perl6.vim
│ │ │ │ ├── puppet.vim
│ │ │ │ ├── r.vim
│ │ │ │ ├── rhelp.vim
│ │ │ │ ├── rnoweb.vim
│ │ │ │ ├── ruby.vim
│ │ │ │ ├── rust.vim
│ │ │ │ ├── sass.vim
│ │ │ │ ├── scala.vim
│ │ │ │ ├── scala.xpt.vim
│ │ │ │ ├── scss.vim
│ │ │ │ ├── stylus.vim
│ │ │ │ ├── tex_LatexBox.vim
│ │ │ │ ├── textile.vim
│ │ │ │ ├── tt2html.vim
│ │ │ │ ├── twig.vim
│ │ │ │ ├── typescript.vim
│ │ │ │ └── xs.vim
│ │ │ ├── indent/
│ │ │ │ ├── arduino.vim
│ │ │ │ ├── clojure.vim
│ │ │ │ ├── coffee.vim
│ │ │ │ ├── cucumber.vim
│ │ │ │ ├── elixir.vim
│ │ │ │ ├── erlang.vim
│ │ │ │ ├── eruby.vim
│ │ │ │ ├── gitconfig.vim
│ │ │ │ ├── go.vim
│ │ │ │ ├── haml.vim
│ │ │ │ ├── haskell.vim
│ │ │ │ ├── html.vim
│ │ │ │ ├── jade.vim
│ │ │ │ ├── javascript.vim
│ │ │ │ ├── jst.vim
│ │ │ │ ├── less.vim
│ │ │ │ ├── ocaml.vim
│ │ │ │ ├── opencl.vim
│ │ │ │ ├── perl.vim
│ │ │ │ ├── perl6.vim
│ │ │ │ ├── puppet.vim
│ │ │ │ ├── ruby.vim
│ │ │ │ ├── rust.vim
│ │ │ │ ├── sass.vim
│ │ │ │ ├── scala.vim
│ │ │ │ ├── scss.vim
│ │ │ │ ├── slim.vim
│ │ │ │ ├── stylus.vim
│ │ │ │ └── tex.vim
│ │ │ ├── spec/
│ │ │ │ ├── build_spec.rb
│ │ │ │ ├── loading_spec.rb
│ │ │ │ └── spec_helper.rb
│ │ │ └── syntax/
│ │ │ ├── arduino.vim
│ │ │ ├── c.vim
│ │ │ ├── cabal.vim
│ │ │ ├── clojure.vim
│ │ │ ├── coffee.vim
│ │ │ ├── cpp.vim
│ │ │ ├── csv.vim
│ │ │ ├── cucumber.vim
│ │ │ ├── dockerfile.vim
│ │ │ ├── elixir.vim
│ │ │ ├── erlang.vim
│ │ │ ├── eruby.vim
│ │ │ ├── git.vim
│ │ │ ├── gitcommit.vim
│ │ │ ├── gitconfig.vim
│ │ │ ├── gitrebase.vim
│ │ │ ├── gitsendemail.vim
│ │ │ ├── go.vim
│ │ │ ├── godoc.vim
│ │ │ ├── haml.vim
│ │ │ ├── haskell.vim
│ │ │ ├── html/
│ │ │ │ ├── aria.vim
│ │ │ │ └── rdfa.vim
│ │ │ ├── html.vim
│ │ │ ├── jade.vim
│ │ │ ├── javascript/
│ │ │ │ └── html5.vim
│ │ │ ├── javascript.vim
│ │ │ ├── json.vim
│ │ │ ├── jst.vim
│ │ │ ├── latextoc.vim
│ │ │ ├── less.vim
│ │ │ ├── markdown.vim
│ │ │ ├── mason.vim
│ │ │ ├── mustache.vim
│ │ │ ├── nginx.vim
│ │ │ ├── ocaml.vim
│ │ │ ├── octave.vim
│ │ │ ├── opencl.vim
│ │ │ ├── perl.vim
│ │ │ ├── perl6.vim
│ │ │ ├── php.vim
│ │ │ ├── pod.vim
│ │ │ ├── proto.vim
│ │ │ ├── puppet.vim
│ │ │ ├── python.vim
│ │ │ ├── rhelp.vim
│ │ │ ├── rnoweb.vim
│ │ │ ├── ruby.vim
│ │ │ ├── rust.vim
│ │ │ ├── sass.vim
│ │ │ ├── sbt.vim
│ │ │ ├── scala.vim
│ │ │ ├── scss.vim
│ │ │ ├── slim.vim
│ │ │ ├── stylus.vim
│ │ │ ├── textile.vim
│ │ │ ├── tmux.vim
│ │ │ ├── tt2.vim
│ │ │ ├── tt2html.vim
│ │ │ ├── tt2js.vim
│ │ │ ├── twig.vim
│ │ │ ├── typescript.vim
│ │ │ ├── vbnet.vim
│ │ │ ├── xs.vim
│ │ │ └── xsl.vim
│ │ ├── vim-repeat/
│ │ │ ├── README.markdown
│ │ │ └── autoload/
│ │ │ └── repeat.vim
│ │ ├── vim-surround/
│ │ │ ├── README.markdown
│ │ │ ├── doc/
│ │ │ │ └── surround.txt
│ │ │ └── plugin/
│ │ │ └── surround.vim
│ │ ├── vim-tbone/
│ │ │ ├── CONTRIBUTING.markdown
│ │ │ ├── README.markdown
│ │ │ ├── autoload/
│ │ │ │ └── tbone.vim
│ │ │ ├── doc/
│ │ │ │ └── tbone.txt
│ │ │ └── plugin/
│ │ │ └── tbone.vim
│ │ ├── webapi-vim/
│ │ │ ├── Makefile
│ │ │ ├── README
│ │ │ ├── autoload/
│ │ │ │ └── webapi/
│ │ │ │ ├── atom.vim
│ │ │ │ ├── base64.vim
│ │ │ │ ├── bit.vim
│ │ │ │ ├── feed.vim
│ │ │ │ ├── hmac.vim
│ │ │ │ ├── html.vim
│ │ │ │ ├── http.vim
│ │ │ │ ├── json.vim
│ │ │ │ ├── jsonrpc.vim
│ │ │ │ ├── metaWeblog.vim
│ │ │ │ ├── oauth.vim
│ │ │ │ ├── sha1.vim
│ │ │ │ ├── soap.vim
│ │ │ │ ├── ucs.vim
│ │ │ │ ├── xml.vim
│ │ │ │ └── xmlrpc.vim
│ │ │ ├── doc/
│ │ │ │ ├── webapi-html.txt
│ │ │ │ ├── webapi-http.txt
│ │ │ │ ├── webapi-json.txt
│ │ │ │ └── webapi-xml.txt
│ │ │ ├── example/
│ │ │ │ ├── gistview.vim
│ │ │ │ ├── google-buzz.vim
│ │ │ │ ├── hatenadiary.vim
│ │ │ │ ├── jugem.vim
│ │ │ │ ├── livedoor.vim
│ │ │ │ ├── rss.vim
│ │ │ │ ├── twitter.vim
│ │ │ │ └── weather.vim
│ │ │ └── webapi.vim.vimup
│ │ └── wildfire.vim/
│ │ ├── LICENSE.txt
│ │ ├── README.md
│ │ ├── autoload/
│ │ │ └── wildfire.vim
│ │ ├── doc/
│ │ │ └── wildfire.txt
│ │ └── plugin/
│ │ └── wildfire.vim
│ └── plugin/
│ ├── BufOnly.vim
│ └── scratch.vim
├── .vimrc
├── .zshrc
├── README.md
├── fonts/
│ └── Droid+Sans+Mono+for+Powerline.otf
└── themes/
├── Smyck.terminal
├── Solarized Dark.terminal
├── Solarized Light.terminal
└── Tomorrow Night Bright.terminal
================================================
FILE CONTENTS
================================================
================================================
FILE: .tmux.conf
================================================
# Bindings {{{
# Remap prefix
unbind C-b
set -g prefix C-Space
# Quick key for moving back to the previous window
bind-key L last-window
# Vim style bindings for pane movement
bind-key -r h select-pane -L
bind-key -r j select-pane -D
bind-key -r k select-pane -U
bind-key -r l select-pane -R
# Fix issue with tmux repeating -r the arrow directions (meaning when you switch panes you can accidentally jump back to the other pane again)
bind-key Up select-pane -U
bind-key Down select-pane -D
bind-key Left select-pane -L
bind-key Right select-pane -R
# Make splitting windows easier
bind-key v split-window -h
bind-key s split-window -v
# Reload tmux config
# Same as in command mode :source-file ~/tmux.conf
# Or outside of tmux with `tmux source-file ~/tmux.conf`
bind-key r source-file ~/.tmux.conf
# Allow Ctrl+k to clear the history
bind-key -n C-k clear-history
# Make resizing panes easier
bind-key < resize-pane -L 5
bind-key > resize-pane -R 5
bind-key + resize-pane -U 5
bind-key - resize-pane -D 5
bind-key = select-layout even-vertical
bind-key | select-layout even-horizontal
# }}}
# Settings {{{
# Ensure terminal starts with its own colour scheme (defined below)
set -g default-terminal "screen-256color"
set-window-option -g utf8 on
# Note: if you have EDITOR=vim set
# then the following two settings aren't needed
# Use Vi style key bindings to move around command line mode
set-option -g status-keys vi
# Use Vi style key bindings to move around copy mode
setw -g mode-keys vi
# Remove delay when pressing esc in Vim
set -sg escape-time 0
# Prevent tmux from renaming the tab when processes change
# e.g. if you're in a directory which is a git repo and you fire up Pry then
# tmux would first rename the tab to 'java' (for Pry) then 'git' when exiting Pry, then finally back to 'zsh'
set-option -g allow-rename off
# Tells tmux up front what shell to expect
set-option -g default-shell /bin/zsh
# Set base to 1
set -g base-index 1
# Enable UTF-8 support in status bar
set -g status on
set -g status-utf8 on
# Increase scrollback lines
set -g history-limit 30000
# Renumber windows automatically after removing a window
# Prevents my OCD and means I don't have to manually run {move|swap}-window
set-option -g renumber-windows on
# Colour reference...
# Light Blue = 31
# Dark Grey = 234
# Light Grey = 240
# White = 254
# sets right side of the status bar to look bit nicer
set -g status-right '#[fg=colour234,bg=white,nobold,nounderscore,noitalics]#[fg=colour250,bg=colour234] %a #[fg=colour247,bg=colour234] #[fg=colour247,bg=colour234] %b %d %R #[fg=colour252,bg=colour234,nobold,nounderscore,noitalics]#[fg=red,bg=colour234]#[fg=white,bg=red] #H'
# sets status bar background colour
set -g status-bg white
# positions each window name to the left most edge of the status bar
set -g status-justify 'left'
# sets default pane border colour
set -g pane-border-fg white
# highlights border of current pane
set -g pane-active-border-fg red
# sets status bar background colour when executing a command via command-line mode
set -g message-bg red
# sets colour of status bar font in command-line mode
set -g message-fg white
# adds separator (in this case some extra breathing space around the list of windows)
setw -g window-status-separator ' '
# sets design of current window listed in the status bar
setw -g window-status-current-format '#[fg=colour231,bg=colour31,bold] #I #W #[fg=colour31,bg=white,nobold,nounderscore,noitalics]'
# Explanation of settings I don't use...
#
# sets background colour of status bar when you try to ESC command-line mode:
# set -g message-command-bg 'colour31'
#
# sets colour of status bar font in default mode:
# setw -g window-status-fg black
#
# sets the background colour of the window listed in the status bar:
# setw -g window-status-bg 'colour234'
#
# sets default design around each window listed in the status bar:
# setw -g window-status-format '#[fg=colour234,bg=colour234,nobold,nounderscore,noitalics]#[default] #I #W #[fg=colour234,bg=colour234,nobold,nounderscore,noitalics]'
#
# sets left side information of status bar:
# set -g status-left '#[fg=colour16,bg=colour254,bold] #S #[fg=colour254,bg=colour240,nobold,nounderscore,noitalics]#[fg=colour237,bg=colour240] #F #[fg=colour240,bg=colour236,nobold,nounderscore,noitalics]#[fg=colour247,bg=colour236] #W #[fg=colour236,bg=colour234,nobold,nounderscore,noitalics]'
# }}}
================================================
FILE: .vim/autoload/pathogen.vim
================================================
" pathogen.vim - path option manipulation
" Maintainer: Tim Pope <http://tpo.pe/>
" Version: 2.2
" Install in ~/.vim/autoload (or ~\vimfiles\autoload).
"
" For management of individually installed plugins in ~/.vim/bundle (or
" ~\vimfiles\bundle), adding `execute pathogen#infect()` to the top of your
" .vimrc is the only other setup necessary.
"
" The API is documented inline below. For maximum ease of reading,
" :set foldmethod=marker
if exists("g:loaded_pathogen") || &cp
finish
endif
let g:loaded_pathogen = 1
function! s:warn(msg)
echohl WarningMsg
echomsg a:msg
echohl NONE
endfunction
" Point of entry for basic default usage. Give a relative path to invoke
" pathogen#incubate() (defaults to "bundle/{}"), or an absolute path to invoke
" pathogen#surround(). For backwards compatibility purposes, a full path that
" does not end in {} or * is given to pathogen#runtime_prepend_subdirectories()
" instead.
function! pathogen#infect(...) abort " {{{1
for path in a:0 ? reverse(copy(a:000)) : ['bundle/{}']
if path =~# '^[^\\/]\+$'
call s:warn('Change pathogen#infect('.string(path).') to pathogen#infect('.string(path.'/{}').')')
call pathogen#incubate(path . '/{}')
elseif path =~# '^[^\\/]\+[\\/]\%({}\|\*\)$'
call pathogen#incubate(path)
elseif path =~# '[\\/]\%({}\|\*\)$'
call pathogen#surround(path)
else
call s:warn('Change pathogen#infect('.string(path).') to pathogen#infect('.string(path.'/{}').')')
call pathogen#surround(path . '/{}')
endif
endfor
call pathogen#cycle_filetype()
return ''
endfunction " }}}1
" Split a path into a list.
function! pathogen#split(path) abort " {{{1
if type(a:path) == type([]) | return a:path | endif
let split = split(a:path,'\\\@<!\%(\\\\\)*\zs,')
return map(split,'substitute(v:val,''\\\([\\,]\)'',''\1'',"g")')
endfunction " }}}1
" Convert a list to a path.
function! pathogen#join(...) abort " {{{1
if type(a:1) == type(1) && a:1
let i = 1
let space = ' '
else
let i = 0
let space = ''
endif
let path = ""
while i < a:0
if type(a:000[i]) == type([])
let list = a:000[i]
let j = 0
while j < len(list)
let escaped = substitute(list[j],'[,'.space.']\|\\[\,'.space.']\@=','\\&','g')
let path .= ',' . escaped
let j += 1
endwhile
else
let path .= "," . a:000[i]
endif
let i += 1
endwhile
return substitute(path,'^,','','')
endfunction " }}}1
" Convert a list to a path with escaped spaces for 'path', 'tag', etc.
function! pathogen#legacyjoin(...) abort " {{{1
return call('pathogen#join',[1] + a:000)
endfunction " }}}1
" Remove duplicates from a list.
function! pathogen#uniq(list) abort " {{{1
let i = 0
let seen = {}
while i < len(a:list)
if (a:list[i] ==# '' && exists('empty')) || has_key(seen,a:list[i])
call remove(a:list,i)
elseif a:list[i] ==# ''
let i += 1
let empty = 1
else
let seen[a:list[i]] = 1
let i += 1
endif
endwhile
return a:list
endfunction " }}}1
" \ on Windows unless shellslash is set, / everywhere else.
function! pathogen#separator() abort " {{{1
return !exists("+shellslash") || &shellslash ? '/' : '\'
endfunction " }}}1
" Convenience wrapper around glob() which returns a list.
function! pathogen#glob(pattern) abort " {{{1
let files = split(glob(a:pattern),"\n")
return map(files,'substitute(v:val,"[".pathogen#separator()."/]$","","")')
endfunction "}}}1
" Like pathogen#glob(), only limit the results to directories.
function! pathogen#glob_directories(pattern) abort " {{{1
return filter(pathogen#glob(a:pattern),'isdirectory(v:val)')
endfunction "}}}1
" Turn filetype detection off and back on again if it was already enabled.
function! pathogen#cycle_filetype() " {{{1
if exists('g:did_load_filetypes')
filetype off
filetype on
endif
endfunction " }}}1
" Check if a bundle is disabled. A bundle is considered disabled if it ends
" in a tilde or its basename or full name is included in the list
" g:pathogen_disabled.
function! pathogen#is_disabled(path) " {{{1
if a:path =~# '\~$'
return 1
elseif !exists("g:pathogen_disabled")
return 0
endif
let sep = pathogen#separator()
let blacklist = g:pathogen_disabled
return index(blacklist, strpart(a:path, strridx(a:path, sep)+1)) != -1 && index(blacklist, a:path) != 1
endfunction "}}}1
" Prepend the given directory to the runtime path and append its corresponding
" after directory. If the directory is already included, move it to the
" outermost position. Wildcards are added as is. Ending a path in /{} causes
" all subdirectories to be added (except those in g:pathogen_disabled).
function! pathogen#surround(path) abort " {{{1
let sep = pathogen#separator()
let rtp = pathogen#split(&rtp)
if a:path =~# '[\\/]{}$'
let path = fnamemodify(a:path[0:-4], ':p:s?[\\/]\=$??')
let before = filter(pathogen#glob_directories(path.sep.'*'), '!pathogen#is_disabled(v:val)')
let after = filter(reverse(pathogen#glob_directories(path.sep."*".sep."after")), '!pathogen#is_disabled(v:val[0:-7])')
call filter(rtp,'v:val[0:strlen(path)-1] !=# path')
else
let path = fnamemodify(a:path, ':p:s?[\\/]\=$??')
let before = [path]
let after = [path . sep . 'after']
call filter(rtp, 'index(before + after, v:val) == -1')
endif
let &rtp = pathogen#join(before, rtp, after)
return &rtp
endfunction " }}}1
" Prepend all subdirectories of path to the rtp, and append all 'after'
" directories in those subdirectories. Deprecated.
function! pathogen#runtime_prepend_subdirectories(path) " {{{1
call s:warn('Change pathogen#runtime_prepend_subdirectories('.string(a:path).') to pathogen#surround('.string(a:path.'/{}').')')
return pathogen#surround(a:path . pathogen#separator() . '{}')
endfunction " }}}1
" For each directory in the runtime path, add a second entry with the given
" argument appended. If the argument ends in '/{}', add a separate entry for
" each subdirectory. The default argument is 'bundle/{}', which means that
" .vim/bundle/*, $VIM/vimfiles/bundle/*, $VIMRUNTIME/bundle/*,
" $VIM/vim/files/bundle/*/after, and .vim/bundle/*/after will be added (on
" UNIX).
function! pathogen#incubate(...) abort " {{{1
let sep = pathogen#separator()
let name = a:0 ? a:1 : 'bundle/{}'
if "\n".s:done_bundles =~# "\\M\n".name."\n"
return ""
endif
let s:done_bundles .= name . "\n"
let list = []
for dir in pathogen#split(&rtp)
if dir =~# '\<after$'
if name =~# '{}$'
let list += filter(pathogen#glob_directories(substitute(dir,'after$',name[0:-3],'').'*'.sep.'after'), '!pathogen#is_disabled(v:val[0:-7])') + [dir]
else
let list += [dir, substitute(dir, 'after$', '', '') . name . sep . 'after']
endif
else
if name =~# '{}$'
let list += [dir] + filter(pathogen#glob_directories(dir.sep.name[0:-3].'*'), '!pathogen#is_disabled(v:val)')
else
let list += [dir . sep . name, dir]
endif
endif
endfor
let &rtp = pathogen#join(pathogen#uniq(list))
return 1
endfunction " }}}1
" Deprecated alias for pathogen#incubate().
function! pathogen#runtime_append_all_bundles(...) abort " {{{1
if a:0
call s:warn('Change pathogen#runtime_append_all_bundles('.string(a:1).') to pathogen#incubate('.string(a:1.'/{}').')')
else
call s:warn('Change pathogen#runtime_append_all_bundles() to pathogen#incubate()')
endif
return call('pathogen#incubate', map(copy(a:000),'v:val . "/{}"'))
endfunction
let s:done_bundles = ''
" }}}1
" Invoke :helptags on all non-$VIM doc directories in runtimepath.
function! pathogen#helptags() abort " {{{1
let sep = pathogen#separator()
for glob in pathogen#split(&rtp)
for dir in split(glob(glob), "\n")
if (dir.sep)[0 : strlen($VIMRUNTIME)] !=# $VIMRUNTIME.sep && filewritable(dir.sep.'doc') == 2 && !empty(filter(split(glob(dir.sep.'doc'.sep.'*'),"\n>"),'!isdirectory(v:val)')) && (!filereadable(dir.sep.'doc'.sep.'tags') || filewritable(dir.sep.'doc'.sep.'tags'))
silent! execute 'helptags' pathogen#fnameescape(dir.'/doc')
endif
endfor
endfor
endfunction " }}}1
command! -bar Helptags :call pathogen#helptags()
" Execute the given command. This is basically a backdoor for --remote-expr.
function! pathogen#execute(...) abort " {{{1
for command in a:000
execute command
endfor
return ''
endfunction " }}}1
" Like findfile(), but hardcoded to use the runtimepath.
function! pathogen#runtime_findfile(file,count) abort "{{{1
let rtp = pathogen#join(1,pathogen#split(&rtp))
let file = findfile(a:file,rtp,a:count)
if file ==# ''
return ''
else
return fnamemodify(file,':p')
endif
endfunction " }}}1
" Backport of fnameescape().
function! pathogen#fnameescape(string) abort " {{{1
if exists('*fnameescape')
return fnameescape(a:string)
elseif a:string ==# '-'
return '\-'
else
return substitute(escape(a:string," \t\n*?[{`$\\%#'\"|!<"),'^[+>]','\\&','')
endif
endfunction " }}}1
if exists(':Vedit')
finish
endif
let s:vopen_warning = 0
function! s:find(count,cmd,file,lcd) " {{{1
let rtp = pathogen#join(1,pathogen#split(&runtimepath))
let file = pathogen#runtime_findfile(a:file,a:count)
if file ==# ''
return "echoerr 'E345: Can''t find file \"".a:file."\" in runtimepath'"
endif
if !s:vopen_warning
let s:vopen_warning = 1
let warning = '|echohl WarningMsg|echo "Install scriptease.vim to continue using :V'.a:cmd.'"|echohl NONE'
else
let warning = ''
endif
if a:lcd
let path = file[0:-strlen(a:file)-2]
execute 'lcd `=path`'
return a:cmd.' '.pathogen#fnameescape(a:file) . warning
else
return a:cmd.' '.pathogen#fnameescape(file) . warning
endif
endfunction " }}}1
function! s:Findcomplete(A,L,P) " {{{1
let sep = pathogen#separator()
let cheats = {
\'a': 'autoload',
\'d': 'doc',
\'f': 'ftplugin',
\'i': 'indent',
\'p': 'plugin',
\'s': 'syntax'}
if a:A =~# '^\w[\\/]' && has_key(cheats,a:A[0])
let request = cheats[a:A[0]].a:A[1:-1]
else
let request = a:A
endif
let pattern = substitute(request,'/\|\'.sep,'*'.sep,'g').'*'
let found = {}
for path in pathogen#split(&runtimepath)
let path = expand(path, ':p')
let matches = split(glob(path.sep.pattern),"\n")
call map(matches,'isdirectory(v:val) ? v:val.sep : v:val')
call map(matches,'expand(v:val, ":p")[strlen(path)+1:-1]')
for match in matches
let found[match] = 1
endfor
endfor
return sort(keys(found))
endfunction " }}}1
command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Ve :execute s:find(<count>,'edit<bang>',<q-args>,0)
command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vedit :execute s:find(<count>,'edit<bang>',<q-args>,0)
command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vopen :execute s:find(<count>,'edit<bang>',<q-args>,1)
command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vsplit :execute s:find(<count>,'split',<q-args>,<bang>1)
command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vvsplit :execute s:find(<count>,'vsplit',<q-args>,<bang>1)
command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vtabedit :execute s:find(<count>,'tabedit',<q-args>,<bang>1)
command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vpedit :execute s:find(<count>,'pedit',<q-args>,<bang>1)
command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vread :execute s:find(<count>,'read',<q-args>,<bang>1)
" vim:set et sw=2:
================================================
FILE: .vim/bundle/CSApprox/README
================================================
This is a mirror of http://www.vim.org/scripts/script.php?script_id=2390
CSApprox.vim
============
DESCRIPTION
============
It's hard to find colorschemes for terminal Vim. Most colorschemes are
written to only support GVim, and don't work at all in terminal Vim.
This plugin makes GVim-only colorschemes Just Work in terminal Vim, as long
as the terminal supports 88 or 256 colors - and most do these days. This
usually requires no user interaction (but see the help for what to do if
things don't Just Work). After getting this plugin happily installed, any
time you use :colorscheme it will do its magic and make the colorscheme Just
Work.
Whenever you change colorschemes using the :colorscheme command this script
will be executed. It will take the colors that the scheme specified for use
in the GUI and use an approximation algorithm to try to gracefully degrade
them to the closest color available in your terminal. If you are running in
a GUI or if your terminal doesn't support 88 or 256 colors, no changes are
made. Also, no changes will be made if the colorscheme seems to have been
high color already.
If for some reason this transparent method isn't suitable to you (for instance
if your environment can't be configured to meet the |csapprox-requirements|,
or you need to work in Vim 6), another option is also available: using the
|:CSApproxSnapshot| command to create a new GUI/88-/256-color terminal
colorscheme. To use this command, a user would generally start GVim, choose a
colorscheme that sets up the desired colors, and then use |:CSApproxSnapshot|
to create a new colorscheme based on those colors that works in high color
terminals. This method is more flexible than the transparent mode and works
in more places, but also requires more user intervention, and makes it harder
to deal with colorschemes being updated and such.
======
NOTES
======
Ideally, this plugin should require absolutely no configuration, but you may
need some tweaking to make sure vim realizes that your terminal supports more
than 16 colors. Also, konsole and Eterm users will want to make sure that
this plugin realizes that the terminal does not use colors that are exactly
xterm-compatible; they will want to skim through the help articles
|csapprox-palettes| and |csapprox-configuration| for a better end result.
==============
SCREENSHOTS
==============
Some quick side-by-side screenshots can be found at
http://www.cs.drexel.edu/~mjw452/CSApprox/
================================================
FILE: .vim/bundle/CSApprox/after/plugin/CSApprox.vim
================================================
" Copyright (c) 2012, Matthew J. Wozniski
" All rights reserved.
"
" Redistribution and use in source and binary forms, with or without
" modification, are permitted provided that the following conditions are met:
" * Redistributions of source code must retain the above copyright
" notice, this list of conditions and the following disclaimer.
" * Redistributions in binary form must reproduce the above copyright
" notice, this list of conditions and the following disclaimer in the
" documentation and/or other materials provided with the distribution.
" * The names of the contributors may not be used to endorse or promote
" products derived from this software without specific prior written
" permission.
"
" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER ``AS IS'' AND ANY
" EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
" WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
" DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
" DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
" (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
" LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
" ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
" SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
" The last thing to do when sourced is to run and actually fix up the colors.
if !has('gui_running') && exists(':CSApprox')
CSApprox
endif
================================================
FILE: .vim/bundle/CSApprox/autoload/csapprox/common.vim
================================================
" Copyright (c) 2012, Matthew J. Wozniski
" All rights reserved.
"
" Redistribution and use in source and binary forms, with or without
" modification, are permitted provided that the following conditions are met:
" * Redistributions of source code must retain the above copyright
" notice, this list of conditions and the following disclaimer.
" * Redistributions in binary form must reproduce the above copyright
" notice, this list of conditions and the following disclaimer in the
" documentation and/or other materials provided with the distribution.
" * The names of the contributors may not be used to endorse or promote
" products derived from this software without specific prior written
" permission.
"
" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER ``AS IS'' AND ANY
" EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
" WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
" DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
" DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
" (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
" LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
" ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
" SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
let s:xterm_colors = [ 0x00, 0x5F, 0x87, 0xAF, 0xD7, 0xFF ]
let s:eterm_colors = [ 0x00, 0x2A, 0x55, 0x7F, 0xAA, 0xD4 ]
let s:konsole_colors = [ 0x00, 0x33, 0x66, 0x99, 0xCC, 0xFF ]
let s:xterm_greys = [ 0x08, 0x12, 0x1C, 0x26, 0x30, 0x3A,
\ 0x44, 0x4E, 0x58, 0x62, 0x6C, 0x76,
\ 0x80, 0x8A, 0x94, 0x9E, 0xA8, 0xB2,
\ 0xBC, 0xC6, 0xD0, 0xDA, 0xE4, 0xEE ]
let s:urxvt_colors = [ 0x00, 0x8B, 0xCD, 0xFF ]
let s:urxvt_greys = [ 0x2E, 0x5C, 0x73, 0x8B,
\ 0xA2, 0xB9, 0xD0, 0xE7 ]
" Uses &term to determine which cube should be use. If &term is set to
" "xterm" or begins with "screen", the variables g:CSApprox_eterm and
" g:CSApprox_konsole can be used to select a different palette.
function! csapprox#common#PaletteType()
if &t_Co == 88
let type = 'urxvt'
elseif &term ==# 'xterm' || &term =~# '^screen' || &term==# 'builtin_gui'
if exists('g:CSApprox_konsole') && g:CSApprox_konsole
let type = 'konsole'
elseif exists('g:CSApprox_eterm') && g:CSApprox_eterm
let type = 'eterm'
else
let type = 'xterm'
endif
elseif &term =~? '^konsole'
" Konsole only used its own palette up til KDE 4.2.0
if executable('kde4-config') && system('kde4-config --kde-version') =~ '^4\.[10]\.'
let type = 'konsole'
elseif executable('kde-config') && system('kde-config --version') =~# 'KDE: 3\.'
let type = 'konsole'
else
let type = 'xterm'
endif
elseif &term =~? '^eterm'
let type = 'eterm'
else
let type = 'xterm'
endif
return type
endfunction
" Retrieve the list of greyscale ramp colors for the current palette
function! csapprox#common#Greys()
return (&t_Co == 88 ? s:urxvt_greys : s:xterm_greys)
endfunction
" Retrieve the list of non-greyscale ramp colors for the current palette
function! csapprox#common#Colors()
return s:{csapprox#common#PaletteType()}_colors
endfunction
================================================
FILE: .vim/bundle/CSApprox/autoload/csapprox/per_component.vim
================================================
" Copyright (c) 2012, Matthew J. Wozniski
" All rights reserved.
"
" Redistribution and use in source and binary forms, with or without
" modification, are permitted provided that the following conditions are met:
" * Redistributions of source code must retain the above copyright
" notice, this list of conditions and the following disclaimer.
" * Redistributions in binary form must reproduce the above copyright
" notice, this list of conditions and the following disclaimer in the
" documentation and/or other materials provided with the distribution.
" * The names of the contributors may not be used to endorse or promote
" products derived from this software without specific prior written
" permission.
"
" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER ``AS IS'' AND ANY
" EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
" WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
" DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
" DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
" (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
" LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
" ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
" SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
" Integer comparator used to sort the complete list of possible colors
function! s:IntCompare(i1, i2)
return a:i1 == a:i2 ? 0 : a:i1 > a:i2 ? 1 : -1
endfunc
" Color comparator to find the nearest element to a given one in a given list
function! s:NearestElemInList(elem, list)
let len = len(a:list)
for i in range(len-1)
if (a:elem <= (a:list[i] + a:list[i+1]) / 2)
return a:list[i]
endif
endfor
return a:list[len-1]
endfunction
" Takes 3 decimal values for r, g, and b, and returns the closest cube number.
"
" This approximator considers closeness based upon the individiual components.
" For each of r, g, and b, it finds the closest cube component available on
" the cube. If the three closest matches can combine to form a valid color,
" this color is used, otherwise we repeat the search with the greys removed,
" meaning that the three new matches must make a valid color when combined.
function! csapprox#per_component#Approximate(r,g,b)
let hex = printf("%02x%02x%02x", a:r, a:g, a:b)
let colors = csapprox#common#Colors()
let greys = csapprox#common#Greys()
let type = csapprox#common#PaletteType()
if !exists('s:approximator_cache_'.type)
let s:approximator_cache_{type} = {}
endif
let rv = get(s:approximator_cache_{type}, hex, -1)
if rv != -1
return rv
endif
" Only obtain sorted list once
if !exists("s:".type."_greys_colors")
let s:{type}_greys_colors = sort(greys + colors, "s:IntCompare")
endif
let greys_colors = s:{type}_greys_colors
let r = s:NearestElemInList(a:r, greys_colors)
let g = s:NearestElemInList(a:g, greys_colors)
let b = s:NearestElemInList(a:b, greys_colors)
let len = len(colors)
if (r == g && g == b && index(greys, r) != -1)
let rv = 16 + len * len * len + index(greys, r)
else
let r = s:NearestElemInList(a:r, colors)
let g = s:NearestElemInList(a:g, colors)
let b = s:NearestElemInList(a:b, colors)
let rv = index(colors, r) * len * len
\ + index(colors, g) * len
\ + index(colors, b)
\ + 16
endif
let s:approximator_cache_{type}[hex] = rv
return rv
endfunction
================================================
FILE: .vim/bundle/CSApprox/autoload/csapprox.vim
================================================
" Copyright (c) 2012, Matthew J. Wozniski
" All rights reserved.
"
" Redistribution and use in source and binary forms, with or without
" modification, are permitted provided that the following conditions are met:
" * Redistributions of source code must retain the above copyright
" notice, this list of conditions and the following disclaimer.
" * Redistributions in binary form must reproduce the above copyright
" notice, this list of conditions and the following disclaimer in the
" documentation and/or other materials provided with the distribution.
" * The names of the contributors may not be used to endorse or promote
" products derived from this software without specific prior written
" permission.
"
" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER ``AS IS'' AND ANY
" EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
" WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
" DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
" DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
" (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
" LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
" ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
" SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
let s:rgb = {}
let s:rgb["alice blue"] = "#f0f8ff"
let s:rgb["aliceblue"] = "#f0f8ff"
let s:rgb["antique white"] = "#faebd7"
let s:rgb["antiquewhite"] = "#faebd7"
let s:rgb["antiquewhite1"] = "#ffefdb"
let s:rgb["antiquewhite2"] = "#eedfcc"
let s:rgb["antiquewhite3"] = "#cdc0b0"
let s:rgb["antiquewhite4"] = "#8b8378"
let s:rgb["aquamarine"] = "#7fffd4"
let s:rgb["aquamarine1"] = "#7fffd4"
let s:rgb["aquamarine2"] = "#76eec6"
let s:rgb["aquamarine3"] = "#66cdaa"
let s:rgb["aquamarine4"] = "#458b74"
let s:rgb["azure"] = "#f0ffff"
let s:rgb["azure1"] = "#f0ffff"
let s:rgb["azure2"] = "#e0eeee"
let s:rgb["azure3"] = "#c1cdcd"
let s:rgb["azure4"] = "#838b8b"
let s:rgb["beige"] = "#f5f5dc"
let s:rgb["bisque"] = "#ffe4c4"
let s:rgb["bisque1"] = "#ffe4c4"
let s:rgb["bisque2"] = "#eed5b7"
let s:rgb["bisque3"] = "#cdb79e"
let s:rgb["bisque4"] = "#8b7d6b"
let s:rgb["black"] = "#000000"
let s:rgb["blanched almond"] = "#ffebcd"
let s:rgb["blanchedalmond"] = "#ffebcd"
let s:rgb["blue violet"] = "#8a2be2"
let s:rgb["blue"] = "#0000ff"
let s:rgb["blue1"] = "#0000ff"
let s:rgb["blue2"] = "#0000ee"
let s:rgb["blue3"] = "#0000cd"
let s:rgb["blue4"] = "#00008b"
let s:rgb["blueviolet"] = "#8a2be2"
let s:rgb["brown"] = "#a52a2a"
let s:rgb["brown1"] = "#ff4040"
let s:rgb["brown2"] = "#ee3b3b"
let s:rgb["brown3"] = "#cd3333"
let s:rgb["brown4"] = "#8b2323"
let s:rgb["burlywood"] = "#deb887"
let s:rgb["burlywood1"] = "#ffd39b"
let s:rgb["burlywood2"] = "#eec591"
let s:rgb["burlywood3"] = "#cdaa7d"
let s:rgb["burlywood4"] = "#8b7355"
let s:rgb["cadet blue"] = "#5f9ea0"
let s:rgb["cadetblue"] = "#5f9ea0"
let s:rgb["cadetblue1"] = "#98f5ff"
let s:rgb["cadetblue2"] = "#8ee5ee"
let s:rgb["cadetblue3"] = "#7ac5cd"
let s:rgb["cadetblue4"] = "#53868b"
let s:rgb["chartreuse"] = "#7fff00"
let s:rgb["chartreuse1"] = "#7fff00"
let s:rgb["chartreuse2"] = "#76ee00"
let s:rgb["chartreuse3"] = "#66cd00"
let s:rgb["chartreuse4"] = "#458b00"
let s:rgb["chocolate"] = "#d2691e"
let s:rgb["chocolate1"] = "#ff7f24"
let s:rgb["chocolate2"] = "#ee7621"
let s:rgb["chocolate3"] = "#cd661d"
let s:rgb["chocolate4"] = "#8b4513"
let s:rgb["coral"] = "#ff7f50"
let s:rgb["coral1"] = "#ff7256"
let s:rgb["coral2"] = "#ee6a50"
let s:rgb["coral3"] = "#cd5b45"
let s:rgb["coral4"] = "#8b3e2f"
let s:rgb["cornflower blue"] = "#6495ed"
let s:rgb["cornflowerblue"] = "#6495ed"
let s:rgb["cornsilk"] = "#fff8dc"
let s:rgb["cornsilk1"] = "#fff8dc"
let s:rgb["cornsilk2"] = "#eee8cd"
let s:rgb["cornsilk3"] = "#cdc8b1"
let s:rgb["cornsilk4"] = "#8b8878"
let s:rgb["cyan"] = "#00ffff"
let s:rgb["cyan1"] = "#00ffff"
let s:rgb["cyan2"] = "#00eeee"
let s:rgb["cyan3"] = "#00cdcd"
let s:rgb["cyan4"] = "#008b8b"
let s:rgb["dark blue"] = "#00008b"
let s:rgb["dark cyan"] = "#008b8b"
let s:rgb["dark goldenrod"] = "#b8860b"
let s:rgb["dark gray"] = "#a9a9a9"
let s:rgb["dark green"] = "#006400"
let s:rgb["dark grey"] = "#a9a9a9"
let s:rgb["dark khaki"] = "#bdb76b"
let s:rgb["dark magenta"] = "#8b008b"
let s:rgb["dark olive green"] = "#556b2f"
let s:rgb["dark orange"] = "#ff8c00"
let s:rgb["dark orchid"] = "#9932cc"
let s:rgb["dark red"] = "#8b0000"
let s:rgb["dark salmon"] = "#e9967a"
let s:rgb["dark sea green"] = "#8fbc8f"
let s:rgb["dark slate blue"] = "#483d8b"
let s:rgb["dark slate gray"] = "#2f4f4f"
let s:rgb["dark slate grey"] = "#2f4f4f"
let s:rgb["dark turquoise"] = "#00ced1"
let s:rgb["dark violet"] = "#9400d3"
let s:rgb["dark yellow"] = "#bbbb00"
let s:rgb["darkblue"] = "#00008b"
let s:rgb["darkcyan"] = "#008b8b"
let s:rgb["darkgoldenrod"] = "#b8860b"
let s:rgb["darkgoldenrod1"] = "#ffb90f"
let s:rgb["darkgoldenrod2"] = "#eead0e"
let s:rgb["darkgoldenrod3"] = "#cd950c"
let s:rgb["darkgoldenrod4"] = "#8b6508"
let s:rgb["darkgray"] = "#a9a9a9"
let s:rgb["darkgreen"] = "#006400"
let s:rgb["darkgrey"] = "#a9a9a9"
let s:rgb["darkkhaki"] = "#bdb76b"
let s:rgb["darkmagenta"] = "#8b008b"
let s:rgb["darkolivegreen"] = "#556b2f"
let s:rgb["darkolivegreen1"] = "#caff70"
let s:rgb["darkolivegreen2"] = "#bcee68"
let s:rgb["darkolivegreen3"] = "#a2cd5a"
let s:rgb["darkolivegreen4"] = "#6e8b3d"
let s:rgb["darkorange"] = "#ff8c00"
let s:rgb["darkorange1"] = "#ff7f00"
let s:rgb["darkorange2"] = "#ee7600"
let s:rgb["darkorange3"] = "#cd6600"
let s:rgb["darkorange4"] = "#8b4500"
let s:rgb["darkorchid"] = "#9932cc"
let s:rgb["darkorchid1"] = "#bf3eff"
let s:rgb["darkorchid2"] = "#b23aee"
let s:rgb["darkorchid3"] = "#9a32cd"
let s:rgb["darkorchid4"] = "#68228b"
let s:rgb["darkred"] = "#8b0000"
let s:rgb["darksalmon"] = "#e9967a"
let s:rgb["darkseagreen"] = "#8fbc8f"
let s:rgb["darkseagreen1"] = "#c1ffc1"
let s:rgb["darkseagreen2"] = "#b4eeb4"
let s:rgb["darkseagreen3"] = "#9bcd9b"
let s:rgb["darkseagreen4"] = "#698b69"
let s:rgb["darkslateblue"] = "#483d8b"
let s:rgb["darkslategray"] = "#2f4f4f"
let s:rgb["darkslategray1"] = "#97ffff"
let s:rgb["darkslategray2"] = "#8deeee"
let s:rgb["darkslategray3"] = "#79cdcd"
let s:rgb["darkslategray4"] = "#528b8b"
let s:rgb["darkslategrey"] = "#2f4f4f"
let s:rgb["darkturquoise"] = "#00ced1"
let s:rgb["darkviolet"] = "#9400d3"
let s:rgb["darkyellow"] = "#bbbb00"
let s:rgb["deep pink"] = "#ff1493"
let s:rgb["deep sky blue"] = "#00bfff"
let s:rgb["deeppink"] = "#ff1493"
let s:rgb["deeppink1"] = "#ff1493"
let s:rgb["deeppink2"] = "#ee1289"
let s:rgb["deeppink3"] = "#cd1076"
let s:rgb["deeppink4"] = "#8b0a50"
let s:rgb["deepskyblue"] = "#00bfff"
let s:rgb["deepskyblue1"] = "#00bfff"
let s:rgb["deepskyblue2"] = "#00b2ee"
let s:rgb["deepskyblue3"] = "#009acd"
let s:rgb["deepskyblue4"] = "#00688b"
let s:rgb["dim gray"] = "#696969"
let s:rgb["dim grey"] = "#696969"
let s:rgb["dimgray"] = "#696969"
let s:rgb["dimgrey"] = "#696969"
let s:rgb["dodger blue"] = "#1e90ff"
let s:rgb["dodgerblue"] = "#1e90ff"
let s:rgb["dodgerblue1"] = "#1e90ff"
let s:rgb["dodgerblue2"] = "#1c86ee"
let s:rgb["dodgerblue3"] = "#1874cd"
let s:rgb["dodgerblue4"] = "#104e8b"
let s:rgb["firebrick"] = "#b22222"
let s:rgb["firebrick1"] = "#ff3030"
let s:rgb["firebrick2"] = "#ee2c2c"
let s:rgb["firebrick3"] = "#cd2626"
let s:rgb["firebrick4"] = "#8b1a1a"
let s:rgb["floral white"] = "#fffaf0"
let s:rgb["floralwhite"] = "#fffaf0"
let s:rgb["forest green"] = "#228b22"
let s:rgb["forestgreen"] = "#228b22"
let s:rgb["gainsboro"] = "#dcdcdc"
let s:rgb["ghost white"] = "#f8f8ff"
let s:rgb["ghostwhite"] = "#f8f8ff"
let s:rgb["gold"] = "#ffd700"
let s:rgb["gold1"] = "#ffd700"
let s:rgb["gold2"] = "#eec900"
let s:rgb["gold3"] = "#cdad00"
let s:rgb["gold4"] = "#8b7500"
let s:rgb["goldenrod"] = "#daa520"
let s:rgb["goldenrod1"] = "#ffc125"
let s:rgb["goldenrod2"] = "#eeb422"
let s:rgb["goldenrod3"] = "#cd9b1d"
let s:rgb["goldenrod4"] = "#8b6914"
let s:rgb["gray"] = "#bebebe"
let s:rgb["gray0"] = "#000000"
let s:rgb["gray1"] = "#030303"
let s:rgb["gray10"] = "#1a1a1a"
let s:rgb["gray100"] = "#ffffff"
let s:rgb["gray11"] = "#1c1c1c"
let s:rgb["gray12"] = "#1f1f1f"
let s:rgb["gray13"] = "#212121"
let s:rgb["gray14"] = "#242424"
let s:rgb["gray15"] = "#262626"
let s:rgb["gray16"] = "#292929"
let s:rgb["gray17"] = "#2b2b2b"
let s:rgb["gray18"] = "#2e2e2e"
let s:rgb["gray19"] = "#303030"
let s:rgb["gray2"] = "#050505"
let s:rgb["gray20"] = "#333333"
let s:rgb["gray21"] = "#363636"
let s:rgb["gray22"] = "#383838"
let s:rgb["gray23"] = "#3b3b3b"
let s:rgb["gray24"] = "#3d3d3d"
let s:rgb["gray25"] = "#404040"
let s:rgb["gray26"] = "#424242"
let s:rgb["gray27"] = "#454545"
let s:rgb["gray28"] = "#474747"
let s:rgb["gray29"] = "#4a4a4a"
let s:rgb["gray3"] = "#080808"
let s:rgb["gray30"] = "#4d4d4d"
let s:rgb["gray31"] = "#4f4f4f"
let s:rgb["gray32"] = "#525252"
let s:rgb["gray33"] = "#545454"
let s:rgb["gray34"] = "#575757"
let s:rgb["gray35"] = "#595959"
let s:rgb["gray36"] = "#5c5c5c"
let s:rgb["gray37"] = "#5e5e5e"
let s:rgb["gray38"] = "#616161"
let s:rgb["gray39"] = "#636363"
let s:rgb["gray4"] = "#0a0a0a"
let s:rgb["gray40"] = "#666666"
let s:rgb["gray41"] = "#696969"
let s:rgb["gray42"] = "#6b6b6b"
let s:rgb["gray43"] = "#6e6e6e"
let s:rgb["gray44"] = "#707070"
let s:rgb["gray45"] = "#737373"
let s:rgb["gray46"] = "#757575"
let s:rgb["gray47"] = "#787878"
let s:rgb["gray48"] = "#7a7a7a"
let s:rgb["gray49"] = "#7d7d7d"
let s:rgb["gray5"] = "#0d0d0d"
let s:rgb["gray50"] = "#7f7f7f"
let s:rgb["gray51"] = "#828282"
let s:rgb["gray52"] = "#858585"
let s:rgb["gray53"] = "#878787"
let s:rgb["gray54"] = "#8a8a8a"
let s:rgb["gray55"] = "#8c8c8c"
let s:rgb["gray56"] = "#8f8f8f"
let s:rgb["gray57"] = "#919191"
let s:rgb["gray58"] = "#949494"
let s:rgb["gray59"] = "#969696"
let s:rgb["gray6"] = "#0f0f0f"
let s:rgb["gray60"] = "#999999"
let s:rgb["gray61"] = "#9c9c9c"
let s:rgb["gray62"] = "#9e9e9e"
let s:rgb["gray63"] = "#a1a1a1"
let s:rgb["gray64"] = "#a3a3a3"
let s:rgb["gray65"] = "#a6a6a6"
let s:rgb["gray66"] = "#a8a8a8"
let s:rgb["gray67"] = "#ababab"
let s:rgb["gray68"] = "#adadad"
let s:rgb["gray69"] = "#b0b0b0"
let s:rgb["gray7"] = "#121212"
let s:rgb["gray70"] = "#b3b3b3"
let s:rgb["gray71"] = "#b5b5b5"
let s:rgb["gray72"] = "#b8b8b8"
let s:rgb["gray73"] = "#bababa"
let s:rgb["gray74"] = "#bdbdbd"
let s:rgb["gray75"] = "#bfbfbf"
let s:rgb["gray76"] = "#c2c2c2"
let s:rgb["gray77"] = "#c4c4c4"
let s:rgb["gray78"] = "#c7c7c7"
let s:rgb["gray79"] = "#c9c9c9"
let s:rgb["gray8"] = "#141414"
let s:rgb["gray80"] = "#cccccc"
let s:rgb["gray81"] = "#cfcfcf"
let s:rgb["gray82"] = "#d1d1d1"
let s:rgb["gray83"] = "#d4d4d4"
let s:rgb["gray84"] = "#d6d6d6"
let s:rgb["gray85"] = "#d9d9d9"
let s:rgb["gray86"] = "#dbdbdb"
let s:rgb["gray87"] = "#dedede"
let s:rgb["gray88"] = "#e0e0e0"
let s:rgb["gray89"] = "#e3e3e3"
let s:rgb["gray9"] = "#171717"
let s:rgb["gray90"] = "#e5e5e5"
let s:rgb["gray91"] = "#e8e8e8"
let s:rgb["gray92"] = "#ebebeb"
let s:rgb["gray93"] = "#ededed"
let s:rgb["gray94"] = "#f0f0f0"
let s:rgb["gray95"] = "#f2f2f2"
let s:rgb["gray96"] = "#f5f5f5"
let s:rgb["gray97"] = "#f7f7f7"
let s:rgb["gray98"] = "#fafafa"
let s:rgb["gray99"] = "#fcfcfc"
let s:rgb["green yellow"] = "#adff2f"
let s:rgb["green"] = "#00ff00"
let s:rgb["green1"] = "#00ff00"
let s:rgb["green2"] = "#00ee00"
let s:rgb["green3"] = "#00cd00"
let s:rgb["green4"] = "#008b00"
let s:rgb["greenyellow"] = "#adff2f"
let s:rgb["grey"] = "#bebebe"
let s:rgb["grey0"] = "#000000"
let s:rgb["grey1"] = "#030303"
let s:rgb["grey10"] = "#1a1a1a"
let s:rgb["grey100"] = "#ffffff"
let s:rgb["grey11"] = "#1c1c1c"
let s:rgb["grey12"] = "#1f1f1f"
let s:rgb["grey13"] = "#212121"
let s:rgb["grey14"] = "#242424"
let s:rgb["grey15"] = "#262626"
let s:rgb["grey16"] = "#292929"
let s:rgb["grey17"] = "#2b2b2b"
let s:rgb["grey18"] = "#2e2e2e"
let s:rgb["grey19"] = "#303030"
let s:rgb["grey2"] = "#050505"
let s:rgb["grey20"] = "#333333"
let s:rgb["grey21"] = "#363636"
let s:rgb["grey22"] = "#383838"
let s:rgb["grey23"] = "#3b3b3b"
let s:rgb["grey24"] = "#3d3d3d"
let s:rgb["grey25"] = "#404040"
let s:rgb["grey26"] = "#424242"
let s:rgb["grey27"] = "#454545"
let s:rgb["grey28"] = "#474747"
let s:rgb["grey29"] = "#4a4a4a"
let s:rgb["grey3"] = "#080808"
let s:rgb["grey30"] = "#4d4d4d"
let s:rgb["grey31"] = "#4f4f4f"
let s:rgb["grey32"] = "#525252"
let s:rgb["grey33"] = "#545454"
let s:rgb["grey34"] = "#575757"
let s:rgb["grey35"] = "#595959"
let s:rgb["grey36"] = "#5c5c5c"
let s:rgb["grey37"] = "#5e5e5e"
let s:rgb["grey38"] = "#616161"
let s:rgb["grey39"] = "#636363"
let s:rgb["grey4"] = "#0a0a0a"
let s:rgb["grey40"] = "#666666"
let s:rgb["grey41"] = "#696969"
let s:rgb["grey42"] = "#6b6b6b"
let s:rgb["grey43"] = "#6e6e6e"
let s:rgb["grey44"] = "#707070"
let s:rgb["grey45"] = "#737373"
let s:rgb["grey46"] = "#757575"
let s:rgb["grey47"] = "#787878"
let s:rgb["grey48"] = "#7a7a7a"
let s:rgb["grey49"] = "#7d7d7d"
let s:rgb["grey5"] = "#0d0d0d"
let s:rgb["grey50"] = "#7f7f7f"
let s:rgb["grey51"] = "#828282"
let s:rgb["grey52"] = "#858585"
let s:rgb["grey53"] = "#878787"
let s:rgb["grey54"] = "#8a8a8a"
let s:rgb["grey55"] = "#8c8c8c"
let s:rgb["grey56"] = "#8f8f8f"
let s:rgb["grey57"] = "#919191"
let s:rgb["grey58"] = "#949494"
let s:rgb["grey59"] = "#969696"
let s:rgb["grey6"] = "#0f0f0f"
let s:rgb["grey60"] = "#999999"
let s:rgb["grey61"] = "#9c9c9c"
let s:rgb["grey62"] = "#9e9e9e"
let s:rgb["grey63"] = "#a1a1a1"
let s:rgb["grey64"] = "#a3a3a3"
let s:rgb["grey65"] = "#a6a6a6"
let s:rgb["grey66"] = "#a8a8a8"
let s:rgb["grey67"] = "#ababab"
let s:rgb["grey68"] = "#adadad"
let s:rgb["grey69"] = "#b0b0b0"
let s:rgb["grey7"] = "#121212"
let s:rgb["grey70"] = "#b3b3b3"
let s:rgb["grey71"] = "#b5b5b5"
let s:rgb["grey72"] = "#b8b8b8"
let s:rgb["grey73"] = "#bababa"
let s:rgb["grey74"] = "#bdbdbd"
let s:rgb["grey75"] = "#bfbfbf"
let s:rgb["grey76"] = "#c2c2c2"
let s:rgb["grey77"] = "#c4c4c4"
let s:rgb["grey78"] = "#c7c7c7"
let s:rgb["grey79"] = "#c9c9c9"
let s:rgb["grey8"] = "#141414"
let s:rgb["grey80"] = "#cccccc"
let s:rgb["grey81"] = "#cfcfcf"
let s:rgb["grey82"] = "#d1d1d1"
let s:rgb["grey83"] = "#d4d4d4"
let s:rgb["grey84"] = "#d6d6d6"
let s:rgb["grey85"] = "#d9d9d9"
let s:rgb["grey86"] = "#dbdbdb"
let s:rgb["grey87"] = "#dedede"
let s:rgb["grey88"] = "#e0e0e0"
let s:rgb["grey89"] = "#e3e3e3"
let s:rgb["grey9"] = "#171717"
let s:rgb["grey90"] = "#e5e5e5"
let s:rgb["grey91"] = "#e8e8e8"
let s:rgb["grey92"] = "#ebebeb"
let s:rgb["grey93"] = "#ededed"
let s:rgb["grey94"] = "#f0f0f0"
let s:rgb["grey95"] = "#f2f2f2"
let s:rgb["grey96"] = "#f5f5f5"
let s:rgb["grey97"] = "#f7f7f7"
let s:rgb["grey98"] = "#fafafa"
let s:rgb["grey99"] = "#fcfcfc"
let s:rgb["honeydew"] = "#f0fff0"
let s:rgb["honeydew1"] = "#f0fff0"
let s:rgb["honeydew2"] = "#e0eee0"
let s:rgb["honeydew3"] = "#c1cdc1"
let s:rgb["honeydew4"] = "#838b83"
let s:rgb["hot pink"] = "#ff69b4"
let s:rgb["hotpink"] = "#ff69b4"
let s:rgb["hotpink1"] = "#ff6eb4"
let s:rgb["hotpink2"] = "#ee6aa7"
let s:rgb["hotpink3"] = "#cd6090"
let s:rgb["hotpink4"] = "#8b3a62"
let s:rgb["indian red"] = "#cd5c5c"
let s:rgb["indianred"] = "#cd5c5c"
let s:rgb["indianred1"] = "#ff6a6a"
let s:rgb["indianred2"] = "#ee6363"
let s:rgb["indianred3"] = "#cd5555"
let s:rgb["indianred4"] = "#8b3a3a"
let s:rgb["ivory"] = "#fffff0"
let s:rgb["ivory1"] = "#fffff0"
let s:rgb["ivory2"] = "#eeeee0"
let s:rgb["ivory3"] = "#cdcdc1"
let s:rgb["ivory4"] = "#8b8b83"
let s:rgb["khaki"] = "#f0e68c"
let s:rgb["khaki1"] = "#fff68f"
let s:rgb["khaki2"] = "#eee685"
let s:rgb["khaki3"] = "#cdc673"
let s:rgb["khaki4"] = "#8b864e"
let s:rgb["lavender blush"] = "#fff0f5"
let s:rgb["lavender"] = "#e6e6fa"
let s:rgb["lavenderblush"] = "#fff0f5"
let s:rgb["lavenderblush1"] = "#fff0f5"
let s:rgb["lavenderblush2"] = "#eee0e5"
let s:rgb["lavenderblush3"] = "#cdc1c5"
let s:rgb["lavenderblush4"] = "#8b8386"
let s:rgb["lawn green"] = "#7cfc00"
let s:rgb["lawngreen"] = "#7cfc00"
let s:rgb["lemon chiffon"] = "#fffacd"
let s:rgb["lemonchiffon"] = "#fffacd"
let s:rgb["lemonchiffon1"] = "#fffacd"
let s:rgb["lemonchiffon2"] = "#eee9bf"
let s:rgb["lemonchiffon3"] = "#cdc9a5"
let s:rgb["lemonchiffon4"] = "#8b8970"
let s:rgb["light blue"] = "#add8e6"
let s:rgb["light coral"] = "#f08080"
let s:rgb["light cyan"] = "#e0ffff"
let s:rgb["light goldenrod yellow"] = "#fafad2"
let s:rgb["light goldenrod"] = "#eedd82"
let s:rgb["light gray"] = "#d3d3d3"
let s:rgb["light green"] = "#90ee90"
let s:rgb["light grey"] = "#d3d3d3"
let s:rgb["light magenta"] = "#ffbbff"
let s:rgb["light pink"] = "#ffb6c1"
let s:rgb["light red"] = "#ffbbbb"
let s:rgb["light salmon"] = "#ffa07a"
let s:rgb["light sea green"] = "#20b2aa"
let s:rgb["light sky blue"] = "#87cefa"
let s:rgb["light slate blue"] = "#8470ff"
let s:rgb["light slate gray"] = "#778899"
let s:rgb["light slate grey"] = "#778899"
let s:rgb["light steel blue"] = "#b0c4de"
let s:rgb["light yellow"] = "#ffffe0"
let s:rgb["lightblue"] = "#add8e6"
let s:rgb["lightblue1"] = "#bfefff"
let s:rgb["lightblue2"] = "#b2dfee"
let s:rgb["lightblue3"] = "#9ac0cd"
let s:rgb["lightblue4"] = "#68838b"
let s:rgb["lightcoral"] = "#f08080"
let s:rgb["lightcyan"] = "#e0ffff"
let s:rgb["lightcyan1"] = "#e0ffff"
let s:rgb["lightcyan2"] = "#d1eeee"
let s:rgb["lightcyan3"] = "#b4cdcd"
let s:rgb["lightcyan4"] = "#7a8b8b"
let s:rgb["lightgoldenrod"] = "#eedd82"
let s:rgb["lightgoldenrod1"] = "#ffec8b"
let s:rgb["lightgoldenrod2"] = "#eedc82"
let s:rgb["lightgoldenrod3"] = "#cdbe70"
let s:rgb["lightgoldenrod4"] = "#8b814c"
let s:rgb["lightgoldenrodyellow"] = "#fafad2"
let s:rgb["lightgray"] = "#d3d3d3"
let s:rgb["lightgreen"] = "#90ee90"
let s:rgb["lightgrey"] = "#d3d3d3"
let s:rgb["lightmagenta"] = "#ffbbff"
let s:rgb["lightpink"] = "#ffb6c1"
let s:rgb["lightpink1"] = "#ffaeb9"
let s:rgb["lightpink2"] = "#eea2ad"
let s:rgb["lightpink3"] = "#cd8c95"
let s:rgb["lightpink4"] = "#8b5f65"
let s:rgb["lightred"] = "#ffbbbb"
let s:rgb["lightsalmon"] = "#ffa07a"
let s:rgb["lightsalmon1"] = "#ffa07a"
let s:rgb["lightsalmon2"] = "#ee9572"
let s:rgb["lightsalmon3"] = "#cd8162"
let s:rgb["lightsalmon4"] = "#8b5742"
let s:rgb["lightseagreen"] = "#20b2aa"
let s:rgb["lightskyblue"] = "#87cefa"
let s:rgb["lightskyblue1"] = "#b0e2ff"
let s:rgb["lightskyblue2"] = "#a4d3ee"
let s:rgb["lightskyblue3"] = "#8db6cd"
let s:rgb["lightskyblue4"] = "#607b8b"
let s:rgb["lightslateblue"] = "#8470ff"
let s:rgb["lightslategray"] = "#778899"
let s:rgb["lightslategrey"] = "#778899"
let s:rgb["lightsteelblue"] = "#b0c4de"
let s:rgb["lightsteelblue1"] = "#cae1ff"
let s:rgb["lightsteelblue2"] = "#bcd2ee"
let s:rgb["lightsteelblue3"] = "#a2b5cd"
let s:rgb["lightsteelblue4"] = "#6e7b8b"
let s:rgb["lightyellow"] = "#ffffe0"
let s:rgb["lightyellow1"] = "#ffffe0"
let s:rgb["lightyellow2"] = "#eeeed1"
let s:rgb["lightyellow3"] = "#cdcdb4"
let s:rgb["lightyellow4"] = "#8b8b7a"
let s:rgb["lime green"] = "#32cd32"
let s:rgb["limegreen"] = "#32cd32"
let s:rgb["linen"] = "#faf0e6"
let s:rgb["magenta"] = "#ff00ff"
let s:rgb["magenta1"] = "#ff00ff"
let s:rgb["magenta2"] = "#ee00ee"
let s:rgb["magenta3"] = "#cd00cd"
let s:rgb["magenta4"] = "#8b008b"
let s:rgb["maroon"] = "#b03060"
let s:rgb["maroon1"] = "#ff34b3"
let s:rgb["maroon2"] = "#ee30a7"
let s:rgb["maroon3"] = "#cd2990"
let s:rgb["maroon4"] = "#8b1c62"
let s:rgb["medium aquamarine"] = "#66cdaa"
let s:rgb["medium blue"] = "#0000cd"
let s:rgb["medium orchid"] = "#ba55d3"
let s:rgb["medium purple"] = "#9370db"
let s:rgb["medium sea green"] = "#3cb371"
let s:rgb["medium slate blue"] = "#7b68ee"
let s:rgb["medium spring green"] = "#00fa9a"
let s:rgb["medium turquoise"] = "#48d1cc"
let s:rgb["medium violet red"] = "#c71585"
let s:rgb["mediumaquamarine"] = "#66cdaa"
let s:rgb["mediumblue"] = "#0000cd"
let s:rgb["mediumorchid"] = "#ba55d3"
let s:rgb["mediumorchid1"] = "#e066ff"
let s:rgb["mediumorchid2"] = "#d15fee"
let s:rgb["mediumorchid3"] = "#b452cd"
let s:rgb["mediumorchid4"] = "#7a378b"
let s:rgb["mediumpurple"] = "#9370db"
let s:rgb["mediumpurple1"] = "#ab82ff"
let s:rgb["mediumpurple2"] = "#9f79ee"
let s:rgb["mediumpurple3"] = "#8968cd"
let s:rgb["mediumpurple4"] = "#5d478b"
let s:rgb["mediumseagreen"] = "#3cb371"
let s:rgb["mediumslateblue"] = "#7b68ee"
let s:rgb["mediumspringgreen"] = "#00fa9a"
let s:rgb["mediumturquoise"] = "#48d1cc"
let s:rgb["mediumvioletred"] = "#c71585"
let s:rgb["midnight blue"] = "#191970"
let s:rgb["midnightblue"] = "#191970"
let s:rgb["mint cream"] = "#f5fffa"
let s:rgb["mintcream"] = "#f5fffa"
let s:rgb["misty rose"] = "#ffe4e1"
let s:rgb["mistyrose"] = "#ffe4e1"
let s:rgb["mistyrose1"] = "#ffe4e1"
let s:rgb["mistyrose2"] = "#eed5d2"
let s:rgb["mistyrose3"] = "#cdb7b5"
let s:rgb["mistyrose4"] = "#8b7d7b"
let s:rgb["moccasin"] = "#ffe4b5"
let s:rgb["navajo white"] = "#ffdead"
let s:rgb["navajowhite"] = "#ffdead"
let s:rgb["navajowhite1"] = "#ffdead"
let s:rgb["navajowhite2"] = "#eecfa1"
let s:rgb["navajowhite3"] = "#cdb38b"
let s:rgb["navajowhite4"] = "#8b795e"
let s:rgb["navy blue"] = "#000080"
let s:rgb["navy"] = "#000080"
let s:rgb["navyblue"] = "#000080"
let s:rgb["old lace"] = "#fdf5e6"
let s:rgb["oldlace"] = "#fdf5e6"
let s:rgb["olive drab"] = "#6b8e23"
let s:rgb["olivedrab"] = "#6b8e23"
let s:rgb["olivedrab1"] = "#c0ff3e"
let s:rgb["olivedrab2"] = "#b3ee3a"
let s:rgb["olivedrab3"] = "#9acd32"
let s:rgb["olivedrab4"] = "#698b22"
let s:rgb["orange red"] = "#ff4500"
let s:rgb["orange"] = "#ffa500"
let s:rgb["orange1"] = "#ffa500"
let s:rgb["orange2"] = "#ee9a00"
let s:rgb["orange3"] = "#cd8500"
let s:rgb["orange4"] = "#8b5a00"
let s:rgb["orangered"] = "#ff4500"
let s:rgb["orangered1"] = "#ff4500"
let s:rgb["orangered2"] = "#ee4000"
let s:rgb["orangered3"] = "#cd3700"
let s:rgb["orangered4"] = "#8b2500"
let s:rgb["orchid"] = "#da70d6"
let s:rgb["orchid1"] = "#ff83fa"
let s:rgb["orchid2"] = "#ee7ae9"
let s:rgb["orchid3"] = "#cd69c9"
let s:rgb["orchid4"] = "#8b4789"
let s:rgb["pale goldenrod"] = "#eee8aa"
let s:rgb["pale green"] = "#98fb98"
let s:rgb["pale turquoise"] = "#afeeee"
let s:rgb["pale violet red"] = "#db7093"
let s:rgb["palegoldenrod"] = "#eee8aa"
let s:rgb["palegreen"] = "#98fb98"
let s:rgb["palegreen1"] = "#9aff9a"
let s:rgb["palegreen2"] = "#90ee90"
let s:rgb["palegreen3"] = "#7ccd7c"
let s:rgb["palegreen4"] = "#548b54"
let s:rgb["paleturquoise"] = "#afeeee"
let s:rgb["paleturquoise1"] = "#bbffff"
let s:rgb["paleturquoise2"] = "#aeeeee"
let s:rgb["paleturquoise3"] = "#96cdcd"
let s:rgb["paleturquoise4"] = "#668b8b"
let s:rgb["palevioletred"] = "#db7093"
let s:rgb["palevioletred1"] = "#ff82ab"
let s:rgb["palevioletred2"] = "#ee799f"
let s:rgb["palevioletred3"] = "#cd6889"
let s:rgb["palevioletred4"] = "#8b475d"
let s:rgb["papaya whip"] = "#ffefd5"
let s:rgb["papayawhip"] = "#ffefd5"
let s:rgb["peach puff"] = "#ffdab9"
let s:rgb["peachpuff"] = "#ffdab9"
let s:rgb["peachpuff1"] = "#ffdab9"
let s:rgb["peachpuff2"] = "#eecbad"
let s:rgb["peachpuff3"] = "#cdaf95"
let s:rgb["peachpuff4"] = "#8b7765"
let s:rgb["peru"] = "#cd853f"
let s:rgb["pink"] = "#ffc0cb"
let s:rgb["pink1"] = "#ffb5c5"
let s:rgb["pink2"] = "#eea9b8"
let s:rgb["pink3"] = "#cd919e"
let s:rgb["pink4"] = "#8b636c"
let s:rgb["plum"] = "#dda0dd"
let s:rgb["plum1"] = "#ffbbff"
let s:rgb["plum2"] = "#eeaeee"
let s:rgb["plum3"] = "#cd96cd"
let s:rgb["plum4"] = "#8b668b"
let s:rgb["powder blue"] = "#b0e0e6"
let s:rgb["powderblue"] = "#b0e0e6"
let s:rgb["purple"] = "#a020f0"
let s:rgb["purple1"] = "#9b30ff"
let s:rgb["purple2"] = "#912cee"
let s:rgb["purple3"] = "#7d26cd"
let s:rgb["purple4"] = "#551a8b"
let s:rgb["red"] = "#ff0000"
let s:rgb["red1"] = "#ff0000"
let s:rgb["red2"] = "#ee0000"
let s:rgb["red3"] = "#cd0000"
let s:rgb["red4"] = "#8b0000"
let s:rgb["rosy brown"] = "#bc8f8f"
let s:rgb["rosybrown"] = "#bc8f8f"
let s:rgb["rosybrown1"] = "#ffc1c1"
let s:rgb["rosybrown2"] = "#eeb4b4"
let s:rgb["rosybrown3"] = "#cd9b9b"
let s:rgb["rosybrown4"] = "#8b6969"
let s:rgb["royal blue"] = "#4169e1"
let s:rgb["royalblue"] = "#4169e1"
let s:rgb["royalblue1"] = "#4876ff"
let s:rgb["royalblue2"] = "#436eee"
let s:rgb["royalblue3"] = "#3a5fcd"
let s:rgb["royalblue4"] = "#27408b"
let s:rgb["saddle brown"] = "#8b4513"
let s:rgb["saddlebrown"] = "#8b4513"
let s:rgb["salmon"] = "#fa8072"
let s:rgb["salmon1"] = "#ff8c69"
let s:rgb["salmon2"] = "#ee8262"
let s:rgb["salmon3"] = "#cd7054"
let s:rgb["salmon4"] = "#8b4c39"
let s:rgb["sandy brown"] = "#f4a460"
let s:rgb["sandybrown"] = "#f4a460"
let s:rgb["sea green"] = "#2e8b57"
let s:rgb["seagreen"] = "#2e8b57"
let s:rgb["seagreen1"] = "#54ff9f"
let s:rgb["seagreen2"] = "#4eee94"
let s:rgb["seagreen3"] = "#43cd80"
let s:rgb["seagreen4"] = "#2e8b57"
let s:rgb["seashell"] = "#fff5ee"
let s:rgb["seashell1"] = "#fff5ee"
let s:rgb["seashell2"] = "#eee5de"
let s:rgb["seashell3"] = "#cdc5bf"
let s:rgb["seashell4"] = "#8b8682"
let s:rgb["sienna"] = "#a0522d"
let s:rgb["sienna1"] = "#ff8247"
let s:rgb["sienna2"] = "#ee7942"
let s:rgb["sienna3"] = "#cd6839"
let s:rgb["sienna4"] = "#8b4726"
let s:rgb["sky blue"] = "#87ceeb"
let s:rgb["skyblue"] = "#87ceeb"
let s:rgb["skyblue1"] = "#87ceff"
let s:rgb["skyblue2"] = "#7ec0ee"
let s:rgb["skyblue3"] = "#6ca6cd"
let s:rgb["skyblue4"] = "#4a708b"
let s:rgb["slate blue"] = "#6a5acd"
let s:rgb["slate gray"] = "#708090"
let s:rgb["slate grey"] = "#708090"
let s:rgb["slateblue"] = "#6a5acd"
let s:rgb["slateblue1"] = "#836fff"
let s:rgb["slateblue2"] = "#7a67ee"
let s:rgb["slateblue3"] = "#6959cd"
let s:rgb["slateblue4"] = "#473c8b"
let s:rgb["slategray"] = "#708090"
let s:rgb["slategray1"] = "#c6e2ff"
let s:rgb["slategray2"] = "#b9d3ee"
let s:rgb["slategray3"] = "#9fb6cd"
let s:rgb["slategray4"] = "#6c7b8b"
let s:rgb["slategrey"] = "#708090"
let s:rgb["snow"] = "#fffafa"
let s:rgb["snow1"] = "#fffafa"
let s:rgb["snow2"] = "#eee9e9"
let s:rgb["snow3"] = "#cdc9c9"
let s:rgb["snow4"] = "#8b8989"
let s:rgb["spring green"] = "#00ff7f"
let s:rgb["springgreen"] = "#00ff7f"
let s:rgb["springgreen1"] = "#00ff7f"
let s:rgb["springgreen2"] = "#00ee76"
let s:rgb["springgreen3"] = "#00cd66"
let s:rgb["springgreen4"] = "#008b45"
let s:rgb["steel blue"] = "#4682b4"
let s:rgb["steelblue"] = "#4682b4"
let s:rgb["steelblue1"] = "#63b8ff"
let s:rgb["steelblue2"] = "#5cacee"
let s:rgb["steelblue3"] = "#4f94cd"
let s:rgb["steelblue4"] = "#36648b"
let s:rgb["tan"] = "#d2b48c"
let s:rgb["tan1"] = "#ffa54f"
let s:rgb["tan2"] = "#ee9a49"
let s:rgb["tan3"] = "#cd853f"
let s:rgb["tan4"] = "#8b5a2b"
let s:rgb["thistle"] = "#d8bfd8"
let s:rgb["thistle1"] = "#ffe1ff"
let s:rgb["thistle2"] = "#eed2ee"
let s:rgb["thistle3"] = "#cdb5cd"
let s:rgb["thistle4"] = "#8b7b8b"
let s:rgb["tomato"] = "#ff6347"
let s:rgb["tomato1"] = "#ff6347"
let s:rgb["tomato2"] = "#ee5c42"
let s:rgb["tomato3"] = "#cd4f39"
let s:rgb["tomato4"] = "#8b3626"
let s:rgb["turquoise"] = "#40e0d0"
let s:rgb["turquoise1"] = "#00f5ff"
let s:rgb["turquoise2"] = "#00e5ee"
let s:rgb["turquoise3"] = "#00c5cd"
let s:rgb["turquoise4"] = "#00868b"
let s:rgb["violet red"] = "#d02090"
let s:rgb["violet"] = "#ee82ee"
let s:rgb["violetred"] = "#d02090"
let s:rgb["violetred1"] = "#ff3e96"
let s:rgb["violetred2"] = "#ee3a8c"
let s:rgb["violetred3"] = "#cd3278"
let s:rgb["violetred4"] = "#8b2252"
let s:rgb["wheat"] = "#f5deb3"
let s:rgb["wheat1"] = "#ffe7ba"
let s:rgb["wheat2"] = "#eed8ae"
let s:rgb["wheat3"] = "#cdba96"
let s:rgb["wheat4"] = "#8b7e66"
let s:rgb["white smoke"] = "#f5f5f5"
let s:rgb["white"] = "#ffffff"
let s:rgb["whitesmoke"] = "#f5f5f5"
let s:rgb["yellow green"] = "#9acd32"
let s:rgb["yellow"] = "#ffff00"
let s:rgb["yellow1"] = "#ffff00"
let s:rgb["yellow2"] = "#eeee00"
let s:rgb["yellow3"] = "#cdcd00"
let s:rgb["yellow4"] = "#8b8b00"
let s:rgb["yellowgreen"] = "#9acd32"
if has('mac') && !has('macunix')
let s:rgb["dark gray"] = "0x808080"
let s:rgb["darkgray"] = "0x808080"
let s:rgb["dark grey"] = "0x808080"
let s:rgb["darkgrey"] = "0x808080"
let s:rgb["gray"] = "0xc0c0c0"
let s:rgb["grey"] = "0xc0c0c0"
let s:rgb["light gray"] = "0xe0e0e0"
let s:rgb["lightgray"] = "0xe0e0e0"
let s:rgb["light grey"] = "0xe0e0e0"
let s:rgb["lightgrey"] = "0xe0e0e0"
let s:rgb["dark red"] = "0x800000"
let s:rgb["darkred"] = "0x800000"
let s:rgb["red"] = "0xdd0806"
let s:rgb["light red"] = "0xffa0a0"
let s:rgb["lightred"] = "0xffa0a0"
let s:rgb["dark blue"] = "0x000080"
let s:rgb["darkblue"] = "0x000080"
let s:rgb["blue"] = "0x0000d4"
let s:rgb["light blue"] = "0xa0a0ff"
let s:rgb["lightblue"] = "0xa0a0ff"
let s:rgb["dark green"] = "0x008000"
let s:rgb["darkgreen"] = "0x008000"
let s:rgb["green"] = "0x006411"
let s:rgb["light green"] = "0xa0ffa0"
let s:rgb["lightgreen"] = "0xa0ffa0"
let s:rgb["dark cyan"] = "0x008080"
let s:rgb["darkcyan"] = "0x008080"
let s:rgb["cyan"] = "0x02abea"
let s:rgb["light cyan"] = "0xa0ffff"
let s:rgb["lightcyan"] = "0xa0ffff"
let s:rgb["dark magenta"] = "0x800080"
let s:rgb["darkmagenta"] = "0x800080"
let s:rgb["magenta"] = "0xf20884"
let s:rgb["light magenta"] = "0xf0a0f0"
let s:rgb["lightmagenta"] = "0xf0a0f0"
let s:rgb["brown"] = "0x804040"
let s:rgb["yellow"] = "0xfcf305"
let s:rgb["light yellow"] = "0xffffa0"
let s:rgb["lightyellow"] = "0xffffa0"
let s:rgb["orange"] = "0xfc8000"
let s:rgb["purple"] = "0xa020f0"
let s:rgb["slateblue"] = "0x6a5acd"
let s:rgb["violet"] = "0x8d38c9"
endif
function! csapprox#rgb()
return s:rgb
endfunction
================================================
FILE: .vim/bundle/CSApprox/doc/CSApprox.txt
================================================
*CSApprox.txt* Bringing GVim colorschemes to the terminal!
*csapprox* *csapprox.vim*
_____ ____ ___ ~
/ ___// __// _ | ___ ___ ____ ___ __ __ ~
/ /__ _\ \ / __ | / _ \ / _ \ / __// _ \ \ \ / ~
\___//___//_/ |_|/ .__// .__//_/ \___//_\_\ ~
/_/ /_/ ~
For Vim version 7.0 or newer
Last changed 14 Sep 2012
By Matt Wozniski
godlygeek@gmail.com
Reference Manual~
*csapprox-toc*
1. Introduction |csapprox-intro|
2. Requirements |csapprox-requirements|
3. Configuration |csapprox-configure|
4. Rationale/Design |csapprox-design|
5. Known Bugs and Limitations |csapprox-limitations|
6. Appendix - Terminals and Palettes |csapprox-terminal-list|
7. Changelog |csapprox-changelog|
8. Contact Info |csapprox-author|
The functionality mentioned here is a plugin, see |add-plugin|.
You can avoid loading this plugin by setting the "CSApprox_loaded" global
variable in your |vimrc| file: >
:let g:CSApprox_loaded = 1
==============================================================================
1. Introduction *csapprox-intro*
It's hard to find colorschemes for terminal Vim. Most colorschemes are
written to only support GVim, and don't work at all in terminal Vim.
This plugin makes GVim-only colorschemes Just Work in terminal Vim, as long
as the terminal supports 88 or 256 colors - and most do these days. This
usually requires no user interaction (but see below for what to do if things
don't Just Work). After getting this plugin happily installed, any time you
use :colorscheme it will do its magic and make the colorscheme Just Work.
Whenever you change colorschemes using the :colorscheme command this script
will be executed. It will take the colors that the scheme specified for use
in the GUI and use an approximation algorithm to try to gracefully degrade
them to the closest color available in your terminal. If you are running in
a GUI or if your terminal doesn't support 88 or 256 colors, no changes are
made. Also, no changes will be made if the colorscheme seems to have been
high color already.
If for some reason this transparent method isn't suitable to you (for instance
if your environment can't be configured to meet the |csapprox-requirements|,
or you need to work in Vim 6), another option is also available: using the
|:CSApproxSnapshot| command to create a new GUI/88-/256-color terminal
colorscheme. To use this command, a user would generally start GVim, choose a
colorscheme that sets up the desired colors, and then use |:CSApproxSnapshot|
to create a new colorscheme based on those colors that works in high color
terminals. This method is more flexible than the transparent mode and works
in more places, but also requires more user intervention, and makes it harder
to deal with colorschemes being updated and such.
*:CSApproxSnapshot*
The full syntax for the command is: >
:CSApproxSnapshot[!] /path/to/new/colorscheme
< For example: >
:CSApproxSnapshot ~/.vim/colors/foobar.vim
<
NOTE: The generated colorscheme will only work in 88- and 256-color terminals,
and in GVim. It will not work at all in a terminal with 16 or fewer
colors. There's just no reliable way to approximate down from
16,777,216 colors to 16 colors, especially without there being any
standard for what those 16 colors look like other than 'orange-ish',
'red-ish', etc.
NOTE: Although |:CSApproxSnapshot| can be used in both GVim and terminal Vim,
the resulting colors might be slightly off when run from terminal Vim.
I can find no way around this; Vim internally sets different colors when
running in a terminal than running in the GUI, and there's no way for
terminal Vim to figure out what color would have been used in GVim.
*:CSApprox*
A command is also provided to run the approximation manually. This might be
useful if some colors were set outside of a colorscheme file, for instance.
By default, it will not change any colors unless no highlight group is set to
a color above 15, which is CSApprox's normal behavior. This probably isn't
useful in most use cases, though. On the other hand, if a ! is provided,
CSApprox will skip that test and update the cterm value for every highlight
group from the corresponding gui color. Syntax:
>
:CSApprox[!]
<
==============================================================================
2. Requirements *csapprox-requirements*
For CSApprox to work, there are 2 major requirements that must be met.
a) GUI support (or vim >= 7.3) *csapprox-gui-support* *csapprox-+gui*
NOTE This section only applies to vim versions before 7.3.000 - a modern vim
does not need GUI support in order for CSApprox to function.
If CSApprox is being used to adjust a scheme's colors transparently, then the
terminal "vim" binary that is being run must be built with GUI support (see
|csapprox-limitations| for an explanation). If |:CSApproxSnapshot| is being
used to create a terminal colorscheme for high color terminals, then the
"vim" binary being used to create the scheme must be built with +gui, but the
scheme can be used in terminal "vim" binaries that weren't built with +gui.
NOTE that creating snapshots with GVim will work better than making them with
Vim, and (obviously) all "gvim" binaries are built with +gui.
Unfortunately, several Linux distributions only include GUI support in their
"gvim" binary, and not in their "vim" binary. You can check if GUI support is
available with the following command:
:echo has('gui')
If that prints 0, the first thing to try would be searching for a larger vim
package provided by your distribution, like "vim-enhanced" on RedHat/CentOS
or "vim-gtk" or "vim-gnome" on Debian/Ubuntu.
If you are unable to obtain a "vim" binary that includes GUI support, but
have a "gvim" binary available, you can probably launch Vim with GUI support
anyway by calling gvim with the |-v| flag in the shell: >
gvim -v
If the above works, you can remove the need to call "gvim -v" instead of "vim"
all the time by creating a symbolic link from your "gvim" binary to "vim"
somewhere in your $PATH, for example:
sudo ln -s $(which gvim) $(which vim)
If launching as "gvim -v" doesn"t work, and no package with GUI support is
available, you will need to compile Vim yourself and ensure that GUI support
is included to use CSApprox in its transparent mode, or create a snapshotted
scheme from GVim to use its snapshot mode. If this is inconvenient for you,
make sure that the Vim maintainer for your distribution knows it; they made a
conscious decision to build "vim" without +gui and "gvim" without terminal
support.
b) Properly configured terminal *csapprox-terminal*
As said above, many modern terminals support 88 or 256 colors, but most of
these default to setting $TERM to something generic (usually "xterm"). Since
Vim uses the value of the "colors" attribute for the current $TERM in terminfo
to figure out the number of colors used internally as 't_Co', this plugin will
either need for 't_Co' to be set to 88 or 256 in |vimrc|, or for $TERM to be
set to something that implies high color support. Possible choices include
"xterm-256color" for 256 color support and "rxvt-unicode" for 88 color
support.
*csapprox-palettes*
Also, there are at least three different 256-color palettes in use. Nearly
all terminals use an xterm-compatible palette, so most users need not concern
themselves with this, with only two exceptions: Eterm uses a slightly
different palette, and older Konsole (pre KDE 2.2.0) used a third palette.
CSApprox has no reliable way to tell which palette your terminal uses, so it
makes some educated guesses:
i) If vim thinks that there are 88 colors available, CSApprox will use the
xterm/urxvt-compatible 88 color palette (I don't know of any other
88 color palette in use anywhere).
ii) If $TERM starts with "Eterm", CSApprox will approximate based on the
Eterm palette.
iii) If $TERM starts with "konsole", CSApprox will use the legacy Konsole
palette if either "kde4-config --kde-version" or "kde-config --version"
reports that the KDE version on the system is less than 4.2.0.
Otherwise, it will use the xterm palette.
iv) If $TERM starts with "xterm" or "screen", then CSApprox looks for the
vim variables "g:CSApprox_eterm" and "g:CSApprox_konsole".
If g:CSApprox_eterm is true, CSApprox uses the Eterm palette.
If g:CSApprox_konsole is true, CSApprox uses the old konsole palette.
Otherwise, CSApprox uses the xterm palette.
v) For all other $TERM values, CSApprox uses the xterm palette.
*csapprox-terminal-example*
To turn on high color support despite an incorrect $TERM, you can override
t_Co (the vim name for the terminfo setting defining how many colors are
available) in your .vimrc, and set either CSApprox_konsole or CSApprox_eterm
if appropriate. You could put something like this into your |vimrc|:
>
if (&term == 'xterm' || &term =~? '^screen') && hostname() == 'my-machine'
" On my machine, I use an old Konsole with 256 color support
set t_Co=256
let g:CSApprox_konsole = 1
endif
Gnome Terminal, as of the time that I am writing this, doesn't support having
the terminal emulator set $TERM to something adequately descriptive. In cases
like this, something like the following would be appropriate:
>
if &term =~ '^\(xterm\|screen\)$' && $COLORTERM == 'gnome-terminal'
set t_Co=256
endif
==============================================================================
3. Configuration *csapprox-configure*
There are several global variables that can be set to configure the behavior
of CSApprox. They are listed roughly based on the likelihood that the end
user might want to know about them.
g:CSApprox_loaded *g:CSApprox_loaded*
If set in your |vimrc|, CSApprox is not loaded. Has no effect on
snapshotted schemes.
g:CSApprox_verbose_level *g:CSApprox_verbose_level*
When CSApprox is run, the 'verbose' option will be temporarily raised to
the value held in this variable unless it is already greater. The default
value is 1, which allows CSApprox to default to warning whenever something
is wrong, even if it is recoverable, but allows the user to quiet us if he
wants by changing this variable to 0. The most important messages will be
shown at verbosity level 1; some less important ones will be shown at
higher verbosity levels. Has no effect on snapshotted schemes.
g:CSApprox_fake_reverse *g:CSApprox_fake_reverse*
In gvim, setting a highlight group like "Visual" (the color of your visual
mode selection) to do reverse video results in it reversing the colors of
each character cell under it. Some terminals don't support this and will
instead always use the default background color on the default foreground
color when asked for reverse video. If this variable is set to a non-zero
number, CSApprox will change any request for reverse video to the "Normal"
group's bg color on the "Normal" group's fg color, instead of asking the
terminal to do reverse video. This provides a middle ground for terminals
that don't properly support reverse video - it's worse than having the
terminal properly reverse the colors of each character cell, but it's
better than the broken behavior of some terminal emulators. This was the
default behavior before CSApprox 4.0.
g:CSApprox_eterm *g:CSApprox_eterm*
If set to a non-zero number, CSApprox will use the Eterm palette when
'term' is set to "xterm" or begins with "screen". Otherwise, the xterm
palette would be used. This also affects snapshotted schemes.
g:CSApprox_konsole *g:CSApprox_konsole*
If set to a non-zero number, CSApprox will use the old Konsole palette
when 'term' is set to "xterm" or begins with "screen". Otherwise, the
xterm palette would be used. This also affects snapshotted schemes.
g:CSApprox_attr_map *g:CSApprox_attr_map*
Since some attributes (like 'guisp') can't be used in a terminal, and
others (like 'italic') are often very ugly in terminals, a generic way to
map between a requested attribute and another attribute is included. This
variable should be set to a Dictionary, where the keys are strings
representing the attributes the author wanted set, and the values are the
strings that the user wants set instead. If a value is '', it means the
attribute should just be ignored. The default is to replace 'italic' with
'underline', and to use 'fg' instead of 'sp': >
let g:CSApprox_attr_map = { 'italic' : 'underline', 'sp' : 'fg' }
<
Your author prefers disabling bold and italic entirely, so uses this: >
let g:CSApprox_attr_map = { 'bold' : '', 'italic' : '', 'sp' : 'fg' }
<
Note: This transformation is considered at the time a snapshotted scheme
is created, rather than when it is used.
Note: You can only map an attribute representing a color to another
attribute representing a color; likewise with boolean attributes.
After all, sp -> bold and italic -> fg would be nonsensical.
*g:CSApprox_hook_pre* *g:CSApprox_hook_{scheme}_pre*
*g:CSApprox_hook_post* *g:CSApprox_hook_{scheme}_post*
g:CSApprox_hook_pre
g:CSApprox_hook_post
g:CSApprox_hook_{scheme}_pre
g:CSApprox_hook_{scheme}_post *csapprox-hooks*
These variables provide a method for adjusting tweaking the approximation
algorithm, either for all schemes, or on a per scheme basis. For
snapshotted schemes, these will only take effect when the snapshotted
scheme is created, rather than when it is used. Each of these variables
may be set to either a String containing a command to be :execute'd, or a
List of such Strings. The _pre hooks are executed before any
approximations have been done. In order to affect the approximation at
this stage, you would need to change the gui colors for a group; the cterm
colors will then be approximated from those gui colors. Example:
>
let g:CSApprox_hook_pre = 'hi Comment guibg=#ffddff'
<
The advantage to tweaking the colors at this stage is that CSApprox will
handle approximating the given gui colors to the proper cterm colors,
regardless of the number of colors the terminal supports. The
disadvantage is that certain things aren't possible, including clearing
the background or foreground color for a group, selecting a precise cterm
color to be used, and overriding the mappings made by g:CSApprox_attr_map.
Another notable disadvantage is that overriding things at this level will
actually affect the gui colors, in case the :gui is used to start gvim
from the running vim instance.
To overcome these disadvantages, the _post hooks are provided. These
hooks will be executed only after all approximations have been completed.
At this stage, in order to have changes appear the cterm* colors must be
modified. For example:
*csapprox-transparency*
>
let g:CSApprox_hook_post = ['hi Normal ctermbg=NONE ctermfg=NONE',
\ 'hi NonText ctermbg=NONE ctermfg=NONE' ]
<
Setting g:CSApprox_hook_post as shown above will clear the background of
the Normal and NonText groups, forcing the terminal's default background
color to be used instead, including any pseudotransparency done by that
terminal emulator. As noted, though, the _post functions do not allow
CSApprox to approximate the colors. This may be desired, but if this is
an inconvenience the function named by g:CSApprox_approximator_function
can still be called manually. For example:
>
let g:CSApprox_hook_post = 'exe "hi Comment ctermbg="'
\ . '. g:CSApprox_approximator_function(0xA0,0x50,0x35)'
<
The _{scheme}_ versions are exactly like their counterparts, except that
they will only be executed if the value of g:colors_name matches the
scheme name embedded in the variable name. They will be executed after
the corresponding hook without _{scheme}_, which provides a way to
override a less specific hook with a more specific one. For example, to
clear the Normal and NonText groups, but only for the colorscheme
"desert", one could do the following:
>
let g:CSApprox_hook_desert_post = ['hi Normal ctermbg=NONE ctermfg=NONE',
\ 'hi NonText ctermbg=NONE ctermfg=NONE' ]
<
One final example: If you want CSApprox to be active for nearly all
colorschemes, but want one or two particular schemes to be ignored, you
can take advantage of the CSApprox logic that skips over any color scheme
that is already high color by setting a color to a number above 255. Note
that most colors greater than 15 will work, but some will not - 256 should
always work. For instance, you can prevent CSApprox from modifying the
colors of the zellner colorscheme like this:
>
let g:CSApprox_hook_zellner_pre = 'hi _FakeGroup ctermbg=256'
<
NOTE: Any characters that would stop the string stored in g:colors_name
from being a valid variable name will be removed before the
_{scheme}_ hook is searched. Basically, this means that first all
characters that are neither alphanumeric nor underscore will be
removed, then any leading digits will be removed. So, for a
colorscheme named "123 foo_bar-baz456.vim", the hook searched for
will be, eg, g:CSApprox_hook_foo_barbaz456_post
g:CSApprox_use_showrgb *g:CSApprox_use_showrgb*
By default, CSApprox will use a built in mapping of color names to values.
This optimization greatly helps speed, but means that colors addressed by
name might not match up perfectly between gvim (which uses the system's
real rgb database) and CSApprox (which uses the builtin database). To
force CSApprox to try the systemwide database first, and only fall back on
the builtin database if it isn't available, set this variable non-zero.
g:CSApprox_approximator_function *g:CSApprox_approximator_function*
If the default approximation function doesn't work well enough, the user
(or another author wishing to extend this plugin) can write another
approximation function. This function should take three numbers,
representing r, g, and b in decimal, and return the index on the color
cube that best matches those colors. Assigning a |Funcref| to this
variable will override the default approximator with the one the Funcref
references. This option will take effect at the time a snapshotted scheme
is created, rather than when it's used.
g:CSApprox_redirfallback *g:CSApprox_redirfallback*
Until Vim 7.2.052, there was a bug in the Vim function synIDattr() that
made it impossible to determine syntax information about the |guisp|
attribute. CSApprox includes a workaround for this problem, as well as a
test that ought to disable this workaround if synIDattr() works properly.
If this test should happen to give improper results somehow, the user can
force the behavior with this variable. When set to 1, the workaround will
always be used, and when set to 0, synIDattr() is blindly used. Needless
to say, if this automatic detection should ever fail, the author would
like to be notified! This option will take effect at the time a
snapshotted scheme is created, rather than when it's used.
==============================================================================
4. Rationale/Design *csapprox-design*
There is a wealth of colorschemes available for Vim. Unfortunately, since
traditional terminal emulators have only supported 2, 8 or 16 colors,
colorscheme authors have tended to avoid writing colorschemes for terminal
Vim, sticking instead to GVim. Even now that nearly every popular terminal
supports either 88 or 256 colors, few colorschemes are written to support
them. This may be because the terminal color codes are just numbers from 0 to
87 or 255 with no semantic meaning, or because the same number doesn't yield
the same color in all terminals, or simply because the colorscheme author
doesn't use the terminal and doesn't want to take the time to support
terminals.
Whatever the reason, this leaves users of many modern terminal emulators in
the awkward position of having a terminal emulator that supports many colors,
but having very few colorschemes that were written to utilize those colors.
This is where CSApprox comes in. It attempts to fill this void allowing GVim
colorschemes to be used in terminal Vim. CSApprox has two distinct modes of
operation. In the first mode, it attempts to make GVim colorschemes
transparently backwards compatible with terminal Vim in a high color terminal.
Basically, whenever a colorscheme is run it should set some colors for the
GUI, and this script will then run and attempt to figure out the closest color
available in the terminal's color palette to the color the scheme author asked
for. Unfortunately, this does not work well all the time, and it has some
limitations (see |csapprox-limitations|). Most of the time, however, this
gives a very close approximation to the GVim colors without requiring any
changes to the colorscheme, or any user interaction. It only requires that
the plugin be installed on the machine where Vim is being run, and that the
user's environment meets the needs specified at |csapprox-requirements|. In
the event that this doesn't work, a second option - using |:CSApproxSnapshot|
to create a new, 88-/256-color capable colorscheme - is available.
Ideally, the aim is for CSApprox to be completely transparent to the user.
This is why the approach I take is entirely different from the GuiColorScheme
script, which will break on any but the simplest colorschemes. Unfortunately,
given the difficulty of determining exactly which terminal emulator the user
is running, and what features it supports, and which color palette it's using,
perfect transparency is difficult. So, to this end, I've attempted to default
to settings that make it unlikely that this script ever makes things worse
(this is why I chose not to override t_Co to 256 myself), and I've attempted
to make it easy to override my choice of defaults when necessary (through
g:CSApprox_approximator_function, g:CSApprox_konsole, g:CSApprox_eterm,
g:CSApprox_attr_map, etc).
In the event that the transparent solution is undesirable, or that the user's
environment can't be configured to allow it (no GVim and no Vim with +gui, for
instance), |:CSApproxSnapshot| should provide a workable alternative - less
cool, and less flexible, but it will work in more environments, and the
snapshotted colorscheme will even work in Vim 6.
If any of my design choices seem to be causing extra work with no real
advantages, though, I'd like to hear about it. Feel free to email me with any
improvements or complaints.
==============================================================================
5. Known Bugs and Limitations *csapprox-limitations*
GUI support or vim >= 7.3 is required for transparently adapting schemes.
There is nothing I can do about this given my chosen design. CSApprox works
by being notified every time a colorscheme sets some GUI colors, then
approximating those colors to similar terminal colors. Unfortunately, when
Vim < 7.3 is not built with GUI support, it doesn't bother to store the GUI
colors, so querying for them fails. This leaves me completely unable to
tell what the colorscheme was trying to do. See |csapprox-+gui| for some
potential workarounds if your distribution doesn't provide a Vim with +gui
and you can't upgrade to a modern vim.
User intervention is sometimes required for information about the terminal.
This is really an insurmountable problem. Unfortunately, most terminal
emulators default to setting $TERM to 'xterm', even when they're not really
compatible with an xterm. $TERM is really the only reliable way to
find anything at all out about the terminal you're running in, so there's no
way to know if the terminal supports 88 or 256 colors without either the
terminal telling me (using $TERM) or the user telling me (using 't_Co').
Similarly, unless $TERM is set to something that implies a certain color
palette ought to be used, there's no way for me to know, so I'm forced to
default to the most common, xterm's palette, and allow the user to override
my choice with |g:CSApprox_konsole| or |g:CSApprox_eterm|. An example of
configuring Vim to work around a terminal where $TERM is set to something
generic without configuring the terminal properly is shown at
|csapprox-terminal-example|.
Some colorschemes could fail to be converted if they try to be too smart.
A colorscheme could decide to only set colors for the mode Vim is running
in. If a scheme only sets GUI colors when the GUI is running, instead of
using the usual approach of setting all colors and letting Vim choose which
to use, my approach falls apart. My method for figuring out what the scheme
author wants the scheme to look like absolutely depends upon him setting the
GUI colors in all modes. Fortunately, the few colorschemes that do this
seem to be, by and large, intended for 256 color terminals already, meaning
that skipping them is the proper behavior. Note that this will only affect
transparently adapted schemes and snapshots made from terminal Vim;
snapshots made from GVim are immune to this problem.
Transparently adapting schemes is slow.
For me, it takes Vim's startup time from 0.15 seconds to 0.35 seconds. This
is probably still acceptable, but it is definitely worth trying to cut down
on this time in future versions. Snapshotted schemes are faster to use,
since all of the hard evaluations are made when they're made instead of when
they're used.
NOTE: As of CSApprox 3.50, the overhead is down to about 0.10 seconds on my
test machine.
It isn't possible to approximate only a particular set of groups.
Unfortunately, the :CSApprox command will always update all groups, even if
only a small set of groups has changed. A future improvement would be to
provide a function called, say, CSApprox(), that takes an optional list of
highlight groups (default: all) and only does approximation for those
groups.
==============================================================================
6. Appendix - Terminals and Palettes *csapprox-terminal-list*
What follows is a list of terminals known to have and known not to have high
color support. This list is certainly incomplete; feel free to contact me
with more to add to either list.
*csapprox-terminals-good*
------------------------------- Good Terminals -------------------------------
The most recent versions of each of these terminals can be compiled with
either 88 or 256 color support.
*csapprox-xterm*
xterm:
256 color palette
Colors composed of: [ 0x00, 0x5F, 0x87, 0xAF, 0xD7, 0xFF ]
Greys composed of: [ 0x08, 0x12, 0x1C, 0x26, 0x30, 0x3A, 0x44, 0x4E,
0x58, 0x62, 0x6C, 0x76, 0x80, 0x8A, 0x94, 0x9E,
0xA8, 0xB2, 0xBC, 0xC6, 0xD0, 0xDA, 0xE4, 0xEE ]
*csapprox-urxvt*
rxvt-unicode (urxvt):
88 colors by default (but a patch is available to use xterm's palette)
Colors composed of: [ 0x00, 0x8B, 0xCD, 0xFF ]
Greys composed of: [ 0x2E, 0x5C, 0x73, 0x8B, 0xA2, 0xB9, 0xD0, 0xE7 ]
*csapprox-pterm* *csapprox-putty*
PuTTY (pterm; putty.exe):
256 colors; same palette as xterm
*csapprox-mrxvt*
Mrxvt (mrxvt):
256 colors; same palette as xterm
*csapprox-gnome-terminal*
GNOME Terminal (gnome-terminal):
256 colors; same palette as xterm
*csapprox-roxterm*
ROXTerm (roxterm):
256 colors; same palette as xterm
*csapprox-xfce4-terminal*
Terminal (xfce4-terminal):
256 colors; same palette as xterm
*csapprox-iterm.app*
iTerm (iTerm.app):
256 colors; same palette as xterm
*csapprox-konsole*
Konsole (konsole):
256 color palette
Colors used to be composed of: [ 0x00, 0x33, 0x66, 0x99, 0xCC, 0xFF ]
As of KDE 2.2.0, colors match the xterm palette
Always used the same greyscales as xterm
*csapprox-eterm*
eterm (Eterm):
256 color palette
Colors composed of: [ 0x00, 0x2A, 0x55, 0x7F, 0xAA, 0xD4 ]
Same greyscales as xterm
You should set the g:CSApprox_eterm variable unless $TERM begins with
'eterm', case insensitive
*csapprox-screen*
GNU Screen (screen):
256 color support. Internally, uses the xterm palette, but this is only
relevant when running screen inside a terminal with fewer than 256 colors,
in which case screen will attempt to map between its own 256 color cube
and the colors supported by the real terminal to the best of its ability,
in much the same way as CSApprox maps between GUI and terminal colors.
*csapprox-terminals-bad*
-------------------------------- Bad Terminals -------------------------------
This is a list of terminals known _not_ to have high color support. If any of
these terminals have high color support added at some point in the future,
please tell me and I'll update this information.
*csapprox-terminal.app*
Terminal.app (as of OS X 10.5.2)
*csapprox-aterm*
aterm (as of version 1.00.01)
*csapprox-xiterm*
xiterm (as of version 0.5)
*csapprox-wterm*
wterm (as of version 6.2.9)
*csapprox-mlterm*
mlterm (as of version 2.9.4)
*csapprox-kterm*
kterm (as of version 6.2.0)
==============================================================================
7. Changelog *csapprox-changelog*
4.00 14 Sep 2012 Fix CSApprox to not fail in vim 7.3 if not +gui, now
that vim behaves properly even without +gui
Provide the |:CSApprox| command to re-run CSApprox's
approximation algorithm even if the colorscheme hasn't
changed - useful for when the user has tweaked some
colors manually.
Better handling for the |inverse| (aka reverse) attribute
for terminals that actually support it - and add the
g:CSApprox_fake_reverse config variable to allow
switching back to the old behavior for terminals that
don't support real reverse video.
Fix an issue where CSApprox would unconditionally leave
'background' set to "light" - now it will leave
'background' unchanged when it runs.
Change the handling for Konsole to use the xterm palette
by for KDE versions >= 2.2.0 - Konsole itself was
changed to drop its old, slightly incompatible palette
in KDE 2.2.0
Fix a minor issue where running vim in recovery mode
with |-r| would result in a complaint from CSApprox that
the terminal didn't have enough colors even when it did.
Fix an issue where, even if CSApprox had been disabled
by setting |g:CSApprox_loaded|, a CSApprox error message
could still be displayed.
3.50 01 Apr 2009 Fix a major regression that prevented the Eterm and
Konsole colors from being correctly snapshotted
Fix a related bug causing incorrect terminal colors
after calling |:CSApproxSnapshot|
Fix a bug causing black to be used instead of dark grey
Have snapshots calculate g:colors_name programmatically
Introduce many tweaks for better speed
Clarify some things at :help csapprox-terminal-example
Default to using our own list of rgb.txt colors rather
than searching, for performance. Add a new variable,
g:CSApprox_use_showrgb, which forces us to try finding
the colors using the "showrgb" program instead, and fall
back on our own list if it isn't available
Remove g:CSApprox_extra_rgb_txt_dirs - not needed in
light of the above change
3.05 31 Jan 2009 Fix a harmless "Undefined variable" error in
|:CSApproxSnapshot|
Fix a behavioral bug when dumping out colors defined
external to the scheme.
3.00 21 Jan 2009 Update the docs for better info on |:CSApproxSnapshot|
Allow snapshotted schemes to work on Vim 6, and work
properly in Konsole and Eterm (thanks David Majnemer!)
Fix a bug causing a syntax error when using GVim while
CSApprox was loaded. (thanks again, David Majnemer!)
2.00 14 Dec 2008 Add a hooks system, allowing users to specify a command
to run, either before or after the approximation
algorithm is run, for all schemes or one specific one.
Also rewrite |:CSApproxSnapshot| to be more maintainable
and less of a hack, and fix several bugs that it
contained.
1.50 19 Nov 2008 Add CSApproxSnapshot command, as an alternative solution
when the user has gvim or a vim with gui support, but
sometimes needs to use a vim without gui support.
1.10 28 Oct 2008 Enable running on systems with no rgb.txt (Penn Su)
Begin distributing a copy of rgb.txt with CSApprox
1.00 04 Oct 2008 First public release
0.90 14 Sep 2008 Initial beta release
==============================================================================
8. Contact Info *csapprox-author*
Your author, a Vim nerd with some free time, was sick of seeing terminals
always get the short end of the stick. He'd like to be notified of any
problems you find - after all, he took the time to write all this lovely
documentation, and this plugin, which took more time than you could possibly
imagine to get working transparently for every colorscheme he could get his
hands on. You can contact him with any problems or praises at
godlygeek@gmail.com
==============================================================================
vim:tw=78:fo=tcq2:isk=!-~,^*,^\|,^\":ts=8:ft=help:norl:
================================================
FILE: .vim/bundle/CSApprox/plugin/CSApprox.vim
================================================
" CSApprox: Make gvim-only colorschemes Just Work terminal vim
" Maintainer: Matthew Wozniski (godlygeek@gmail.com)
" Date: Fri, 14 Sep 2012 01:12:13 -0400
" Version: 4.00
" History: :help csapprox-changelog
"
" Long Description:
" It's hard to find colorschemes for terminal Vim. Most colorschemes are
" written to only support GVim, and don't work at all in terminal Vim.
"
" This plugin makes GVim-only colorschemes Just Work in terminal Vim, as long
" as the terminal supports 88 or 256 colors - and most do these days. This
" usually requires no user interaction (but see below for what to do if things
" don't Just Work). After getting this plugin happily installed, any time you
" use :colorscheme it will do its magic and make the colorscheme Just Work.
"
" Whenever you change colorschemes using the :colorscheme command this script
" will be executed. It will take the colors that the scheme specified for use
" in the GUI and use an approximation algorithm to try to gracefully degrade
" them to the closest color available in your terminal. If you are running in
" a GUI or if your terminal doesn't support 88 or 256 colors, no changes are
" made. Also, no changes will be made if the colorscheme seems to have been
" high color already.
"
" License:
" Copyright (c) 2012, Matthew J. Wozniski
" All rights reserved.
"
" Redistribution and use in source and binary forms, with or without
" modification, are permitted provided that the following conditions are met:
" * Redistributions of source code must retain the above copyright
" notice, this list of conditions and the following disclaimer.
" * Redistributions in binary form must reproduce the above copyright
" notice, this list of conditions and the following disclaimer in the
" documentation and/or other materials provided with the distribution.
" * The names of the contributors may not be used to endorse or promote
" products derived from this software without specific prior written
" permission.
"
" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER ``AS IS'' AND ANY
" EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
" WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
" DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
" DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
" (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
" LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
" ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
" SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
" {>1} Basic plugin setup
" {>2} Check preconditions
" Quit if the user doesn't want or need us or is missing the gui feature. We
" need +gui to be able to check the gui color settings; vim doesn't bother to
" store them if it is not built with +gui.
if exists('g:CSApprox_loaded')
finish
elseif !has('gui') && v:version < 703
" Vim versions less than < 7.3.0 need +gui.
" Warn unless the user set g:CSApprox_verbose_level to zero.
if get(g:, 'CSApprox_verbose_level', 1)
echomsg "CSApprox needs gui support - not loading."
echomsg " See :help |csapprox-+gui| for possible workarounds."
endif
finish
endif
" {1} Mark us as loaded, and disable all compatibility options for now.
let g:CSApprox_loaded = 1
let s:savecpo = &cpo
set cpo&vim
" {>1} Collect info for the set highlights
" {>2} Determine if synIDattr is usable
" synIDattr() couldn't support 'guisp' until 7.2.052. This function returns
" true if :redir is needed to find the 'guisp' attribute, false if synIDattr()
" is functional. This test can be overridden by setting the global variable
" g:CSApprox_redirfallback to 1 (to force use of :redir) or to 0 (to force use
" of synIDattr()).
function! s:NeedRedirFallback()
if !exists("g:CSApprox_redirfallback")
let g:CSApprox_redirfallback = (v:version == 702 && !has('patch52'))
\ || v:version < 702
endif
return g:CSApprox_redirfallback
endfunction
" {>2} Collect and store the highlights
" Get a dictionary containing information for every highlight group not merely
" linked to another group. Return value is a dictionary, with highlight group
" numbers for keys and values that are dictionaries with four keys each,
" 'name', 'term', 'cterm', and 'gui'. 'name' holds the group name, and each
" of the others holds highlight information for that particular mode.
function! s:Highlights(modes)
let rv = {}
let i = 0
while 1
let i += 1
" Only interested in groups that exist and aren't linked
if synIDtrans(i) == 0
break
endif
" Handle vim bug allowing groups with name == "" to be created
if synIDtrans(i) != i || len(synIDattr(i, "name")) == 0
continue
endif
let rv[i] = {}
let rv[i].name = synIDattr(i, "name")
for where in a:modes
let rv[i][where] = {}
for attr in s:PossibleAttributes()
let rv[i][where][attr] = synIDattr(i, attr, where)
endfor
for attr in [ "fg", "bg" ]
let rv[i][where][attr] = synIDattr(i, attr.'#', where)
endfor
if where == "gui"
let rv[i][where]["sp"] = s:SynGuiSp(i, rv[i].name)
else
let rv[i][where]["sp"] = -1
endif
for attr in [ "fg", "bg", "sp" ]
if rv[i][where][attr] == -1
let rv[i][where][attr] = ''
endif
endfor
endfor
endwhile
return rv
endfunction
" {>2} Retrieve guisp
" Get guisp using whichever method is specified by _redir_fallback
function! s:SynGuiSp(idx, name)
if !s:NeedRedirFallback()
return s:SynGuiSpAttr(a:idx)
else
return s:SynGuiSpRedir(a:name)
endif
endfunction
" {>3} Implementation for retrieving guisp with redir hack
function! s:SynGuiSpRedir(name)
redir => temp
exe 'sil hi ' . a:name
redir END
let temp = matchstr(temp, 'guisp=\zs.*')
if len(temp) == 0 || temp[0] =~ '\s'
let temp = ""
else
" Make sure we can handle guisp='dark red'
let temp = substitute(temp, '[\x00].*', '', '')
let temp = substitute(temp, '\s*\(c\=term\|gui\).*', '', '')
let temp = substitute(temp, '\s*$', '', '')
endif
return temp
endfunction
" {>3} Implementation for retrieving guisp with synIDattr()
function! s:SynGuiSpAttr(idx)
return synIDattr(a:idx, 'sp#', 'gui')
endfunction
" {>1} Handle color names
" Place to store rgb.txt name to color mappings - lazy loaded if needed
let s:rgb = {}
" {>2} Builtin gui color names
" gui_x11.c and gui_gtk_x11.c have some default colors names that are searched
" if the x server doesn't know about a color. If 'showrgb' is available,
" we'll default to using these color names and values, and overwrite them with
" other values if 'showrgb' tells us about those colors.
let s:rgb_defaults = { "lightred" : "#FFBBBB",
\ "lightgreen" : "#88FF88",
\ "lightmagenta" : "#FFBBFF",
\ "darkcyan" : "#008888",
\ "darkblue" : "#0000BB",
\ "darkred" : "#BB0000",
\ "darkmagenta" : "#BB00BB",
\ "darkgrey" : "#BBBBBB",
\ "darkyellow" : "#BBBB00",
\ "gray10" : "#1A1A1A",
\ "grey10" : "#1A1A1A",
\ "gray20" : "#333333",
\ "grey20" : "#333333",
\ "gray30" : "#4D4D4D",
\ "grey30" : "#4D4D4D",
\ "gray40" : "#666666",
\ "grey40" : "#666666",
\ "gray50" : "#7F7F7F",
\ "grey50" : "#7F7F7F",
\ "gray60" : "#999999",
\ "grey60" : "#999999",
\ "gray70" : "#B3B3B3",
\ "grey70" : "#B3B3B3",
\ "gray80" : "#CCCCCC",
\ "grey80" : "#CCCCCC",
\ "gray90" : "#E5E5E5",
\ "grey90" : "#E5E5E5" }
" {>2} Colors that vim will use by name in one of the default schemes, either
" for bg=light or for bg=dark. This lets us avoid loading the entire rgb.txt
" database when the scheme itself doesn't ask for colors by name.
let s:rgb_presets = { "black" : "#000000",
\ "blue" : "#0000ff",
\ "brown" : "#a52a2a",
\ "cyan" : "#00ffff",
\ "darkblue" : "#00008b",
\ "darkcyan" : "#008b8b",
\ "darkgrey" : "#a9a9a9",
\ "darkmagenta" : "#8b008b",
\ "green" : "#00ff00",
\ "grey" : "#bebebe",
\ "grey40" : "#666666",
\ "grey90" : "#e5e5e5",
\ "lightblue" : "#add8e6",
\ "lightcyan" : "#e0ffff",
\ "lightgrey" : "#d3d3d3",
\ "lightmagenta" : "#ffbbff",
\ "magenta" : "#ff00ff",
\ "red" : "#ff0000",
\ "seagreen" : "#2e8b57",
\ "white" : "#ffffff",
\ "yellow" : "#ffff00" }
" {>2} Find available color names
" Find the valid named colors. By default, use our own rgb list, but try to
" retrieve the system's list if g:CSApprox_use_showrgb is set to true. Store
" the color names and color values to the dictionary s:rgb - the keys are
" color names (in lowercase), the values are strings representing color values
" (as '#rrggbb').
function! s:UpdateRgbHash()
try
if !exists("g:CSApprox_use_showrgb") || !g:CSApprox_use_showrgb
throw "Not using showrgb"
endif
" We want to use the 'showrgb' program, if it's around
let lines = split(system('showrgb'), '\n')
if v:shell_error || !exists('lines') || empty(lines)
throw "'showrgb' didn't give us an rgb.txt"
endif
let s:rgb = copy(s:rgb_defaults)
" fmt is (blanks?)(red)(blanks)(green)(blanks)(blue)(blanks)(name)
let parsepat = '^\s*\(\d\+\)\s\+\(\d\+\)\s\+\(\d\+\)\s\+\(.*\)$'
for line in lines
let v = matchlist(line, parsepat)
if len(v) < 0
throw "CSApprox: Bad RGB line: " . string(line)
endif
let s:rgb[tolower(v[4])] = printf("#%02x%02x%02x", v[1], v[2], v[3])
endfor
catch
try
let s:rgb = csapprox#rgb()
catch
echohl ErrorMsg
echomsg "Can't call rgb() from autoload/csapprox.vim"
echomsg "Named colors will not be available!"
echohl None
endtry
endtry
return 0
endfunction
" {>1} Derive and set cterm attributes
" {>2} List of all possible attributes
function! s:PossibleAttributes()
return [ "bold", "italic", "reverse", "underline", "undercurl" ]
endfunction
" {>2} Attribute overrides
" Allow the user to override a specified attribute with another attribute.
" For example, the default is to map 'italic' to 'underline' (since many
" terminals cannot display italic text, and gvim itself will replace italics
" with underlines where italicizing is impossible), and to replace 'sp' with
" 'fg' (since terminals can't use one color for the underline and another for
" the foreground, we color the entire word). This default can of course be
" overridden by the user, by setting g:CSApprox_attr_map. This map must be
" a dictionary of string keys, representing the same attributes that synIDattr
" can look up, to string values, representing the attribute mapped to or an
" empty string to disable the given attribute entirely.
function! s:attr_map(attr)
let rv = get(g:CSApprox_attr_map, a:attr, a:attr)
return rv
endfunction
function! s:NormalizeAttrMap(map)
let old = copy(a:map)
let new = filter(a:map, '0')
let valid_attrs = [ 'bg', 'fg', 'sp' ] + s:PossibleAttributes()
let colorattrs = [ 'fg', 'bg', 'sp' ]
for olhs in keys(old)
if olhs ==? 'inverse'
let nlhs = 'reverse'
endif
let orhs = old[olhs]
if orhs ==? 'inverse'
let nrhs = 'reverse'
endif
let nlhs = tolower(olhs)
let nrhs = tolower(orhs)
try
if index(valid_attrs, nlhs) == -1
echomsg "CSApprox: Bad attr map (removing unrecognized attribute " . olhs . ")"
elseif nrhs != '' && index(valid_attrs, nrhs) == -1
echomsg "CSApprox: Bad attr map (removing unrecognized attribute " . orhs . ")"
elseif nrhs != '' && !!(index(colorattrs, nlhs)+1) != !!(index(colorattrs, nrhs)+1)
echomsg "CSApprox: Bad attr map (removing " . olhs . "; type mismatch with " . orhs . ")"
elseif nrhs == 'sp'
echomsg "CSApprox: Bad attr map (removing " . olhs . "; can't map to 'sp')"
else
let new[nlhs] = nrhs
endif
catch
echo v:exception
endtry
endfor
endfunction
" {>2} Normalize the GUI settings of a highlight group
" If the Normal group is cleared, set it to gvim's default, black on white
" Though this would be a really weird thing for a scheme to do... *shrug*
function! s:FixupGuiInfo(highlights)
if a:highlights[s:hlid_normal].gui.bg == ''
let a:highlights[s:hlid_normal].gui.bg = 'white'
endif
if a:highlights[s:hlid_normal].gui.fg == ''
let a:highlights[s:hlid_normal].gui.fg = 'black'
endif
endfunction
" {>2} Map gui settings to cterm settings
" Given information about a highlight group, replace the cterm settings with
" the mapped gui settings, applying any attribute overrides along the way. In
" particular, this gives special treatment to the 'reverse' attribute and the
" 'guisp' attribute. In particular, if the 'reverse' attribute is set for
" gvim, we unset it for the terminal and instead set ctermfg to match guibg
" and vice versa, since terminals can consider a 'reverse' flag to mean using
" default-bg-on-default-fg instead of current-bg-on-current-fg. We also
" ensure that the 'sp' attribute is never set for cterm, since no terminal can
" handle that particular highlight. If the user wants to display the guisp
" color, he should map it to either 'fg' or 'bg' using g:CSApprox_attr_map.
function! s:FixupCtermInfo(highlights)
for hl in values(a:highlights)
if !has_key(hl, 'cterm')
let hl["cterm"] = {}
endif
" Find attributes to be set in the terminal
for attr in s:PossibleAttributes()
let hl.cterm[attr] = ''
if hl.gui[attr] == 1
if s:attr_map(attr) != ''
let hl.cterm[ s:attr_map(attr) ] = 1
endif
endif
endfor
for color in [ "bg", "fg" ]
let eff_color = color
if hl.cterm['reverse']
let eff_color = (color == 'bg' ? 'fg' : 'bg')
endif
let hl.cterm[color] = get(hl.gui, s:attr_map(eff_color), '')
endfor
if hl.gui['sp'] != '' && s:attr_map('sp') != ''
let hl.cterm[s:attr_map('sp')] = hl.gui['sp']
endif
if exists("g:CSApprox_fake_reverse") && g:CSApprox_fake_reverse
if hl.cterm['reverse'] && hl.cterm.bg == ''
let hl.cterm.bg = 'fg'
endif
if hl.cterm['reverse'] && hl.cterm.fg == ''
let hl.cterm.fg = 'bg'
endif
if hl.cterm['reverse']
let hl.cterm.reverse = ''
endif
endif
endfor
endfunction
" {>2} Kludge around inability to reference autoload functions
function! s:DefaultApproximator(...)
return call('csapprox#per_component#Approximate', a:000)
endfunction
" {>2} Set cterm colors for a highlight group
" Given the information for a single highlight group (ie, the value of
" one of the items in s:Highlights() already normalized with s:FixupCtermInfo
" and s:FixupGuiInfo), handle matching the gvim colors to the closest cterm
" colors by calling the appropriate approximator as specified with the
" g:CSApprox_approximator_function variable and set the colors and attributes
" appropriately to match the gui.
function! s:SetCtermFromGui(hl)
let hl = a:hl
" Set up the default approximator function, if needed
if !exists("g:CSApprox_approximator_function")
let g:CSApprox_approximator_function = function("s:DefaultApproximator")
endif
" Clear existing highlights
exe 'hi ' . hl.name . ' cterm=NONE ctermbg=NONE ctermfg=NONE'
for which in [ 'bg', 'fg' ]
let val = hl.cterm[which]
" Skip unset colors
if val == -1 || val == ""
continue
endif
" Try translating anything but 'fg', 'bg', #rrggbb, and rrggbb from an
" rgb.txt color to a #rrggbb color
if val !~? '^[fb]g$' && val !~ '^#\=\x\{6}$'
try
" First see if it is in our preset-by-vim rgb list
let val = s:rgb_presets[tolower(val)]
catch
" Then try loading and checking our real rgb list
if empty(s:rgb)
call s:UpdateRgbHash()
endif
try
let val = s:rgb[tolower(val)]
catch
" And then barf if we still haven't found it
if &verbose
echomsg "CSApprox: Colorscheme uses unknown color \"" . val . "\""
endif
continue
endtry
endtry
endif
if val =~? '^[fb]g$'
exe 'hi ' . hl.name . ' cterm' . which . '=' . val
let hl.cterm[which] = val
elseif val =~ '^#\=\x\{6}$'
let val = substitute(val, '^#', '', '')
let r = str2nr(val[0:1], 16)
let g = str2nr(val[2:3], 16)
let b = str2nr(val[4:5], 16)
let hl.cterm[which] = g:CSApprox_approximator_function(r, g, b)
exe 'hi ' . hl.name . ' cterm' . which . '=' . hl.cterm[which]
else
throw "Internal error handling color: " . val
endif
endfor
" Finally, set the attributes
let attrs = s:PossibleAttributes()
call filter(attrs, 'hl.cterm[v:val] == 1')
if !empty(attrs)
exe 'hi ' . hl.name . ' cterm=' . join(attrs, ',')
endif
endfunction
" {>1} Top-level control
" Cache the highlight ID of the normal group; it's used often and won't change
let s:hlid_normal = hlID('Normal')
" {>2} Builtin cterm color names above 15
" Vim defines some color name to high color mappings internally (see
" syntax.c:do_highlight). Since we don't want to overwrite a colorscheme that
" was actually written for a high color terminal with our choices, but have no
" way to tell if a colorscheme was written for a high color terminal, we fall
" back on guessing. If any highlight group has a cterm color set to 16 or
" higher, we assume that the user has used a high color colorscheme - unless
" that color is one of the below, which vim can set internally when a color is
" requested by name.
let s:presets_88 = []
let s:presets_88 += [32] " Brown
let s:presets_88 += [72] " DarkYellow
let s:presets_88 += [84] " Gray
let s:presets_88 += [84] " Grey
let s:presets_88 += [82] " DarkGray
let s:presets_88 += [82] " DarkGrey
let s:presets_88 += [43] " LightBlue
let s:presets_88 += [61] " LightGreen
let s:presets_88 += [63] " LightCyan
let s:presets_88 += [74] " LightRed
let s:presets_88 += [75] " LightMagenta
let s:presets_88 += [78] " LightYellow
let s:presets_256 = []
let s:presets_256 += [130] " Brown
let s:presets_256 += [130] " DarkYellow
let s:presets_256 += [248] " Gray
let s:presets_256 += [248] " Grey
let s:presets_256 += [242] " DarkGray
let s:presets_256 += [242] " DarkGrey
let s:presets_256 += [ 81] " LightBlue
let s:presets_256 += [121] " LightGreen
let s:presets_256 += [159] " LightCyan
let s:presets_256 += [224] " LightRed
let s:presets_256 += [225] " LightMagenta
let s:presets_256 += [229] " LightYellow
" {>2} Wrapper around :exe to allow :executing multiple commands.
" "cmd" is the command to be :executed.
" If the variable is a String, it is :executed.
" If the variable is a List, each element is :executed.
function! s:exe(cmd)
if type(a:cmd) == type('')
exe a:cmd
else
for cmd in a:cmd
call s:exe(cmd)
endfor
endif
endfunction
" {>2} Function to handle hooks
" Prototype: HandleHooks(type [, scheme])
" "type" is the type of hook to be executed, ie. "pre" or "post"
" "scheme" is the name of the colorscheme that is currently active, if known
"
" If the variables g:CSApprox_hook_{type} and g:CSApprox_hook_{scheme}_{type}
" exist, this will :execute them in that order. If one does not exist, it
" will silently be ignored.
"
" If the scheme name contains characters that are invalid in a variable name,
" they will simply be removed. Ie, g:colors_name = "123 foo_bar-baz456"
" becomes "foo_barbaz456"
"
" NOTE: Exceptions will be printed out, rather than end processing early. The
" rationale is that it is worse for the user to fix the hook in an editor with
" broken colors. :)
function! s:HandleHooks(type, ...)
let type = a:type
let scheme = (a:0 == 1 ? a:1 : "")
let scheme = substitute(scheme, '[^[:alnum:]_]', '', 'g')
let scheme = substitute(scheme, '^\d\+', '', '')
for cmd in [ 'g:CSApprox_hook_' . type,
\ 'g:CSApprox_' . scheme . '_hook_' . type,
\ 'g:CSApprox_hook_' . scheme . '_' . type ]
if exists(cmd)
try
call s:exe(eval(cmd))
catch
echomsg "Error processing " . cmd . ":"
echomsg v:exception
endtry
endif
endfor
endfunction
" {>2} Main function
" Wrapper around the actual implementation to make it easier to ensure that
" all temporary settings are restored by the time we return, whether or not
" something was thrown. Additionally, sets the 'verbose' option to the max of
" g:CSApprox_verbose_level (default 1) and &verbose for the duration of the
" main function. This allows us to default to a message whenever any error,
" even a recoverable one, occurs, meaning the user quickly finds out when
" something's wrong, but makes it very easy for the user to make us silent.
function! s:CSApprox(...)
try
if a:0 == 1 && a:1
if !exists('s:inhibit_hicolor_test')
let s:inhibit_hicolor_test = 0
endif
let s:inhibit_hicolor_test += 1
endif
let savelz = &lz
set lz
if exists("g:CSApprox_attr_map") && type(g:CSApprox_attr_map) == type({})
call s:NormalizeAttrMap(g:CSApprox_attr_map)
else
let g:CSApprox_attr_map = { 'italic' : 'underline', 'sp' : 'fg' }
endif
" colors_name must be unset and reset, or vim will helpfully reload the
" colorscheme when we set the background for the Normal group.
" See the help entries ':hi-normal-cterm' and 'g:colors_name'
if exists("g:colors_name")
let colors_name = g:colors_name
unlet g:colors_name
endif
" Similarly, the global variable "syntax_cmd" must be set to something vim
" doesn't recognize, lest vim helpfully switch all colors back to the
" default whenever the Normal group is changed (in syncolor.vim)...
if exists("g:syntax_cmd")
let syntax_cmd = g:syntax_cmd
endif
let g:syntax_cmd = "PLEASE DON'T CHANGE ANY COLORS!!!"
" Set up our verbosity level, if needed.
" Default to 1, so the user can know if something's wrong.
if !exists("g:CSApprox_verbose_level")
let g:CSApprox_verbose_level = 1
endif
call s:HandleHooks("pre", (exists("colors_name") ? colors_name : ""))
let old_bg = &bg
" Set 'verbose' set to the maximum of &verbose and CSApprox_verbose_level
exe max([&vbs, g:CSApprox_verbose_level]) 'verbose call s:CSApproxImpl()'
let &bg = old_bg
call s:HandleHooks("post", (exists("colors_name") ? colors_name : ""))
finally
if exists("colors_name")
let g:colors_name = colors_name
endif
unlet g:syntax_cmd
if exists("syntax_cmd")
let g:syntax_cmd = syntax_cmd
endif
let &lz = savelz
if a:0 == 1 && a:1
let s:inhibit_hicolor_test -= 1
if s:inhibit_hicolor_test == 0
unlet s:inhibit_hicolor_test
endif
endif
endtry
endfunction
" {>2} CSApprox implementation
" Verifies that the user has not started the gui, and that vim recognizes his
" terminal as having enough colors for us to go on, then gathers the existing
" highlights and sets the cterm colors to match the gui colors for all those
" highlights (unless the colorscheme was already high-color).
function! s:CSApproxImpl()
" Return if not running in an 88/256 color terminal
if &t_Co != 256 && &t_Co != 88
if &verbose && &t_Co != ''
echomsg "CSApprox skipped; terminal only has" &t_Co "colors, not 88/256"
echomsg "Try checking :help csapprox-terminal for workarounds"
endif
return
endif
" Get the current highlight colors
let highlights = s:Highlights(["gui"])
let hinums = keys(highlights)
" Make sure that the script is not already 256 color by checking to make
" sure that no groups are set to a value above 256, unless the color they're
" set to can be set internally by vim (gotten by scraping
" color_numbers_{88,256} in syntax.c:do_highlight)
"
" XXX: s:inhibit_hicolor_test allows this test to be skipped for snapshots
if !exists("s:inhibit_hicolor_test") || !s:inhibit_hicolor_test
for hlid in hinums
for type in [ 'bg', 'fg' ]
let color = synIDattr(hlid, type, 'cterm')
if color > 15 && index(s:presets_{&t_Co}, str2nr(color)) < 0
" The value is set above 15, and wasn't set by vim.
if &verbose >= 2
echomsg 'CSApprox: Exiting - high' type 'color found for' highlights[hlid].name
endif
return
endif
endfor
endfor
endif
call s:FixupGuiInfo(highlights)
call s:FixupCtermInfo(highlights)
" We need to set the Normal group first so 'bg' and 'fg' work as colors
call insert(hinums, remove(hinums, index(hinums, string(s:hlid_normal))))
" then set each color's cterm attributes to match gui
for hlid in hinums
call s:SetCtermFromGui(highlights[hlid])
endfor
endfunction
" {>2} Write out the current colors to an 88/256 color colorscheme file.
" "file" - destination filename
" "overwrite" - overwrite an existing file
function! s:CSApproxSnapshot(file, overwrite)
let force = a:overwrite
let file = fnamemodify(a:file, ":p")
if empty(file)
throw "Bad file name: \"" . file . "\""
elseif (filewritable(fnamemodify(file, ':h')) != 2)
throw "Cannot write to directory \"" . fnamemodify(file, ':h') . "\""
elseif (glob(file) || filereadable(file)) && !force
" TODO - respect 'confirm' here and prompt if it's set.
echohl ErrorMsg
echomsg "E13: File exists (add ! to override)"
echohl None
return
endif
" Sigh... This is basically a bug, but one that I have no chance of fixing.
" Vim decides that Pmenu should be highlighted in 'LightMagenta' in terminal
" vim and as 'Magenta' in gvim... And I can't ask it what color it actually
" *wants*. As far as I can see, there's no way for me to learn that
" I should output 'Magenta' when 'LightMagenta' is provided by vim for the
" terminal.
if !has('gui_running')
echohl WarningMsg
echomsg "Warning: The written colorscheme may have incorrect colors"
echomsg " when CSApproxSnapshot is used in terminal vim!"
echohl None
endif
let save_t_Co = &t_Co
let s:inhibit_hicolor_test = 1
if exists("g:CSApprox_konsole")
let save_CSApprox_konsole = g:CSApprox_konsole
endif
if exists("g:CSApprox_eterm")
let save_CSApprox_eterm = g:CSApprox_eterm
endif
" Needed just like in CSApprox()
if exists("g:colors_name")
let colors_name = g:colors_name
unlet g:colors_name
endif
" Needed just like in CSApprox()
if exists("g:syntax_cmd")
let syntax_cmd = g:syntax_cmd
endif
let g:syntax_cmd = "PLEASE DON'T CHANGE ANY COLORS!!!"
try
let lines = []
let lines += [ '" This scheme was created by CSApproxSnapshot' ]
let lines += [ '" on ' . strftime("%a, %d %b %Y") ]
let lines += [ '' ]
let lines += [ 'hi clear' ]
let lines += [ 'if exists("syntax_on")' ]
let lines += [ ' syntax reset' ]
let lines += [ 'endif' ]
let lines += [ '' ]
let lines += [ 'if v:version < 700' ]
let lines += [ ' let g:colors_name = expand("<sfile>:t:r")' ]
let lines += [ ' command! -nargs=+ CSAHi exe "hi" substitute(substitute(<q-args>, "undercurl", "underline", "g"), "guisp\\S\\+", "", "g")' ]
let lines += [ 'else' ]
let lines += [ ' let g:colors_name = expand("<sfile>:t:r")' ]
let lines += [ ' command! -nargs=+ CSAHi exe "hi" <q-args>' ]
let lines += [ 'endif' ]
let lines += [ '' ]
let lines += [ 'function! s:old_kde()' ]
let lines += [ ' " Konsole only used its own palette up til KDE 4.2.0' ]
let lines += [ " if executable('kde4-config') && system('kde4-config --kde-version') =~ '^4\.[10]\.'" ]
let lines += [ ' return 1' ]
let lines += [ " elseif executable('kde-config') && system('kde-config --version') =~# 'KDE: 3\.'" ]
let lines += [ ' return 1' ]
let lines += [ ' else' ]
let lines += [ ' return 0' ]
let lines += [ ' endif' ]
let lines += [ 'endfunction' ]
let lines += [ '' ]
let lines += [ 'if 0' ]
for round in [ 'konsole', 'eterm', 'xterm', 'urxvt' ]
sil! unlet g:CSApprox_eterm
sil! unlet g:CSApprox_konsole
if round == 'konsole'
let g:CSApprox_konsole = 1
elseif round == 'eterm'
let g:CSApprox_eterm = 1
endif
if round == 'urxvt'
set t_Co=88
else
set t_Co=256
endif
call s:CSApprox()
let highlights = s:Highlights(["term", "cterm", "gui"])
call s:FixupGuiInfo(highlights)
if round == 'konsole' || round == 'eterm'
if round == 'konsole'
let term_matches_round = '(&term =~? "^konsole" && s:old_kde())'
else
let term_matches_round = '&term =~? "^' . round . '"'
endif
let lines += [ 'elseif has("gui_running") || (&t_Co == ' . &t_Co
\ . ' && (&term ==# "xterm" || &term =~# "^screen")'
\ . ' && exists("g:CSApprox_' . round . '")'
\ . ' && g:CSApprox_' . round . ')'
\ . ' || ' . term_matches_round ]
else
let lines += [ 'elseif has("gui_running") || &t_Co == ' . &t_Co ]
endif
let hinums = keys(highlights)
call insert(hinums, remove(hinums, index(hinums, string(s:hlid_normal))))
for hlnum in hinums
let hl = highlights[hlnum]
let line = ' CSAHi ' . hl.name
for type in [ 'term', 'cterm', 'gui' ]
let attrs = s:PossibleAttributes()
call filter(attrs, 'hl[type][v:val] == 1')
let line .= ' ' . type . '=' . (empty(attrs) ? 'NONE' : join(attrs, ','))
if type != 'term'
let line .= ' ' . type . 'bg=' . (len(hl[type].bg) ? hl[type].bg : 'bg')
let line .= ' ' . type . 'fg=' . (len(hl[type].fg) ? hl[type].fg : 'fg')
if type == 'gui' && hl.gui.sp !~ '^\s*$'
let line .= ' ' . type . 'sp=' . hl[type].sp
endif
endif
endfor
let lines += [ line ]
endfor
endfor
let lines += [ 'endif' ]
let lines += [ '' ]
let lines += [ 'if 1' ]
let lines += [ ' delcommand CSAHi' ]
let lines += [ 'endif' ]
call writefile(lines, file)
finally
let &t_Co = save_t_Co
if exists("save_CSApprox_konsole")
let g:CSApprox_konsole = save_CSApprox_konsole
endif
if exists("save_CSApprox_eterm")
let g:CSApprox_eterm = save_CSApprox_eterm
endif
if exists("colors_name")
let g:colors_name = colors_name
endif
unlet g:syntax_cmd
if exists("syntax_cmd")
let g:syntax_cmd = syntax_cmd
endif
call s:CSApprox()
unlet s:inhibit_hicolor_test
endtry
endfunction
" {>2} Snapshot user command
command! -bang -nargs=1 -complete=file -bar CSApproxSnapshot
\ call s:CSApproxSnapshot(<f-args>, strlen("<bang>"))
" {>2} Manual updates
command -bang -bar CSApprox call s:CSApprox(strlen("<bang>"))
" {>1} Autocmds
" Set up an autogroup to hook us on the completion of any :colorscheme command
augroup CSApprox
au!
au ColorScheme * call s:CSApprox()
"au User CSApproxPost highlight Normal ctermbg=none | highlight NonText ctermbg=None
augroup END
" {>1} Restore compatibility options
let &cpo = s:savecpo
unlet s:savecpo
" {0} vim:sw=2:sts=2:et:fdm=expr:fde=substitute(matchstr(getline(v\:lnum),'^\\s*"\\s*{\\zs.\\{-}\\ze}'),'^$','=','')
================================================
FILE: .vim/bundle/Gist.vim/README
================================================
This is a mirror of http://www.vim.org/scripts/script.php?script_id=2423
This is vimscript for gist (http://gist.github.com)
Usage:
:Gist
post whole text to gist.
:'<,'>Gist
post selected text to gist.
:Gist -p
post whole text to gist with private.
if you got empty gist list, try :Gist --abandon
:Gist -a
post whole text to gist with anonymous.
:Gist -m
post multi buffer to gist.
:Gist -e
edit the gist. (shoud be work on gist buffer)
you can update the gist with :w command on gist buffer.
:Gist -e foo.js
edit the gist with name 'foo.js'. (shoud be work on gist buffer)
:Gist -d
delete the gist. (should be work on gist buffer)
password authentication is needed.
:Gist -f
fork the gist. (should be work on gist buffer)
password authentication is needed.
:Gist XXXXX
get gist XXXXX.
:Gist -c XXXXX.
get gist XXXXX and put to clipboard.
:Gist -l
list gists from mine.
:Gist -la
list gists from all.
Tips:
if set g:gist_clip_command, gist.vim will copy the gist code
with option '-c'.
# mac
let g:gist_clip_command = 'pbcopy'
# linux
let g:gist_clip_command = 'xclip -selection clipboard'
# others(cygwin?)
let g:gist_clip_command = 'putclip'
if you want to detect filetype from filename...
let g:gist_detect_filetype = 1
if you want to open browser after the post...
let g:gist_open_browser_after_post = 1
if you want to change the browser...
let g:gist_browser_command = 'w3m %URL%'
or
let g:gist_browser_command = 'opera %URL% &'
on windows, should work with original setting.
Require:
curl command (http://curl.haxx.se/)
and if you want to use profile of git, it require git command.
================================================
FILE: .vim/bundle/Gist.vim/README.mkd
================================================
### Gist.vim
This is a vimscript for creating gists (http://gist.github.com).
For the latest version please see https://github.com/mattn/gist-vim.
## Usage:
- Post current buffer to gist, using default privacy option.
:Gist
- Post selected text to gist, using default privacy option.
This applies to all permutations listed below (except multi).
:'<,'>Gist
- Create a private gist.
:Gist -p
- Create a public gist.
(Only relevant if you've set gists to be private by default.)
:Gist -P
> This is only relevant if you've set gists to be private by default;
> if you get an empty gist list, try ":Gist --abandon".
- Create a gist anonymously.
:Gist -a
- Create a gist with all open buffers.
:Gist -m
- Edit the gist (you need to have opened the gist buffer first).
You can update the gist with the ":w" command within the gist buffer.
:Gist -e
- Edit the gist with name 'foo.js' (you need to have opened the gist buffer
first).
:Gist -e foo.js
- Post/Edit with the description " (you need to have opened the gist buffer
first). >
:Gist -s something
:Gist -e -s something
- Delete the gist (you need to have opened the gist buffer first).
Password authentication is needed.
:Gist -d
- Fork the gist (you need to have opened the gist buffer first).
Password authentication is needed.
:Gist -f
- Star the gist (you need to have opened the gist buffer first).
Password authentication is needed.
:Gist +1
- Unstar the gist (you need to have opened the gist buffer first).
Password authentication is needed.
:Gist -1
- Get gist XXXXX.
:Gist XXXXX
- Get gist XXXXX and add to clipboard.
:Gist -c XXXXX
- List your public gists.
:Gist -l
- List gists from user "mattn".
:Gist -l mattn
- List everyone's gists.
:Gist -la
- List gists from your starred gists.
:Gist -ls
## Tips:
If you set g:gist_clip_command, gist.vim will copy the gist code with option
'-c'.
- Mac:
let g:gist_clip_command = 'pbcopy'
- Linux:
let g:gist_clip_command = 'xclip -selection clipboard'
- Others (cygwin?):
let g:gist_clip_command = 'putclip'
If you want to detect filetype from the filename:
let g:gist_detect_filetype = 1
If you want to open browser after the post:
let g:gist_open_browser_after_post = 1
If you want to change the browser:
let g:gist_browser_command = 'w3m %URL%'
or:
let g:gist_browser_command = 'opera %URL% &'
On windows, this should work with your user settings.
If you want to show your private gists with ":Gist -l":
let g:gist_show_privates = 1
If you want your gist to be private by default:
let g:gist_post_private = 1
If you want to manipulate multiple files in a gist:
let g:gist_get_multiplefile = 1
You need to either set global git config:
$ git config --global github.user Username
## Requirements:
- curl command (http://curl.haxx.se/)
- webapi-vim (https://github.com/mattn/webapi-vim)
- and if you want to use your git profile, the git command-line client.
## License:
Copyright 2010 by Yasuhiro Matsumoto
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
OF THE POSSIBILITY OF SUCH DAMAGE.
## Install:
Copy it to your plugin directory.
gist.vim will create a curl cookie-jar file in your runtimepath.
- rtp:
- plugin/gist.vim
- cookies/github
If you want to uninstall gist.vim, remember to also remove `~/.gist-vim`.
## Setup:
This plugin uses github API v3. Setting value is stored in `~/.gist-vim`.
gist-vim have two ways to access APIs.
First, you need to set your Github username in global git config:
$ git config --global github.user Username
Then, gist.vim will ask for your password to create an authorization when you
first use it. The password is not stored and only the OAuth access token will
be kept for later use. You can revoke the token at any time from the list of
["Authorized applications" on Github's "Account Settings" page](https://github.com/settings/applications).
================================================
FILE: .vim/bundle/Gist.vim/autoload/gist.vim
================================================
"=============================================================================
" File: gist.vim
" Author: Yasuhiro Matsumoto <mattn.jp@gmail.com>
" Last Change: 27-Sep-2012.
" Version: 7.0
" WebPage: http://github.com/mattn/gist-vim
" License: BSD
let s:save_cpo = &cpo
set cpo&vim
let s:configfile = expand('~/.gist-vim')
if !exists('g:github_user')
let s:system = function(get(g:, 'webapi#system_function', 'system'))
let g:github_user = substitute(s:system('git config --get github.user'), "\n", '', '')
if strlen(g:github_user) == 0
let g:github_user = $GITHUB_USER
end
endif
function! s:get_browser_command()
let gist_browser_command = get(g:, 'gist_browser_command', '')
if gist_browser_command == ''
if has('win32') || has('win64')
let gist_browser_command = '!start rundll32 url.dll,FileProtocolHandler %URL%'
elseif has('mac') || has('macunix') || has('gui_macvim') || system('uname') =~? '^darwin'
let gist_browser_command = 'open %URL%'
elseif executable('xdg-open')
let gist_browser_command = 'xdg-open %URL%'
elseif executable('firefox')
let gist_browser_command = 'firefox %URL% &'
else
let gist_browser_command = ''
endif
endif
return gist_browser_command
endfunction
function! s:open_browser(url)
let cmd = s:get_browser_command()
if len(cmd) == 0
redraw
echohl WarningMsg
echo "It seems that you don't have general web browser. Open URL below."
echohl None
echo a:url
return
endif
if cmd =~ '^!'
let cmd = substitute(cmd, '%URL%', '\=shellescape(a:url)', 'g')
silent! exec cmd
elseif cmd =~ '^:[A-Z]'
let cmd = substitute(cmd, '%URL%', '\=a:url', 'g')
exec cmd
else
let cmd = substitute(cmd, '%URL%', '\=shellescape(a:url)', 'g')
call system(cmd)
endif
endfunction
function! s:shellwords(str)
let words = split(a:str, '\%(\([^ \t\''"]\+\)\|''\([^\'']*\)''\|"\(\%([^\"\\]\|\\.\)*\)"\)\zs\s*\ze')
let words = map(words, 'substitute(v:val, ''\\\([\\ ]\)'', ''\1'', "g")')
let words = map(words, 'matchstr(v:val, ''^\%\("\zs\(.*\)\ze"\|''''\zs\(.*\)\ze''''\|.*\)$'')')
return words
endfunction
function! s:format_gist(gist)
let files = sort(keys(a:gist.files))
if empty(files)
return ""
endif
let file = a:gist.files[files[0]]
if has_key(file, "content")
let code = file.content
let code = "\n".join(map(split(code, "\n"), '" ".v:val'), "\n")
else
let code = ""
endif
return printf("gist: %s %s%s", a:gist.id, type(a:gist.description)==0?"": a:gist.description, code)
endfunction
" Note: A colon in the file name has side effects on Windows due to NTFS Alternate Data Streams; avoid it.
let s:bufprefix = 'gist' . (has('unix') ? ':' : '_')
function! s:GistList(gistls, page)
if a:gistls == '-all'
let url = 'https://api.github.com/gists/public'
elseif get(g:, 'gist_show_privates', 0) && a:gistls == 'starred'
let url = 'https://api.github.com/gists/starred'
elseif get(g:, 'gist_show_privates') && a:gistls == 'mine'
let url = 'https://api.github.com/gists'
else
let url = 'https://api.github.com/users/'.a:gistls.'/gists'
endif
let winnum = bufwinnr(bufnr(s:bufprefix.a:gistls))
if winnum != -1
if winnum != bufwinnr('%')
exe winnum 'wincmd w'
endif
setlocal modifiable
else
exec 'silent noautocmd split' s:bufprefix.a:gistls
endif
if a:page > 1
let oldlines = getline(0, line('$'))
let url = url . '?page=' . a:page
endif
setlocal modifiable
let old_undolevels = &undolevels
let oldlines = []
silent %d _
redraw | echon 'Listing gists... '
let auth = s:GistGetAuthHeader()
if len(auth) == 0
bw!
redraw
echohl ErrorMsg | echomsg 'Canceled' | echohl None
return
endif
let res = webapi#http#get(url, '', { "Authorization": auth })
if v:shell_error != 0
bw!
redraw
echohl ErrorMsg | echomsg 'Gists not found' | echohl None
return
endif
let content = webapi#json#decode(res.content)
if type(content) == 4 && has_key(content, 'message') && len(content.message)
bw!
redraw
echohl ErrorMsg | echomsg content.message | echohl None
if content.message == 'Bad credentials'
call delete(s:configfile)
endif
return
endif
let lines = map(filter(content, '!empty(v:val.files)'), 's:format_gist(v:val)')
call setline(1, split(join(lines, "\n"), "\n"))
$put='more...'
let b:gistls = a:gistls
let b:page = a:page
setlocal buftype=nofile bufhidden=hide noswapfile
setlocal nomodified
setlocal nomodifiable
syntax match SpecialKey /^gist:/he=e-1
nnoremap <silent> <buffer> <cr> :call <SID>GistListAction(0)<cr>
nnoremap <silent> <buffer> <s-cr> :call <SID>GistListAction(1)<cr>
cal cursor(1+len(oldlines),1)
nohlsearch
redraw | echo ''
endfunction
function! gist#list(user, ...)
let page = get(a:000, 0, 0)
if a:user == '-all'
let url = 'https://api.github.com/gists/public'
elseif get(g:, 'gist_show_privates', 0) && a:user == 'starred'
let url = 'https://api.github.com/gists/starred'
elseif get(g:, 'gist_show_privates') && a:user == 'mine'
let url = 'https://api.github.com/gists'
else
let url = 'https://api.github.com/users/'.a:user.'/gists'
endif
let auth = s:GistGetAuthHeader()
if len(auth) == 0
return []
endif
let res = webapi#http#get(url, '', { "Authorization": auth })
return webapi#json#decode(res.content)
endfunction
function! s:GistGetFileName(gistid)
let auth = s:GistGetAuthHeader()
if len(auth) == 0
return ''
endif
let res = webapi#http#get('https://api.github.com/gists/'.a:gistid, '', { "Authorization": auth })
let gist = webapi#json#decode(res.content)
if has_key(gist, 'files')
return sort(keys(gist.files))[0]
endif
return ''
endfunction
function! s:GistDetectFiletype(gistid)
let auth = s:GistGetAuthHeader()
if len(auth) == 0
return ''
endif
let res = webapi#http#get('https://api.github.com/gists/'.a:gistid, '', { "Authorization": auth })
let gist = webapi#json#decode(res.content)
let filename = sort(keys(gist.files))[0]
let ext = fnamemodify(filename, ':e')
if has_key(s:extmap, ext)
let type = s:extmap[ext]
else
let type = get(gist.files[filename], "type", "text")
endif
silent! exec "setlocal ft=".tolower(type)
endfunction
function! s:GistWrite(fname)
if substitute(a:fname, '\\', '/', 'g') == expand("%:p:gs@\\@/@")
Gist -e
else
exe "w".(v:cmdbang ? "!" : "") fnameescape(v:cmdarg) fnameescape(a:fname)
silent! exe "file" fnameescape(a:fname)
silent! au! BufWriteCmd <buffer>
endif
endfunction
function! s:GistGet(gistid, clipboard)
redraw | echon 'Getting gist... '
let res = webapi#http#get('https://api.github.com/gists/'.a:gistid, '', { "Authorization": s:GistGetAuthHeader() })
let status = matchstr(matchstr(res.header, '^Status:'), '^[^:]\+: \zs.*')
if status =~ '^2'
let gist = webapi#json#decode(res.content)
if get(g:, 'gist_get_multiplefile', 0) != 0
let num_file = len(keys(gist.files))
else
let num_file = 1
endif
redraw
if num_file > len(keys(gist.files))
echohl ErrorMsg | echomsg 'Gist not found' | echohl None
return
endif
for n in range(num_file)
try
let old_undolevels = &undolevels
let filename = sort(keys(gist.files))[n]
let winnum = bufwinnr(bufnr(s:bufprefix.a:gistid."/".filename))
if winnum != -1
if winnum != bufwinnr('%')
exe winnum 'wincmd w'
endif
setlocal modifiable
else
exec 'silent noautocmd new'
setlocal noswapfile
exec 'noautocmd file' s:bufprefix.a:gistid."/".fnameescape(filename)
endif
set undolevels=-1
filetype detect
silent %d _
let content = gist.files[filename].content
call setline(1, split(content, "\n"))
let b:gist = {
\ "filename": filename,
\ "id": gist.id,
\ "description": gist.description,
\ "private": gist.public =~ 'true',
\}
catch
let &undolevels = old_undolevels
bw!
redraw
echohl ErrorMsg | echomsg 'Gist contains binary' | echohl None
return
endtry
let &undolevels = old_undolevels
setlocal buftype=acwrite bufhidden=delete noswapfile
setlocal nomodified
doau StdinReadPost,BufRead,BufReadPost
let gist_detect_filetype = get(g:, 'gist_detect_filetype', 0)
if (&ft == '' && gist_detect_filetype == 1) || gist_detect_filetype == 2
call s:GistDetectFiletype(a:gistid)
endif
if a:clipboard
if exists('g:gist_clip_command')
exec 'silent w !'.g:gist_clip_command
elseif has('clipboard')
silent! %yank +
else
%yank
endif
endif
1
au! BufWriteCmd <buffer> call s:GistWrite(expand("<amatch>"))
endfor
else
bw!
redraw
echohl ErrorMsg | echomsg 'Gist not found' | echohl None
return
endif
endfunction
function! s:GistListAction(shift)
let line = getline('.')
let mx = '^gist:\s*\zs\(\w\+\)\ze.*'
if line =~# mx
let gistid = matchstr(line, mx)
if a:shift
call s:open_browser("https://gist.github.com/" . gistid)
else
call s:GistGet(gistid, 0)
endif
return
endif
if line =~# '^more\.\.\.$'
call s:GistList(b:gistls, b:page+1)
return
endif
endfunction
function! s:GistUpdate(content, gistid, gistnm, desc)
let gist = { "id": a:gistid, "files" : {}, "description": "","public": function('webapi#json#true') }
if exists('b:gist')
if has_key(b:gist, 'private') && b:gist.private | let gist["public"] = function('webapi#json#false') | endif
if has_key(b:gist, 'description') | let gist["description"] = b:gist.description | endif
if has_key(b:gist, 'filename') | let filename = b:gist.filename | endif
else
let filename = a:gistnm
if len(filename) == 0 | let filename = s:GistGetFileName(a:gistid) | endif
if len(filename) == 0 | let filename = s:get_current_filename(1) | endif
endif
let auth = s:GistGetAuthHeader()
if len(auth) == 0
redraw
echohl ErrorMsg | echomsg 'Canceled' | echohl None
return
endif
" Update description
" If no new description specified, keep the old description
if a:desc != ' '
let gist["description"] = a:desc
else
let res = webapi#http#get('https://api.github.com/gists/'.a:gistid, '', { "Authorization": auth })
let status = matchstr(matchstr(res.header, '^Status:'), '^[^:]\+: \zs.*')
if status =~ '^2'
let old_gist = webapi#json#decode(res.content)
let gist["description"] = old_gist.description
endif
endif
let gist.files[filename] = { "content": a:content, "filename": filename }
redraw | echon 'Updating gist... '
let res = webapi#http#post('https://api.github.com/gists/' . a:gistid,
\ webapi#json#encode(gist), {
\ "Authorization": auth,
\ "Content-Type": "application/json",
\})
let status = matchstr(matchstr(res.header, '^Status:'), '^[^:]\+: \zs.*')
if status =~ '^2'
let obj = webapi#json#decode(res.content)
let loc = obj["html_url"]
redraw | echomsg 'Done: '.loc
let b:gist = {"id": a:gistid, "filename": filename}
setlocal nomodified
else
let loc = ''
let status = matchstr(status, '^\d\+\s*\zs.*')
echohl ErrorMsg | echomsg 'Post failed: '.status | echohl None
endif
return loc
endfunction
function! s:GistDelete(gistid)
let auth = s:GistGetAuthHeader()
if len(auth) == 0
redraw
echohl ErrorMsg | echomsg 'Canceled' | echohl None
return
endif
redraw | echon 'Deleting gist... '
let res = webapi#http#post('https://api.github.com/gists/'.a:gistid, '', {
\ "Authorization": auth,
\ "Content-Type": "application/json",
\}, 'DELETE')
let status = matchstr(matchstr(res.header, '^Status:'), '^[^:]\+: \zs.*')
if status =~ '^2'
redraw | echomsg 'Done: '
if exists('b:gist')
unlet b:gist
endif
else
let status = matchstr(status, '^\d\+\s*\zs.*')
echohl ErrorMsg | echomsg 'Delete failed: '.status | echohl None
endif
endfunction
function! s:get_current_filename(no)
let filename = expand('%:t')
if len(filename) == 0 && &ft != ''
let pair = filter(items(s:extmap), 'v:val[1] == &ft')
if len(pair) > 0
let filename = printf('gistfile%d%s', a:no, pair[0][0])
endif
endif
if filename == ''
let filename = printf('gistfile%d.txt', a:no)
endif
return filename
endfunction
" GistPost function:
" Post new gist to github
"
" if there is an embedded gist url or gist id in your file,
" it will just update it.
" -- by c9s
"
" embedded gist url format:
"
" Gist: https://gist.github.com/123123
"
" embedded gist id format:
"
" GistID: 123123
"
function! s:GistPost(content, private, desc, anonymous)
let gist = { "files" : {}, "description": "","public": function('webapi#json#true') }
if a:desc != ' ' | let gist["description"] = a:desc | endif
if a:private | let gist["public"] = function('webapi#json#false') | endif
let filename = s:get_current_filename(1)
let gist.files[filename] = { "content": a:content, "filename": filename }
let header = {"Content-Type": "application/json"}
if !a:anonymous
let auth = s:GistGetAuthHeader()
if len(auth) == 0
redraw
echohl ErrorMsg | echomsg 'Canceled' | echohl None
return
endif
let header["Authorization"] = auth
endif
redraw | echon 'Posting it to gist... '
let res = webapi#http#post('https://api.github.com/gists', webapi#json#encode(gist), header)
let status = matchstr(matchstr(res.header, '^Status:'), '^[^:]\+: \zs.*')
if status =~ '^2'
let obj = webapi#json#decode(res.content)
let loc = obj["html_url"]
redraw | echomsg 'Done: '.loc
let b:gist = {
\ "filename": filename,
\ "id": matchstr(loc, '[^/]\+$'),
\ "description": gist['description'],
\ "private": a:private,
\}
else
let loc = ''
let status = matchstr(status, '^\d\+\s*\zs.*')
echohl ErrorMsg | echomsg 'Post failed: '.status | echohl None
endif
return loc
endfunction
function! s:GistPostBuffers(private, desc, anonymous)
let bufnrs = range(1, bufnr("$"))
let bn = bufnr('%')
let query = []
let gist = { "files" : {}, "description": "","public": function('webapi#json#true') }
if a:desc != ' ' | let gist["description"] = a:desc | endif
if a:private | let gist["public"] = function('webapi#json#false') | endif
let index = 1
for bufnr in bufnrs
if !bufexists(bufnr) || buflisted(bufnr) == 0
continue
endif
echo "Creating gist content".index."... "
silent! exec "buffer!" bufnr
let content = join(getline(1, line('$')), "\n")
let filename = s:get_current_filename(index)
let gist.files[filename] = { "content": content, "filename": filename }
let index = index + 1
endfor
silent! exec "buffer!" bn
let header = {"Content-Type": "application/json"}
if !a:anonymous
let auth = s:GistGetAuthHeader()
if len(auth) == 0
redraw
echohl ErrorMsg | echomsg 'Canceled' | echohl None
return
endif
let header["Authorization"] = auth
endif
redraw | echon 'Posting it to gist... '
let res = webapi#http#post('https://api.github.com/gists', webapi#json#encode(gist), header)
let status = matchstr(matchstr(res.header, '^Status:'), '^[^:]\+: \zs.*')
if status =~ '^2'
let obj = webapi#json#decode(res.content)
let loc = obj["html_url"]
redraw | echomsg 'Done: '.loc
let b:gist = {"id": matchstr(loc, '[^/]\+$'), "filename": filename, "private": a:private}
else
let loc = ''
let status = matchstr(status, '^\d\+\s*\zs.*')
echohl ErrorMsg | echomsg 'Post failed: '.status | echohl None
endif
return loc
endfunction
function! gist#Gist(count, line1, line2, ...)
redraw
if strlen(g:github_user) == 0
echohl ErrorMsg | echomsg "You don't have github account. read ':help gist-vim-setup'." | echohl None
return
endif
let bufname = bufname("%")
" find GistID: in content , then we should just update
let gistid = ''
let gistls = ''
let gistnm = ''
let gistdesc = ' '
let private = get(g:, 'gist_post_private', 0)
let multibuffer = 0
let clipboard = 0
let deletepost = 0
let editpost = 0
let anonymous = 0
let listmx = '^\%(-l\|--list\)\s*\([^\s]\+\)\?$'
let bufnamemx = '^' . s:bufprefix .'\(\zs[0-9a-f]\+\ze\|\zs[0-9a-f]\+\ze[/\\].*\)$'
if bufname =~ bufnamemx
let gistidbuf = matchstr(bufname, bufnamemx)
else
let gistidbuf = matchstr(join(getline(a:line1, a:line2), "\n"), 'GistID:\s*\zs\w\+')
endif
let args = (a:0 > 0) ? s:shellwords(a:1) : []
for arg in args
if arg =~ '^\(-h\|--help\)$\C'
help :Gist
return
elseif arg =~ '^\(-la\|--listall\)$\C'
let gistls = '-all'
elseif arg =~ '^\(-ls\|--liststar\)$\C'
let gistls = 'starred'
elseif arg =~ '^\(-l\|--list\)$\C'
if get(g:, 'gist_show_privates')
let gistls = 'mine'
else
let gistls = g:github_user
endif
elseif arg =~ '^\(-m\|--multibuffer\)$\C'
let multibuffer = 1
elseif arg =~ '^\(-p\|--private\)$\C'
let private = 1
elseif arg =~ '^\(-P\|--public\)$\C'
let private = 0
elseif arg =~ '^\(-a\|--anonymous\)$\C'
let anonymous = 1
elseif arg =~ '^\(-s\|--description\)$\C'
let gistdesc = ''
elseif arg =~ '^\(-c\|--clipboard\)$\C'
let clipboard = 1
elseif arg =~ '^\(-d\|--delete\)$\C' && gistidbuf != ''
let gistid = gistidbuf
let deletepost = 1
elseif arg =~ '^\(-e\|--edit\)$\C' && gistidbuf != ''
let gistid = gistidbuf
let editpost = 1
elseif arg =~ '^\(+1\|--star\)$\C' && gistidbuf != ''
let auth = s:GistGetAuthHeader()
if len(auth) == 0
echohl ErrorMsg | echomsg 'Canceled' | echohl None
else
let gistid = gistidbuf
let res = webapi#http#post('https://api.github.com/gists/'.gistid.'/star', '', { "Authorization": auth }, 'PUT')
let status = matchstr(matchstr(res.header, '^Status:'), '^[^:]\+: \zs.*')
if status =~ '^2'
echomsg "Stared" gistid
else
echohl ErrorMsg | echomsg 'Star failed' | echohl None
endif
endif
return
elseif arg =~ '^\(-1\|--unstar\)$\C' && gistidbuf != ''
let auth = s:GistGetAuthHeader()
if len(auth) == 0
echohl ErrorMsg | echomsg 'Canceled' | echohl None
else
let gistid = gistidbuf
let res = webapi#http#post('https://api.github.com/gists/'.gistid.'/star', '', { "Authorization": auth }, 'DELETE')
if status =~ '^2'
echomsg "Unstared" gistid
else
echohl ErrorMsg | echomsg 'Unstar failed' | echohl None
endif
endif
return
elseif arg =~ '^\(-f\|--fork\)$\C' && gistidbuf != ''
let auth = s:GistGetAuthHeader()
if len(auth) == 0
echohl ErrorMsg | echomsg 'Canceled' | echohl None
return
else
let gistid = gistidbuf
let res = webapi#http#post('https://api.github.com/gists/'.gistid.'/fork', '', { "Authorization": auth })
let status = matchstr(matchstr(res.header, '^Status:'), '^[^:]\+: \zs.*')
if status =~ '^2'
let obj = webapi#json#decode(res.content)
let gistid = obj["id"]
else
echohl ErrorMsg | echomsg 'Fork failed' | echohl None
return
endif
endif
elseif arg !~ '^-' && len(gistnm) == 0
if gistdesc != ' '
let gistdesc = matchstr(arg, '^\s*\zs.*\ze\s*$')
elseif editpost == 1 || deletepost == 1
let gistnm = arg
elseif len(gistls) > 0 && arg != '^\w\+$\C'
let gistls = arg
elseif arg =~ '^[0-9a-z]\+$\C'
let gistid = arg
else
echohl ErrorMsg | echomsg 'Invalid arguments: '.arg | echohl None
unlet args
return 0
endif
elseif len(arg) > 0
echohl ErrorMsg | echomsg 'Invalid arguments: '.arg | echohl None
unlet args
return 0
endif
endfor
unlet args
"echo "gistid=".gistid
"echo "gistls=".gistls
"echo "gistnm=".gistnm
"echo "gistdesc=".gistdesc
"echo "private=".private
"echo "clipboard=".clipboard
"echo "editpost=".editpost
"echo "deletepost=".deletepost
if gistidbuf != '' && gistid == '' && editpost == 0 && deletepost == 0
let editpost = 1
let gistid = gistidbuf
endif
if len(gistls) > 0
call s:GistList(gistls, 1)
elseif len(gistid) > 0 && editpost == 0 && deletepost == 0
call s:GistGet(gistid, clipboard)
else
let url = ''
if multibuffer == 1
let url = s:GistPostBuffers(private, gistdesc, anonymous)
else
if a:count < 1
let content = join(getline(a:line1, a:line2), "\n")
else
let save_regcont = @"
let save_regtype = getregtype('"')
silent! normal! gvy
let content = @"
call setreg('"', save_regcont, save_regtype)
endif
if editpost == 1
let url = s:GistUpdate(content, gistid, gistnm, gistdesc)
elseif deletepost == 1
call s:GistDelete(gistid)
else
let url = s:GistPost(content, private, gistdesc, anonymous)
endif
if a:count >= 1 && get(g:, 'gist_keep_selection', 0) == 1
silent! normal! gv
endif
endif
if len(url) > 0
if get(g:, 'gist_open_browser_after_post', 0) == 1
call s:open_browser(url)
endif
let gist_put_url_to_clipboard_after_post = get(g:, 'gist_put_url_to_clipboard_after_post', 1)
if gist_put_url_to_clipboard_after_post > 0
if gist_put_url_to_clipboard_after_post == 2
let url = url . "\n"
endif
if exists('g:gist_clip_command')
call system(g:gist_clip_command, url)
elseif has('unix') && !has('xterm_clipboard')
let @" = url
else
let @+ = url
endif
endif
endif
endif
return 1
endfunction
function! s:GistGetAuthHeader()
if get(g:, 'gist_use_password_in_gitconfig', 0) != 0
let password = substitute(system('git config --get github.password'), "\n", '', '')
if password =~ '^!' | let password = system(password[1:]) | endif
return printf("basic %s", webapi#base64#b64encode(g:github_user.":".password))
endif
let auth = ""
if filereadable(s:configfile)
let str = join(readfile(s:configfile), "")
if type(str) == 1
let auth = str
endif
endif
if len(auth) > 0
return auth
endif
redraw
echohl WarningMsg
echo 'Gist.vim requires authorization to use the Github API. These settings are stored in "~/.gist-vim". If you want to revoke, do "rm ~/.gist-vim".'
echohl None
let password = inputsecret("Github Password for ".g:github_user.":")
if len(password) > 0
let insecureSecret = printf("basic %s", webapi#base64#b64encode(g:github_user.":".password))
let res = webapi#http#post('https://api.github.com/authorizations', webapi#json#encode({
\ "scopes" : ["gist"],
\ "note" : "Gist.vim on ".hostname(),
\ "note_url" : "http://www.vim.org/scripts/script.php?script_id=2423"
\}), {
\ "Content-Type" : "application/json",
\ "Authorization" : insecureSecret,
\})
let authorization = webapi#json#decode(res.content)
if has_key(authorization, 'token')
let secret = printf("token %s", authorization.token)
call writefile([secret], s:configfile)
if !(has('win32') || has('win64'))
call system("chmod go= ".s:configfile)
endif
elseif has_key(authorization, 'message')
echohl WarningMsg
echo authorization.message
echohl None
let secret = ''
endif
else
let secret = ''
endif
return secret
endfunction
let s:extmap = {
\".adb": "ada",
\".ahk": "ahk",
\".arc": "arc",
\".as": "actionscript",
\".asm": "asm",
\".asp": "asp",
\".aw": "php",
\".b": "b",
\".bat": "bat",
\".befunge": "befunge",
\".bmx": "bmx",
\".boo": "boo",
\".c-objdump": "c-objdump",
\".c": "c",
\".cfg": "cfg",
\".cfm": "cfm",
\".ck": "ck",
\".cl": "cl",
\".clj": "clj",
\".cmake": "cmake",
\".coffee": "coffee",
\".cpp": "cpp",
\".cppobjdump": "cppobjdump",
\".cs": "csharp",
\".css": "css",
\".cw": "cw",
\".d-objdump": "d-objdump",
\".d": "d",
\".darcspatch": "darcspatch",
\".diff": "diff",
\".duby": "duby",
\".dylan": "dylan",
\".e": "e",
\".ebuild": "ebuild",
\".eclass": "eclass",
\".el": "lisp",
\".erb": "erb",
\".erl": "erlang",
\".f90": "f90",
\".factor": "factor",
\".feature": "feature",
\".fs": "fs",
\".fy": "fy",
\".go": "go",
\".groovy": "groovy",
\".gs": "gs",
\".gsp": "gsp",
\".haml": "haml",
\".hs": "haskell",
\".html": "html",
\".hx": "hx",
\".ik": "ik",
\".ino": "ino",
\".io": "io",
\".j": "j",
\".java": "java",
\".js": "javascript",
\".json": "json",
\".jsp": "jsp",
\".kid": "kid",
\".lhs": "lhs",
\".lisp": "lisp",
\".ll": "ll",
\".lua": "lua",
\".ly": "ly",
\".m": "objc",
\".mak": "mak",
\".man": "man",
\".mao": "mao",
\".matlab": "matlab",
\".md": "markdown",
\".minid": "minid",
\".ml": "ml",
\".moo": "moo",
\".mu": "mu",
\".mustache": "mustache",
\".mxt": "mxt",
\".myt": "myt",
\".n": "n",
\".nim": "nim",
\".nu": "nu",
\".numpy": "numpy",
\".objdump": "objdump",
\".ooc": "ooc",
\".parrot": "parrot",
\".pas": "pas",
\".pasm": "pasm",
\".pd": "pd",
\".phtml": "phtml",
\".pir": "pir",
\".pl": "perl",
\".po": "po",
\".py": "python",
\".pytb": "pytb",
\".pyx": "pyx",
\".r": "r",
\".raw": "raw",
\".rb": "ruby",
\".rhtml": "rhtml",
\".rkt": "rkt",
\".rs": "rs",
\".rst": "rst",
\".s": "s",
\".sass": "sass",
\".sc": "sc",
\".scala": "scala",
\".scm": "scheme",
\".scpt": "scpt",
\".scss": "scss",
\".self": "self",
\".sh": "sh",
\".sml": "sml",
\".sql": "sql",
\".st": "smalltalk",
\".tcl": "tcl",
\".tcsh": "tcsh",
\".tex": "tex",
\".textile": "textile",
\".tpl": "smarty",
\".twig": "twig",
\".txt" : "text",
\".v": "verilog",
\".vala": "vala",
\".vb": "vbnet",
\".vhd": "vhdl",
\".vim": "vim",
\".weechatlog": "weechatlog",
\".xml": "xml",
\".xq": "xquery",
\".xs": "xs",
\".yml": "yaml",
\}
let &cpo = s:save_cpo
unlet s:save_cpo
" vim:set et:
================================================
FILE: .vim/bundle/Gist.vim/doc/gist-vim.txt
================================================
*Gist.vim* Vimscript for creating gists (http://gist.github.com)
Usage |gist-vim-usage|
Tips |gist-vim-tips|
Requirements |gist-vim-requirements|
License |gist-vim-license|
Install |gist-vim-install|
Setup |gist-vim-setup|
This is a vimscript for creating gists (http://gist.github.com)
For the latest version please see https://github.com/mattn/gist-vim.
==============================================================================
USAGE *:Gist* *gist-vim-usage*
- Post current buffer to gist, using default privacy option. >
:Gist
<
- Post selected text to gist, using defualt privacy option.
This applies to all permutations listed below (except multi). >
:'<,'>Gist
<
- Create a private gist. >
:Gist -p
<
- Create a public gist.
(Only relevant if you've set gists to be private by default.) >
:Gist -P
<
- Post whole text to gist as public.
This is only relevant if you've set gists to be private by default.
>
:Gist -P
<
- Create a gist anonymously. >
:Gist -a
<
- Create a gist with all open buffers. >
:Gist -m
<
- Edit the gist (you need to have opened the gist buffer first).
You can update the gist with the {:w} command within the gist buffer. >
:Gist -e
<
- Edit the gist with name "foo.js" (you need to have opened the gist buffer
first). >
:Gist -e foo.js
<
- Post/Edit with the description " (you need to have opened the gist buffer
first). >
:Gist -s something
:Gist -e -s something
<
- Delete the gist (you need to have opened the gist buffer first).
Password authentication is needed. >
:Gist -d
<
- Fork the gist (you need to have opened the gist buffer first).
Password authentication is needed. >
:Gist -f
<
- Star the gist (you need to have opened the gist buffer first).
Password authentication is needed.
>
:Gist +1
<
- Unstar the gist (you need to have opened the gist buffer first).
Password authentication is needed.
>
:Gist -1
<
- Get gist XXXXX. >
:Gist XXXXX
<
- Get gist XXXXX and add to clipboard. >
:Gist -c XXXXX
<
- List your public gists. >
:Gist -l
<
- List gists from user "mattn". >
:Gist -l mattn
<
- List everyone's gists. >
:Gist -la
<
- List gists from your starred gists.
>
:Gist -ls
<
==============================================================================
TIPS *gist-vim-tips*
If you set "g:gist_clip_command", gist.vim will copy the gist code with option
"-c".
- Mac: >
let g:gist_clip_command = 'pbcopy'
<
- Linux: >
let g:gist_clip_command = 'xclip -selection clipboard'
<
- Others (cygwin?): >
let g:gist_clip_command = 'putclip'
<
If you want to detect filetype from the filename: >
let g:gist_detect_filetype = 1
<
If you want to open the browser after the post: >
let g:gist_open_browser_after_post = 1
<
If you want to change the browser: >
let g:gist_browser_command = 'w3m %URL%'
<
or: >
let g:gist_browser_command = 'opera %URL% &'
<
On windows, this should work with your user settings.
If you want to show your private gists with ":Gist -l": >
let g:gist_show_privates = 1
<
If you want to edit all files for gists containing more than one: >
let g:gist_get_multiplefile = 1
<
If you want to update a gist, embed >
GistID: xxxxx
>
in your local file, then call >
:Gist
>
==============================================================================
REQUIREMENTS *gist-vim-requirements*
- curl command (http://curl.haxx.se/)
- webapi-vim (https://github.com/mattn/webapi-vim)
- and, if you want to use your git profile, the git command-line client.
==============================================================================
LICENSE *gist-vim-license*
Copyright 2010 by Yasuhiro Matsumoto
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
OF THE POSSIBILITY OF SUCH DAMAGE.
==============================================================================
INSTALL *gist-vim-install*
Copy gist.vim to your plugin directory.
gist.vim will create a curl cookie-jar file in your runtimepath.
rtp:
- plugin/gist.vim
- cookies/github
If you want to uninstall gist.vim, remember to also remove "cookies/github".
==============================================================================
SETUP *gist-vim-setup*
This plugin uses github API v3. Setting value is stored in `~/.gist.vim`.
gist-vim have two ways to access APIs.
First, you need to set your Github username in global git config:
>
$ git config --global github.user Username
<
Then, gist.vim will ask for your password to create an authorization when you
first use it. The password is not stored and only the OAuth access token will
be kept for later use. You can revoke the token at any time from the list of
"Authorized applications" on Github's "Account Settings" page.
(https://github.com/settings/applications)
If you happen to have your password already written in ~/.gitconfig like
below:
>
[github]
password = xxxxx
<
Then, add following into your ~/.vimrc
>
let g:gist_use_password_in_gitconfig = 1
<
This is not secure at all, so strongly discouraged.
==============================================================================
THANKS *gist-vim-thanks*
AD7six
Bruno Bigras
c9s
Daniel Bretoi
Jeremy Michael Cantrell
Kien N
kongo2002
MATSUU Takuto
Matthew Weier O'Phinney
ornicar
Roland Schilter
steve
tyru
Will Gray
netj
vim:tw=78:ts=8:ft=help:norl:
================================================
FILE: .vim/bundle/Gist.vim/plugin/gist.vim
================================================
"=============================================================================
" File: gist.vim
" Author: Yasuhiro Matsumoto <mattn.jp@gmail.com>
" WebPage: http://github.com/mattn/gist-vim
" License: BSD
" GetLatestVimScripts: 2423 1 :AutoInstall: gist.vim
" script type: plugin
if &cp || (exists('g:loaded_gist_vim') && g:loaded_gist_vim)
finish
endif
let g:loaded_gist_vim = 1
if !exists('g:github_user') && !executable('git')
echohl ErrorMsg | echomsg "Gist: require 'git' command" | echohl None
finish
endif
if !executable('curl')
echohl ErrorMsg | echomsg "Gist: require 'curl' command" | echohl None
finish
endif
command! -nargs=? -range=% Gist :call gist#Gist(<count>, <line1>, <line2>, <f-args>)
" vim:set et:
================================================
FILE: .vim/bundle/Tabmerge/README
================================================
This is a mirror of http://www.vim.org/scripts/script.php?script_id=1961
Usage:
:Tabmerge [tab number] [top|bottom|left|right]
The tab number can be "$" for the last tab. If the tab number isn't specified the tab to the right of the current tab is merged. If there is no right tab, the left tab is merged.
The location specifies where in the current tab to merge the windows. Defaults to "top".
================================================
FILE: .vim/bundle/Tabmerge/plugin/Tabmerge.vim
================================================
" Tabmerge -- Merge the windows in a tab with the current tab.
"
" Copyright July 17, 2007 Christian J. Robinson <infynity@onewest.net>
"
" Distributed under the terms of the Vim license. See ":help license".
" Usage:
"
" :Tabmerge [tab number] [top|bottom|left|right]
"
" The tab number can be "$" for the last tab. If the tab number isn't
" specified the tab to the right of the current tab is merged. If there
" is no right tab, the left tab is merged.
"
" The location specifies where in the current tab to merge the windows.
" Defaults to "top".
"
" Limitations:
"
" Vertical windows are merged as horizontal splits. Doing otherwise would be
" nearly impossible.
if v:version < 700
echoerr "Tabmerge.vim requires at least Vim version 7"
finish
endif
command! -nargs=* Tabmerge call Tabmerge(<f-args>)
function! Tabmerge(...) " {{{1
if a:0 > 2
echohl ErrorMsg
echo "Too many arguments"
echohl None
return
elseif a:0 == 2
let tabnr = a:1
let where = a:2
elseif a:0 == 1
if a:1 =~ '^\d\+$' || a:1 == '$'
let tabnr = a:1
else
let where = a:1
endif
endif
if !exists('l:where')
let where = 'top'
endif
if !exists('l:tabnr')
if type(tabpagebuflist(tabpagenr() + 1)) == 3
let tabnr = tabpagenr() + 1
elseif type(tabpagebuflist(tabpagenr() - 1)) == 3
let tabnr = tabpagenr() - 1
else
echohl ErrorMsg
echo "Already only one tab"
echohl None
return
endif
endif
if tabnr == '$'
let tabnr = tabpagenr(tabnr)
else
let tabnr = tabnr
endif
let tabwindows = tabpagebuflist(tabnr)
if type(tabwindows) == 0 && tabwindows == 0
echohl ErrorMsg
echo "No such tab number: " . tabnr
echohl None
return
elseif tabnr == tabpagenr()
echohl ErrorMsg
echo "Can't merge with the current tab"
echohl None
return
endif
if where =~? '^t\(op\)\?$'
let where = 'topleft'
elseif where =~? '^b\(ot\(tom\)\?\)\?$'
let where = 'botright'
elseif where =~? '^l\(eft\)\?$'
let where = 'leftabove vertical'
elseif where =~? '^r\(ight\)\?$'
let where = 'rightbelow vertical'
else
echohl ErrorMsg
echo "Invalid location: " . a:2
echohl None
return
endif
let save_switchbuf = &switchbuf
let &switchbuf = ''
if where == 'top'
let tabwindows = reverse(tabwindows)
endif
for buf in tabwindows
exe where . ' sbuffer ' . buf
endfor
exe 'tabclose ' . tabnr
let &switchbuf = save_switchbuf
endfunction
" vim:fdm=marker:fdc=2:fdl=1:
================================================
FILE: .vim/bundle/ZoomWin/autoload/ZoomWin.vim
================================================
" ZoomWin: Brief-like ability to zoom into/out-of a window
" Author: Charles Campbell
" original version by Ron Aaron
" Date: Mar 09, 2014
" Version: 25n ASTRO-ONLY
" History: see :help zoomwin-history {{{1
" GetLatestVimScripts: 508 1 :AutoInstall: ZoomWin.vim
" ---------------------------------------------------------------------
" Load Once: {{{1
if &cp || exists("g:loaded_ZoomWin")
finish
endif
if v:version < 702
echohl WarningMsg
echo "***warning*** this version of ZoomWin needs vim 7.2"
echohl Normal
finish
endif
let s:keepcpo = &cpo
let g:loaded_ZoomWin = "v25n"
if !exists("g:zoomwin_localoptlist")
let s:localoptlist = ["ai","ar","bh","bin","bl","bomb","bt","cfu","ci","cin","cink","cino","cinw","cms","com","cpt","diff","efm","eol","ep","et","fenc","fex","ff","flp","fo","ft","gp","imi","ims","inde","inex","indk","inf","isk","key","kmp","lisp","mps","ml","ma","mod","nf","ofu","oft","pi","qe","ro","sw","sn","si","sts","spc","spf","spl","sua","swf","smc","syn","ts","tx","tw","udf","wfh","wfw","wm"]
else
let s:localoptlist = g:zoomwin_localoptlist
endif
set cpo&vim
"DechoTabOn
" =====================================================================
" Functions: {{{1
" ---------------------------------------------------------------------
" ZoomWin#ZoomWin: toggles between a single-window and a multi-window layout {{{2
" The original version was by Ron Aaron.
fun! ZoomWin#ZoomWin()
" let g:decho_hide= 1 "Decho
let lzkeep = &lz
set lz
" call Dfunc("ZoomWin#ZoomWin() winbufnr(2)=".winbufnr(2))
" if the vim doesn't have +mksession, only a partial zoom is available {{{3
if !has("mksession")
if !exists("s:partialzoom")
echomsg "missing the +mksession feature; only a partial zoom is available"
let s:partialzoom= 0
endif
if v:version < 630
echoerr "***sorry*** you need an updated vim, preferably with +mksession"
elseif s:partialzoom
" partial zoom out
let s:partialzoom= 0
exe s:winrestore
else
" partial zoom in
let s:partialzoom= 1
let s:winrestore = winrestcmd()
res
endif
let &lz = lzkeep
" call Dret("ZoomWin#ZoomWin : partialzoom=".s:partialzoom)
return
endif
" Close certain windows and save user settings {{{3
call s:ZoomWinPreserve(0)
call s:SaveUserSettings()
if winbufnr(2) == -1
" there's only one window - restore to multiple-windows mode (zoom out) {{{3
" call Decho("there's only one window - restore to multiple windows")
if exists("s:sessionfile") && filereadable(s:sessionfile)
" save position in current one-window-only
" call Decho("save position in current one-window-only in sponly (s:sessionfile<".s:sessionfile.">)")
let sponly = s:SavePosn(0)
let s:origline = line(".")
let s:origcol = virtcol(".")
let s:swv = deepcopy(getwinvar(winnr(),""),1)
sil! unlet key value
for [key,value] in items(s:swv)
exe "sil! unlet w:".key
sil! unlet key value
endfor
" source session file to restore window layout
let ei_keep = &ei
set ei=all noswf bh=hide
exe 'sil! so '.fnameescape(s:sessionfile)
let v:this_session= s:sesskeep
let winrestore = winrestcmd()
" restore any and all window variables
call s:RestoreWinVars()
if exists("s:savedposn1")
" restore windows' positioning and buffers
" call Decho("restore windows, positions, buffers")
noautocmd windo call s:RestorePosn(s:savedposn{winnr()})|unlet s:savedposn{winnr()}
call s:GotoWinNum(s:winkeep)
execute winrestore
unlet s:winkeep
endif
if exists("s:swv")
" restore window variables which possibly were modified while in one-window mode
for [key,value] in items(s:swv)
sil! call setwinvar(winnr(),key,value)
sil! unlet key value
endfor
endif
if line(".") != s:origline || virtcol(".") != s:origcol
" If the cursor hasn't moved from the original position,
" then let the position remain what it was in the original
" multi-window layout.
" call Decho("restore position using sponly")
call s:RestorePosn(sponly)
endif
" delete session file and variable holding its name
" call Decho("delete session file<".s:sessionfile.">")
" call delete(s:sessionfile)
unlet s:sessionfile
let &ei = ei_keep
endif
" I don't know why -- but netrw-generated windows end up as [Scratch] even though the bufname is correct.
" Following code fixes this. Without the if..[Scratch] test, though, when one attempts to write a file
" one gets an E13. Thus, only [Scratch] windows will be affected by this windo command.
let curwin= winnr()
let winrestore = winrestcmd()
noautocmd windo if bufname(winbufnr(winnr())) == '[Scratch]'|exe "sil! file ".fnameescape(bufname(winbufnr(winnr())))|endif
exe curwin."wincmd w"
" Restore local window settings
call s:RestoreWinSettings()
execute winrestore
" zoomwinstate used by g:ZoomWin_funcref()
let zoomwinstate= 0
else " there's more than one window - go to only-one-window mode (zoom in){{{3
" call Decho("there's multiple windows - goto one-window-only")
let s:winkeep = winnr()
let s:sesskeep = v:this_session
" doesn't work with the command line window (normal mode q:)
if &bt == "nofile" && expand("%") == (v:version < 702 ? 'command-line' : '[Command Line]')
echoerr "***error*** ZoomWin#ZoomWin doesn't work with the ".expand("%")." window"
let &lz= lzkeep
" call Dret("ZoomWin#ZoomWin : ".expand('%')." window error")
return
endif
" disable all events (autocmds)
" call Decho("disable events")
let ei_keep= &ei
set ei=all
let winrestore = winrestcmd()
" Save local window settings
call s:SaveWinSettings()
" save all window variables
call s:SaveWinVars()
" save window positioning commands
" call Decho("save window positioning commands")
noautocmd windo let s:savedposn{winnr()}= s:SavePosn(1)
call s:GotoWinNum(s:winkeep)
execute winrestore
" set up name of session file
let s:sessionfile= tempname()
" call Decho("s:sessionfile<".s:sessionfile.">")
" save session
" call Decho("save session")
let ssop_keep = &ssop
let &ssop = 'blank,help,winsize,folds,globals,localoptions,options'
exe 'mksession! '.fnameescape(s:sessionfile)
let keepyy= @@
let keepy0= @0
let keepy1= @1
let keepy2= @2
let keepy3= @3
let keepy4= @4
let keepy5= @5
let keepy6= @6
let keepy7= @7
let keepy8= @8
let keepy9= @9
set lz ei=all bh=
if v:version >= 700
let curwin = winnr()
try
exe "keepalt keepmarks new! ".fnameescape(s:sessionfile)
catch /^Vim\%((\a\+)\)\=:E/
let seswin = -1
windo if winheight(winnr()) > 1 | let seswin= winnr() | endif
if seswin < 0
echoerr "Too many windows (not enough room)"
sil! call delete(s:sessionfile)
unlet s:sessionfile
let &lz= lzkeep
" call Dret("ZoomWin#ZoomWin : too many windows")
return
endif
exe seswin."wincmd w"
exe "keepalt keepmarks new! ".fnameescape(s:sessionfile)
endtry
" modify the session (so that it merely restores window layout)
sil! keepjumps keepmarks v/wincmd\|split\|resize/d
" save modified session
" wipe out session window and buffer
" restore cursor to the window that was current before editing the session file
keepalt w!
keepalt bw!
exe curwin."wincmd w"
else
exe "new! ".fnameescape(s:sessionfile)
v/wincmd\|split\|resize/d
w!
bw!
endif
let @@= keepyy
let @0= keepy0
let @1= keepy1
let @2= keepy2
let @3= keepy3
let @4= keepy4
let @5= keepy5
let @6= keepy6
let @7= keepy7
let @8= keepy8
let @9= keepy9
call histdel('search', -1)
let @/ = histget('search', -1)
" restore user's session options and restore event handling
" call Decho("restore user session options and event handling")
set nolz
let &ssop = ssop_keep
let curwin= winnr()
sil! only!
let &ei = ei_keep
echomsg expand("%")
call s:RestoreOneWinSettings(curwin)
" zoomwinstate used by g:ZoomWin_funcref()
let zoomwinstate= 1
endif
" restore user option settings {{{3
call s:RestoreUserSettings()
" Re-open certain windows {{{3
call s:ZoomWinPreserve(1)
" call user's optional funcref (callback) functions
if exists("g:ZoomWin_funcref")
if type(g:ZoomWin_funcref) == 2
call g:ZoomWin_funcref(zoomwinstate)
elseif type(g:ZoomWin_funcref) == 3
for Fncref in g:ZoomWin_funcref
if type(Fncref) == 2
call Fncref(zoomwinstate)
endif
endfor
endif
endif
let &lz= lzkeep
" call Dret("ZoomWin#ZoomWin")
endfun
" ---------------------------------------------------------------------
" SavePosn: this function sets up a savedposn variable that {{{2
" has the commands necessary to restore the view
" of the current window.
fun! s:SavePosn(savewinhoriz)
" call Dfunc("SavePosn(savewinhoriz=".a:savewinhoriz.") file<".expand("%").">")
let swline = line(".")
if swline == 1 && getline(1) == ""
" empty buffer
let savedposn= "silent b ".winbufnr(0)
" call Dret("SavePosn savedposn<".savedposn.">")
return savedposn
endif
let swcol = col(".")
if swcol >= col("$")
let swcol= swcol + virtcol(".") - virtcol("$") " adjust for virtual edit (cursor past end-of-line)
endif
let swwline = winline()-1
let swwcol = virtcol(".") - wincol()
" call Decho("swline #".swline)
" call Decho("swcol #".swcol)
" call Decho("swwline#".swwline)
" call Decho("swwcol #".swwcol)
let savedposn = "sil! b ".winbufnr(0)
let savedposn = savedposn."|".swline
let savedposn = savedposn."|sil! norm! 0z\<cr>"
if swwline > 0
let savedposn= savedposn.":sil! norm! ".swwline."\<c-y>\<cr>"
endif
if a:savewinhoriz
if swwcol > 0
let savedposn= savedposn.":sil! norm! 0".swwcol."zl\<cr>"
endif
let savedposn= savedposn.":sil! call cursor(".swline.",".swcol.")\<cr>"
" handle certain special settings for the multi-window savedposn call
" bufhidden buftype buflisted
let settings= ""
if &bh != ""
" call Decho("special handling: changing buf#".bufnr("%")."'s bh=".&bh." to hide")
let settings="bh=".&bh
setl bh=hide
endif
if !&bl
" call Decho("special handling: changing buf#".bufnr("%")."'s bl=".&bl." to bl")
let settings= settings." nobl"
setl bl
endif
if &bt != ""
" call Decho("special handling: changing buf#".bufnr("%")."'s bt=".&bt.' to ""')
let settings= settings." bt=".&bt
setl bt=
endif
if settings != ""
let savedposn= savedposn.":setl ".settings."\<cr>"
endif
else
let savedposn= savedposn.":sil! call cursor(".swline.",".swcol.")\<cr>"
endif
" call Dret("SavePosn savedposn<".savedposn."> : buf#".bufnr("%")." bh=".&bh." bl=".&bl." bt=".&bt)
return savedposn
endfun
" ---------------------------------------------------------------------
" s:RestorePosn: this function restores noname and scratch windows {{{2
fun! s:RestorePosn(savedposn)
" call Dfunc("RestorePosn(savedposn<".a:savedposn.">) win#".winnr()." scb=".&scb)
if &scb
setl noscb
" try " Decho
exe a:savedposn
" catch /^Vim\%((\a\+)\)\=:E/ " Decho
" call Decho("error occurred") " Decho
" endtry " Decho
setl scb
else
" try " Decho
exe a:savedposn
" catch /^Vim\%((\a\+)\)\=:E/ " Decho
" call Decho("error occurred") " Decho
" endtry " Decho
endif
" call Dret("RestorePosn")
endfun
" ---------------------------------------------------------------------
" CleanupSessionFile: if you exit Vim before cleaning up the {{{2
" supposed-to-be temporary session file
fun! ZoomWin#CleanupSessionFile()
" call Dfunc("ZoomWin#CleanupSessionFile()")
if exists("s:sessionfile") && filereadable(s:sessionfile)
" call Decho("sessionfile exists and is readable; deleting it")
sil! call delete(s:sessionfile)
unlet s:sessionfile
endif
" call Dret("ZoomWin#CleanupSessionFile")
endfun
" ---------------------------------------------------------------------
" GotoWinNum: this function puts cursor into specified window {{{2
fun! s:GotoWinNum(winnum)
" call Dfunc("GotoWinNum(winnum=".a:winnum.") winnr=".winnr())
if a:winnum != winnr()
exe a:winnum."wincmd w"
endif
" call Dret("GotoWinNum")
endfun
" ---------------------------------------------------------------------
" ZoomWinPreserve: This function, largely written by David Fishburn, {{{2
" allows ZoomWin to "preserve" certain windows:
"
" TagList, by Yegappan Lakshmanan
" http://vim.sourceforge.net/scripts/script.php?script_id=273
"
" WinManager, by Srinath Avadhanula
" http://vim.sourceforge.net/scripts/script.php?script_id=95
"
" It does so by closing the associated window upon entry to ZoomWin
" and re-opening it upon exit by using commands provided by the
" utilities themselves.
fun! s:ZoomWinPreserve(open)
" call Dfunc("ZoomWinPreserve(open=".a:open.")")
if a:open == 0
" Close Taglist
if exists('g:zoomwin_preserve_taglist') && exists('g:loaded_taglist')
" If taglist window is open then close it.
let s:taglist_winnum = bufwinnr(g:TagList_title)
if s:taglist_winnum != -1
" Close the window
exec "sil! Tlist"
endif
endif
" Close Winmanager
if exists('g:zoomwin_preserve_winmanager') && exists('g:loaded_winmanager')
" If the winmanager window is open then close it.
let s:is_winmgr_vis = IsWinManagerVisible()
if s:is_winmgr_vis == 1
exec "WMClose"
endif
endif
else
" Re-open Taglist
if exists('g:zoomwin_preserve_taglist') && exists('g:loaded_taglist')
" If taglist window was open, open it again
if s:taglist_winnum != -1
exec "sil! Tlist"
endif
endif
" Re-Open Winmanager
if exists('g:zoomwin_preserve_winmanager') && exists('g:loaded_winmanager')
" If the winmanager window is open then close it.
if s:is_winmgr_vis == 1
exec "WManager"
endif
endif
endif
" call Dret("ZoomWinPreserve")
endfun
" ---------------------------------------------------------------------
" s:SaveWinVars: saves a copy of all window-variables into the script variable s:swv_#, {{{2
" where # is the current window number, for all windows.
fun! s:SaveWinVars()
" call Dfunc("s:SaveWinVars()")
noautocmd windo let s:swv_{winnr()}= deepcopy(getwinvar(winnr(),""),1)|let s:swvmatches_{winnr()}= getmatches()
" call Dret("s:SaveWinVars")
endfun
" ---------------------------------------------------------------------
" s:RestoreWinVars: restores window variables for all windows {{{2
fun! s:RestoreWinVars()
" call Dfunc("s:RestoreWinVars()")
" windo call Decho(string(s:swv_{winnr()}))
noautocmd windo if exists("s:swv_{winnr()}") |sil! unlet s:key s:value |for [s:key,s:value] in items(s:swv_{winnr()})|call setwinvar(winnr(),s:key,s:value)|exe "sil! unlet s:key s:value"|endfor|call setmatches(s:swvmatches_{winnr()})|unlet s:swvmatches_{winnr()}|unlet s:swv_{winnr()}|endif
" call Dret("s:RestoreWinVars")
endfun
" ---------------------------------------------------------------------
" s:SaveUserSettings: save user options, set to zoomwin-safe options. {{{2
" Force window minimum height/width to be >= 1
fun! s:SaveUserSettings()
" call Dfunc("s:SaveUserSettings()")
let s:keep_hidden = &hidden
let s:keep_shm = &shm
let s:keep_siso = &siso
let s:keep_so = &so
let s:keep_ss = &ss
let s:keep_wfh = &wfh
let s:keep_write = &write
if has("clipboard")
" call Decho("@* save before: s:keep_star=".@*)
let s:keep_star = @*
" call Decho("@* save after : s:keep_star=".@*)
endif
let s:keep_swf = &swf
if v:version < 603
if &wmh == 0 || &wmw == 0
let s:keep_wmh = &wmh
let s:keep_wmw = &wmw
sil! set wmh=1
gitextract_v4dsqjfv/
├── .tmux.conf
├── .vim/
│ ├── autoload/
│ │ └── pathogen.vim
│ ├── bundle/
│ │ ├── CSApprox/
│ │ │ ├── README
│ │ │ ├── after/
│ │ │ │ └── plugin/
│ │ │ │ └── CSApprox.vim
│ │ │ ├── autoload/
│ │ │ │ ├── csapprox/
│ │ │ │ │ ├── common.vim
│ │ │ │ │ └── per_component.vim
│ │ │ │ └── csapprox.vim
│ │ │ ├── doc/
│ │ │ │ └── CSApprox.txt
│ │ │ └── plugin/
│ │ │ └── CSApprox.vim
│ │ ├── Gist.vim/
│ │ │ ├── README
│ │ │ ├── README.mkd
│ │ │ ├── autoload/
│ │ │ │ └── gist.vim
│ │ │ ├── doc/
│ │ │ │ └── gist-vim.txt
│ │ │ └── plugin/
│ │ │ └── gist.vim
│ │ ├── Tabmerge/
│ │ │ ├── README
│ │ │ └── plugin/
│ │ │ └── Tabmerge.vim
│ │ ├── ZoomWin/
│ │ │ ├── autoload/
│ │ │ │ └── ZoomWin.vim
│ │ │ ├── doc/
│ │ │ │ └── ZoomWin.txt
│ │ │ └── plugin/
│ │ │ └── ZoomWinPlugin.vim
│ │ ├── ack.vim/
│ │ │ ├── README.md
│ │ │ ├── Rakefile
│ │ │ ├── doc/
│ │ │ │ └── ack.txt
│ │ │ └── plugin/
│ │ │ └── ack.vim
│ │ ├── camelcasemotion/
│ │ │ ├── README
│ │ │ ├── autoload/
│ │ │ │ └── camelcasemotion.vim
│ │ │ ├── doc/
│ │ │ │ └── camelcasemotion.txt
│ │ │ └── plugin/
│ │ │ └── camelcasemotion.vim
│ │ ├── ctrlp.vim/
│ │ │ ├── autoload/
│ │ │ │ ├── ctrlp/
│ │ │ │ │ ├── bookmarkdir.vim
│ │ │ │ │ ├── buffertag.vim
│ │ │ │ │ ├── changes.vim
│ │ │ │ │ ├── dir.vim
│ │ │ │ │ ├── line.vim
│ │ │ │ │ ├── mixed.vim
│ │ │ │ │ ├── mrufiles.vim
│ │ │ │ │ ├── quickfix.vim
│ │ │ │ │ ├── rtscript.vim
│ │ │ │ │ ├── tag.vim
│ │ │ │ │ ├── undo.vim
│ │ │ │ │ └── utils.vim
│ │ │ │ └── ctrlp.vim
│ │ │ ├── doc/
│ │ │ │ └── ctrlp.txt
│ │ │ ├── plugin/
│ │ │ │ └── ctrlp.vim
│ │ │ └── readme.md
│ │ ├── emmet-vim/
│ │ │ ├── Makefile
│ │ │ ├── README.mkd
│ │ │ ├── TODO
│ │ │ ├── TUTORIAL
│ │ │ ├── autoload/
│ │ │ │ ├── emmet/
│ │ │ │ │ ├── lang/
│ │ │ │ │ │ ├── css.vim
│ │ │ │ │ │ ├── haml.vim
│ │ │ │ │ │ ├── html.vim
│ │ │ │ │ │ ├── less.vim
│ │ │ │ │ │ ├── sass.vim
│ │ │ │ │ │ ├── scss.vim
│ │ │ │ │ │ └── slim.vim
│ │ │ │ │ ├── lang.vim
│ │ │ │ │ ├── lorem/
│ │ │ │ │ │ ├── en.vim
│ │ │ │ │ │ └── ja.vim
│ │ │ │ │ └── util.vim
│ │ │ │ └── emmet.vim
│ │ │ ├── doc/
│ │ │ │ └── emmet.txt
│ │ │ ├── emmet.vim.vimup
│ │ │ ├── plugin/
│ │ │ │ └── emmet.vim
│ │ │ └── unittest.vim
│ │ ├── gruvbox/
│ │ │ ├── README.md
│ │ │ ├── autoload/
│ │ │ │ └── gruvbox.vim
│ │ │ ├── colors/
│ │ │ │ └── gruvbox.vim
│ │ │ ├── gruvbox_256palette.sh
│ │ │ └── gruvbox_256palette_osx.sh
│ │ ├── html5.vim/
│ │ │ ├── CHANGES.markdown
│ │ │ ├── Makefile
│ │ │ ├── README.md
│ │ │ ├── autoload/
│ │ │ │ ├── htmlcomplete.vim
│ │ │ │ └── xml/
│ │ │ │ ├── aria.vim
│ │ │ │ └── html5.vim
│ │ │ ├── config.mk
│ │ │ ├── indent/
│ │ │ │ └── html.vim
│ │ │ └── syntax/
│ │ │ ├── html/
│ │ │ │ ├── aria.vim
│ │ │ │ └── rdfa.vim
│ │ │ ├── html.vim
│ │ │ └── javascript/
│ │ │ └── html5.vim
│ │ ├── nerdtree/
│ │ │ ├── README.markdown
│ │ │ ├── autoload/
│ │ │ │ └── nerdtree.vim
│ │ │ ├── doc/
│ │ │ │ └── NERD_tree.txt
│ │ │ ├── lib/
│ │ │ │ └── nerdtree/
│ │ │ │ ├── bookmark.vim
│ │ │ │ ├── creator.vim
│ │ │ │ ├── key_map.vim
│ │ │ │ ├── menu_controller.vim
│ │ │ │ ├── menu_item.vim
│ │ │ │ ├── opener.vim
│ │ │ │ ├── path.vim
│ │ │ │ ├── tree_dir_node.vim
│ │ │ │ └── tree_file_node.vim
│ │ │ ├── nerdtree_plugin/
│ │ │ │ ├── exec_menuitem.vim
│ │ │ │ └── fs_menu.vim
│ │ │ ├── plugin/
│ │ │ │ └── NERD_tree.vim
│ │ │ └── syntax/
│ │ │ └── nerdtree.vim
│ │ ├── paredit.vim/
│ │ │ ├── README
│ │ │ ├── doc/
│ │ │ │ └── paredit.txt
│ │ │ └── plugin/
│ │ │ └── paredit.vim
│ │ ├── rainbow_parentheses.vim/
│ │ │ ├── autoload/
│ │ │ │ └── rainbow_parentheses.vim
│ │ │ ├── plugin/
│ │ │ │ └── rainbow_parentheses.vim
│ │ │ └── readme.md
│ │ ├── supertab/
│ │ │ ├── Makefile
│ │ │ ├── README.rst
│ │ │ ├── doc/
│ │ │ │ └── supertab.txt
│ │ │ └── plugin/
│ │ │ └── supertab.vim
│ │ ├── syntastic/
│ │ │ ├── CONTRIBUTING.md
│ │ │ ├── LICENCE
│ │ │ ├── README.markdown
│ │ │ ├── autoload/
│ │ │ │ └── syntastic/
│ │ │ │ ├── c.vim
│ │ │ │ ├── log.vim
│ │ │ │ ├── postprocess.vim
│ │ │ │ ├── preprocess.vim
│ │ │ │ └── util.vim
│ │ │ ├── doc/
│ │ │ │ └── syntastic.txt
│ │ │ ├── plugin/
│ │ │ │ ├── syntastic/
│ │ │ │ │ ├── autoloclist.vim
│ │ │ │ │ ├── balloons.vim
│ │ │ │ │ ├── checker.vim
│ │ │ │ │ ├── cursor.vim
│ │ │ │ │ ├── highlighting.vim
│ │ │ │ │ ├── loclist.vim
│ │ │ │ │ ├── modemap.vim
│ │ │ │ │ ├── notifiers.vim
│ │ │ │ │ ├── registry.vim
│ │ │ │ │ └── signs.vim
│ │ │ │ └── syntastic.vim
│ │ │ └── syntax_checkers/
│ │ │ ├── actionscript/
│ │ │ │ └── mxmlc.vim
│ │ │ ├── ada/
│ │ │ │ └── gcc.vim
│ │ │ ├── applescript/
│ │ │ │ └── osacompile.vim
│ │ │ ├── asciidoc/
│ │ │ │ └── asciidoc.vim
│ │ │ ├── asm/
│ │ │ │ └── gcc.vim
│ │ │ ├── bemhtml/
│ │ │ │ └── bemhtmllint.vim
│ │ │ ├── c/
│ │ │ │ ├── avrgcc.vim
│ │ │ │ ├── checkpatch.vim
│ │ │ │ ├── cppcheck.vim
│ │ │ │ ├── gcc.vim
│ │ │ │ ├── make.vim
│ │ │ │ ├── oclint.vim
│ │ │ │ ├── sparse.vim
│ │ │ │ └── splint.vim
│ │ │ ├── chef/
│ │ │ │ └── foodcritic.vim
│ │ │ ├── co/
│ │ │ │ └── coco.vim
│ │ │ ├── cobol/
│ │ │ │ └── cobc.vim
│ │ │ ├── coffee/
│ │ │ │ ├── coffee.vim
│ │ │ │ └── coffeelint.vim
│ │ │ ├── coq/
│ │ │ │ └── coqtop.vim
│ │ │ ├── cpp/
│ │ │ │ ├── cppcheck.vim
│ │ │ │ ├── cpplint.vim
│ │ │ │ ├── gcc.vim
│ │ │ │ └── oclint.vim
│ │ │ ├── cs/
│ │ │ │ └── mcs.vim
│ │ │ ├── css/
│ │ │ │ ├── csslint.vim
│ │ │ │ ├── phpcs.vim
│ │ │ │ └── prettycss.vim
│ │ │ ├── cucumber/
│ │ │ │ └── cucumber.vim
│ │ │ ├── cuda/
│ │ │ │ └── nvcc.vim
│ │ │ ├── d/
│ │ │ │ └── dmd.vim
│ │ │ ├── dart/
│ │ │ │ └── dartanalyzer.vim
│ │ │ ├── docbk/
│ │ │ │ └── xmllint.vim
│ │ │ ├── dustjs/
│ │ │ │ └── swiffer.vim
│ │ │ ├── elixir/
│ │ │ │ └── elixir.vim
│ │ │ ├── erlang/
│ │ │ │ ├── erlang_check_file.erl
│ │ │ │ ├── escript.vim
│ │ │ │ └── syntaxerl.vim
│ │ │ ├── eruby/
│ │ │ │ └── ruby.vim
│ │ │ ├── fortran/
│ │ │ │ └── gfortran.vim
│ │ │ ├── glsl/
│ │ │ │ └── cgc.vim
│ │ │ ├── go/
│ │ │ │ ├── go.vim
│ │ │ │ ├── gofmt.vim
│ │ │ │ ├── golint.vim
│ │ │ │ ├── gotype.vim
│ │ │ │ └── govet.vim
│ │ │ ├── haml/
│ │ │ │ ├── haml.vim
│ │ │ │ └── haml_lint.vim
│ │ │ ├── handlebars/
│ │ │ │ └── handlebars.vim
│ │ │ ├── haskell/
│ │ │ │ ├── ghc-mod.vim
│ │ │ │ ├── hdevtools.vim
│ │ │ │ └── hlint.vim
│ │ │ ├── haxe/
│ │ │ │ └── haxe.vim
│ │ │ ├── hss/
│ │ │ │ └── hss.vim
│ │ │ ├── html/
│ │ │ │ ├── jshint.vim
│ │ │ │ ├── tidy.vim
│ │ │ │ ├── validator.vim
│ │ │ │ └── w3.vim
│ │ │ ├── java/
│ │ │ │ ├── checkstyle.vim
│ │ │ │ └── javac.vim
│ │ │ ├── javascript/
│ │ │ │ ├── closurecompiler.vim
│ │ │ │ ├── eslint.vim
│ │ │ │ ├── gjslint.vim
│ │ │ │ ├── jscs.vim
│ │ │ │ ├── jshint.vim
│ │ │ │ ├── jsl.vim
│ │ │ │ ├── jslint.vim
│ │ │ │ └── jsxhint.vim
│ │ │ ├── json/
│ │ │ │ ├── jsonlint.vim
│ │ │ │ └── jsonval.vim
│ │ │ ├── less/
│ │ │ │ ├── less-lint.coffee
│ │ │ │ ├── less-lint.js
│ │ │ │ └── lessc.vim
│ │ │ ├── lex/
│ │ │ │ └── flex.vim
│ │ │ ├── limbo/
│ │ │ │ └── limbo.vim
│ │ │ ├── lisp/
│ │ │ │ └── clisp.vim
│ │ │ ├── llvm/
│ │ │ │ └── llvm.vim
│ │ │ ├── lua/
│ │ │ │ └── luac.vim
│ │ │ ├── matlab/
│ │ │ │ └── mlint.vim
│ │ │ ├── nasm/
│ │ │ │ └── nasm.vim
│ │ │ ├── nroff/
│ │ │ │ └── mandoc.vim
│ │ │ ├── objc/
│ │ │ │ ├── gcc.vim
│ │ │ │ └── oclint.vim
│ │ │ ├── objcpp/
│ │ │ │ ├── gcc.vim
│ │ │ │ └── oclint.vim
│ │ │ ├── ocaml/
│ │ │ │ └── camlp4o.vim
│ │ │ ├── perl/
│ │ │ │ ├── perl.vim
│ │ │ │ ├── perlcritic.vim
│ │ │ │ └── podchecker.vim
│ │ │ ├── php/
│ │ │ │ ├── php.vim
│ │ │ │ ├── phpcs.vim
│ │ │ │ └── phpmd.vim
│ │ │ ├── po/
│ │ │ │ └── msgfmt.vim
│ │ │ ├── pod/
│ │ │ │ └── podchecker.vim
│ │ │ ├── puppet/
│ │ │ │ ├── puppet.vim
│ │ │ │ └── puppetlint.vim
│ │ │ ├── python/
│ │ │ │ ├── compile.py
│ │ │ │ ├── flake8.vim
│ │ │ │ ├── frosted.vim
│ │ │ │ ├── pep257.vim
│ │ │ │ ├── pep8.vim
│ │ │ │ ├── py3kwarn.vim
│ │ │ │ ├── pyflakes.vim
│ │ │ │ ├── pylama.vim
│ │ │ │ ├── pylint.vim
│ │ │ │ └── python.vim
│ │ │ ├── racket/
│ │ │ │ ├── code-ayatollah.vim
│ │ │ │ └── racket.vim
│ │ │ ├── rst/
│ │ │ │ ├── rst2pseudoxml.vim
│ │ │ │ └── rstcheck.vim
│ │ │ ├── ruby/
│ │ │ │ ├── jruby.vim
│ │ │ │ ├── macruby.vim
│ │ │ │ ├── mri.vim
│ │ │ │ ├── rubocop.vim
│ │ │ │ └── rubylint.vim
│ │ │ ├── rust/
│ │ │ │ └── rustc.vim
│ │ │ ├── sass/
│ │ │ │ └── sass.vim
│ │ │ ├── scala/
│ │ │ │ ├── fsc.vim
│ │ │ │ └── scalac.vim
│ │ │ ├── scss/
│ │ │ │ ├── sass.vim
│ │ │ │ └── scss_lint.vim
│ │ │ ├── sh/
│ │ │ │ ├── checkbashisms.vim
│ │ │ │ ├── sh.vim
│ │ │ │ └── shellcheck.vim
│ │ │ ├── slim/
│ │ │ │ └── slimrb.vim
│ │ │ ├── tcl/
│ │ │ │ └── nagelfar.vim
│ │ │ ├── tex/
│ │ │ │ ├── chktex.vim
│ │ │ │ └── lacheck.vim
│ │ │ ├── texinfo/
│ │ │ │ └── makeinfo.vim
│ │ │ ├── text/
│ │ │ │ ├── atdtool.vim
│ │ │ │ └── language_check.vim
│ │ │ ├── twig/
│ │ │ │ └── twiglint.vim
│ │ │ ├── typescript/
│ │ │ │ └── tsc.vim
│ │ │ ├── vala/
│ │ │ │ └── valac.vim
│ │ │ ├── verilog/
│ │ │ │ └── verilator.vim
│ │ │ ├── vhdl/
│ │ │ │ └── ghdl.vim
│ │ │ ├── vim/
│ │ │ │ └── vimlint.vim
│ │ │ ├── xhtml/
│ │ │ │ ├── jshint.vim
│ │ │ │ └── tidy.vim
│ │ │ ├── xml/
│ │ │ │ └── xmllint.vim
│ │ │ ├── xslt/
│ │ │ │ └── xmllint.vim
│ │ │ ├── yacc/
│ │ │ │ └── bison.vim
│ │ │ ├── yaml/
│ │ │ │ ├── jsyaml.vim
│ │ │ │ └── yamlxs.vim
│ │ │ ├── z80/
│ │ │ │ └── z80syntaxchecker.vim
│ │ │ ├── zpt/
│ │ │ │ └── zptlint.vim
│ │ │ └── zsh/
│ │ │ ├── shellcheck.vim
│ │ │ └── zsh.vim
│ │ ├── tabular/
│ │ │ ├── README.md
│ │ │ ├── after/
│ │ │ │ └── plugin/
│ │ │ │ └── TabularMaps.vim
│ │ │ ├── autoload/
│ │ │ │ └── tabular.vim
│ │ │ ├── doc/
│ │ │ │ └── Tabular.txt
│ │ │ └── plugin/
│ │ │ └── Tabular.vim
│ │ ├── targets.vim/
│ │ │ ├── LICENSE
│ │ │ ├── README.md
│ │ │ ├── autoload/
│ │ │ │ └── targets.vim
│ │ │ ├── cheatsheet.md
│ │ │ ├── doc/
│ │ │ │ └── targets.txt
│ │ │ ├── plugin/
│ │ │ │ └── targets.vim
│ │ │ └── test/
│ │ │ ├── Makefile
│ │ │ ├── test.vim
│ │ │ ├── test1.in
│ │ │ ├── test1.ok
│ │ │ ├── test1.out
│ │ │ ├── test2.in
│ │ │ ├── test2.ok
│ │ │ ├── test2.out
│ │ │ ├── test3.in
│ │ │ ├── test3.ok
│ │ │ ├── test3.out
│ │ │ ├── test4.in
│ │ │ ├── test4.ok
│ │ │ └── test4.out
│ │ ├── textutil.vim/
│ │ │ ├── README
│ │ │ └── plugin/
│ │ │ └── textutil.vim
│ │ ├── tomorrow-night-vim/
│ │ │ └── colors/
│ │ │ ├── Tomorrow-Night-Blue.vim
│ │ │ ├── Tomorrow-Night-Bright.vim
│ │ │ ├── Tomorrow-Night-Eighties.vim
│ │ │ ├── Tomorrow-Night.vim
│ │ │ └── Tomorrow.vim
│ │ ├── vim-airline/
│ │ │ ├── .travis.yml
│ │ │ ├── Gemfile
│ │ │ ├── LICENSE
│ │ │ ├── README.md
│ │ │ ├── Rakefile
│ │ │ ├── autoload/
│ │ │ │ ├── airline/
│ │ │ │ │ ├── builder.vim
│ │ │ │ │ ├── debug.vim
│ │ │ │ │ ├── deprecation.vim
│ │ │ │ │ ├── extensions/
│ │ │ │ │ │ ├── branch.vim
│ │ │ │ │ │ ├── bufferline.vim
│ │ │ │ │ │ ├── commandt.vim
│ │ │ │ │ │ ├── csv.vim
│ │ │ │ │ │ ├── ctrlp.vim
│ │ │ │ │ │ ├── default.vim
│ │ │ │ │ │ ├── eclim.vim
│ │ │ │ │ │ ├── example.vim
│ │ │ │ │ │ ├── hunks.vim
│ │ │ │ │ │ ├── netrw.vim
│ │ │ │ │ │ ├── promptline.vim
│ │ │ │ │ │ ├── quickfix.vim
│ │ │ │ │ │ ├── syntastic.vim
│ │ │ │ │ │ ├── tabline/
│ │ │ │ │ │ │ ├── default.vim
│ │ │ │ │ │ │ ├── unique_tail.vim
│ │ │ │ │ │ │ └── unique_tail_improved.vim
│ │ │ │ │ │ ├── tabline.vim
│ │ │ │ │ │ ├── tagbar.vim
│ │ │ │ │ │ ├── tmuxline.vim
│ │ │ │ │ │ ├── undotree.vim
│ │ │ │ │ │ ├── unite.vim
│ │ │ │ │ │ ├── virtualenv.vim
│ │ │ │ │ │ └── whitespace.vim
│ │ │ │ │ ├── extensions.vim
│ │ │ │ │ ├── highlighter.vim
│ │ │ │ │ ├── init.vim
│ │ │ │ │ ├── parts.vim
│ │ │ │ │ ├── section.vim
│ │ │ │ │ ├── themes/
│ │ │ │ │ │ ├── badwolf.vim
│ │ │ │ │ │ ├── base16.vim
│ │ │ │ │ │ ├── bubblegum.vim
│ │ │ │ │ │ ├── dark.vim
│ │ │ │ │ │ ├── hybrid.vim
│ │ │ │ │ │ ├── jellybeans.vim
│ │ │ │ │ │ ├── kalisi.vim
│ │ │ │ │ │ ├── kolor.vim
│ │ │ │ │ │ ├── laederon.vim
│ │ │ │ │ │ ├── light.vim
│ │ │ │ │ │ ├── lucius.vim
│ │ │ │ │ │ ├── luna.vim
│ │ │ │ │ │ ├── molokai.vim
│ │ │ │ │ │ ├── monochrome.vim
│ │ │ │ │ │ ├── murmur.vim
│ │ │ │ │ │ ├── powerlineish.vim
│ │ │ │ │ │ ├── serene.vim
│ │ │ │ │ │ ├── simple.vim
│ │ │ │ │ │ ├── sol.vim
│ │ │ │ │ │ ├── solarized.vim
│ │ │ │ │ │ ├── tomorrow.vim
│ │ │ │ │ │ ├── ubaryd.vim
│ │ │ │ │ │ ├── understated.vim
│ │ │ │ │ │ ├── wombat.vim
│ │ │ │ │ │ └── zenburn.vim
│ │ │ │ │ ├── themes.vim
│ │ │ │ │ └── util.vim
│ │ │ │ └── airline.vim
│ │ │ ├── doc/
│ │ │ │ └── airline.txt
│ │ │ ├── plugin/
│ │ │ │ └── airline.vim
│ │ │ └── t/
│ │ │ ├── airline.vim
│ │ │ ├── builder.vim
│ │ │ ├── commands.vim
│ │ │ ├── extensions_default.vim
│ │ │ ├── highlighter.vim
│ │ │ ├── init.vim
│ │ │ ├── parts.vim
│ │ │ ├── section.vim
│ │ │ ├── themes.vim
│ │ │ └── util.vim
│ │ ├── vim-bookmarks/
│ │ │ ├── .travis.yml
│ │ │ ├── CONTRIBUTING.md
│ │ │ ├── Gemfile
│ │ │ ├── Guardfile
│ │ │ ├── LICENSE
│ │ │ ├── README.md
│ │ │ ├── Rakefile
│ │ │ ├── autoload/
│ │ │ │ ├── bm.vim
│ │ │ │ ├── bm_sign.vim
│ │ │ │ └── util.vim
│ │ │ ├── doc/
│ │ │ │ └── bookmarks.txt
│ │ │ ├── plugin/
│ │ │ │ └── bookmark.vim
│ │ │ └── t/
│ │ │ ├── bm_sign_spec.vim
│ │ │ ├── bm_spec.vim
│ │ │ └── util_spec.vim
│ │ ├── vim-choosewin/
│ │ │ ├── README-JP.md
│ │ │ ├── README.md
│ │ │ ├── Rakefile
│ │ │ ├── VERSION
│ │ │ ├── autoload/
│ │ │ │ ├── choosewin/
│ │ │ │ │ ├── data/
│ │ │ │ │ │ ├── _sample
│ │ │ │ │ │ ├── large
│ │ │ │ │ │ ├── small
│ │ │ │ │ │ └── small_horizontal
│ │ │ │ │ ├── font.vim
│ │ │ │ │ ├── highlighter.vim
│ │ │ │ │ ├── hlmanager.vim
│ │ │ │ │ └── overlay.vim
│ │ │ │ └── choosewin.vim
│ │ │ ├── doc/
│ │ │ │ └── choosewin.txt
│ │ │ ├── misc/
│ │ │ │ └── work.vim
│ │ │ ├── plugin/
│ │ │ │ └── choosewin.vim
│ │ │ └── test/
│ │ │ └── font.vim
│ │ ├── vim-classpath/
│ │ │ ├── README.markdown
│ │ │ ├── autoload/
│ │ │ │ └── classpath.vim
│ │ │ ├── doc/
│ │ │ │ └── classpath.txt
│ │ │ └── plugin/
│ │ │ └── classpath.vim
│ │ ├── vim-clojure-static/
│ │ │ ├── LICENSE.txt
│ │ │ ├── README.markdown
│ │ │ ├── autoload/
│ │ │ │ └── clojurecomplete.vim
│ │ │ ├── clj/
│ │ │ │ ├── project.clj
│ │ │ │ ├── src/
│ │ │ │ │ └── vim_clojure_static/
│ │ │ │ │ ├── generate.clj
│ │ │ │ │ ├── test.clj
│ │ │ │ │ └── update.clj
│ │ │ │ ├── test/
│ │ │ │ │ └── vim_clojure_static/
│ │ │ │ │ └── syntax_test.clj
│ │ │ │ └── vim/
│ │ │ │ └── test-runtime.vim
│ │ │ ├── doc/
│ │ │ │ └── clojure.txt
│ │ │ ├── ftdetect/
│ │ │ │ └── clojure.vim
│ │ │ ├── ftplugin/
│ │ │ │ └── clojure.vim
│ │ │ ├── indent/
│ │ │ │ └── clojure.vim
│ │ │ └── syntax/
│ │ │ └── clojure.vim
│ │ ├── vim-colors-solarized/
│ │ │ ├── README.mkd
│ │ │ ├── autoload/
│ │ │ │ └── togglebg.vim
│ │ │ ├── colors/
│ │ │ │ └── solarized.vim
│ │ │ └── doc/
│ │ │ └── solarized.txt
│ │ ├── vim-commentary/
│ │ │ ├── README.markdown
│ │ │ ├── doc/
│ │ │ │ └── commentary.txt
│ │ │ └── plugin/
│ │ │ └── commentary.vim
│ │ ├── vim-css-color/
│ │ │ ├── README.md
│ │ │ ├── after/
│ │ │ │ └── syntax/
│ │ │ │ ├── css.vim
│ │ │ │ ├── html.vim
│ │ │ │ ├── less.vim
│ │ │ │ ├── sass.vim
│ │ │ │ ├── stylus.vim
│ │ │ │ └── vim.vim
│ │ │ ├── autoload/
│ │ │ │ └── css_color.vim
│ │ │ └── tests/
│ │ │ ├── bench
│ │ │ ├── example.less
│ │ │ ├── example.sass
│ │ │ ├── example.stylus
│ │ │ └── torture.css
│ │ ├── vim-cucumber/
│ │ │ ├── compiler/
│ │ │ │ └── cucumber.vim
│ │ │ ├── ftdetect/
│ │ │ │ └── cucumber.vim
│ │ │ ├── ftplugin/
│ │ │ │ └── cucumber.vim
│ │ │ ├── indent/
│ │ │ │ └── cucumber.vim
│ │ │ └── syntax/
│ │ │ └── cucumber.vim
│ │ ├── vim-dispatch/
│ │ │ ├── CONTRIBUTING.markdown
│ │ │ ├── README.markdown
│ │ │ ├── autoload/
│ │ │ │ ├── dispatch/
│ │ │ │ │ ├── headless.vim
│ │ │ │ │ ├── iterm.vim
│ │ │ │ │ ├── screen.vim
│ │ │ │ │ ├── tmux.vim
│ │ │ │ │ ├── windows.vim
│ │ │ │ │ └── x11.vim
│ │ │ │ └── dispatch.vim
│ │ │ ├── doc/
│ │ │ │ └── dispatch.txt
│ │ │ └── plugin/
│ │ │ └── dispatch.vim
│ │ ├── vim-endwise/
│ │ │ ├── README.markdown
│ │ │ └── plugin/
│ │ │ └── endwise.vim
│ │ ├── vim-fireplace/
│ │ │ ├── CONTRIBUTING.markdown
│ │ │ ├── README.markdown
│ │ │ ├── autoload/
│ │ │ │ ├── fireplace/
│ │ │ │ │ └── nrepl.vim
│ │ │ │ └── nrepl/
│ │ │ │ └── fireplace_connection.vim
│ │ │ ├── compiler/
│ │ │ │ └── lein.vim
│ │ │ ├── doc/
│ │ │ │ └── fireplace.txt
│ │ │ ├── plugin/
│ │ │ │ ├── fireplace/
│ │ │ │ │ └── zip.vim
│ │ │ │ └── fireplace.vim
│ │ │ └── python/
│ │ │ └── nrepl_fireplace.py
│ │ ├── vim-fugitive/
│ │ │ ├── CONTRIBUTING.markdown
│ │ │ ├── README.markdown
│ │ │ ├── doc/
│ │ │ │ └── fugitive.txt
│ │ │ └── plugin/
│ │ │ └── fugitive.vim
│ │ ├── vim-gitgutter/
│ │ │ ├── README.mkd
│ │ │ ├── autoload/
│ │ │ │ ├── debug.vim
│ │ │ │ ├── diff.vim
│ │ │ │ ├── highlight.vim
│ │ │ │ ├── hunk.vim
│ │ │ │ ├── sign.vim
│ │ │ │ └── utility.vim
│ │ │ ├── doc/
│ │ │ │ └── gitgutter.txt
│ │ │ └── plugin/
│ │ │ └── gitgutter.vim
│ │ ├── vim-haml/
│ │ │ ├── compiler/
│ │ │ │ ├── haml.vim
│ │ │ │ └── sass.vim
│ │ │ ├── ftdetect/
│ │ │ │ └── haml.vim
│ │ │ ├── ftplugin/
│ │ │ │ ├── haml.vim
│ │ │ │ ├── sass.vim
│ │ │ │ └── scss.vim
│ │ │ ├── indent/
│ │ │ │ ├── haml.vim
│ │ │ │ ├── sass.vim
│ │ │ │ └── scss.vim
│ │ │ └── syntax/
│ │ │ ├── haml.vim
│ │ │ ├── sass.vim
│ │ │ └── scss.vim
│ │ ├── vim-localrc/
│ │ │ ├── autoload/
│ │ │ │ └── localrc.vim
│ │ │ ├── doc/
│ │ │ │ └── localrc.txt
│ │ │ └── plugin/
│ │ │ └── localrc.vim
│ │ ├── vim-markdown/
│ │ │ ├── ftdetect/
│ │ │ │ └── markdown.vim
│ │ │ ├── ftplugin/
│ │ │ │ └── markdown.vim
│ │ │ └── syntax/
│ │ │ └── markdown.vim
│ │ ├── vim-polyglot/
│ │ │ ├── .travis.yml
│ │ │ ├── Gemfile
│ │ │ ├── README.md
│ │ │ ├── after/
│ │ │ │ ├── ftdetect/
│ │ │ │ │ └── rspec.vim
│ │ │ │ ├── ftplugin/
│ │ │ │ │ └── haskell.vim
│ │ │ │ ├── indent/
│ │ │ │ │ └── html.vim
│ │ │ │ └── syntax/
│ │ │ │ ├── coffee.vim
│ │ │ │ ├── cpp.vim
│ │ │ │ ├── css/
│ │ │ │ │ └── vim-coloresque.vim
│ │ │ │ ├── haml.vim
│ │ │ │ ├── help.vim
│ │ │ │ ├── html.vim
│ │ │ │ ├── less.vim
│ │ │ │ ├── rspec.vim
│ │ │ │ ├── ruby.vim
│ │ │ │ ├── rust.vim
│ │ │ │ ├── sass.vim
│ │ │ │ ├── scss.vim
│ │ │ │ ├── stylus.vim
│ │ │ │ ├── tex.vim
│ │ │ │ └── vim.vim
│ │ │ ├── autoload/
│ │ │ │ ├── clojurecomplete.vim
│ │ │ │ ├── coffee.vim
│ │ │ │ ├── erlangcomplete.vim
│ │ │ │ ├── go/
│ │ │ │ │ └── complete.vim
│ │ │ │ ├── htmlcomplete.vim
│ │ │ │ ├── rubycomplete.vim
│ │ │ │ └── xml/
│ │ │ │ ├── aria.vim
│ │ │ │ └── html5.vim
│ │ │ ├── build
│ │ │ ├── compiler/
│ │ │ │ ├── cake.vim
│ │ │ │ ├── coffee.vim
│ │ │ │ ├── cucumber.vim
│ │ │ │ ├── erlang.vim
│ │ │ │ ├── eruby.vim
│ │ │ │ ├── exunit.vim
│ │ │ │ ├── go.vim
│ │ │ │ ├── haml.vim
│ │ │ │ ├── rake.vim
│ │ │ │ ├── rspec.vim
│ │ │ │ ├── ruby.vim
│ │ │ │ ├── rubyunit.vim
│ │ │ │ ├── rustc.vim
│ │ │ │ ├── sass.vim
│ │ │ │ └── typescript.vim
│ │ │ ├── ftdetect/
│ │ │ │ └── polyglot.vim
│ │ │ ├── ftplugin/
│ │ │ │ ├── clojure.vim
│ │ │ │ ├── coffee.vim
│ │ │ │ ├── csv.vim
│ │ │ │ ├── cucumber.vim
│ │ │ │ ├── elixir.vim
│ │ │ │ ├── erlang.vim
│ │ │ │ ├── erlang_refactor.vim
│ │ │ │ ├── eruby.vim
│ │ │ │ ├── git.vim
│ │ │ │ ├── gitcommit.vim
│ │ │ │ ├── gitconfig.vim
│ │ │ │ ├── gitrebase.vim
│ │ │ │ ├── gitsendemail.vim
│ │ │ │ ├── go/
│ │ │ │ │ ├── fmt.vim
│ │ │ │ │ └── import.vim
│ │ │ │ ├── go.vim
│ │ │ │ ├── haml.vim
│ │ │ │ ├── jade.vim
│ │ │ │ ├── latex-box/
│ │ │ │ │ ├── common.vim
│ │ │ │ │ ├── complete.vim
│ │ │ │ │ ├── findmain.vim
│ │ │ │ │ ├── folding.vim
│ │ │ │ │ ├── latexmk.vim
│ │ │ │ │ ├── mappings.vim
│ │ │ │ │ └── motion.vim
│ │ │ │ ├── latextoc.vim
│ │ │ │ ├── less.vim
│ │ │ │ ├── markdown.vim
│ │ │ │ ├── mustache.vim
│ │ │ │ ├── ocaml.vim
│ │ │ │ ├── opencl.vim
│ │ │ │ ├── perl.vim
│ │ │ │ ├── perl6.vim
│ │ │ │ ├── puppet.vim
│ │ │ │ ├── r.vim
│ │ │ │ ├── rhelp.vim
│ │ │ │ ├── rnoweb.vim
│ │ │ │ ├── ruby.vim
│ │ │ │ ├── rust.vim
│ │ │ │ ├── sass.vim
│ │ │ │ ├── scala.vim
│ │ │ │ ├── scala.xpt.vim
│ │ │ │ ├── scss.vim
│ │ │ │ ├── stylus.vim
│ │ │ │ ├── tex_LatexBox.vim
│ │ │ │ ├── textile.vim
│ │ │ │ ├── tt2html.vim
│ │ │ │ ├── twig.vim
│ │ │ │ ├── typescript.vim
│ │ │ │ └── xs.vim
│ │ │ ├── indent/
│ │ │ │ ├── arduino.vim
│ │ │ │ ├── clojure.vim
│ │ │ │ ├── coffee.vim
│ │ │ │ ├── cucumber.vim
│ │ │ │ ├── elixir.vim
│ │ │ │ ├── erlang.vim
│ │ │ │ ├── eruby.vim
│ │ │ │ ├── gitconfig.vim
│ │ │ │ ├── go.vim
│ │ │ │ ├── haml.vim
│ │ │ │ ├── haskell.vim
│ │ │ │ ├── html.vim
│ │ │ │ ├── jade.vim
│ │ │ │ ├── javascript.vim
│ │ │ │ ├── jst.vim
│ │ │ │ ├── less.vim
│ │ │ │ ├── ocaml.vim
│ │ │ │ ├── opencl.vim
│ │ │ │ ├── perl.vim
│ │ │ │ ├── perl6.vim
│ │ │ │ ├── puppet.vim
│ │ │ │ ├── ruby.vim
│ │ │ │ ├── rust.vim
│ │ │ │ ├── sass.vim
│ │ │ │ ├── scala.vim
│ │ │ │ ├── scss.vim
│ │ │ │ ├── slim.vim
│ │ │ │ ├── stylus.vim
│ │ │ │ └── tex.vim
│ │ │ ├── spec/
│ │ │ │ ├── build_spec.rb
│ │ │ │ ├── loading_spec.rb
│ │ │ │ └── spec_helper.rb
│ │ │ └── syntax/
│ │ │ ├── arduino.vim
│ │ │ ├── c.vim
│ │ │ ├── cabal.vim
│ │ │ ├── clojure.vim
│ │ │ ├── coffee.vim
│ │ │ ├── cpp.vim
│ │ │ ├── csv.vim
│ │ │ ├── cucumber.vim
│ │ │ ├── dockerfile.vim
│ │ │ ├── elixir.vim
│ │ │ ├── erlang.vim
│ │ │ ├── eruby.vim
│ │ │ ├── git.vim
│ │ │ ├── gitcommit.vim
│ │ │ ├── gitconfig.vim
│ │ │ ├── gitrebase.vim
│ │ │ ├── gitsendemail.vim
│ │ │ ├── go.vim
│ │ │ ├── godoc.vim
│ │ │ ├── haml.vim
│ │ │ ├── haskell.vim
│ │ │ ├── html/
│ │ │ │ ├── aria.vim
│ │ │ │ └── rdfa.vim
│ │ │ ├── html.vim
│ │ │ ├── jade.vim
│ │ │ ├── javascript/
│ │ │ │ └── html5.vim
│ │ │ ├── javascript.vim
│ │ │ ├── json.vim
│ │ │ ├── jst.vim
│ │ │ ├── latextoc.vim
│ │ │ ├── less.vim
│ │ │ ├── markdown.vim
│ │ │ ├── mason.vim
│ │ │ ├── mustache.vim
│ │ │ ├── nginx.vim
│ │ │ ├── ocaml.vim
│ │ │ ├── octave.vim
│ │ │ ├── opencl.vim
│ │ │ ├── perl.vim
│ │ │ ├── perl6.vim
│ │ │ ├── php.vim
│ │ │ ├── pod.vim
│ │ │ ├── proto.vim
│ │ │ ├── puppet.vim
│ │ │ ├── python.vim
│ │ │ ├── rhelp.vim
│ │ │ ├── rnoweb.vim
│ │ │ ├── ruby.vim
│ │ │ ├── rust.vim
│ │ │ ├── sass.vim
│ │ │ ├── sbt.vim
│ │ │ ├── scala.vim
│ │ │ ├── scss.vim
│ │ │ ├── slim.vim
│ │ │ ├── stylus.vim
│ │ │ ├── textile.vim
│ │ │ ├── tmux.vim
│ │ │ ├── tt2.vim
│ │ │ ├── tt2html.vim
│ │ │ ├── tt2js.vim
│ │ │ ├── twig.vim
│ │ │ ├── typescript.vim
│ │ │ ├── vbnet.vim
│ │ │ ├── xs.vim
│ │ │ └── xsl.vim
│ │ ├── vim-repeat/
│ │ │ ├── README.markdown
│ │ │ └── autoload/
│ │ │ └── repeat.vim
│ │ ├── vim-surround/
│ │ │ ├── README.markdown
│ │ │ ├── doc/
│ │ │ │ └── surround.txt
│ │ │ └── plugin/
│ │ │ └── surround.vim
│ │ ├── vim-tbone/
│ │ │ ├── CONTRIBUTING.markdown
│ │ │ ├── README.markdown
│ │ │ ├── autoload/
│ │ │ │ └── tbone.vim
│ │ │ ├── doc/
│ │ │ │ └── tbone.txt
│ │ │ └── plugin/
│ │ │ └── tbone.vim
│ │ ├── webapi-vim/
│ │ │ ├── Makefile
│ │ │ ├── README
│ │ │ ├── autoload/
│ │ │ │ └── webapi/
│ │ │ │ ├── atom.vim
│ │ │ │ ├── base64.vim
│ │ │ │ ├── bit.vim
│ │ │ │ ├── feed.vim
│ │ │ │ ├── hmac.vim
│ │ │ │ ├── html.vim
│ │ │ │ ├── http.vim
│ │ │ │ ├── json.vim
│ │ │ │ ├── jsonrpc.vim
│ │ │ │ ├── metaWeblog.vim
│ │ │ │ ├── oauth.vim
│ │ │ │ ├── sha1.vim
│ │ │ │ ├── soap.vim
│ │ │ │ ├── ucs.vim
│ │ │ │ ├── xml.vim
│ │ │ │ └── xmlrpc.vim
│ │ │ ├── doc/
│ │ │ │ ├── webapi-html.txt
│ │ │ │ ├── webapi-http.txt
│ │ │ │ ├── webapi-json.txt
│ │ │ │ └── webapi-xml.txt
│ │ │ ├── example/
│ │ │ │ ├── gistview.vim
│ │ │ │ ├── google-buzz.vim
│ │ │ │ ├── hatenadiary.vim
│ │ │ │ ├── jugem.vim
│ │ │ │ ├── livedoor.vim
│ │ │ │ ├── rss.vim
│ │ │ │ ├── twitter.vim
│ │ │ │ └── weather.vim
│ │ │ └── webapi.vim.vimup
│ │ └── wildfire.vim/
│ │ ├── LICENSE.txt
│ │ ├── README.md
│ │ ├── autoload/
│ │ │ └── wildfire.vim
│ │ ├── doc/
│ │ │ └── wildfire.txt
│ │ └── plugin/
│ │ └── wildfire.vim
│ └── plugin/
│ ├── BufOnly.vim
│ └── scratch.vim
├── .vimrc
├── .zshrc
├── README.md
├── fonts/
│ └── Droid+Sans+Mono+for+Powerline.otf
└── themes/
├── Smyck.terminal
├── Solarized Dark.terminal
├── Solarized Light.terminal
└── Tomorrow Night Bright.terminal
SYMBOL INDEX (12 symbols across 1 files)
FILE: .vim/bundle/vim-fireplace/python/nrepl_fireplace.py
function noop (line 9) | def noop():
function vim_encode (line 12) | def vim_encode(data):
function bdecode (line 30) | def bdecode(f, char=None):
class Connection (line 68) | class Connection:
method __init__ (line 69) | def __init__(self, host, port, custom_poll=noop, keepalive_file=None):
method poll (line 78) | def poll(self):
method close (line 83) | def close(self):
method send (line 86) | def send(self, payload):
method receive (line 90) | def receive(self, char=None):
method call (line 99) | def call(self, payload, terminators, selectors):
function dispatch (line 111) | def dispatch(host, port, poll, keepalive, command, *args):
function main (line 118) | def main(host, port, keepalive, command, *args):
Condensed preview — 759 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (5,926K chars).
[
{
"path": ".tmux.conf",
"chars": 4457,
"preview": "# Bindings {{{\n# Remap prefix\nunbind C-b\nset -g prefix C-Space\n\n# Quick key for moving back to the previous window\nbind-"
},
{
"path": ".vim/autoload/pathogen.vim",
"chars": 11733,
"preview": "\" pathogen.vim - path option manipulation\n\" Maintainer: Tim Pope <http://tpo.pe/>\n\" Version: 2.2\n\n\" Install in ~/"
},
{
"path": ".vim/bundle/CSApprox/README",
"chars": 2474,
"preview": "This is a mirror of http://www.vim.org/scripts/script.php?script_id=2390\n\nCSApprox.vim\n\n============\nDESCRIPTION\n======="
},
{
"path": ".vim/bundle/CSApprox/after/plugin/CSApprox.vim",
"chars": 1641,
"preview": "\" Copyright (c) 2012, Matthew J. Wozniski\n\" All rights reserved.\n\"\n\" Redistribution and use in source and binary forms, "
},
{
"path": ".vim/bundle/CSApprox/autoload/csapprox/common.vim",
"chars": 3472,
"preview": "\" Copyright (c) 2012, Matthew J. Wozniski\n\" All rights reserved.\n\"\n\" Redistribution and use in source and binary forms, "
},
{
"path": ".vim/bundle/CSApprox/autoload/csapprox/per_component.vim",
"chars": 3640,
"preview": "\" Copyright (c) 2012, Matthew J. Wozniski\n\" All rights reserved.\n\"\n\" Redistribution and use in source and binary forms, "
},
{
"path": ".vim/bundle/CSApprox/autoload/csapprox.vim",
"chars": 39799,
"preview": "\" Copyright (c) 2012, Matthew J. Wozniski\n\" All rights reserved.\n\"\n\" Redistribution and use in source and binary forms, "
},
{
"path": ".vim/bundle/CSApprox/doc/CSApprox.txt",
"chars": 37521,
"preview": "*CSApprox.txt* Bringing GVim colorschemes to the terminal!\n\n *csapp"
},
{
"path": ".vim/bundle/CSApprox/plugin/CSApprox.vim",
"chars": 32756,
"preview": "\" CSApprox: Make gvim-only colorschemes Just Work terminal vim\n\" Maintainer: Matthew Wozniski (godlygeek@gmail.com)\n"
},
{
"path": ".vim/bundle/Gist.vim/README",
"chars": 1780,
"preview": "This is a mirror of http://www.vim.org/scripts/script.php?script_id=2423\n\nThis is vimscript for gist (http://gist.github"
},
{
"path": ".vim/bundle/Gist.vim/README.mkd",
"chars": 5272,
"preview": "### Gist.vim\n\nThis is a vimscript for creating gists (http://gist.github.com).\n\nFor the latest version please see https:"
},
{
"path": ".vim/bundle/Gist.vim/autoload/gist.vim",
"chars": 26415,
"preview": "\"=============================================================================\n\" File: gist.vim\n\" Author: Yasuhiro Matsu"
},
{
"path": ".vim/bundle/Gist.vim/doc/gist-vim.txt",
"chars": 7183,
"preview": "*Gist.vim* Vimscript for creating gists (http://gist.github.com)\n\nUsage |gist-v"
},
{
"path": ".vim/bundle/Gist.vim/plugin/gist.vim",
"chars": 734,
"preview": "\"=============================================================================\n\" File: gist.vim\n\" Author: Yasuhiro Matsu"
},
{
"path": ".vim/bundle/Tabmerge/README",
"chars": 402,
"preview": "This is a mirror of http://www.vim.org/scripts/script.php?script_id=1961\n\nUsage:\n :Tabmerge [tab number] [top|bottom|lef"
},
{
"path": ".vim/bundle/Tabmerge/plugin/Tabmerge.vim",
"chars": 2428,
"preview": "\" Tabmerge -- Merge the windows in a tab with the current tab.\n\"\n\" Copyright July 17, 2007 Christian J. Robinson <infyni"
},
{
"path": ".vim/bundle/ZoomWin/autoload/ZoomWin.vim",
"chars": 19207,
"preview": "\" ZoomWin:\tBrief-like ability to zoom into/out-of a window\n\" Author:\tCharles Campbell\n\"\t\t\toriginal version by Ron Aaron\n"
},
{
"path": ".vim/bundle/ZoomWin/doc/ZoomWin.txt",
"chars": 10318,
"preview": "*ZoomWin.txt*\tZoom into/out-of a window\t\tMar 09, 2014\nAuthors: Charles E. Campbell\t\t\t\t*zoomwin*\n Ron Aaron\nCopyr"
},
{
"path": ".vim/bundle/ZoomWin/plugin/ZoomWinPlugin.vim",
"chars": 1515,
"preview": "\" ZoomWin:\tBrief-like ability to zoom into/out-of a window\n\" Author:\tCharles Campbell\n\"\t\t\toriginal version by Ron Aaron\n"
},
{
"path": ".vim/bundle/ack.vim/README.md",
"chars": 3773,
"preview": "# ack.vim #\n\nThis plugin is a front for the Perl module\n[App::Ack](http://search.cpan.org/~petdance/ack/ack). Ack can b"
},
{
"path": ".vim/bundle/ack.vim/Rakefile",
"chars": 608,
"preview": "# Added by Josh Nichols, a.k.a. technicalpickles\nrequire 'rake'\n\nfiles = ['doc/ack.txt', 'plugin/ack.vim']\n\ndesc 'Instal"
},
{
"path": ".vim/bundle/ack.vim/doc/ack.txt",
"chars": 3365,
"preview": "*ack.txt* Plugin that integrates ack with Vim\n\n======================================================================="
},
{
"path": ".vim/bundle/ack.vim/plugin/ack.vim",
"chars": 3559,
"preview": "\" NOTE: You must, of course, install the ack script\n\" in your path.\n\" On Debian / Ubuntu:\n\" sudo apt-get install"
},
{
"path": ".vim/bundle/camelcasemotion/README",
"chars": 2845,
"preview": "This is a mirror of http://www.vim.org/scripts/script.php?script_id=1905\n\nDESCRIPTION\nVim provides many built-in motions"
},
{
"path": ".vim/bundle/camelcasemotion/autoload/camelcasemotion.vim",
"chars": 8376,
"preview": "\" camelcasemotion.vim: Motion through CamelCaseWords and underscore_notation. \n\"\n\" DEPENDENCIES:\n\" - Requires Vim 7.0 "
},
{
"path": ".vim/bundle/camelcasemotion/doc/camelcasemotion.txt",
"chars": 9986,
"preview": "*camelcasemotion.txt* Motion through CamelCaseWords and underscore_notation. \n\n\t\t CAMEL CASE MOTION by Ingo Kar"
},
{
"path": ".vim/bundle/camelcasemotion/plugin/camelcasemotion.vim",
"chars": 9194,
"preview": "\" camelcasemotion.vim: Motion through CamelCaseWords and underscore_notation. \n\"\n\" DEPENDENCIES:\n\" - Requires Vim 7.0 "
},
{
"path": ".vim/bundle/ctrlp.vim/autoload/ctrlp/bookmarkdir.vim",
"chars": 3639,
"preview": "\" =============================================================================\n\" File: autoload/ctrlp/bookmark"
},
{
"path": ".vim/bundle/ctrlp.vim/autoload/ctrlp/buffertag.vim",
"chars": 7278,
"preview": "\" =============================================================================\n\" File: autoload/ctrlp/bufferta"
},
{
"path": ".vim/bundle/ctrlp.vim/autoload/ctrlp/changes.vim",
"chars": 2675,
"preview": "\" =============================================================================\n\" File: autoload/ctrlp/changes."
},
{
"path": ".vim/bundle/ctrlp.vim/autoload/ctrlp/dir.vim",
"chars": 2705,
"preview": "\" =============================================================================\n\" File: autoload/ctrlp/dir.vim\n"
},
{
"path": ".vim/bundle/ctrlp.vim/autoload/ctrlp/line.vim",
"chars": 2104,
"preview": "\" =============================================================================\n\" File: autoload/ctrlp/line.vim"
},
{
"path": ".vim/bundle/ctrlp.vim/autoload/ctrlp/mixed.vim",
"chars": 2690,
"preview": "\" =============================================================================\n\" File: autoload/ctrlp/mixed.vi"
},
{
"path": ".vim/bundle/ctrlp.vim/autoload/ctrlp/mrufiles.vim",
"chars": 4064,
"preview": "\" =============================================================================\n\" File: autoload/ctrlp/mrufiles"
},
{
"path": ".vim/bundle/ctrlp.vim/autoload/ctrlp/quickfix.vim",
"chars": 1532,
"preview": "\" =============================================================================\n\" File: autoload/ctrlp/quickfix"
},
{
"path": ".vim/bundle/ctrlp.vim/autoload/ctrlp/rtscript.vim",
"chars": 1809,
"preview": "\" =============================================================================\n\" File: autoload/ctrlp/rtscript"
},
{
"path": ".vim/bundle/ctrlp.vim/autoload/ctrlp/tag.vim",
"chars": 3462,
"preview": "\" =============================================================================\n\" File: autoload/ctrlp/tag.vim\n"
},
{
"path": ".vim/bundle/ctrlp.vim/autoload/ctrlp/undo.vim",
"chars": 3708,
"preview": "\" =============================================================================\n\" File: autoload/ctrlp/undo.vim"
},
{
"path": ".vim/bundle/ctrlp.vim/autoload/ctrlp/utils.vim",
"chars": 2886,
"preview": "\" =============================================================================\n\" File: autoload/ctrlp/utils.vi"
},
{
"path": ".vim/bundle/ctrlp.vim/autoload/ctrlp.vim",
"chars": 63088,
"preview": "\" =============================================================================\n\" File: autoload/ctrlp.vim\n\" De"
},
{
"path": ".vim/bundle/ctrlp.vim/doc/ctrlp.txt",
"chars": 54998,
"preview": "*ctrlp.txt* Fuzzy file, buffer, mru, tag, ... finder. v1.79\n*CtrlP* *ControlP* *'ctrlp'* *'ctrl-p'*\n=============="
},
{
"path": ".vim/bundle/ctrlp.vim/plugin/ctrlp.vim",
"chars": 2481,
"preview": "\" =============================================================================\n\" File: plugin/ctrlp.vim\n\" Desc"
},
{
"path": ".vim/bundle/ctrlp.vim/readme.md",
"chars": 3573,
"preview": "# ctrlp.vim\nFull path fuzzy __file__, __buffer__, __mru__, __tag__, __...__ finder for Vim.\n\n* Written in pure Vimscript"
},
{
"path": ".vim/bundle/emmet-vim/Makefile",
"chars": 190,
"preview": "all : emmet-vim.zip\n\nremove-zip:\n\t-rm doc/tags\n\t-rm emmet-vim.zip\n\nemmet-vim.zip: remove-zip\n\tzip -r emmet-vim.zip autol"
},
{
"path": ".vim/bundle/emmet-vim/README.mkd",
"chars": 2946,
"preview": "# Emmet-vim\n\n[emmet-vim](http://mattn.github.com/emmet-vim) is a vim plug-in\nwhich provides support for expanding abbrev"
},
{
"path": ".vim/bundle/emmet-vim/TODO",
"chars": 0,
"preview": ""
},
{
"path": ".vim/bundle/emmet-vim/TUTORIAL",
"chars": 4391,
"preview": "Tutorial for Emmet.vim\n\n mattn <mattn.jp@gmail.com>\n\n1. Expand an Abb"
},
{
"path": ".vim/bundle/emmet-vim/autoload/emmet/lang/css.vim",
"chars": 9835,
"preview": "function! emmet#lang#css#findTokens(str)\n return substitute(substitute(a:str, '^.*[;{]\\s*', '', ''), '}\\s*$', '', '')\ne"
},
{
"path": ".vim/bundle/emmet-vim/autoload/emmet/lang/haml.vim",
"chars": 9348,
"preview": "function! emmet#lang#haml#findTokens(str)\n return emmet#lang#html#findTokens(a:str)\nendfunction\n\nfunction! emmet#lang#h"
},
{
"path": ".vim/bundle/emmet-vim/autoload/emmet/lang/html.vim",
"chars": 26603,
"preview": "let s:mx = '\\([+>]\\|[<^]\\+\\)\\{-}\\s*'\n\\ .'\\((*\\)\\{-}\\s*'\n\\ .'\\([@#.]\\{-}[a-zA-Z_\\!][a-zA-Z0-9:_\\!\\-$]*\\|{\\%([^$"
},
{
"path": ".vim/bundle/emmet-vim/autoload/emmet/lang/less.vim",
"chars": 1281,
"preview": "function! emmet#lang#less#findTokens(str)\n return emmet#lang#html#findTokens(a:str)\nendfunction\n\nfunction! emmet#lang#l"
},
{
"path": ".vim/bundle/emmet-vim/autoload/emmet/lang/sass.vim",
"chars": 4074,
"preview": "function! emmet#lang#sass#findTokens(str)\n return a:str\nendfunction\n\nfunction! emmet#lang#sass#parseIntoTree(abbr, type"
},
{
"path": ".vim/bundle/emmet-vim/autoload/emmet/lang/scss.vim",
"chars": 3369,
"preview": "function! emmet#lang#scss#findTokens(str)\n return emmet#lang#html#findTokens(a:str)\nendfunction\n\nfunction! emmet#lang#s"
},
{
"path": ".vim/bundle/emmet-vim/autoload/emmet/lang/slim.vim",
"chars": 7997,
"preview": "function! emmet#lang#slim#findTokens(str)\n return emmet#lang#html#findTokens(a:str)\nendfunction\n\nfunction! emmet#lang#s"
},
{
"path": ".vim/bundle/emmet-vim/autoload/emmet/lang.vim",
"chars": 284,
"preview": "let s:exists = {}\nfunction! emmet#lang#exists(type)\n if len(a:type) == 0\n return 0\n elseif has_key(s:exists, a:type"
},
{
"path": ".vim/bundle/emmet-vim/autoload/emmet/lorem/en.vim",
"chars": 3310,
"preview": "function! emmet#lorem#en#expand(command)\n let wcount = matchstr(a:command, '\\(\\d*\\)$')\n let wcount = wcount > 0 ? wcou"
},
{
"path": ".vim/bundle/emmet-vim/autoload/emmet/lorem/ja.vim",
"chars": 1020,
"preview": "scriptencoding utf-8\n\nfunction! emmet#lorem#ja#expand(command)\n let wcount = matchstr(a:command, '^\\%(lorem\\|lipsum\\)\\("
},
{
"path": ".vim/bundle/emmet-vim/autoload/emmet/util.vim",
"chars": 10949,
"preview": "\"==============================================================================\n\" region utils\n\"========================"
},
{
"path": ".vim/bundle/emmet-vim/autoload/emmet.vim",
"chars": 63208,
"preview": "\"=============================================================================\n\" emmet.vim\n\" Author: Yasuhiro Matsumoto "
},
{
"path": ".vim/bundle/emmet-vim/doc/emmet.txt",
"chars": 14472,
"preview": "*emmet.txt*\tEmmet for Vim\n\n\t -------------------------------------------------------\n\t Emmet: vim plugins for HTML"
},
{
"path": ".vim/bundle/emmet-vim/emmet.vim.vimup",
"chars": 10068,
"preview": "script_name: Emmet.vim\nscript_id: '2981'\nscript_type: utility\nscript_package: emmet-vim.zip\nscript_version: '0.83'\nrequi"
},
{
"path": ".vim/bundle/emmet-vim/plugin/emmet.vim",
"chars": 7987,
"preview": "\"=============================================================================\n\" File: emmet.vim\n\" Author: Yasuhiro Mats"
},
{
"path": ".vim/bundle/emmet-vim/unittest.vim",
"chars": 35261,
"preview": "\" {{{\nlet s:sfile = expand('<sfile>')\n\nfunction! s:reload(d)\n exe \"so\" a:d.\"/plugin/emmet.vim\"\n for f in split(globpat"
},
{
"path": ".vim/bundle/gruvbox/README.md",
"chars": 2848,
"preview": "gruvbox\n=======\n\nRetro groove color scheme for Vim.\n\nGruvbox is heavily inspired by [badwolf][], [jellybeans][] and [sol"
},
{
"path": ".vim/bundle/gruvbox/autoload/gruvbox.vim",
"chars": 910,
"preview": "\" -----------------------------------------------------------------------------\n\" File: gruvbox.vim\n\" Description: Retro"
},
{
"path": ".vim/bundle/gruvbox/colors/gruvbox.vim",
"chars": 26577,
"preview": "\" -----------------------------------------------------------------------------\n\" File: gruvbox.vim\n\" Description: Retro"
},
{
"path": ".vim/bundle/gruvbox/gruvbox_256palette.sh",
"chars": 4568,
"preview": "#!/bin/sh\n\nif [ \"${TERM%%-*}\" = \"screen\" ]; then\n\tif [ -n \"$TMUX\" ]; then\n\t\tprintf \"\\033Ptmux;\\033\\033]4;236;rgb:32/30/2"
},
{
"path": ".vim/bundle/gruvbox/gruvbox_256palette_osx.sh",
"chars": 4568,
"preview": "#!/bin/sh\n\nif [ \"${TERM%%-*}\" = \"screen\" ]; then\n\tif [ -n \"$TMUX\" ]; then\n\t\tprintf \"\\033Ptmux;\\033\\033]4;236;rgb:26/24/2"
},
{
"path": ".vim/bundle/html5.vim/CHANGES.markdown",
"chars": 509,
"preview": "# html5.vim\n\n## Change Log\n\n### Version 0.27\n\n- Added inline SVG\n\n### Version 0.26\n\n- Support multi-value attributes (Mo"
},
{
"path": ".vim/bundle/html5.vim/Makefile",
"chars": 11034,
"preview": "# vim:filetype=make:foldmethod=marker:fdl=0:\n#\n# Makefile: install/uninstall/link vim plugin files.\n# Author: Cornelius "
},
{
"path": ".vim/bundle/html5.vim/README.md",
"chars": 2824,
"preview": "# html5.vim\n\nHTML5 + inline SVG omnicomplete funtion, indent and syntax for Vim.\nBased on the default htmlcomplete.vim.\n"
},
{
"path": ".vim/bundle/html5.vim/autoload/htmlcomplete.vim",
"chars": 28460,
"preview": "\" Vim completion script\n\" Language:\tHTML and XHTML\n\" Maintainer:\tMikolaj Machowski ( mikmach AT wp DOT pl )\n\" Last Chang"
},
{
"path": ".vim/bundle/html5.vim/autoload/xml/aria.vim",
"chars": 13204,
"preview": "\" Vim completion for WAI-ARIA data file\n\" Language: HTML + WAI-ARIA\n\" Maintainer: othree <othree@gmail.com>\n\" "
},
{
"path": ".vim/bundle/html5.vim/autoload/xml/html5.vim",
"chars": 34706,
"preview": "\" Vim completion for HTML5 data file\n\" Language: HTML5\n\" Maintainer: othree <othree@gmail.com>\n\" Last Change: "
},
{
"path": ".vim/bundle/html5.vim/config.mk",
"chars": 14,
"preview": "VERSION=0.26\n\n"
},
{
"path": ".vim/bundle/html5.vim/indent/html.vim",
"chars": 11451,
"preview": "\" Description: HTML5 and inline SVG indenter\n\" Changed By: HT de Beer <H.T.de.Beer@gmail.com>\n\" Last Change: 201210"
},
{
"path": ".vim/bundle/html5.vim/syntax/html/aria.vim",
"chars": 1615,
"preview": "\" Vim syntax file\n\" Language:\t WAI-ARIA\n\" Maintainer:\tothree <othree@gmail.com>\n\" URL:\t\t http://github.com/othree/"
},
{
"path": ".vim/bundle/html5.vim/syntax/html/rdfa.vim",
"chars": 397,
"preview": "\" Vim syntax file\n\" Language: RDFa\n\" Maintainer: othree <othree@gmail.com>\n\" URL: http://github.com/othre"
},
{
"path": ".vim/bundle/html5.vim/syntax/html.vim",
"chars": 8483,
"preview": "\" Vim syntax file\n\" Language:\tHTML (version 5)\n\" Maintainer:\tRodrigo Machado <rcmachado@gmail.com>\n\" URL:\t\thttp://rm.blo"
},
{
"path": ".vim/bundle/html5.vim/syntax/javascript/html5.vim",
"chars": 2570,
"preview": "\" Vim syntax file\n\" Language:\t HTML5 New Stuff\n\" Maintainer:\tothree <othree@gmail.com>\n\" URL:\t\t http://github.com/"
},
{
"path": ".vim/bundle/nerdtree/README.markdown",
"chars": 4803,
"preview": "The NERD Tree\n=============\n\nIntro\n-----\n\nThe NERD tree allows you to explore your filesystem and to open files and\ndire"
},
{
"path": ".vim/bundle/nerdtree/autoload/nerdtree.vim",
"chars": 46633,
"preview": "if exists(\"g:loaded_nerdtree_autoload\")\n finish\nendif\nlet g:loaded_nerdtree_autoload = 1\n\nfunction! nerdtree#version("
},
{
"path": ".vim/bundle/nerdtree/doc/NERD_tree.txt",
"chars": 55911,
"preview": "*NERD_tree.txt* A tree explorer plugin that owns your momma!\n\n\n\n omg its ... ~\n\n ________ ________ _ ______"
},
{
"path": ".vim/bundle/nerdtree/lib/nerdtree/bookmark.vim",
"chars": 10394,
"preview": "\"CLASS: Bookmark\n\"============================================================\nlet s:Bookmark = {}\nlet g:NERDTreeBookmar"
},
{
"path": ".vim/bundle/nerdtree/lib/nerdtree/creator.vim",
"chars": 10200,
"preview": "\"CLASS: Creator\n\"Creates primary/secondary/mirror nerdtree windows. Sets up all the window and\n\"buffer options and key m"
},
{
"path": ".vim/bundle/nerdtree/lib/nerdtree/key_map.vim",
"chars": 3993,
"preview": "\"CLASS: KeyMap\n\"============================================================\nlet s:KeyMap = {}\nlet g:NERDTreeKeyMap = s:"
},
{
"path": ".vim/bundle/nerdtree/lib/nerdtree/menu_controller.vim",
"chars": 5160,
"preview": "\"CLASS: MenuController\n\"============================================================\nlet s:MenuController = {}\nlet g:NER"
},
{
"path": ".vim/bundle/nerdtree/lib/nerdtree/menu_item.vim",
"chars": 3296,
"preview": "\"CLASS: MenuItem\n\"============================================================\nlet s:MenuItem = {}\nlet g:NERDTreeMenuIte"
},
{
"path": ".vim/bundle/nerdtree/lib/nerdtree/opener.vim",
"chars": 7854,
"preview": "\"CLASS: Opener\n\"============================================================\nlet s:Opener = {}\nlet g:NERDTreeOpener = s:"
},
{
"path": ".vim/bundle/nerdtree/lib/nerdtree/path.vim",
"chars": 20014,
"preview": "\"we need to use this number many times for sorting... so we calculate it only\n\"once here\nlet s:NERDTreeSortStarIndex = i"
},
{
"path": ".vim/bundle/nerdtree/lib/nerdtree/tree_dir_node.vim",
"chars": 15672,
"preview": "\"CLASS: TreeDirNode\n\"A subclass of NERDTreeFileNode.\n\"\n\"The 'composite' part of the file/dir composite.\n\"==============="
},
{
"path": ".vim/bundle/nerdtree/lib/nerdtree/tree_file_node.vim",
"chars": 15336,
"preview": "\"CLASS: TreeFileNode\n\"This class is the parent of the TreeDirNode class and is the\n\"'Component' part of the composite de"
},
{
"path": ".vim/bundle/nerdtree/nerdtree_plugin/exec_menuitem.vim",
"chars": 1614,
"preview": "\" ============================================================================\n\" File: exec_menuitem.vim\n\" Descri"
},
{
"path": ".vim/bundle/nerdtree/nerdtree_plugin/fs_menu.vim",
"chars": 9955,
"preview": "\" ============================================================================\n\" File: fs_menu.vim\n\" Description:"
},
{
"path": ".vim/bundle/nerdtree/plugin/NERD_tree.vim",
"chars": 8237,
"preview": "\" ============================================================================\n\" File: NERD_tree.vim\n\" Descriptio"
},
{
"path": ".vim/bundle/nerdtree/syntax/nerdtree.vim",
"chars": 3741,
"preview": "let s:tree_up_dir_line = '.. (up a dir)'\n\"NERDTreeFlags are syntax items that should be invisible, but give clues as to\n"
},
{
"path": ".vim/bundle/paredit.vim/README",
"chars": 1257,
"preview": "This is a mirror of http://www.vim.org/scripts/script.php?script_id=3998\n\nParedit performs structured editing of Lisp S-"
},
{
"path": ".vim/bundle/paredit.vim/doc/paredit.txt",
"chars": 23152,
"preview": "*paredit.txt* Paredit Last Change: 29 Dec 2013\n\nParedit Mode for Vim "
},
{
"path": ".vim/bundle/paredit.vim/plugin/paredit.vim",
"chars": 64564,
"preview": "\" paredit.vim:\n\" Paredit mode for Slimv\n\" Version: 0.9.12\n\" Last Change: 20 Nov 2013\n\" Maintainer: "
},
{
"path": ".vim/bundle/rainbow_parentheses.vim/autoload/rainbow_parentheses.vim",
"chars": 3030,
"preview": "\"==============================================================================\n\" Description: Rainbow colors for paren"
},
{
"path": ".vim/bundle/rainbow_parentheses.vim/plugin/rainbow_parentheses.vim",
"chars": 841,
"preview": "\"==============================================================================\n\" Description: Rainbow colors for paren"
},
{
"path": ".vim/bundle/rainbow_parentheses.vim/readme.md",
"chars": 1197,
"preview": "# Better Rainbow Parentheses\n\n### Options:\n\n```vim\nlet g:rbpt_colorpairs = [\n \\ ['brown', 'RoyalBlue3'],\n \\ "
},
{
"path": ".vim/bundle/supertab/Makefile",
"chars": 307,
"preview": "SHELL=/bin/bash\n\nall: dist\n\ndist:\n\t@rm supertab.vmb 2> /dev/null || true\n\t@vim -c 'r! git ls-files doc plugin' \\\n\t\t-c '$"
},
{
"path": ".vim/bundle/supertab/README.rst",
"chars": 5895,
"preview": ".. Copyright (c) 2012 - 2013, Eric Van Dewoestine\n All rights reserved.\n\n Redistribution and use of this software in"
},
{
"path": ".vim/bundle/supertab/doc/supertab.txt",
"chars": 18813,
"preview": "*supertab.txt*\n\nAuthor: Eric Van Dewoestine <ervandew@gmail.com>\n Original concept and versions up to 0.32 writte"
},
{
"path": ".vim/bundle/supertab/plugin/supertab.vim",
"chars": 29501,
"preview": "\" Author: Eric Van Dewoestine <ervandew@gmail.com>\n\" Original concept and versions up to 0.32 written by\n\" "
},
{
"path": ".vim/bundle/syntastic/CONTRIBUTING.md",
"chars": 2004,
"preview": "# Bug reports / Github issues\n\nWhen reporting a bug make sure you search the existing github issues for the\nsame/similar"
},
{
"path": ".vim/bundle/syntastic/LICENCE",
"chars": 474,
"preview": " DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE\n Version 2, December 2004\n\nCopyright (C) 2004 S"
},
{
"path": ".vim/bundle/syntastic/README.markdown",
"chars": 10231,
"preview": " ,\n / \\,,_ .'|\n ,{{| /}}}}/_.' ____________________________"
},
{
"path": ".vim/bundle/syntastic/autoload/syntastic/c.vim",
"chars": 11904,
"preview": "if exists(\"g:loaded_syntastic_c_autoload\") || !exists(\"g:loaded_syntastic_plugin\")\n finish\nendif\nlet g:loaded_syntast"
},
{
"path": ".vim/bundle/syntastic/autoload/syntastic/log.vim",
"chars": 4175,
"preview": "if exists(\"g:loaded_syntastic_log_autoload\") || !exists(\"g:loaded_syntastic_plugin\")\n finish\nendif\nlet g:loaded_synta"
},
{
"path": ".vim/bundle/syntastic/autoload/syntastic/postprocess.vim",
"chars": 1967,
"preview": "if exists(\"g:loaded_syntastic_postprocess_autoload\") || !exists(\"g:loaded_syntastic_plugin\")\n finish\nendif\nlet g:load"
},
{
"path": ".vim/bundle/syntastic/autoload/syntastic/preprocess.vim",
"chars": 2451,
"preview": "if exists(\"g:loaded_syntastic_preprocess_autoload\") || !exists(\"g:loaded_syntastic_plugin\")\n finish\nendif\nlet g:loade"
},
{
"path": ".vim/bundle/syntastic/autoload/syntastic/util.vim",
"chars": 8100,
"preview": "if exists('g:loaded_syntastic_util_autoload') || !exists(\"g:loaded_syntastic_plugin\")\n finish\nendif\nlet g:loaded_synt"
},
{
"path": ".vim/bundle/syntastic/doc/syntastic.txt",
"chars": 32064,
"preview": "*syntastic.txt* Syntax checking on the fly has never been so pimp.\n*syntastic*\n\n\n It's a bird! It's"
},
{
"path": ".vim/bundle/syntastic/plugin/syntastic/autoloclist.vim",
"chars": 1143,
"preview": "if exists(\"g:loaded_syntastic_notifier_autoloclist\") || !exists(\"g:loaded_syntastic_plugin\")\n finish\nendif\nlet g:load"
},
{
"path": ".vim/bundle/syntastic/plugin/syntastic/balloons.vim",
"chars": 1913,
"preview": "if exists(\"g:loaded_syntastic_notifier_balloons\") || !exists(\"g:loaded_syntastic_plugin\")\n finish\nendif\nlet g:loaded_"
},
{
"path": ".vim/bundle/syntastic/plugin/syntastic/checker.vim",
"chars": 5422,
"preview": "if exists(\"g:loaded_syntastic_checker\") || !exists(\"g:loaded_syntastic_plugin\")\n finish\nendif\nlet g:loaded_syntastic_"
},
{
"path": ".vim/bundle/syntastic/plugin/syntastic/cursor.vim",
"chars": 1819,
"preview": "if exists(\"g:loaded_syntastic_notifier_cursor\") || !exists(\"g:loaded_syntastic_plugin\")\n finish\nendif\nlet g:loaded_sy"
},
{
"path": ".vim/bundle/syntastic/plugin/syntastic/highlighting.vim",
"chars": 2932,
"preview": "if exists(\"g:loaded_syntastic_notifier_highlighting\") || !exists(\"g:loaded_syntastic_plugin\")\n finish\nendif\nlet g:loa"
},
{
"path": ".vim/bundle/syntastic/plugin/syntastic/loclist.vim",
"chars": 7603,
"preview": "if exists(\"g:loaded_syntastic_loclist\") || !exists(\"g:loaded_syntastic_plugin\")\n finish\nendif\nlet g:loaded_syntastic_"
},
{
"path": ".vim/bundle/syntastic/plugin/syntastic/modemap.vim",
"chars": 2245,
"preview": "if exists(\"g:loaded_syntastic_modemap\") || !exists(\"g:loaded_syntastic_plugin\")\n finish\nendif\nlet g:loaded_syntastic_"
},
{
"path": ".vim/bundle/syntastic/plugin/syntastic/notifiers.vim",
"chars": 1979,
"preview": "if exists(\"g:loaded_syntastic_notifiers\") || !exists(\"g:loaded_syntastic_plugin\")\n finish\nendif\nlet g:loaded_syntasti"
},
{
"path": ".vim/bundle/syntastic/plugin/syntastic/registry.vim",
"chars": 8982,
"preview": "if exists(\"g:loaded_syntastic_registry\") || !exists(\"g:loaded_syntastic_plugin\")\n finish\nendif\nlet g:loaded_syntastic"
},
{
"path": ".vim/bundle/syntastic/plugin/syntastic/signs.vim",
"chars": 4501,
"preview": "if exists(\"g:loaded_syntastic_notifier_signs\") || !exists(\"g:loaded_syntastic_plugin\")\n finish\nendif\nlet g:loaded_syn"
},
{
"path": ".vim/bundle/syntastic/plugin/syntastic.vim",
"chars": 18362,
"preview": "\"============================================================================\n\"File: syntastic.vim\n\"Description: "
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/actionscript/mxmlc.vim",
"chars": 2557,
"preview": "\"============================================================================\n\"File: mxmlc.vim\n\"Description: Acti"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/ada/gcc.vim",
"chars": 1421,
"preview": "\"============================================================================\n\"File: ada.vim\n\"Description: Syntax"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/applescript/osacompile.vim",
"chars": 1851,
"preview": "\"==============================================================================\n\" FileName: applescript.vim\n\" "
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/asciidoc/asciidoc.vim",
"chars": 1692,
"preview": "\"============================================================================\n\"File: asciidoc.vim\n\"Description: S"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/asm/gcc.vim",
"chars": 1839,
"preview": "\"============================================================================\n\"File: gcc.vim\n\"Description: Syntax"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/bemhtml/bemhtmllint.vim",
"chars": 1263,
"preview": "\"============================================================================\n\"File: bemhtmllint.vim\n\"Description"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/c/avrgcc.vim",
"chars": 1945,
"preview": "\"============================================================================\n\"File: avrgcc.vim\n\"Description: Syn"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/c/checkpatch.vim",
"chars": 1979,
"preview": "\"============================================================================\n\"File: checkpatch.vim\n\"Description:"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/c/cppcheck.vim",
"chars": 2364,
"preview": "\"============================================================================\n\"File: cppcheck.vim\n\"Description: S"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/c/gcc.vim",
"chars": 2085,
"preview": "\"============================================================================\n\"File: c.vim\n\"Description: Syntax c"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/c/make.vim",
"chars": 2069,
"preview": "\"============================================================================\n\"File: make.vim\n\"Description: Synta"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/c/oclint.vim",
"chars": 2158,
"preview": "\"============================================================================\n\"File: oclint.vim\n\"Description: Syn"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/c/sparse.vim",
"chars": 1947,
"preview": "\"============================================================================\n\"File: sparse.vim\n\"Description: Syn"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/c/splint.vim",
"chars": 2123,
"preview": "\"============================================================================\n\"File: splint.vim\n\"Description: Syn"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/chef/foodcritic.vim",
"chars": 1327,
"preview": "\"============================================================================\n\"File: foodcritic.vim\n\"Description:"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/co/coco.vim",
"chars": 1382,
"preview": "\"============================================================================\n\"File: co.vim\n\"Description: Syntax "
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/cobol/cobc.vim",
"chars": 1534,
"preview": "\"============================================================================\n\"File: cobc.vim\n\"Description: Synta"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/coffee/coffee.vim",
"chars": 1938,
"preview": "\"============================================================================\n\"File: coffee.vim\n\"Description: Syn"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/coffee/coffeelint.vim",
"chars": 1463,
"preview": "\"============================================================================\n\"File: coffeelint.vim\n\"Description:"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/coq/coqtop.vim",
"chars": 1359,
"preview": "\"============================================================================\n\"File: coqtop.vim\n\"Description: Syn"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/cpp/cppcheck.vim",
"chars": 1344,
"preview": "\"============================================================================\n\"File: cppcheck.vim\n\"Description: S"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/cpp/cpplint.vim",
"chars": 2052,
"preview": "\"============================================================================\n\"File: cpplint.vim\n\"Description: Sy"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/cpp/gcc.vim",
"chars": 1894,
"preview": "\"============================================================================\n\"File: cpp.vim\n\"Description: Syntax"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/cpp/oclint.vim",
"chars": 1317,
"preview": "\"============================================================================\n\"File: oclint.vim\n\"Description: Syn"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/cs/mcs.vim",
"chars": 1287,
"preview": "\"============================================================================\n\"File: cs.vim\n\"Description: Syntax "
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/css/csslint.vim",
"chars": 1913,
"preview": "\"============================================================================\n\"File: css.vim\n\"Description: Syntax"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/css/phpcs.vim",
"chars": 1071,
"preview": "\"============================================================================\n\"File: phpcs.vim\n\"Description: Synt"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/css/prettycss.vim",
"chars": 1938,
"preview": "\"============================================================================\n\"File: prettycss.vim\n\"Description: "
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/cucumber/cucumber.vim",
"chars": 1428,
"preview": "\"============================================================================\n\"File: cucumber.vim\n\"Description: S"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/cuda/nvcc.vim",
"chars": 2696,
"preview": "\"============================================================================\n\"File: cuda.vim\n\"Description: Synta"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/d/dmd.vim",
"chars": 1923,
"preview": "\"============================================================================\n\"File: d.vim\n\"Description: Syntax c"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/dart/dartanalyzer.vim",
"chars": 2371,
"preview": "\"============================================================================\n\"File: dartanalyzer.vim\n\"Descriptio"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/docbk/xmllint.vim",
"chars": 1004,
"preview": "\"============================================================================\n\"File: docbk.vim\n\"Description: Synt"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/dustjs/swiffer.vim",
"chars": 1265,
"preview": "\"============================================================================\n\"File: swiffer.vim\n\"Description: Du"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/elixir/elixir.vim",
"chars": 1728,
"preview": "\"============================================================================\n\"File: elixir.vim\n\"Description: Syn"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/erlang/erlang_check_file.erl",
"chars": 2152,
"preview": "#!/usr/bin/env escript\n-export([main/1]).\n\nmain([FileName]) ->\n LibDirs = filelib:wildcard(\"{lib,deps}/*/ebin\"),\n "
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/erlang/escript.vim",
"chars": 2011,
"preview": "\"============================================================================\n\"File: erlang.vim\n\"Description: Syn"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/erlang/syntaxerl.vim",
"chars": 1244,
"preview": "\"============================================================================\n\"File: syntaxerl.vim\n\"Description: "
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/eruby/ruby.vim",
"chars": 2472,
"preview": "\"============================================================================\n\"File: ruby.vim\n\"Description: Synta"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/fortran/gfortran.vim",
"chars": 1742,
"preview": "\"============================================================================\n\"File: fortran.vim\n\"Description: Sy"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/glsl/cgc.vim",
"chars": 2336,
"preview": "\"============================================================================\n\"File: glsl.vim\n\"Description: Synta"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/go/go.vim",
"chars": 3040,
"preview": "\"============================================================================\n\"File: go.vim\n\"Description: Check g"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/go/gofmt.vim",
"chars": 1509,
"preview": "\"============================================================================\n\"File: gofmt.vim\n\"Description: Chec"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/go/golint.vim",
"chars": 1257,
"preview": "\"============================================================================\n\"File: golint.vim\n\"Description: Che"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/go/gotype.vim",
"chars": 1562,
"preview": "\"============================================================================\n\"File: gotype.vim\n\"Description: Per"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/go/govet.vim",
"chars": 1655,
"preview": "\"============================================================================\n\"File: govet.vim\n\"Description: Perf"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/haml/haml.vim",
"chars": 1672,
"preview": "\"============================================================================\n\"File: haml.vim\n\"Description: Synta"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/haml/haml_lint.vim",
"chars": 1311,
"preview": "\"============================================================================\n\"File: haml_lint.vim\n\"Description: "
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/handlebars/handlebars.vim",
"chars": 1473,
"preview": "\"============================================================================\n\"File: handlebars.vim\n\"Description:"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/haskell/ghc-mod.vim",
"chars": 2583,
"preview": "\"============================================================================\n\"File: ghc-mod.vim\n\"Description: Sy"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/haskell/hdevtools.vim",
"chars": 1653,
"preview": "\"============================================================================\n\"File: hdevtools.vim\n\"Description: "
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/haskell/hlint.vim",
"chars": 1010,
"preview": "\"============================================================================\n\"File: hlint.vim\n\"Description: Synt"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/haxe/haxe.vim",
"chars": 1899,
"preview": "\"============================================================================\n\"File: haxe.vim\n\"Description: Synta"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/hss/hss.vim",
"chars": 1258,
"preview": "\"============================================================================\n\"File: hss.vim\n\"Description: Syntax"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/html/jshint.vim",
"chars": 1961,
"preview": "\"============================================================================\n\"File: jshint.vim\n\"Description: Jav"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/html/tidy.vim",
"chars": 7731,
"preview": "\"============================================================================\n\"File: tidy.vim\n\"Description: Synta"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/html/validator.vim",
"chars": 3576,
"preview": "\"============================================================================\n\"File: validator.vim\n\"Description: "
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/html/w3.vim",
"chars": 2342,
"preview": "\"============================================================================\n\"File: w3.vim\n\"Description: Syntax "
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/java/checkstyle.vim",
"chars": 2083,
"preview": "\"============================================================================\n\"File: checkstyle.vim\n\"Description:"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/java/javac.vim",
"chars": 15377,
"preview": "\"============================================================================\n\"File: javac.vim\n\"Description: Synt"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/javascript/closurecompiler.vim",
"chars": 2688,
"preview": "\"============================================================================\n\"File: closurecompiler.vim\n\"Descrip"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/javascript/eslint.vim",
"chars": 1641,
"preview": "\"============================================================================\n\"File: eslint.vim\n\"Description: Jav"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/javascript/gjslint.vim",
"chars": 1671,
"preview": "\"============================================================================\n\"File: gjslint.vim\n\"Description: Ja"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/javascript/jscs.vim",
"chars": 1417,
"preview": "\"============================================================================\n\"File: jscs.vim\n\"Description: Javas"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/javascript/jshint.vim",
"chars": 2209,
"preview": "\"============================================================================\n\"File: jshint.vim\n\"Description: Jav"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/javascript/jsl.vim",
"chars": 1722,
"preview": "\"============================================================================\n\"File: jsl.vim\n\"Description: Javasc"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/javascript/jslint.vim",
"chars": 1740,
"preview": "\"============================================================================\n\"File: jslint.vim\n\"Description: Jav"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/javascript/jsxhint.vim",
"chars": 1850,
"preview": "\"============================================================================\n\"File: jsxhint.vim\n\"Description: Ja"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/json/jsonlint.vim",
"chars": 1455,
"preview": "\"============================================================================\n\"File: jsonlint.vim\n\"Description: J"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/json/jsonval.vim",
"chars": 1383,
"preview": "\"============================================================================\n\"File: jsonval.vim\n\"Description: JS"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/less/less-lint.coffee",
"chars": 1064,
"preview": "#!/usr/bin/env node\n\nfs = require 'fs'\nless = require 'less'\nargs = process.argv.slice(1)\noptions = {}\n\nargs = args.filt"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/less/less-lint.js",
"chars": 1302,
"preview": "// Generated by CoffeeScript 1.3.3\n(function() {\n var args, fs, less, options, parser;\n\n fs = require('fs');\n\n less ="
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/less/lessc.vim",
"chars": 2382,
"preview": "\"============================================================================\n\"File: less.vim\n\"Description: Synta"
},
{
"path": ".vim/bundle/syntastic/syntax_checkers/lex/flex.vim",
"chars": 1679,
"preview": "\"============================================================================\n\"File: lex.vim\n\"Description: Syntax"
}
]
// ... and 559 more files (download for full content)
About this extraction
This page contains the full source code of the Integralist/ProVim GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 759 files (5.3 MB), approximately 1.4M tokens, and a symbol index with 12 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.