Repository: amix/vimrc Branch: master Commit: 46294d589d15 Files: 1840 Total size: 12.5 MB Directory structure: gitextract_fk472klm/ ├── .gitignore ├── LICENSE ├── README.md ├── autoload/ │ └── pathogen.vim ├── install_awesome_parameterized.sh ├── install_awesome_vimrc.sh ├── install_basic_vimrc.sh ├── sources_forked/ │ ├── peaksea/ │ │ └── colors/ │ │ └── peaksea.vim │ ├── set_tabline/ │ │ └── plugin/ │ │ └── set_tabline.vim │ ├── vim-irblack-forked/ │ │ ├── README │ │ └── colors/ │ │ └── ir_black.vim │ └── vim-peepopen/ │ ├── README │ ├── README.md │ └── plugin/ │ └── peepopen.vim ├── sources_non_forked/ │ ├── ack.vim/ │ │ ├── .gitignore │ │ ├── LICENSE │ │ ├── README.md │ │ ├── autoload/ │ │ │ └── ack.vim │ │ ├── doc/ │ │ │ ├── ack.txt │ │ │ └── ack_quick_help.txt │ │ ├── ftplugin/ │ │ │ └── qf.vim │ │ └── plugin/ │ │ └── ack.vim │ ├── ale/ │ │ ├── LICENSE │ │ ├── ale_linters/ │ │ │ ├── ada/ │ │ │ │ ├── adals.vim │ │ │ │ ├── cspell.vim │ │ │ │ └── gcc.vim │ │ │ ├── ansible/ │ │ │ │ ├── ansible_lint.vim │ │ │ │ └── language_server.vim │ │ │ ├── apiblueprint/ │ │ │ │ └── drafter.vim │ │ │ ├── apkbuild/ │ │ │ │ ├── apkbuild_lint.vim │ │ │ │ └── secfixes_check.vim │ │ │ ├── asciidoc/ │ │ │ │ ├── alex.vim │ │ │ │ ├── cspell.vim │ │ │ │ ├── languagetool.vim │ │ │ │ ├── proselint.vim │ │ │ │ ├── redpen.vim │ │ │ │ ├── textlint.vim │ │ │ │ ├── vale.vim │ │ │ │ └── writegood.vim │ │ │ ├── asm/ │ │ │ │ ├── gcc.vim │ │ │ │ └── llvm_mc.vim │ │ │ ├── astro/ │ │ │ │ └── eslint.vim │ │ │ ├── avra/ │ │ │ │ └── avra.vim │ │ │ ├── awk/ │ │ │ │ └── gawk.vim │ │ │ ├── bats/ │ │ │ │ └── shellcheck.vim │ │ │ ├── bib/ │ │ │ │ └── bibclean.vim │ │ │ ├── bicep/ │ │ │ │ ├── az_bicep.vim │ │ │ │ └── bicep.vim │ │ │ ├── bitbake/ │ │ │ │ └── oelint_adv.vim │ │ │ ├── bzl/ │ │ │ │ └── buildifier.vim │ │ │ ├── c/ │ │ │ │ ├── cc.vim │ │ │ │ ├── ccls.vim │ │ │ │ ├── clangcheck.vim │ │ │ │ ├── clangd.vim │ │ │ │ ├── clangtidy.vim │ │ │ │ ├── cppcheck.vim │ │ │ │ ├── cpplint.vim │ │ │ │ ├── cquery.vim │ │ │ │ ├── cspell.vim │ │ │ │ └── flawfinder.vim │ │ │ ├── cairo/ │ │ │ │ ├── scarb.vim │ │ │ │ ├── sierra.vim │ │ │ │ └── starknet.vim │ │ │ ├── chef/ │ │ │ │ ├── cookstyle.vim │ │ │ │ └── foodcritic.vim │ │ │ ├── clojure/ │ │ │ │ ├── clj_kondo.vim │ │ │ │ └── joker.vim │ │ │ ├── cloudformation/ │ │ │ │ └── cfn_python_lint.vim │ │ │ ├── cmake/ │ │ │ │ ├── cmake_lint.vim │ │ │ │ └── cmakelint.vim │ │ │ ├── coffee/ │ │ │ │ ├── coffee.vim │ │ │ │ └── coffeelint.vim │ │ │ ├── cpp/ │ │ │ │ ├── cc.vim │ │ │ │ ├── ccls.vim │ │ │ │ ├── clangcheck.vim │ │ │ │ ├── clangd.vim │ │ │ │ ├── clangtidy.vim │ │ │ │ ├── clazy.vim │ │ │ │ ├── cppcheck.vim │ │ │ │ ├── cpplint.vim │ │ │ │ ├── cquery.vim │ │ │ │ ├── cspell.vim │ │ │ │ └── flawfinder.vim │ │ │ ├── crystal/ │ │ │ │ ├── ameba.vim │ │ │ │ └── crystal.vim │ │ │ ├── cs/ │ │ │ │ ├── csc.vim │ │ │ │ ├── cspell.vim │ │ │ │ ├── mcs.vim │ │ │ │ └── mcsc.vim │ │ │ ├── css/ │ │ │ │ ├── cspell.vim │ │ │ │ ├── csslint.vim │ │ │ │ ├── fecs.vim │ │ │ │ ├── stylelint.vim │ │ │ │ └── vscodecss.vim │ │ │ ├── cucumber/ │ │ │ │ └── cucumber.vim │ │ │ ├── cuda/ │ │ │ │ ├── clangd.vim │ │ │ │ └── nvcc.vim │ │ │ ├── cypher/ │ │ │ │ └── cypher_lint.vim │ │ │ ├── d/ │ │ │ │ ├── dls.vim │ │ │ │ └── dmd.vim │ │ │ ├── dafny/ │ │ │ │ └── dafny.vim │ │ │ ├── dart/ │ │ │ │ ├── analysis_server.vim │ │ │ │ ├── dart_analyze.vim │ │ │ │ └── language_server.vim │ │ │ ├── desktop/ │ │ │ │ └── desktop_file_validate.vim │ │ │ ├── dockerfile/ │ │ │ │ ├── dockerfile_lint.vim │ │ │ │ ├── dockerlinter.vim │ │ │ │ └── hadolint.vim │ │ │ ├── elixir/ │ │ │ │ ├── credo.vim │ │ │ │ ├── cspell.vim │ │ │ │ ├── dialyxir.vim │ │ │ │ ├── dogma.vim │ │ │ │ ├── elixir_ls.vim │ │ │ │ ├── lexical.vim │ │ │ │ └── mix.vim │ │ │ ├── elm/ │ │ │ │ ├── ls.vim │ │ │ │ └── make.vim │ │ │ ├── erlang/ │ │ │ │ ├── dialyzer.vim │ │ │ │ ├── elvis.vim │ │ │ │ ├── erlang_ls.vim │ │ │ │ ├── erlc.vim │ │ │ │ └── syntaxerl.vim │ │ │ ├── eruby/ │ │ │ │ ├── erb.vim │ │ │ │ ├── erblint.vim │ │ │ │ ├── erubi.vim │ │ │ │ ├── erubis.vim │ │ │ │ └── ruumba.vim │ │ │ ├── fish/ │ │ │ │ └── fish.vim │ │ │ ├── fortran/ │ │ │ │ ├── gcc.vim │ │ │ │ └── language_server.vim │ │ │ ├── fountain/ │ │ │ │ └── proselint.vim │ │ │ ├── fuse/ │ │ │ │ └── fusionlint.vim │ │ │ ├── gitcommit/ │ │ │ │ └── gitlint.vim │ │ │ ├── gleam/ │ │ │ │ └── gleamlsp.vim │ │ │ ├── glimmer/ │ │ │ │ └── embertemplatelint.vim │ │ │ ├── glsl/ │ │ │ │ ├── glslang.vim │ │ │ │ └── glslls.vim │ │ │ ├── go/ │ │ │ │ ├── bingo.vim │ │ │ │ ├── cspell.vim │ │ │ │ ├── gobuild.vim │ │ │ │ ├── gofmt.vim │ │ │ │ ├── golangci_lint.vim │ │ │ │ ├── gopls.vim │ │ │ │ ├── gosimple.vim │ │ │ │ ├── gotype.vim │ │ │ │ ├── govet.vim │ │ │ │ ├── langserver.vim │ │ │ │ ├── revive.vim │ │ │ │ └── staticcheck.vim │ │ │ ├── graphql/ │ │ │ │ ├── eslint.vim │ │ │ │ └── gqlint.vim │ │ │ ├── groovy/ │ │ │ │ └── npmgroovylint.vim │ │ │ ├── hack/ │ │ │ │ ├── hack.vim │ │ │ │ └── hhast.vim │ │ │ ├── haml/ │ │ │ │ └── hamllint.vim │ │ │ ├── handlebars/ │ │ │ │ └── embertemplatelint.vim │ │ │ ├── haskell/ │ │ │ │ ├── cabal_ghc.vim │ │ │ │ ├── cspell.vim │ │ │ │ ├── ghc.vim │ │ │ │ ├── ghc_mod.vim │ │ │ │ ├── hdevtools.vim │ │ │ │ ├── hie.vim │ │ │ │ ├── hlint.vim │ │ │ │ ├── hls.vim │ │ │ │ ├── stack_build.vim │ │ │ │ └── stack_ghc.vim │ │ │ ├── help/ │ │ │ │ ├── alex.vim │ │ │ │ ├── cspell.vim │ │ │ │ ├── proselint.vim │ │ │ │ └── writegood.vim │ │ │ ├── html/ │ │ │ │ ├── alex.vim │ │ │ │ ├── angular.vim │ │ │ │ ├── cspell.vim │ │ │ │ ├── eslint.vim │ │ │ │ ├── fecs.vim │ │ │ │ ├── htmlhint.vim │ │ │ │ ├── proselint.vim │ │ │ │ ├── stylelint.vim │ │ │ │ ├── tidy.vim │ │ │ │ ├── vscodehtml.vim │ │ │ │ └── writegood.vim │ │ │ ├── hurl/ │ │ │ │ └── hurlfmt.vim │ │ │ ├── idris/ │ │ │ │ └── idris.vim │ │ │ ├── ink/ │ │ │ │ └── ls.vim │ │ │ ├── inko/ │ │ │ │ └── inko.vim │ │ │ ├── ispc/ │ │ │ │ └── ispc.vim │ │ │ ├── java/ │ │ │ │ ├── checkstyle.vim │ │ │ │ ├── cspell.vim │ │ │ │ ├── eclipselsp.vim │ │ │ │ ├── javac.vim │ │ │ │ ├── javalsp.vim │ │ │ │ └── pmd.vim │ │ │ ├── javascript/ │ │ │ │ ├── biome.vim │ │ │ │ ├── cspell.vim │ │ │ │ ├── deno.vim │ │ │ │ ├── eslint.vim │ │ │ │ ├── fecs.vim │ │ │ │ ├── flow.vim │ │ │ │ ├── flow_ls.vim │ │ │ │ ├── jscs.vim │ │ │ │ ├── jshint.vim │ │ │ │ ├── standard.vim │ │ │ │ ├── tsserver.vim │ │ │ │ └── xo.vim │ │ │ ├── json/ │ │ │ │ ├── biome.vim │ │ │ │ ├── cspell.vim │ │ │ │ ├── eslint.vim │ │ │ │ ├── jq.vim │ │ │ │ ├── jsonlint.vim │ │ │ │ ├── spectral.vim │ │ │ │ └── vscodejson.vim │ │ │ ├── json5/ │ │ │ │ └── eslint.vim │ │ │ ├── jsonc/ │ │ │ │ ├── biome.vim │ │ │ │ └── eslint.vim │ │ │ ├── jsonnet/ │ │ │ │ ├── jsonnet_lint.vim │ │ │ │ └── jsonnetfmt.vim │ │ │ ├── julia/ │ │ │ │ └── languageserver.vim │ │ │ ├── kotlin/ │ │ │ │ ├── kotlinc.vim │ │ │ │ ├── ktlint.vim │ │ │ │ └── languageserver.vim │ │ │ ├── less/ │ │ │ │ ├── lessc.vim │ │ │ │ └── stylelint.vim │ │ │ ├── llvm/ │ │ │ │ └── llc.vim │ │ │ ├── lua/ │ │ │ │ ├── cspell.vim │ │ │ │ ├── lua_language_server.vim │ │ │ │ ├── luac.vim │ │ │ │ ├── luacheck.vim │ │ │ │ └── selene.vim │ │ │ ├── mail/ │ │ │ │ ├── alex.vim │ │ │ │ ├── languagetool.vim │ │ │ │ ├── proselint.vim │ │ │ │ └── vale.vim │ │ │ ├── make/ │ │ │ │ └── checkmake.vim │ │ │ ├── markdown/ │ │ │ │ ├── alex.vim │ │ │ │ ├── cspell.vim │ │ │ │ ├── languagetool.vim │ │ │ │ ├── markdownlint.vim │ │ │ │ ├── marksman.vim │ │ │ │ ├── mdl.vim │ │ │ │ ├── proselint.vim │ │ │ │ ├── redpen.vim │ │ │ │ ├── remark_lint.vim │ │ │ │ ├── textlint.vim │ │ │ │ ├── vale.vim │ │ │ │ └── writegood.vim │ │ │ ├── matlab/ │ │ │ │ └── mlint.vim │ │ │ ├── mercury/ │ │ │ │ └── mmc.vim │ │ │ ├── nasm/ │ │ │ │ └── nasm.vim │ │ │ ├── nim/ │ │ │ │ ├── nimcheck.vim │ │ │ │ └── nimlsp.vim │ │ │ ├── nix/ │ │ │ │ ├── deadnix.vim │ │ │ │ ├── nix.vim │ │ │ │ ├── rnix_lsp.vim │ │ │ │ └── statix.vim │ │ │ ├── nroff/ │ │ │ │ ├── alex.vim │ │ │ │ ├── proselint.vim │ │ │ │ └── writegood.vim │ │ │ ├── objc/ │ │ │ │ ├── ccls.vim │ │ │ │ ├── clang.vim │ │ │ │ └── clangd.vim │ │ │ ├── objcpp/ │ │ │ │ ├── clang.vim │ │ │ │ └── clangd.vim │ │ │ ├── ocaml/ │ │ │ │ ├── merlin.vim │ │ │ │ ├── ocamllsp.vim │ │ │ │ └── ols.vim │ │ │ ├── ocamlinterface/ │ │ │ │ ├── merlin.vim │ │ │ │ └── ocamllsp.vim │ │ │ ├── odin/ │ │ │ │ └── ols.vim │ │ │ ├── openapi/ │ │ │ │ ├── ibm_validator.vim │ │ │ │ └── yamllint.vim │ │ │ ├── openscad/ │ │ │ │ └── sca2d.vim │ │ │ ├── perl/ │ │ │ │ ├── perl.vim │ │ │ │ └── perlcritic.vim │ │ │ ├── perl6/ │ │ │ │ └── perl6.vim │ │ │ ├── php/ │ │ │ │ ├── cspell.vim │ │ │ │ ├── intelephense.vim │ │ │ │ ├── langserver.vim │ │ │ │ ├── phan.vim │ │ │ │ ├── php.vim │ │ │ │ ├── phpactor.vim │ │ │ │ ├── phpcs.vim │ │ │ │ ├── phpmd.vim │ │ │ │ ├── phpstan.vim │ │ │ │ ├── psalm.vim │ │ │ │ └── tlint.vim │ │ │ ├── po/ │ │ │ │ ├── alex.vim │ │ │ │ ├── msgfmt.vim │ │ │ │ ├── proselint.vim │ │ │ │ └── writegood.vim │ │ │ ├── pod/ │ │ │ │ ├── alex.vim │ │ │ │ ├── proselint.vim │ │ │ │ └── writegood.vim │ │ │ ├── pony/ │ │ │ │ └── ponyc.vim │ │ │ ├── powershell/ │ │ │ │ ├── cspell.vim │ │ │ │ ├── powershell.vim │ │ │ │ └── psscriptanalyzer.vim │ │ │ ├── prolog/ │ │ │ │ └── swipl.vim │ │ │ ├── proto/ │ │ │ │ ├── buf_lint.vim │ │ │ │ ├── protoc_gen_lint.vim │ │ │ │ └── protolint.vim │ │ │ ├── pug/ │ │ │ │ └── puglint.vim │ │ │ ├── puppet/ │ │ │ │ ├── languageserver.vim │ │ │ │ ├── puppet.vim │ │ │ │ └── puppetlint.vim │ │ │ ├── purescript/ │ │ │ │ └── ls.vim │ │ │ ├── pyrex/ │ │ │ │ └── cython.vim │ │ │ ├── python/ │ │ │ │ ├── bandit.vim │ │ │ │ ├── cspell.vim │ │ │ │ ├── flake8.vim │ │ │ │ ├── flakehell.vim │ │ │ │ ├── jedils.vim │ │ │ │ ├── mypy.vim │ │ │ │ ├── prospector.vim │ │ │ │ ├── pycln.vim │ │ │ │ ├── pycodestyle.vim │ │ │ │ ├── pydocstyle.vim │ │ │ │ ├── pyflakes.vim │ │ │ │ ├── pylama.vim │ │ │ │ ├── pylint.vim │ │ │ │ ├── pylsp.vim │ │ │ │ ├── pyre.vim │ │ │ │ ├── pyright.vim │ │ │ │ ├── refurb.vim │ │ │ │ ├── ruff.vim │ │ │ │ ├── unimport.vim │ │ │ │ └── vulture.vim │ │ │ ├── qml/ │ │ │ │ ├── qmlfmt.vim │ │ │ │ └── qmllint.vim │ │ │ ├── r/ │ │ │ │ ├── languageserver.vim │ │ │ │ └── lintr.vim │ │ │ ├── racket/ │ │ │ │ ├── langserver.vim │ │ │ │ └── raco.vim │ │ │ ├── reason/ │ │ │ │ ├── ls.vim │ │ │ │ ├── merlin.vim │ │ │ │ └── ols.vim │ │ │ ├── rego/ │ │ │ │ ├── cspell.vim │ │ │ │ └── opacheck.vim │ │ │ ├── review/ │ │ │ │ └── redpen.vim │ │ │ ├── robot/ │ │ │ │ └── rflint.vim │ │ │ ├── rst/ │ │ │ │ ├── alex.vim │ │ │ │ ├── cspell.vim │ │ │ │ ├── proselint.vim │ │ │ │ ├── redpen.vim │ │ │ │ ├── rstcheck.vim │ │ │ │ ├── textlint.vim │ │ │ │ ├── vale.vim │ │ │ │ └── writegood.vim │ │ │ ├── ruby/ │ │ │ │ ├── brakeman.vim │ │ │ │ ├── cspell.vim │ │ │ │ ├── debride.vim │ │ │ │ ├── packwerk.vim │ │ │ │ ├── rails_best_practices.vim │ │ │ │ ├── reek.vim │ │ │ │ ├── rubocop.vim │ │ │ │ ├── ruby.vim │ │ │ │ ├── solargraph.vim │ │ │ │ ├── sorbet.vim │ │ │ │ ├── standardrb.vim │ │ │ │ └── steep.vim │ │ │ ├── rust/ │ │ │ │ ├── analyzer.vim │ │ │ │ ├── cargo.vim │ │ │ │ ├── cspell.vim │ │ │ │ ├── rls.vim │ │ │ │ └── rustc.vim │ │ │ ├── salt/ │ │ │ │ └── salt_lint.vim │ │ │ ├── sass/ │ │ │ │ ├── sasslint.vim │ │ │ │ └── stylelint.vim │ │ │ ├── scala/ │ │ │ │ ├── cspell.vim │ │ │ │ ├── fsc.vim │ │ │ │ ├── metals.vim │ │ │ │ ├── sbtserver.vim │ │ │ │ ├── scalac.vim │ │ │ │ └── scalastyle.vim │ │ │ ├── scss/ │ │ │ │ ├── sasslint.vim │ │ │ │ ├── scsslint.vim │ │ │ │ └── stylelint.vim │ │ │ ├── sh/ │ │ │ │ ├── bashate.vim │ │ │ │ ├── cspell.vim │ │ │ │ ├── language_server.vim │ │ │ │ ├── shell.vim │ │ │ │ └── shellcheck.vim │ │ │ ├── slim/ │ │ │ │ └── slimlint.vim │ │ │ ├── sml/ │ │ │ │ ├── smlnj.vim │ │ │ │ └── smlnj_cm.vim │ │ │ ├── solidity/ │ │ │ │ ├── solc.vim │ │ │ │ ├── solhint.vim │ │ │ │ └── solium.vim │ │ │ ├── spec/ │ │ │ │ └── rpmlint.vim │ │ │ ├── sql/ │ │ │ │ ├── sqlfluff.vim │ │ │ │ ├── sqlint.vim │ │ │ │ └── sqllint.vim │ │ │ ├── stylus/ │ │ │ │ └── stylelint.vim │ │ │ ├── sugarss/ │ │ │ │ └── stylelint.vim │ │ │ ├── svelte/ │ │ │ │ └── svelteserver.vim │ │ │ ├── swift/ │ │ │ │ ├── appleswiftformat.vim │ │ │ │ ├── cspell.vim │ │ │ │ ├── sourcekitlsp.vim │ │ │ │ └── swiftlint.vim │ │ │ ├── systemd/ │ │ │ │ └── systemd_analyze.vim │ │ │ ├── tcl/ │ │ │ │ └── nagelfar.vim │ │ │ ├── terraform/ │ │ │ │ ├── checkov.vim │ │ │ │ ├── terraform.vim │ │ │ │ ├── terraform_ls.vim │ │ │ │ ├── terraform_lsp.vim │ │ │ │ ├── tflint.vim │ │ │ │ └── tfsec.vim │ │ │ ├── testft/ │ │ │ │ └── testlinter.vim │ │ │ ├── tex/ │ │ │ │ ├── alex.vim │ │ │ │ ├── chktex.vim │ │ │ │ ├── cspell.vim │ │ │ │ ├── lacheck.vim │ │ │ │ ├── proselint.vim │ │ │ │ ├── redpen.vim │ │ │ │ ├── texlab.vim │ │ │ │ ├── textlint.vim │ │ │ │ ├── vale.vim │ │ │ │ └── writegood.vim │ │ │ ├── texinfo/ │ │ │ │ ├── alex.vim │ │ │ │ ├── cspell.vim │ │ │ │ ├── proselint.vim │ │ │ │ └── writegood.vim │ │ │ ├── text/ │ │ │ │ ├── alex.vim │ │ │ │ ├── cspell.vim │ │ │ │ ├── languagetool.vim │ │ │ │ ├── proselint.vim │ │ │ │ ├── redpen.vim │ │ │ │ ├── textlint.vim │ │ │ │ ├── vale.vim │ │ │ │ └── writegood.vim │ │ │ ├── thrift/ │ │ │ │ ├── thrift.vim │ │ │ │ └── thriftcheck.vim │ │ │ ├── typescript/ │ │ │ │ ├── biome.vim │ │ │ │ ├── cspell.vim │ │ │ │ ├── deno.vim │ │ │ │ ├── eslint.vim │ │ │ │ ├── standard.vim │ │ │ │ ├── tslint.vim │ │ │ │ ├── tsserver.vim │ │ │ │ ├── typecheck.vim │ │ │ │ └── xo.vim │ │ │ ├── v/ │ │ │ │ └── v.vim │ │ │ ├── vala/ │ │ │ │ └── vala_lint.vim │ │ │ ├── verilog/ │ │ │ │ ├── hdl_checker.vim │ │ │ │ ├── iverilog.vim │ │ │ │ ├── slang.vim │ │ │ │ ├── verilator.vim │ │ │ │ ├── vlog.vim │ │ │ │ ├── xvlog.vim │ │ │ │ └── yosys.vim │ │ │ ├── vhdl/ │ │ │ │ ├── ghdl.vim │ │ │ │ ├── hdl_checker.vim │ │ │ │ ├── vcom.vim │ │ │ │ └── xvhdl.vim │ │ │ ├── vim/ │ │ │ │ ├── ale_custom_linting_rules.vim │ │ │ │ ├── vimls.vim │ │ │ │ └── vint.vim │ │ │ ├── vue/ │ │ │ │ ├── cspell.vim │ │ │ │ ├── vls.vim │ │ │ │ └── volar.vim │ │ │ ├── wgsl/ │ │ │ │ └── naga.vim │ │ │ ├── xhtml/ │ │ │ │ ├── alex.vim │ │ │ │ ├── cspell.vim │ │ │ │ ├── proselint.vim │ │ │ │ └── writegood.vim │ │ │ ├── xml/ │ │ │ │ └── xmllint.vim │ │ │ ├── yaml/ │ │ │ │ ├── actionlint.vim │ │ │ │ ├── circleci.vim │ │ │ │ ├── gitlablint.vim │ │ │ │ ├── ls.vim │ │ │ │ ├── spectral.vim │ │ │ │ ├── swaglint.vim │ │ │ │ └── yamllint.vim │ │ │ ├── yang/ │ │ │ │ └── yang_lsp.vim │ │ │ ├── zeek/ │ │ │ │ └── zeek.vim │ │ │ └── zig/ │ │ │ └── zls.vim │ │ ├── autoload/ │ │ │ ├── ale/ │ │ │ │ ├── ant.vim │ │ │ │ ├── args.vim │ │ │ │ ├── assert.vim │ │ │ │ ├── balloon.vim │ │ │ │ ├── c.vim │ │ │ │ ├── code_action.vim │ │ │ │ ├── codefix.vim │ │ │ │ ├── command.vim │ │ │ │ ├── completion/ │ │ │ │ │ └── python.vim │ │ │ │ ├── completion.vim │ │ │ │ ├── cursor.vim │ │ │ │ ├── d.vim │ │ │ │ ├── debugging.vim │ │ │ │ ├── definition.vim │ │ │ │ ├── dhall.vim │ │ │ │ ├── engine/ │ │ │ │ │ └── ignore.vim │ │ │ │ ├── engine.vim │ │ │ │ ├── events.vim │ │ │ │ ├── filename_mapping.vim │ │ │ │ ├── filerename.vim │ │ │ │ ├── filetypes.vim │ │ │ │ ├── fix/ │ │ │ │ │ └── registry.vim │ │ │ │ ├── fix.vim │ │ │ │ ├── fixers/ │ │ │ │ │ ├── alejandra.vim │ │ │ │ │ ├── appleswiftformat.vim │ │ │ │ │ ├── astyle.vim │ │ │ │ │ ├── autoflake.vim │ │ │ │ │ ├── autoimport.vim │ │ │ │ │ ├── autopep8.vim │ │ │ │ │ ├── bibclean.vim │ │ │ │ │ ├── biome.vim │ │ │ │ │ ├── black.vim │ │ │ │ │ ├── brittany.vim │ │ │ │ │ ├── buf_format.vim │ │ │ │ │ ├── buildifier.vim │ │ │ │ │ ├── clangformat.vim │ │ │ │ │ ├── clangtidy.vim │ │ │ │ │ ├── cmakeformat.vim │ │ │ │ │ ├── crystal.vim │ │ │ │ │ ├── css_beautify.vim │ │ │ │ │ ├── dart_format.vim │ │ │ │ │ ├── dartfmt.vim │ │ │ │ │ ├── deno.vim │ │ │ │ │ ├── dfmt.vim │ │ │ │ │ ├── dhall_format.vim │ │ │ │ │ ├── dhall_freeze.vim │ │ │ │ │ ├── dhall_lint.vim │ │ │ │ │ ├── dotnet_format.vim │ │ │ │ │ ├── dprint.vim │ │ │ │ │ ├── dune.vim │ │ │ │ │ ├── elm_format.vim │ │ │ │ │ ├── erbformatter.vim │ │ │ │ │ ├── erblint.vim │ │ │ │ │ ├── erlfmt.vim │ │ │ │ │ ├── eslint.vim │ │ │ │ │ ├── fecs.vim │ │ │ │ │ ├── fish_indent.vim │ │ │ │ │ ├── fixjson.vim │ │ │ │ │ ├── floskell.vim │ │ │ │ │ ├── forge.vim │ │ │ │ │ ├── fourmolu.vim │ │ │ │ │ ├── generic.vim │ │ │ │ │ ├── generic_python.vim │ │ │ │ │ ├── gleam_format.vim │ │ │ │ │ ├── gnatpp.vim │ │ │ │ │ ├── gofmt.vim │ │ │ │ │ ├── gofumpt.vim │ │ │ │ │ ├── goimports.vim │ │ │ │ │ ├── golines.vim │ │ │ │ │ ├── gomod.vim │ │ │ │ │ ├── google_java_format.vim │ │ │ │ │ ├── gopls.vim │ │ │ │ │ ├── hackfmt.vim │ │ │ │ │ ├── help.vim │ │ │ │ │ ├── hfmt.vim │ │ │ │ │ ├── hindent.vim │ │ │ │ │ ├── hlint.vim │ │ │ │ │ ├── html_beautify.vim │ │ │ │ │ ├── htmlbeautifier.vim │ │ │ │ │ ├── hurlfmt.vim │ │ │ │ │ ├── importjs.vim │ │ │ │ │ ├── isort.vim │ │ │ │ │ ├── jq.vim │ │ │ │ │ ├── jsonnetfmt.vim │ │ │ │ │ ├── ktlint.vim │ │ │ │ │ ├── latexindent.vim │ │ │ │ │ ├── lua_format.vim │ │ │ │ │ ├── luafmt.vim │ │ │ │ │ ├── mix_format.vim │ │ │ │ │ ├── nickel_format.vim │ │ │ │ │ ├── nimpretty.vim │ │ │ │ │ ├── nixfmt.vim │ │ │ │ │ ├── nixpkgsfmt.vim │ │ │ │ │ ├── npmgroovylint.vim │ │ │ │ │ ├── ocamlformat.vim │ │ │ │ │ ├── ocp_indent.vim │ │ │ │ │ ├── opafmt.vim │ │ │ │ │ ├── ormolu.vim │ │ │ │ │ ├── packer.vim │ │ │ │ │ ├── pandoc.vim │ │ │ │ │ ├── perltidy.vim │ │ │ │ │ ├── pgformatter.vim │ │ │ │ │ ├── php_cs_fixer.vim │ │ │ │ │ ├── phpcbf.vim │ │ │ │ │ ├── pint.vim │ │ │ │ │ ├── prettier.vim │ │ │ │ │ ├── prettier_eslint.vim │ │ │ │ │ ├── prettier_standard.vim │ │ │ │ │ ├── protolint.vim │ │ │ │ │ ├── ptop.vim │ │ │ │ │ ├── puppetlint.vim │ │ │ │ │ ├── purs_tidy.vim │ │ │ │ │ ├── purty.vim │ │ │ │ │ ├── pycln.vim │ │ │ │ │ ├── pyflyby.vim │ │ │ │ │ ├── qmlfmt.vim │ │ │ │ │ ├── raco_fmt.vim │ │ │ │ │ ├── refmt.vim │ │ │ │ │ ├── remark_lint.vim │ │ │ │ │ ├── reorder_python_imports.vim │ │ │ │ │ ├── rubocop.vim │ │ │ │ │ ├── rubyfmt.vim │ │ │ │ │ ├── ruff.vim │ │ │ │ │ ├── ruff_format.vim │ │ │ │ │ ├── rufo.vim │ │ │ │ │ ├── rustfmt.vim │ │ │ │ │ ├── rustywind.vim │ │ │ │ │ ├── scalafmt.vim │ │ │ │ │ ├── shfmt.vim │ │ │ │ │ ├── sorbet.vim │ │ │ │ │ ├── sqlfluff.vim │ │ │ │ │ ├── sqlfmt.vim │ │ │ │ │ ├── sqlformat.vim │ │ │ │ │ ├── standard.vim │ │ │ │ │ ├── standardrb.vim │ │ │ │ │ ├── statix.vim │ │ │ │ │ ├── stylelint.vim │ │ │ │ │ ├── styler.vim │ │ │ │ │ ├── stylish_haskell.vim │ │ │ │ │ ├── stylua.vim │ │ │ │ │ ├── swiftformat.vim │ │ │ │ │ ├── syntax_tree.vim │ │ │ │ │ ├── terraform.vim │ │ │ │ │ ├── textlint.vim │ │ │ │ │ ├── tidy.vim │ │ │ │ │ ├── tslint.vim │ │ │ │ │ ├── uncrustify.vim │ │ │ │ │ ├── vfmt.vim │ │ │ │ │ ├── xmllint.vim │ │ │ │ │ ├── xo.vim │ │ │ │ │ ├── yamlfix.vim │ │ │ │ │ ├── yamlfmt.vim │ │ │ │ │ ├── yapf.vim │ │ │ │ │ └── zigfmt.vim │ │ │ │ ├── floating_preview.vim │ │ │ │ ├── go.vim │ │ │ │ ├── gradle/ │ │ │ │ │ └── init.gradle │ │ │ │ ├── gradle.vim │ │ │ │ ├── handlers/ │ │ │ │ │ ├── alex.vim │ │ │ │ │ ├── atools.vim │ │ │ │ │ ├── biome.vim │ │ │ │ │ ├── cairo.vim │ │ │ │ │ ├── ccls.vim │ │ │ │ │ ├── cppcheck.vim │ │ │ │ │ ├── cpplint.vim │ │ │ │ │ ├── cspell.vim │ │ │ │ │ ├── css.vim │ │ │ │ │ ├── deadnix.vim │ │ │ │ │ ├── deno.vim │ │ │ │ │ ├── elixir.vim │ │ │ │ │ ├── embertemplatelint.vim │ │ │ │ │ ├── eslint.vim │ │ │ │ │ ├── fecs.vim │ │ │ │ │ ├── flawfinder.vim │ │ │ │ │ ├── gawk.vim │ │ │ │ │ ├── gcc.vim │ │ │ │ │ ├── go.vim │ │ │ │ │ ├── haskell.vim │ │ │ │ │ ├── haskell_stack.vim │ │ │ │ │ ├── hdl_checker.vim │ │ │ │ │ ├── hlint.vim │ │ │ │ │ ├── inko.vim │ │ │ │ │ ├── ktlint.vim │ │ │ │ │ ├── languagetool.vim │ │ │ │ │ ├── markdownlint.vim │ │ │ │ │ ├── naga.vim │ │ │ │ │ ├── ocamllsp.vim │ │ │ │ │ ├── ols.vim │ │ │ │ │ ├── openscad.vim │ │ │ │ │ ├── pony.vim │ │ │ │ │ ├── redpen.vim │ │ │ │ │ ├── ruby.vim │ │ │ │ │ ├── rust.vim │ │ │ │ │ ├── scala.vim │ │ │ │ │ ├── sh.vim │ │ │ │ │ ├── shellcheck.vim │ │ │ │ │ ├── sml.vim │ │ │ │ │ ├── spectral.vim │ │ │ │ │ ├── statix.vim │ │ │ │ │ ├── textlint.vim │ │ │ │ │ ├── tslint.vim │ │ │ │ │ ├── tsserver.vim │ │ │ │ │ ├── unix.vim │ │ │ │ │ ├── vale.vim │ │ │ │ │ ├── writegood.vim │ │ │ │ │ ├── xo.vim │ │ │ │ │ └── yamllint.vim │ │ │ │ ├── highlight.vim │ │ │ │ ├── history.vim │ │ │ │ ├── hover.vim │ │ │ │ ├── java.vim │ │ │ │ ├── job.vim │ │ │ │ ├── julia.vim │ │ │ │ ├── linter.vim │ │ │ │ ├── list.vim │ │ │ │ ├── loclist_jumping.vim │ │ │ │ ├── lsp/ │ │ │ │ │ ├── message.vim │ │ │ │ │ ├── reset.vim │ │ │ │ │ ├── response.vim │ │ │ │ │ └── tsserver_message.vim │ │ │ │ ├── lsp.vim │ │ │ │ ├── lsp_linter.vim │ │ │ │ ├── lsp_window.vim │ │ │ │ ├── lua.vim │ │ │ │ ├── maven.vim │ │ │ │ ├── node.vim │ │ │ │ ├── organize_imports.vim │ │ │ │ ├── other_source.vim │ │ │ │ ├── path.vim │ │ │ │ ├── pattern_options.vim │ │ │ │ ├── powershell.vim │ │ │ │ ├── preview.vim │ │ │ │ ├── python.vim │ │ │ │ ├── racket.vim │ │ │ │ ├── references.vim │ │ │ │ ├── rename.vim │ │ │ │ ├── ruby.vim │ │ │ │ ├── semver.vim │ │ │ │ ├── sign.vim │ │ │ │ ├── socket.vim │ │ │ │ ├── statusline.vim │ │ │ │ ├── swift.vim │ │ │ │ ├── symbol.vim │ │ │ │ ├── test.vim │ │ │ │ ├── toggle.vim │ │ │ │ ├── uri/ │ │ │ │ │ └── jdt.vim │ │ │ │ ├── uri.vim │ │ │ │ ├── util.vim │ │ │ │ └── virtualtext.vim │ │ │ ├── ale.vim │ │ │ └── asyncomplete/ │ │ │ └── sources/ │ │ │ └── ale.vim │ │ ├── doc/ │ │ │ ├── ale-ada.txt │ │ │ ├── ale-ansible.txt │ │ │ ├── ale-apkbuild.txt │ │ │ ├── ale-asciidoc.txt │ │ │ ├── ale-asm.txt │ │ │ ├── ale-astro.txt │ │ │ ├── ale-avra.txt │ │ │ ├── ale-awk.txt │ │ │ ├── ale-bats.txt │ │ │ ├── ale-bazel.txt │ │ │ ├── ale-bib.txt │ │ │ ├── ale-bicep.txt │ │ │ ├── ale-bitbake.txt │ │ │ ├── ale-c.txt │ │ │ ├── ale-cairo.txt │ │ │ ├── ale-chef.txt │ │ │ ├── ale-clojure.txt │ │ │ ├── ale-cloudformation.txt │ │ │ ├── ale-cmake.txt │ │ │ ├── ale-cpp.txt │ │ │ ├── ale-cs.txt │ │ │ ├── ale-css.txt │ │ │ ├── ale-cuda.txt │ │ │ ├── ale-d.txt │ │ │ ├── ale-dafny.txt │ │ │ ├── ale-dart.txt │ │ │ ├── ale-desktop.txt │ │ │ ├── ale-development.txt │ │ │ ├── ale-dhall.txt │ │ │ ├── ale-dockerfile.txt │ │ │ ├── ale-elixir.txt │ │ │ ├── ale-elm.txt │ │ │ ├── ale-erlang.txt │ │ │ ├── ale-eruby.txt │ │ │ ├── ale-fish.txt │ │ │ ├── ale-fortran.txt │ │ │ ├── ale-fountain.txt │ │ │ ├── ale-fuse.txt │ │ │ ├── ale-gitcommit.txt │ │ │ ├── ale-gleam.txt │ │ │ ├── ale-glsl.txt │ │ │ ├── ale-go.txt │ │ │ ├── ale-graphql.txt │ │ │ ├── ale-groovy.txt │ │ │ ├── ale-hack.txt │ │ │ ├── ale-handlebars.txt │ │ │ ├── ale-haskell.txt │ │ │ ├── ale-hcl.txt │ │ │ ├── ale-help.txt │ │ │ ├── ale-html.txt │ │ │ ├── ale-hurl.txt │ │ │ ├── ale-idris.txt │ │ │ ├── ale-ink.txt │ │ │ ├── ale-inko.txt │ │ │ ├── ale-ispc.txt │ │ │ ├── ale-java.txt │ │ │ ├── ale-javascript.txt │ │ │ ├── ale-json.txt │ │ │ ├── ale-json5.txt │ │ │ ├── ale-jsonc.txt │ │ │ ├── ale-jsonnet.txt │ │ │ ├── ale-julia.txt │ │ │ ├── ale-kotlin.txt │ │ │ ├── ale-latex.txt │ │ │ ├── ale-less.txt │ │ │ ├── ale-llvm.txt │ │ │ ├── ale-lua.txt │ │ │ ├── ale-make.txt │ │ │ ├── ale-markdown.txt │ │ │ ├── ale-mercury.txt │ │ │ ├── ale-nasm.txt │ │ │ ├── ale-nickel.txt │ │ │ ├── ale-nim.txt │ │ │ ├── ale-nix.txt │ │ │ ├── ale-nroff.txt │ │ │ ├── ale-objc.txt │ │ │ ├── ale-objcpp.txt │ │ │ ├── ale-ocaml.txt │ │ │ ├── ale-odin.txt │ │ │ ├── ale-openapi.txt │ │ │ ├── ale-openscad.txt │ │ │ ├── ale-packer.txt │ │ │ ├── ale-pascal.txt │ │ │ ├── ale-pawn.txt │ │ │ ├── ale-perl.txt │ │ │ ├── ale-perl6.txt │ │ │ ├── ale-php.txt │ │ │ ├── ale-po.txt │ │ │ ├── ale-pod.txt │ │ │ ├── ale-pony.txt │ │ │ ├── ale-powershell.txt │ │ │ ├── ale-prolog.txt │ │ │ ├── ale-proto.txt │ │ │ ├── ale-pug.txt │ │ │ ├── ale-puppet.txt │ │ │ ├── ale-purescript.txt │ │ │ ├── ale-pyrex.txt │ │ │ ├── ale-python.txt │ │ │ ├── ale-qml.txt │ │ │ ├── ale-r.txt │ │ │ ├── ale-racket.txt │ │ │ ├── ale-reasonml.txt │ │ │ ├── ale-rego.txt │ │ │ ├── ale-restructuredtext.txt │ │ │ ├── ale-robot.txt │ │ │ ├── ale-ruby.txt │ │ │ ├── ale-rust.txt │ │ │ ├── ale-salt.tmt │ │ │ ├── ale-sass.txt │ │ │ ├── ale-scala.txt │ │ │ ├── ale-scss.txt │ │ │ ├── ale-sh.txt │ │ │ ├── ale-sml.txt │ │ │ ├── ale-solidity.txt │ │ │ ├── ale-spec.txt │ │ │ ├── ale-sql.txt │ │ │ ├── ale-stylus.txt │ │ │ ├── ale-sugarss.txt │ │ │ ├── ale-supported-languages-and-tools.txt │ │ │ ├── ale-svelte.txt │ │ │ ├── ale-swift.txt │ │ │ ├── ale-systemd.txt │ │ │ ├── ale-tcl.txt │ │ │ ├── ale-terraform.txt │ │ │ ├── ale-tex.txt │ │ │ ├── ale-texinfo.txt │ │ │ ├── ale-text.txt │ │ │ ├── ale-thrift.txt │ │ │ ├── ale-toml.txt │ │ │ ├── ale-typescript.txt │ │ │ ├── ale-v.txt │ │ │ ├── ale-vala.txt │ │ │ ├── ale-verilog.txt │ │ │ ├── ale-vhdl.txt │ │ │ ├── ale-vim-help.txt │ │ │ ├── ale-vim.txt │ │ │ ├── ale-vue.txt │ │ │ ├── ale-wgsl.txt │ │ │ ├── ale-xhtml.txt │ │ │ ├── ale-xml.txt │ │ │ ├── ale-yaml.txt │ │ │ ├── ale-yang.txt │ │ │ ├── ale-zeek.txt │ │ │ ├── ale-zig.txt │ │ │ └── ale.txt │ │ ├── ftplugin/ │ │ │ ├── ale-fix-suggest.vim │ │ │ ├── ale-info.vim │ │ │ ├── ale-preview-selection.vim │ │ │ └── ale-preview.vim │ │ ├── lspconfig.vim │ │ ├── lua/ │ │ │ └── ale/ │ │ │ ├── diagnostics.lua │ │ │ └── util.lua │ │ ├── plugin/ │ │ │ └── ale.vim │ │ ├── rplugin/ │ │ │ └── python3/ │ │ │ └── deoplete/ │ │ │ └── sources/ │ │ │ └── ale.py │ │ ├── supported-tools.md │ │ ├── syntax/ │ │ │ ├── ale-fix-suggest.vim │ │ │ ├── ale-info.vim │ │ │ └── ale-preview-selection.vim │ │ └── test-files/ │ │ └── python/ │ │ └── no_uv/ │ │ └── whatever.py │ ├── auto-pairs/ │ │ ├── .gitignore │ │ ├── README.md │ │ ├── doc/ │ │ │ └── AutoPairs.txt │ │ └── plugin/ │ │ └── auto-pairs.vim │ ├── bufexplorer/ │ │ ├── .gitignore │ │ ├── .goreleaser.yaml │ │ ├── LICENSE │ │ ├── README.md │ │ ├── doc/ │ │ │ └── bufexplorer.txt │ │ ├── how_to_release.txt │ │ └── plugin/ │ │ └── bufexplorer.vim │ ├── copilot.vim/ │ │ ├── .gitattributes │ │ ├── .github/ │ │ │ ├── pull_request_template.md │ │ │ └── workflows/ │ │ │ └── auto-close-pr.yml │ │ ├── .gitignore │ │ ├── LICENSE.md │ │ ├── README.md │ │ ├── SECURITY.md │ │ ├── autoload/ │ │ │ ├── copilot/ │ │ │ │ ├── client.vim │ │ │ │ ├── handlers.vim │ │ │ │ ├── job.vim │ │ │ │ ├── logger.vim │ │ │ │ ├── panel.vim │ │ │ │ ├── util.vim │ │ │ │ └── version.vim │ │ │ └── copilot.vim │ │ ├── dist/ │ │ │ ├── compiled/ │ │ │ │ ├── darwin/ │ │ │ │ │ ├── arm64/ │ │ │ │ │ │ └── kerberos.node │ │ │ │ │ └── x64/ │ │ │ │ │ └── kerberos.node │ │ │ │ ├── linux/ │ │ │ │ │ ├── arm64/ │ │ │ │ │ │ └── kerberos.node │ │ │ │ │ └── x64/ │ │ │ │ │ └── kerberos.node │ │ │ │ └── win32/ │ │ │ │ └── x64/ │ │ │ │ └── kerberos.node │ │ │ ├── crypt32.node │ │ │ ├── language-server.js │ │ │ ├── resources/ │ │ │ │ ├── cl100k_base.tiktoken.noindex │ │ │ │ └── o200k_base.tiktoken.noindex │ │ │ ├── tree-sitter-go.wasm │ │ │ ├── tree-sitter-javascript.wasm │ │ │ ├── tree-sitter-python.wasm │ │ │ ├── tree-sitter-ruby.wasm │ │ │ ├── tree-sitter-tsx.wasm │ │ │ ├── tree-sitter-typescript.wasm │ │ │ └── tree-sitter.wasm │ │ ├── doc/ │ │ │ └── copilot.txt │ │ ├── lua/ │ │ │ └── _copilot.lua │ │ ├── plugin/ │ │ │ └── copilot.vim │ │ └── syntax/ │ │ ├── copilot.vim │ │ └── copilotlog.vim │ ├── ctrlp.vim/ │ │ ├── .github/ │ │ │ └── FUNDING.yml │ │ ├── .gitignore │ │ ├── LICENSE │ │ ├── autoload/ │ │ │ ├── ctrlp/ │ │ │ │ ├── autoignore.vim │ │ │ │ ├── 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.cnx │ │ │ └── ctrlp.txt │ │ ├── plugin/ │ │ │ └── ctrlp.vim │ │ └── readme.md │ ├── dracula/ │ │ ├── .github/ │ │ │ ├── issue_template.md │ │ │ └── pull_request_template.md │ │ ├── .gitignore │ │ ├── INSTALL.md │ │ ├── LICENSE │ │ ├── README.md │ │ ├── autoload/ │ │ │ ├── airline/ │ │ │ │ └── themes/ │ │ │ │ └── dracula.vim │ │ │ ├── dracula.vim │ │ │ └── lightline/ │ │ │ └── colorscheme/ │ │ │ └── dracula.vim │ │ ├── colors/ │ │ │ └── dracula.vim │ │ └── doc/ │ │ └── dracula.txt │ ├── editorconfig-vim/ │ │ ├── .appveyor.yml │ │ ├── .editorconfig │ │ ├── .gitignore │ │ ├── .gitmodules │ │ ├── .travis.yml │ │ ├── CONTRIBUTORS │ │ ├── LICENSE │ │ ├── LICENSE.PSF │ │ ├── README.md │ │ ├── autoload/ │ │ │ ├── editorconfig.vim │ │ │ ├── editorconfig_core/ │ │ │ │ ├── fnmatch.vim │ │ │ │ ├── handler.vim │ │ │ │ ├── ini.vim │ │ │ │ └── util.vim │ │ │ └── editorconfig_core.vim │ │ ├── doc/ │ │ │ └── editorconfig.txt │ │ ├── ftdetect/ │ │ │ └── editorconfig.vim │ │ ├── mkzip.sh │ │ ├── plugin/ │ │ │ └── editorconfig.vim │ │ └── tests/ │ │ ├── core/ │ │ │ ├── CMakeLists.txt │ │ │ ├── CTestCustom.cmake │ │ │ ├── ecvbslib.vbs │ │ │ ├── ecvimlib.ps1 │ │ │ ├── editorconfig │ │ │ ├── editorconfig.bat │ │ │ ├── editorconfig1.vbs │ │ │ └── editorconfig2.ps1 │ │ ├── fetch-vim.bat │ │ ├── fetch-vim.sh │ │ ├── plugin/ │ │ │ ├── .gitignore │ │ │ ├── Gemfile │ │ │ ├── Rakefile │ │ │ └── spec/ │ │ │ ├── .editorconfig │ │ │ └── editorconfig_spec.rb │ │ └── travis-test.sh │ ├── gist-vim/ │ │ ├── .github/ │ │ │ └── FUNDING.yml │ │ ├── Makefile │ │ ├── README.md │ │ ├── autoload/ │ │ │ └── gist.vim │ │ ├── doc/ │ │ │ └── gist-vim.txt │ │ ├── gist.vim.vimup │ │ └── plugin/ │ │ └── gist.vim │ ├── goyo.vim/ │ │ ├── .github/ │ │ │ └── FUNDING.yml │ │ ├── LICENSE │ │ ├── autoload/ │ │ │ └── goyo.vim │ │ ├── doc/ │ │ │ └── goyo.txt │ │ └── plugin/ │ │ └── goyo.vim │ ├── gruvbox/ │ │ ├── CHANGELOG.md │ │ ├── README.md │ │ ├── autoload/ │ │ │ ├── airline/ │ │ │ │ └── themes/ │ │ │ │ └── gruvbox.vim │ │ │ ├── gruvbox.vim │ │ │ └── lightline/ │ │ │ └── colorscheme/ │ │ │ └── gruvbox.vim │ │ ├── colors/ │ │ │ └── gruvbox.vim │ │ ├── gruvbox_256palette.sh │ │ ├── gruvbox_256palette_osx.sh │ │ └── package.json │ ├── lightline-ale/ │ │ ├── LICENSE │ │ ├── README.md │ │ ├── autoload/ │ │ │ └── lightline/ │ │ │ └── ale.vim │ │ └── plugin/ │ │ └── lightline/ │ │ └── ale.vim │ ├── lightline.vim/ │ │ ├── .github/ │ │ │ └── workflows/ │ │ │ └── ci.yaml │ │ ├── .gitignore │ │ ├── LICENSE │ │ ├── README.md │ │ ├── autoload/ │ │ │ ├── lightline/ │ │ │ │ ├── colorscheme/ │ │ │ │ │ ├── 16color.vim │ │ │ │ │ ├── OldHope.vim │ │ │ │ │ ├── PaperColor.vim │ │ │ │ │ ├── PaperColor_dark.vim │ │ │ │ │ ├── PaperColor_light.vim │ │ │ │ │ ├── Tomorrow.vim │ │ │ │ │ ├── Tomorrow_Night.vim │ │ │ │ │ ├── Tomorrow_Night_Blue.vim │ │ │ │ │ ├── Tomorrow_Night_Bright.vim │ │ │ │ │ ├── Tomorrow_Night_Eighties.vim │ │ │ │ │ ├── apprentice.vim │ │ │ │ │ ├── ayu_dark.vim │ │ │ │ │ ├── ayu_light.vim │ │ │ │ │ ├── ayu_mirage.vim │ │ │ │ │ ├── darcula.vim │ │ │ │ │ ├── default.vim │ │ │ │ │ ├── deus.vim │ │ │ │ │ ├── jellybeans.vim │ │ │ │ │ ├── landscape.vim │ │ │ │ │ ├── materia.vim │ │ │ │ │ ├── material.vim │ │ │ │ │ ├── molokai.vim │ │ │ │ │ ├── nord.vim │ │ │ │ │ ├── one.vim │ │ │ │ │ ├── powerline.vim │ │ │ │ │ ├── powerlineish.vim │ │ │ │ │ ├── rosepine.vim │ │ │ │ │ ├── rosepine_moon.vim │ │ │ │ │ ├── selenized_black.vim │ │ │ │ │ ├── selenized_dark.vim │ │ │ │ │ ├── selenized_light.vim │ │ │ │ │ ├── selenized_white.vim │ │ │ │ │ ├── seoul256.vim │ │ │ │ │ ├── simpleblack.vim │ │ │ │ │ ├── solarized.vim │ │ │ │ │ ├── srcery_drk.vim │ │ │ │ │ └── wombat.vim │ │ │ │ ├── colorscheme.vim │ │ │ │ ├── colortable.vim │ │ │ │ └── tab.vim │ │ │ └── lightline.vim │ │ ├── colorscheme.md │ │ ├── doc/ │ │ │ └── lightline.txt │ │ ├── plugin/ │ │ │ └── lightline.vim │ │ └── test/ │ │ ├── .themisrc │ │ ├── autocmd.vim │ │ ├── concatenate.vim │ │ ├── error.vim │ │ ├── expand.vim │ │ ├── highlight.vim │ │ ├── link.vim │ │ ├── mode.vim │ │ ├── onetab.vim │ │ ├── popup.vim │ │ ├── quickfix.vim │ │ ├── subseparator.vim │ │ ├── tabline.vim │ │ ├── tabs.vim │ │ ├── toggle.vim │ │ └── uniq.vim │ ├── mayansmoke/ │ │ ├── README │ │ └── colors/ │ │ └── mayansmoke.vim │ ├── mru.vim/ │ │ ├── README │ │ └── plugin/ │ │ └── mru.vim │ ├── nerdtree/ │ │ ├── .github/ │ │ │ ├── ISSUE_TEMPLATE/ │ │ │ │ ├── bug.md │ │ │ │ ├── feature_request.md │ │ │ │ └── question.md │ │ │ ├── PULL_REQUEST_TEMPLATE.md │ │ │ └── workflows/ │ │ │ └── vint.yml │ │ ├── .gitignore │ │ ├── .vintrc.yaml │ │ ├── CHANGELOG.md │ │ ├── LICENCE │ │ ├── README.markdown │ │ ├── _config.yml │ │ ├── autoload/ │ │ │ ├── nerdtree/ │ │ │ │ └── ui_glue.vim │ │ │ └── nerdtree.vim │ │ ├── doc/ │ │ │ └── NERDTree.txt │ │ ├── lib/ │ │ │ └── nerdtree/ │ │ │ ├── bookmark.vim │ │ │ ├── creator.vim │ │ │ ├── event.vim │ │ │ ├── flag_set.vim │ │ │ ├── key_map.vim │ │ │ ├── menu_controller.vim │ │ │ ├── menu_item.vim │ │ │ ├── nerdtree.vim │ │ │ ├── notifier.vim │ │ │ ├── opener.vim │ │ │ ├── path.vim │ │ │ ├── tree_dir_node.vim │ │ │ ├── tree_file_node.vim │ │ │ └── ui.vim │ │ ├── nerdtree_plugin/ │ │ │ ├── exec_menuitem.vim │ │ │ ├── fs_menu.vim │ │ │ └── vcs.vim │ │ ├── plugin/ │ │ │ └── NERD_tree.vim │ │ └── syntax/ │ │ └── nerdtree.vim │ ├── nginx.vim/ │ │ ├── CHANGELOG.md │ │ ├── README.md │ │ ├── ftdetect/ │ │ │ └── nginx.vim │ │ ├── ftplugin/ │ │ │ └── nginx.vim │ │ ├── indent/ │ │ │ └── nginx.vim │ │ └── syntax/ │ │ └── nginx.vim │ ├── open_file_under_cursor.vim/ │ │ └── plugin/ │ │ └── open_file_under_cursor.vim │ ├── rust.vim/ │ │ ├── .github/ │ │ │ └── workflows/ │ │ │ └── ci.yml │ │ ├── .gitignore │ │ ├── .vintrc.yml │ │ ├── ISSUE_TEMPLATE.md │ │ ├── LICENSE-APACHE │ │ ├── LICENSE-MIT │ │ ├── README.md │ │ ├── after/ │ │ │ └── syntax/ │ │ │ └── rust.vim │ │ ├── autoload/ │ │ │ ├── cargo/ │ │ │ │ └── quickfix.vim │ │ │ ├── cargo.vim │ │ │ ├── rust/ │ │ │ │ ├── debugging.vim │ │ │ │ ├── delimitmate.vim │ │ │ │ └── tags.vim │ │ │ ├── rust.vim │ │ │ └── rustfmt.vim │ │ ├── compiler/ │ │ │ ├── cargo.vim │ │ │ └── rustc.vim │ │ ├── ctags/ │ │ │ └── rust.ctags │ │ ├── doc/ │ │ │ └── rust.txt │ │ ├── ftdetect/ │ │ │ └── rust.vim │ │ ├── ftplugin/ │ │ │ ├── rust/ │ │ │ │ └── tagbar.vim │ │ │ └── rust.vim │ │ ├── indent/ │ │ │ └── rust.vim │ │ ├── plugin/ │ │ │ ├── cargo.vim │ │ │ └── rust.vim │ │ ├── syntax/ │ │ │ └── rust.vim │ │ ├── syntax_checkers/ │ │ │ └── rust/ │ │ │ ├── cargo.vim │ │ │ └── rustc.vim │ │ ├── test/ │ │ │ ├── .gitignore │ │ │ ├── Dockerfile │ │ │ ├── coverage.vader │ │ │ ├── indent.vader │ │ │ ├── run-tests │ │ │ ├── sample.rs │ │ │ └── vimrc │ │ └── triagebot.toml │ ├── tabular/ │ │ ├── .gitignore │ │ ├── LICENSE.md │ │ ├── README.md │ │ ├── after/ │ │ │ └── plugin/ │ │ │ └── TabularMaps.vim │ │ ├── autoload/ │ │ │ └── tabular.vim │ │ ├── doc/ │ │ │ └── Tabular.txt │ │ └── plugin/ │ │ └── Tabular.vim │ ├── tlib/ │ │ ├── .gitignore │ │ ├── CHANGES.TXT │ │ ├── LICENSE.TXT │ │ ├── README │ │ ├── addon-info.json │ │ ├── autoload/ │ │ │ ├── tinykeymap/ │ │ │ │ └── map/ │ │ │ │ └── para_move.vim │ │ │ ├── tlib/ │ │ │ │ ├── Filter_cnf.vim │ │ │ │ ├── Filter_cnfd.vim │ │ │ │ ├── Filter_fuzzy.vim │ │ │ │ ├── Filter_glob.vim │ │ │ │ ├── Object.vim │ │ │ │ ├── Test.vim │ │ │ │ ├── TestChild.vim │ │ │ │ ├── World.vim │ │ │ │ ├── agent.vim │ │ │ │ ├── arg.vim │ │ │ │ ├── assert.vim │ │ │ │ ├── autocmdgroup.vim │ │ │ │ ├── balloon.vim │ │ │ │ ├── bitwise.vim │ │ │ │ ├── buffer.vim │ │ │ │ ├── cache.vim │ │ │ │ ├── char.vim │ │ │ │ ├── cmd.vim │ │ │ │ ├── comments.vim │ │ │ │ ├── date.vim │ │ │ │ ├── dictionary.vim │ │ │ │ ├── dir.vim │ │ │ │ ├── eval.vim │ │ │ │ ├── file.vim │ │ │ │ ├── fixes.vim │ │ │ │ ├── grep.vim │ │ │ │ ├── hash.vim │ │ │ │ ├── hook.vim │ │ │ │ ├── input.vim │ │ │ │ ├── list.vim │ │ │ │ ├── loclist.vim │ │ │ │ ├── map.vim │ │ │ │ ├── normal.vim │ │ │ │ ├── notify.vim │ │ │ │ ├── number.vim │ │ │ │ ├── paragraph.vim │ │ │ │ ├── persistent.vim │ │ │ │ ├── progressbar.vim │ │ │ │ ├── qfl.vim │ │ │ │ ├── rx.vim │ │ │ │ ├── scratch.vim │ │ │ │ ├── selection.vim │ │ │ │ ├── signs.vim │ │ │ │ ├── string.vim │ │ │ │ ├── syntax.vim │ │ │ │ ├── sys.vim │ │ │ │ ├── tab.vim │ │ │ │ ├── tag.vim │ │ │ │ ├── textobjects.vim │ │ │ │ ├── time.vim │ │ │ │ ├── trace.vim │ │ │ │ ├── type.vim │ │ │ │ ├── url.vim │ │ │ │ ├── var.vim │ │ │ │ ├── vcs.vim │ │ │ │ ├── vim.vim │ │ │ │ └── win.vim │ │ │ └── tlib.vim │ │ ├── doc/ │ │ │ └── tlib.txt │ │ ├── etc/ │ │ │ └── tpl_tlib.txt │ │ ├── macros/ │ │ │ └── tlib.vim │ │ ├── plugin/ │ │ │ └── 02tlib.vim │ │ ├── samples/ │ │ │ └── tlib/ │ │ │ └── input/ │ │ │ └── tlib_input_list.vim │ │ ├── scripts/ │ │ │ └── create_crc_table.rb │ │ └── spec/ │ │ └── tlib/ │ │ ├── arg.vim │ │ ├── date.vim │ │ ├── dictionary.vim │ │ ├── eval.vim │ │ ├── file.vim │ │ ├── hash.vim │ │ ├── input.vim │ │ ├── list.vim │ │ ├── rx.vim │ │ ├── string.vim │ │ ├── url.vim │ │ └── var.vim │ ├── typescript-vim/ │ │ ├── README.md │ │ ├── compiler/ │ │ │ ├── typescript.vim │ │ │ └── typescriptreact.vim │ │ ├── ftdetect/ │ │ │ └── typescript.vim │ │ ├── ftplugin/ │ │ │ ├── typescript.vim │ │ │ └── typescriptreact.vim │ │ ├── indent/ │ │ │ ├── typescript.vim │ │ │ └── typescriptreact.vim │ │ └── syntax/ │ │ ├── typescript.vim │ │ └── typescriptreact.vim │ ├── vim-abolish/ │ │ ├── .github/ │ │ │ └── FUNDING.yml │ │ ├── .gitignore │ │ ├── CONTRIBUTING.markdown │ │ ├── README.markdown │ │ ├── doc/ │ │ │ └── abolish.txt │ │ └── plugin/ │ │ └── abolish.vim │ ├── vim-addon-mw-utils/ │ │ ├── .gitignore │ │ ├── autoload/ │ │ │ ├── buf_utils.vim │ │ │ ├── cached_file_contents.vim │ │ │ ├── env_reload.vim │ │ │ ├── funcref.vim │ │ │ ├── glob.vim │ │ │ ├── glob_linux.vim │ │ │ ├── tiny_cmd.vim │ │ │ └── tovl/ │ │ │ ├── scratch_buffer.vim │ │ │ └── ui/ │ │ │ └── filter_list.vim │ │ ├── doc/ │ │ │ ├── cached_file_contents.txt │ │ │ ├── funcref.txt │ │ │ └── tiny_cmd.txt │ │ └── vim-addon-mw-utils-addon-info.txt │ ├── vim-bundle-mako/ │ │ ├── README.md │ │ ├── ftdetect/ │ │ │ └── mako.vim │ │ ├── ftplugin/ │ │ │ └── mako.vim │ │ ├── indent/ │ │ │ └── mako.vim │ │ └── syntax/ │ │ └── mako.vim │ ├── vim-coffee-script/ │ │ ├── .gitignore │ │ ├── Copying.md │ │ ├── Makefile │ │ ├── News.md │ │ ├── Readme.md │ │ ├── Thanks.md │ │ ├── Todo.md │ │ ├── after/ │ │ │ ├── indent/ │ │ │ │ └── html.vim │ │ │ └── syntax/ │ │ │ ├── haml.vim │ │ │ └── html.vim │ │ ├── autoload/ │ │ │ └── coffee.vim │ │ ├── compiler/ │ │ │ ├── cake.vim │ │ │ └── coffee.vim │ │ ├── doc/ │ │ │ └── coffee-script.txt │ │ ├── ftdetect/ │ │ │ ├── coffee.vim │ │ │ └── vim-literate-coffeescript.vim │ │ ├── ftplugin/ │ │ │ ├── coffee.vim │ │ │ └── litcoffee.vim │ │ ├── indent/ │ │ │ ├── coffee.vim │ │ │ └── litcoffee.vim │ │ ├── syntax/ │ │ │ ├── coffee.vim │ │ │ └── litcoffee.vim │ │ └── test/ │ │ ├── test-interp.coffee │ │ ├── test-ops.coffee │ │ ├── test-reserved.coffee │ │ ├── test.coffee.md │ │ ├── test.haml │ │ ├── test.html │ │ └── test.litcoffee │ ├── vim-colors-solarized/ │ │ ├── README.mkd │ │ ├── autoload/ │ │ │ └── togglebg.vim │ │ ├── colors/ │ │ │ └── solarized.vim │ │ └── doc/ │ │ └── solarized.txt │ ├── vim-commentary/ │ │ ├── .github/ │ │ │ └── FUNDING.yml │ │ ├── .gitignore │ │ ├── CONTRIBUTING.markdown │ │ ├── README.markdown │ │ ├── doc/ │ │ │ └── commentary.txt │ │ └── plugin/ │ │ └── commentary.vim │ ├── vim-expand-region/ │ │ ├── MIT-LICENSE.txt │ │ ├── README.md │ │ ├── autoload/ │ │ │ └── expand_region.vim │ │ ├── doc/ │ │ │ └── expand_region.txt │ │ └── plugin/ │ │ └── expand_region.vim │ ├── vim-flake8/ │ │ ├── LICENSE │ │ ├── README.md │ │ ├── autoload/ │ │ │ └── flake8.vim │ │ └── ftplugin/ │ │ └── python_flake8.vim │ ├── vim-fugitive/ │ │ ├── autoload/ │ │ │ └── fugitive.vim │ │ ├── doc/ │ │ │ └── fugitive.txt │ │ ├── ftdetect/ │ │ │ └── fugitive.vim │ │ ├── ftplugin/ │ │ │ └── fugitiveblame.vim │ │ ├── plugin/ │ │ │ └── fugitive.vim │ │ └── syntax/ │ │ ├── fugitive.vim │ │ └── fugitiveblame.vim │ ├── vim-gist/ │ │ ├── .github/ │ │ │ └── FUNDING.yml │ │ ├── README.md │ │ ├── autoload/ │ │ │ └── gist.vim │ │ ├── doc/ │ │ │ └── gist-vim.txt │ │ └── plugin/ │ │ └── gist.vim │ ├── vim-gitgutter/ │ │ ├── .github/ │ │ │ └── issue_template.md │ │ ├── .gitignore │ │ ├── LICENCE │ │ ├── README.mkd │ │ ├── autoload/ │ │ │ ├── gitgutter/ │ │ │ │ ├── async.vim │ │ │ │ ├── debug.vim │ │ │ │ ├── diff.vim │ │ │ │ ├── diff_highlight.vim │ │ │ │ ├── fold.vim │ │ │ │ ├── highlight.vim │ │ │ │ ├── hunk.vim │ │ │ │ ├── sign.vim │ │ │ │ └── utility.vim │ │ │ └── gitgutter.vim │ │ ├── doc/ │ │ │ └── gitgutter.txt │ │ ├── plugin/ │ │ │ └── gitgutter.vim │ │ └── test/ │ │ ├── .gitattributes │ │ ├── .gitconfig │ │ ├── cp932.txt │ │ ├── fixture.foo │ │ ├── fixture.txt │ │ ├── fixture_dos.txt │ │ ├── fixture_dos_noeol.txt │ │ ├── runner.vim │ │ ├── test │ │ └── test_gitgutter.vim │ ├── vim-indent-guides/ │ │ ├── .github/ │ │ │ └── workflows/ │ │ │ └── vint.yml │ │ ├── .gitignore │ │ ├── LICENSE │ │ ├── README.markdown │ │ ├── autoload/ │ │ │ ├── color_helper.vim │ │ │ └── indent_guides.vim │ │ ├── doc/ │ │ │ └── indent_guides.txt │ │ ├── plugin/ │ │ │ └── indent_guides.vim │ │ └── test-files/ │ │ ├── test-ts2sw0et.txt │ │ ├── test-ts2sw2et.txt │ │ ├── test-ts2sw2noet.txt │ │ ├── test-ts2sw4noet.txt │ │ ├── test-ts4sw4et.txt │ │ ├── test-ts4sw4noet.txt │ │ ├── test-ts8sw2noet.txt │ │ ├── test-ts8sw8et.txt │ │ └── test-ts8sw8noet.txt │ ├── vim-indent-object/ │ │ ├── .gitignore │ │ ├── LICENSE │ │ ├── README.md │ │ ├── doc/ │ │ │ └── indent-object.txt │ │ └── plugin/ │ │ └── indent-object.vim │ ├── vim-javascript/ │ │ ├── ISSUE_TEMPLATE.md │ │ ├── README.md │ │ ├── after/ │ │ │ └── ftplugin/ │ │ │ └── javascript.vim │ │ ├── compiler/ │ │ │ └── eslint.vim │ │ ├── extras/ │ │ │ ├── ctags │ │ │ ├── flow.vim │ │ │ ├── jsdoc.vim │ │ │ └── ngdoc.vim │ │ ├── ftdetect/ │ │ │ ├── flow.vim │ │ │ └── javascript.vim │ │ ├── indent/ │ │ │ └── javascript.vim │ │ └── syntax/ │ │ ├── flow.vim │ │ └── javascript.vim │ ├── vim-lastplace/ │ │ ├── .gitignore │ │ ├── LICENSE │ │ ├── README.md │ │ ├── doc/ │ │ │ └── vim-lastplace.txt │ │ └── plugin/ │ │ └── vim-lastplace.vim │ ├── vim-less/ │ │ ├── .gitignore │ │ ├── README.md │ │ ├── after/ │ │ │ └── syntax/ │ │ │ └── html.vim │ │ ├── ftdetect/ │ │ │ └── less.vim │ │ ├── ftplugin/ │ │ │ └── less.vim │ │ ├── indent/ │ │ │ └── less.vim │ │ └── syntax/ │ │ └── less.vim │ ├── vim-markdown/ │ │ ├── .github/ │ │ │ └── workflows/ │ │ │ ├── reviewdog.yml │ │ │ ├── vader.yml │ │ │ └── vint.yml │ │ ├── .gitignore │ │ ├── .vintrc.yaml │ │ ├── CONTRIBUTING.md │ │ ├── Makefile │ │ ├── README.md │ │ ├── after/ │ │ │ └── ftplugin/ │ │ │ └── markdown.vim │ │ ├── doc/ │ │ │ └── vim-markdown.txt │ │ ├── ftdetect/ │ │ │ └── markdown.vim │ │ ├── ftplugin/ │ │ │ └── markdown.vim │ │ ├── indent/ │ │ │ └── markdown.vim │ │ ├── registry/ │ │ │ └── markdown.yaml │ │ ├── syntax/ │ │ │ └── markdown.vim │ │ └── test/ │ │ ├── README.md │ │ ├── folding-toc.vader │ │ ├── folding.vader │ │ ├── ge_test.md │ │ ├── header-decrease.vader │ │ ├── indent-new-list-item.vader │ │ ├── indent.md │ │ ├── indent.vader │ │ ├── insert-toc.vader │ │ ├── map.vader │ │ ├── python-folding.vader │ │ ├── run-tests.sh │ │ ├── setextoatx.vader │ │ ├── strikethrough.vader │ │ ├── syntax-singleline.vader │ │ ├── syntax.md │ │ ├── syntax.vader │ │ ├── table-format.vader │ │ ├── toc-autofit.vader │ │ ├── toc.vader │ │ └── vimrc │ ├── vim-multiple-cursors/ │ │ ├── .gitignore │ │ ├── .rspec │ │ ├── .travis.yml │ │ ├── CHANGELOG.md │ │ ├── CONTRIBUTING.md │ │ ├── Gemfile │ │ ├── MIT-LICENSE.txt │ │ ├── README.md │ │ ├── Rakefile │ │ ├── autoload/ │ │ │ └── multiple_cursors.vim │ │ ├── doc/ │ │ │ └── multiple_cursors.txt │ │ ├── plugin/ │ │ │ └── multiple_cursors.vim │ │ └── spec/ │ │ ├── benchmark_spec.rb │ │ ├── multiple_cursors_spec.rb │ │ └── spec_helper.rb │ ├── vim-pug/ │ │ ├── README.md │ │ ├── ftdetect/ │ │ │ └── pug.vim │ │ ├── ftplugin/ │ │ │ └── pug.vim │ │ ├── indent/ │ │ │ └── pug.vim │ │ └── syntax/ │ │ └── pug.vim │ ├── vim-pyte/ │ │ ├── README │ │ └── colors/ │ │ └── pyte.vim │ ├── vim-python-pep8-indent/ │ │ ├── .circleci/ │ │ │ └── config.yml │ │ ├── .coveragerc │ │ ├── .dockerignore │ │ ├── .gitignore │ │ ├── CONTRIBUTING.rst │ │ ├── COPYING.txt │ │ ├── Dockerfile │ │ ├── Gemfile │ │ ├── Makefile │ │ ├── README.rst │ │ ├── docker-compose.yml │ │ ├── indent/ │ │ │ ├── cython.vim │ │ │ └── python.vim │ │ └── spec/ │ │ ├── indent/ │ │ │ ├── bytes_spec.rb │ │ │ ├── cython_spec.rb │ │ │ └── indent_spec.rb │ │ ├── make-coverage │ │ ├── spec_helper.rb │ │ └── vimrc │ ├── vim-repeat/ │ │ ├── README.markdown │ │ └── autoload/ │ │ └── repeat.vim │ ├── vim-rhubarb/ │ │ ├── LICENSE │ │ ├── autoload/ │ │ │ └── rhubarb.vim │ │ ├── doc/ │ │ │ └── rhubarb.txt │ │ └── plugin/ │ │ └── rhubarb.vim │ ├── vim-ruby/ │ │ ├── .gitignore │ │ ├── .rspec │ │ ├── CONTRIBUTORS │ │ ├── ChangeLog │ │ ├── Gemfile │ │ ├── INSTALL.markdown │ │ ├── NEWS │ │ ├── README.markdown │ │ ├── autoload/ │ │ │ └── rubycomplete.vim │ │ ├── compiler/ │ │ │ ├── eruby.vim │ │ │ ├── rake.vim │ │ │ ├── rspec.vim │ │ │ ├── ruby.vim │ │ │ └── rubyunit.vim │ │ ├── doc/ │ │ │ ├── ft-ruby-indent.txt │ │ │ ├── ft-ruby-omni.txt │ │ │ ├── ft-ruby-plugin.txt │ │ │ └── ft-ruby-syntax.txt │ │ ├── etc/ │ │ │ └── examples/ │ │ │ ├── generators/ │ │ │ │ └── syntax.rb │ │ │ └── indent/ │ │ │ └── closing_brackets.rb │ │ ├── ftdetect/ │ │ │ ├── ruby.vim │ │ │ └── ruby_extra.vim │ │ ├── ftplugin/ │ │ │ ├── eruby.vim │ │ │ └── ruby.vim │ │ ├── indent/ │ │ │ ├── eruby.vim │ │ │ └── ruby.vim │ │ ├── spec/ │ │ │ ├── indent/ │ │ │ │ ├── arguments_spec.rb │ │ │ │ ├── basic_spec.rb │ │ │ │ ├── blocks_spec.rb │ │ │ │ ├── case_in_spec.rb │ │ │ │ ├── continuations_spec.rb │ │ │ │ ├── end_constructs_spec.rb │ │ │ │ ├── eruby_spec.rb │ │ │ │ ├── hanging_elements_spec.rb │ │ │ │ ├── identifiers_spec.rb │ │ │ │ ├── indent_access_modifier_spec.rb │ │ │ │ ├── method_definitions_spec.rb │ │ │ │ ├── nesting_spec.rb │ │ │ │ └── splat_spec.rb │ │ │ ├── spec_helper.rb │ │ │ ├── syntax/ │ │ │ │ ├── blocks_spec.rb │ │ │ │ ├── characters_spec.rb │ │ │ │ ├── comments_spec.rb │ │ │ │ ├── line_continuations_spec.rb │ │ │ │ ├── maxmempattern_limit_spec.rb │ │ │ │ ├── methods_spec.rb │ │ │ │ ├── operators_spec.rb │ │ │ │ ├── regular_expressions_spec.rb │ │ │ │ ├── statement_modifiers_spec.rb │ │ │ │ ├── strings/ │ │ │ │ │ ├── heredoc_spec.rb │ │ │ │ │ ├── interpolation_spec.rb │ │ │ │ │ └── strings_spec.rb │ │ │ │ └── symbols_spec.rb │ │ │ └── vim/ │ │ │ └── plugin/ │ │ │ └── syntax_test.vim │ │ └── syntax/ │ │ ├── eruby.vim │ │ └── ruby.vim │ ├── vim-snipmate/ │ │ ├── .gitignore │ │ ├── Contributors.md │ │ ├── README.md │ │ ├── addon-info.json │ │ ├── after/ │ │ │ └── plugin/ │ │ │ └── snipMate.vim │ │ ├── autoload/ │ │ │ ├── snipMate.vim │ │ │ ├── snipMate_python_demo.vim │ │ │ └── snipmate/ │ │ │ ├── jumping.vim │ │ │ ├── legacy.vim │ │ │ ├── parse.vim │ │ │ └── util.vim │ │ ├── doc/ │ │ │ └── snipMate.txt │ │ ├── ftplugin/ │ │ │ ├── html_snip_helper.vim │ │ │ └── snippets.vim │ │ ├── indent/ │ │ │ └── snippets.vim │ │ ├── plugin/ │ │ │ └── snipMate.vim │ │ ├── syntax/ │ │ │ ├── snippet.vim │ │ │ └── snippets.vim │ │ └── t/ │ │ ├── jumping.vim │ │ ├── parser.vim │ │ └── tests.sh │ ├── vim-snippets/ │ │ ├── .gitignore │ │ ├── .travis.yml │ │ ├── AUTHORS │ │ ├── LICENSE │ │ ├── README.md │ │ ├── UltiSnips/ │ │ │ ├── README │ │ │ ├── ada.snippets │ │ │ ├── all.snippets │ │ │ ├── bib.snippets │ │ │ ├── bindzone.snippets │ │ │ ├── blade.snippets │ │ │ ├── c.snippets │ │ │ ├── coffee-jasmine.snippets │ │ │ ├── coffee-react.snippets │ │ │ ├── coffee.snippets │ │ │ ├── cpp.snippets │ │ │ ├── crystal.snippets │ │ │ ├── cs.snippets │ │ │ ├── css.snippets │ │ │ ├── cuda.snippets │ │ │ ├── d.snippets │ │ │ ├── django.snippets │ │ │ ├── eelixir.snippets │ │ │ ├── ejs.snippets │ │ │ ├── elm.snippets │ │ │ ├── erlang.snippets │ │ │ ├── eruby.snippets │ │ │ ├── gitcommit.snippets │ │ │ ├── go.snippets │ │ │ ├── haskell.snippets │ │ │ ├── help.snippets │ │ │ ├── html.snippets │ │ │ ├── html_minimal.snippets │ │ │ ├── htmldjango.snippets │ │ │ ├── htmljinja.snippets │ │ │ ├── java.snippets │ │ │ ├── javascript-angular.snippets │ │ │ ├── javascript-ember.snippets │ │ │ ├── javascript-jasmine-arrow.snippets │ │ │ ├── javascript-jsdoc.snippets │ │ │ ├── javascript-node.snippets │ │ │ ├── javascript.snippets │ │ │ ├── javascript_react.snippets │ │ │ ├── jinja2.snippets │ │ │ ├── json.snippets │ │ │ ├── julia.snippets │ │ │ ├── ledger.snippets │ │ │ ├── lhaskell.snippets │ │ │ ├── lua.snippets │ │ │ ├── mako.snippets │ │ │ ├── markdown.snippets │ │ │ ├── matlab.snippets │ │ │ ├── objc.snippets │ │ │ ├── ocaml.snippets │ │ │ ├── octave.snippets │ │ │ ├── pandoc.snippets │ │ │ ├── perl.snippets │ │ │ ├── php-laravel.snippets │ │ │ ├── php-phpspec.snippets │ │ │ ├── php-symfony2.snippets │ │ │ ├── php.snippets │ │ │ ├── plsql.snippets │ │ │ ├── proto.snippets │ │ │ ├── puppet.snippets │ │ │ ├── python.snippets │ │ │ ├── r.snippets │ │ │ ├── rails.snippets │ │ │ ├── rnoweb.snippets │ │ │ ├── robot.snippets │ │ │ ├── rst.snippets │ │ │ ├── ruby.snippets │ │ │ ├── rust.snippets │ │ │ ├── sh.snippets │ │ │ ├── smarty.snippets │ │ │ ├── snippets.snippets │ │ │ ├── soy.snippets │ │ │ ├── supercollider.snippets │ │ │ ├── svelte.snippets │ │ │ ├── tcl.snippets │ │ │ ├── tex.snippets │ │ │ ├── texmath.snippets │ │ │ ├── typescript.snippets │ │ │ ├── typescript_react.snippets │ │ │ ├── vim.snippets │ │ │ ├── vue.snippets │ │ │ ├── xhtml.snippets │ │ │ ├── xml.snippets │ │ │ └── zsh.snippets │ │ ├── addon-info.json │ │ ├── autoload/ │ │ │ └── vim_snippets.vim │ │ ├── plugin/ │ │ │ └── vimsnippets.vim │ │ ├── pythonx/ │ │ │ ├── javascript_snippets.py │ │ │ └── vimsnippets.py │ │ ├── snippets/ │ │ │ ├── _.snippets │ │ │ ├── actionscript.snippets │ │ │ ├── ada.snippets │ │ │ ├── all.snippets │ │ │ ├── alpaca.snippets │ │ │ ├── apache.snippets │ │ │ ├── arduino.snippets │ │ │ ├── asm.snippets │ │ │ ├── autoit.snippets │ │ │ ├── awk.snippets │ │ │ ├── bash.snippets │ │ │ ├── c.snippets │ │ │ ├── chef.snippets │ │ │ ├── clojure.snippets │ │ │ ├── cmake.snippets │ │ │ ├── codeigniter.snippets │ │ │ ├── coffee/ │ │ │ │ ├── angular_coffee.snippets │ │ │ │ ├── coffee.snippets │ │ │ │ ├── jquery_coffee.snippets │ │ │ │ └── requirejs_coffee.snippets │ │ │ ├── cpp.snippets │ │ │ ├── crystal.snippets │ │ │ ├── cs.snippets │ │ │ ├── css.snippets │ │ │ ├── cuda.snippets │ │ │ ├── d.snippets │ │ │ ├── dart-flutter.snippets │ │ │ ├── dart.snippets │ │ │ ├── diff.snippets │ │ │ ├── django.snippets │ │ │ ├── dosini.snippets │ │ │ ├── eelixir.snippets │ │ │ ├── elixir.snippets │ │ │ ├── elm.snippets │ │ │ ├── erlang.snippets │ │ │ ├── eruby.snippets │ │ │ ├── falcon.snippets │ │ │ ├── fortran.snippets │ │ │ ├── freemarker.snippets │ │ │ ├── fsharp.snippets │ │ │ ├── gdscript.snippets │ │ │ ├── gitcommit.snippets │ │ │ ├── gleam.snippets │ │ │ ├── go.snippets │ │ │ ├── haml.snippets │ │ │ ├── handlebars.snippets │ │ │ ├── haskell.snippets │ │ │ ├── heex.snippets │ │ │ ├── helm.snippets │ │ │ ├── html.snippets │ │ │ ├── htmldjango.snippets │ │ │ ├── htmltornado.snippets │ │ │ ├── idris.snippets │ │ │ ├── jade.snippets │ │ │ ├── java.snippets │ │ │ ├── javascript/ │ │ │ │ ├── javascript-jquery.snippets │ │ │ │ ├── javascript-react.snippets │ │ │ │ ├── javascript-redux.snippets │ │ │ │ ├── javascript-requirejs.snippets │ │ │ │ ├── javascript.node.snippets │ │ │ │ └── javascript.snippets │ │ │ ├── javascript-bemjson.snippets │ │ │ ├── javascript-d3.snippets │ │ │ ├── javascript-jasmine.snippets │ │ │ ├── javascript-mocha.snippets │ │ │ ├── javascript-openui5.snippets │ │ │ ├── jenkins.snippets │ │ │ ├── jinja.snippets │ │ │ ├── jsp.snippets │ │ │ ├── julia.snippets │ │ │ ├── kotlin.snippets │ │ │ ├── laravel.snippets │ │ │ ├── ledger.snippets │ │ │ ├── lfe.snippets │ │ │ ├── liquid.snippets │ │ │ ├── lpc.snippets │ │ │ ├── ls.snippets │ │ │ ├── lua.snippets │ │ │ ├── make.snippets │ │ │ ├── mako.snippets │ │ │ ├── markdown.snippets │ │ │ ├── matlab.snippets │ │ │ ├── mustache.snippets │ │ │ ├── objc.snippets │ │ │ ├── ocaml.snippets │ │ │ ├── octave.snippets │ │ │ ├── openfoam.snippets │ │ │ ├── org.snippets │ │ │ ├── pandoc.snippets │ │ │ ├── perl.snippets │ │ │ ├── perl6.snippets │ │ │ ├── phoenix.snippets │ │ │ ├── php.snippets │ │ │ ├── plsql.snippets │ │ │ ├── po.snippets │ │ │ ├── processing.snippets │ │ │ ├── progress.snippets │ │ │ ├── ps1.snippets │ │ │ ├── puppet.snippets │ │ │ ├── purescript.snippets │ │ │ ├── python.snippets │ │ │ ├── r.snippets │ │ │ ├── racket.snippets │ │ │ ├── rails.snippets │ │ │ ├── reason.snippets │ │ │ ├── rmd.snippets │ │ │ ├── rst.snippets │ │ │ ├── ruby.snippets │ │ │ ├── rust.snippets │ │ │ ├── sass.snippets │ │ │ ├── scala.snippets │ │ │ ├── scheme.snippets │ │ │ ├── scss.snippets │ │ │ ├── sh.snippets │ │ │ ├── simplemvcf.snippets │ │ │ ├── slim.snippets │ │ │ ├── smarty.snippets │ │ │ ├── snippets.snippets │ │ │ ├── sql.snippets │ │ │ ├── stylus.snippets │ │ │ ├── supercollider.snippets │ │ │ ├── svelte.snippets │ │ │ ├── systemverilog.snippets │ │ │ ├── tcl.snippets │ │ │ ├── tex.snippets │ │ │ ├── textile.snippets │ │ │ ├── twig.snippets │ │ │ ├── typescript.snippets │ │ │ ├── typescriptreact.snippets │ │ │ ├── verilog.snippets │ │ │ ├── vhdl.snippets │ │ │ ├── vim.snippets │ │ │ ├── vue.snippets │ │ │ ├── xml.snippets │ │ │ ├── xslt.snippets │ │ │ ├── yii-chtml.snippets │ │ │ ├── yii.snippets │ │ │ └── zsh.snippets │ │ └── tests.sh │ ├── vim-surround/ │ │ ├── .github/ │ │ │ └── FUNDING.yml │ │ ├── .gitignore │ │ ├── README.markdown │ │ ├── doc/ │ │ │ └── surround.txt │ │ └── plugin/ │ │ └── surround.vim │ ├── vim-yankstack/ │ │ ├── .gitignore │ │ ├── Gemfile │ │ ├── README.md │ │ ├── autoload/ │ │ │ └── yankstack.vim │ │ ├── doc/ │ │ │ └── yankstack.txt │ │ ├── plugin/ │ │ │ └── yankstack.vim │ │ └── spec/ │ │ ├── fixtures/ │ │ │ └── repeat.vim │ │ ├── spec_helper.rb │ │ └── yankstack/ │ │ └── yankstack_spec.rb │ └── vim-zenroom2/ │ ├── README.markdown │ └── plugin/ │ └── zenroom2.vim ├── temp_dirs/ │ ├── README.md │ └── undodir/ │ └── .gitignore ├── update_plugins.py └── vimrcs/ ├── basic.vim ├── extended.vim ├── filetypes.vim └── plugins_config.vim ================================================ FILE CONTENTS ================================================ ================================================ FILE: .gitignore ================================================ temp_dirs/undodir/* sources_non_forked/ack.vim/.netrwhist temp_dirs/yankring_history_v2.txt sources_forked/yankring/doc/tags sources_non_forked/tlib/doc/tags sources_non_forked/ctrlp.vim/doc/tags* my_plugins/ my_configs.vim tags .DS_Store ================================================ FILE: LICENSE ================================================ The MIT License (MIT) Copyright (c) 2016 Amir Salihefendic Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ================================================ FILE: README.md ================================================ ![VIM](https://dnp4pehkvoo6n.cloudfront.net/43c5af597bd5c1a64eb1829f011c208f/as/Ultimate%20Vimrc.svg) # The Ultimate vimrc Over the last 10 years, I have used and tweaked Vim. This configuration is the ultimate vimrc (or at least my version of it). There are two versions: * **The Basic**: If you want something small just copy [basic.vim](https://github.com/amix/vimrc/blob/master/vimrcs/basic.vim) into your ~/.vimrc and you will have a good basic setup * **The Awesome**: Includes a ton of useful plugins, color schemes, and configurations I would, of course, recommend using the awesome version. ## How to install the Awesome version? ### Install for your own user only The awesome version includes a lot of great plugins, configurations and color schemes that make Vim a lot better. To install it simply do following from your terminal: git clone --depth=1 https://github.com/amix/vimrc.git ~/.vim_runtime sh ~/.vim_runtime/install_awesome_vimrc.sh ### Install for multiple users To install for multiple users, the repository needs to be cloned to a location accessible for all the intended users. git clone --depth=1 https://github.com/amix/vimrc.git /opt/vim_runtime sh /opt/vim_runtime/install_awesome_parameterized.sh /opt/vim_runtime user0 user1 user2 # to install for all users with home directories, note that root will not be included sh /opt/vim_runtime/install_awesome_parameterized.sh /opt/vim_runtime --all Naturally, `/opt/vim_runtime` can be any directory, as long as all the users specified have read access. ## Fonts I recommend using [IBM Plex Mono font](https://github.com/IBM/plex) (it's an open-source and awesome font that can make your code look beautiful). The Awesome vimrc is already setup to try to use it. Some other fonts that Awesome will try to use: * [Hack](http://sourcefoundry.org/hack/) * [Source Code Pro](https://adobe-fonts.github.io/source-code-pro/) ## How to install the Basic version? The basic version is just one file and no plugins. Just copy [basic.vim](https://github.com/amix/vimrc/blob/master/vimrcs/basic.vim) and paste it into your vimrc. The basic version is useful to install on remote servers where you don't need many plugins, and you don't do many edits. git clone --depth=1 https://github.com/amix/vimrc.git ~/.vim_runtime sh ~/.vim_runtime/install_basic_vimrc.sh ## How to install on Windows? Use [gitforwindows](http://gitforwindows.org/) to checkout the repository and run the installation instructions above. No special instructions needed ;-) ## How to install on Linux If you have vim aliased as `vi` instead of `vim`, make sure to either alias it: `alias vi=vim`. Otherwise, `apt-get install vim` ## How to update to latest version? Just do a git rebase! cd ~/.vim_runtime git reset --hard git clean -d --force git pull --rebase python update_plugins.py # use python3 if python is unavailable ## Some screenshots Colors when editing a Python file: ![Screenshot 1](https://dnp4pehkvoo6n.cloudfront.net/07583008e4da885801657e8781777844/as/Python%20editing.png) [NERD Tree](https://github.com/preservim/nerdtree) plugin in a terminal window: ![Screenshot 3](https://dnp4pehkvoo6n.cloudfront.net/ae719203166585d64728f28398f4b1b7/as/Terminal%20usage.png) Distraction free mode using [goyo.vim](https://github.com/junegunn/goyo.vim) and [vim-zenroom2](https://github.com/amix/vim-zenroom2): ![Screenshot 4](https://dnp4pehkvoo6n.cloudfront.net/f0dcc4c9739148c56cbf8285a910ac41/as/Zen%20mode.png) ## Included Plugins I recommend reading the docs of these plugins to understand them better. Each plugin provides a much better Vim experience! * [ack.vim](https://github.com/mileszs/ack.vim): Vim plugin for `the_silver_searcher` (ag) or ack -- a wicked fast grep * [bufexplorer.zip](https://github.com/vim-scripts/bufexplorer.zip): Quickly and easily switch between buffers. This plugin can be opened with `` * [ctrlp.vim](https://github.com/ctrlpvim/ctrlp.vim): Fuzzy file, buffer, mru and tag finder. It's mapped to `` * [goyo.vim](https://github.com/junegunn/goyo.vim) and [vim-zenroom2](https://github.com/amix/vim-zenroom2): * [lightline.vim](https://github.com/itchyny/lightline.vim): A light and configurable statusline/tabline for Vim * [NERD Tree](https://github.com/preservim/nerdtree): A tree explorer plugin for vim * [open_file_under_cursor.vim](https://github.com/amix/open_file_under_cursor.vim): Open file under cursor when pressing `gf` * [pathogen.vim](https://github.com/tpope/vim-pathogen): Manage your vim runtimepath * [snipmate.vim](https://github.com/garbas/vim-snipmate): snipmate.vim aims to be a concise vim script that implements some of TextMate's snippets features in Vim * [ale](https://github.com/dense-analysis/ale): Syntax and lint checking for vim (ALE requires NeoVim >= 0.2.0 or Vim 8 with +timers +job +channel) * [vim-commentary](https://github.com/tpope/vim-commentary): Comment stuff out. Use `gcc` to comment out a line (takes a count), `gc` to comment out the target of a motion. `gcu` uncomments a set of adjacent commented lines * [vim-expand-region](https://github.com/terryma/vim-expand-region): Allows you to visually select increasingly larger regions of text using the same key combination * [vim-fugitive](https://github.com/tpope/vim-fugitive): A Git wrapper so awesome, it should be illegal * [vim-indent-object](https://github.com/michaeljsmith/vim-indent-object): Defines a new text object representing lines of code at the same indent level. Useful for python/vim scripts * [vim-multiple-cursors](https://github.com/terryma/vim-multiple-cursors): Sublime Text style multiple selections for Vim, CTRL+N is remapped to CTRL+S (due to YankRing) * [vim-yankstack](https://github.com/maxbrunsfeld/vim-yankstack): Maintains a history of previous yanks, changes and deletes * [vim-zenroom2](https://github.com/amix/vim-zenroom2) Remove all clutter and focus only on the essential. Similar to iA Writer or Write Room * [gist-vim](https://github.com/mattn/gist-vim) Easily create gists from Vim using the `:Gist` command * [vim-indent-guides](https://github.com/nathanaelkane/vim-indent-guides) Is a plugin for visually displaying indent levels in Vim * [editorconfig-vim](https://github.com/editorconfig/editorconfig-vim) EditorConfig helps maintain consistent coding styles for multiple developers working on the same project across various editors and IDEs * [copilot.vim](https://github.com/github/copilot.vim) Plugin for GitHub Copilot (AI autocompletion FTW 😅) ## Included color schemes Type `:colorscheme ` to try out color schemes on the fly, or add the command to `~/.vim_runtime/my_configs.vim` (see [below](#how-to-include-your-own-stuff)), for example `colorscheme pyte`. * [peaksea](https://github.com/vim-scripts/peaksea): The default * [dracula](https://github.com/dracula/vim) * [vim-colors-solarized](https://github.com/altercation/vim-colors-solarized) * [vim-irblack](https://github.com/wgibbs/vim-irblack) * [mayansmoke](https://github.com/vim-scripts/mayansmoke) * [vim-pyte](https://github.com/therubymug/vim-pyte) ## Included modes * [vim-coffee-script](https://github.com/kchmck/vim-coffee-script) * [vim-less](https://github.com/groenewege/vim-less) * [vim-bundle-mako](https://github.com/sophacles/vim-bundle-mako) * [vim-markdown](https://github.com/plasticboy/vim-markdown) * [nginx.vim](https://github.com/vim-scripts/nginx.vim): Highlights configuration files for nginx * [rust.vim](https://github.com/rust-lang/rust.vim) * [vim-ruby](https://github.com/vim-ruby/vim-ruby) * [typescript-vim](https://github.com/leafgarland/typescript-vim) * [vim-javascript](https://github.com/pangloss/vim-javascript) * [vim-python-pep8-indent](https://github.com/Vimjas/vim-python-pep8-indent) ## How to include your own stuff? After you have installed the setup, create an empty `~/.vim_runtime/my_configs.vim` file for further customization. This file's syntax matches `vimrc` syntax, and add `vimrc` lines like `set number` as needed. For instance, my `my_configs.vim` looks like this: ~/.vim_runtime > cat my_configs.vim map ct :cd ~/Desktop/Todoist/todoist map cw :cd ~/Desktop/Wedoist/wedoist You can also install your plugins, for instance, via pathogen you can install [vim-rails](https://github.com/tpope/vim-rails): cd ~/.vim_runtime git clone git://github.com/tpope/vim-rails.git my_plugins/vim-rails You can also install plugins without any plugin manager (vim 8+ required): * Create pack plugin directory:\ `mkdir -p ~/.vim_runtime/pack/plugins/start` * Clone the plugin that you want in that directory, for example:\ `git clone --depth=1 git://github.com/maxmellon/vim-jsx-pretty ~/.vim_runtime/pack/plugins/start/vim-jsx-pretty` ## Key Mappings The [leader](http://learnvimscriptthehardway.stevelosh.com/chapters/06.html#leader) is `,`, so whenever you see `` it means `,`. ### Normal mode mappings Fast saving of a buffer (`w`): ```vim nmap w :w! ``` Map `` to `/` (search) and `+` to `?` (backwards search): ```vim map / map ? ``` Disable highlights when you press ``: ```vim map :noh ``` Smart way to move between windows (`j` etc.): ```vim map j map k map h map l ``` Closing of the current buffer(s) (`bd` and (`ba`)): ```vim " Close current buffer map bd :Bclose " Close all buffers map ba :1,1000 bd! ``` Useful mappings for managing tabs: ```vim map tn :tabnew map to :tabonly map tc :tabclose map tm :tabmove " Opens a new tab with the current buffer's path " Super useful when editing files in the same directory map te :tabedit =escape(expand("%:p:h"), " ")/ ``` Switch [CWD](http://vim.wikia.com/wiki/Set_working_directory_to_the_current_file) to the directory of the open buffer: ```vim map cd :cd %:p:h:pwd ``` Open `ack.vim` for fast search: ```vim map g :Ack ``` Quickly open a buffer for scripbble: ```vim map q :e ~/buffer ``` Toggle paste mode on and off: ```vim map pp :setlocal paste! ``` ### Visual mode mappings Visual mode pressing `*` or `#` searches for the current selection: ```vim vnoremap * :call VisualSelection('f') vnoremap # :call VisualSelection('b') ``` When you press gv you `Ack.vim` after the selected text: ```vim vnoremap gv :call VisualSelection('gv', '') ``` When you press `r` you can search and replace the selected text: ```vim vnoremap r :call VisualSelection('replace') ``` Surround the visual selection in parenthesis/brackets/etc.: ```vim vnoremap $1 `>a)` vnoremap $2 `>a]` vnoremap $3 `>a}` vnoremap $$ `>a"` vnoremap $q `>a'` vnoremap $e `>a`` ``` ### Insert mode mappings Quickly insert parenthesis/brackets/etc.: ```vim inoremap $1 ()i inoremap $2 []i inoremap $3 {}i inoremap $4 {o}O inoremap $q ''i inoremap $e ""i inoremap $t <>i ``` Insert the current date and time (useful for timestamps): ```vim iab xdate =strftime("%d/%m/%y %H:%M:%S") ``` ### Command line mappings $q is super useful when browsing on the command line. It deletes everything until the last slash: ```vim cno $q eDeleteTillSlash() ``` Bash like keys for the command line: ```vim cnoremap cnoremap cnoremap cnoremap cnoremap ``` Write the file as sudo (works only on Unix). Super useful when you open a file and you don't have permissions to save your changes. [Vim tip](http://vim.wikia.com/wiki/Su-write): :W ### Plugin related mappings Open [bufexplorer](https://github.com/vim-scripts/bufexplorer.zip) to see and manage the current buffers (`o`): ```vim map o :BufExplorer ``` Open [ctrlp.vim](https://github.com/kien/ctrlp.vim) plugin to quickly find a file or a buffer (`j` or `f`): ```vim " Quickly find and open a file in the CWD let g:ctrlp_map = '' " Quickly find and open a recently opened file map f :MRU " Quickly find and open a buffer map b :CtrlPBuffer ``` [NERD Tree](https://github.com/preservim/nerdtree) mappings: ```vim map nn :NERDTreeToggle map nb :NERDTreeFromBookmark map nf :NERDTreeFind ``` [goyo.vim](https://github.com/junegunn/goyo.vim) and [vim-zenroom2](https://github.com/amix/vim-zenroom2) lets you only focus on one thing at a time. It removes all the distractions and centers the content. It has a special look when editing Markdown, reStructuredText and textfiles. It only has one mapping. (`z`) ```vim map z :Goyo ``` [vim-multiple-cursors](https://github.com/terryma/vim-multiple-cursors) mappings to manage multiple cursors at once: ```vim let g:multi_cursor_start_word_key = '' let g:multi_cursor_select_all_word_key = '' let g:multi_cursor_start_key = 'g' let g:multi_cursor_select_all_key = 'g' let g:multi_cursor_next_key = '' let g:multi_cursor_prev_key = '' let g:multi_cursor_skip_key = '' let g:multi_cursor_quit_key = '' ``` [vim-yankstack](https://github.com/maxbrunsfeld/vim-yankstack) mappings to manage the kill-ring (clipboard): ```vim nmap yankstack_substitute_older_paste nmap yankstack_substitute_newer_paste ``` [ctrl-p](https://github.com/ctrlpvim/ctrlp.vim) mappings to easily find and open a file, buffer, etc.: ```vim let g:ctrlp_map = '' map j :CtrlP map :CtrlPBuffer ``` [vim-snipmate](https://github.com/garbas/vim-snipmate) mappings to autocomplete via snippets: ```vim ino =snipMate#TriggerSnippet() snor i=snipMate#TriggerSnippet() ``` [vim-surround](https://github.com/tpope/vim-surround) mappings to easily surround a string with `_()` gettext annotation: ```vim vmap Si S(i_f) au FileType mako vmap Si S"i${ _(2f"a) } ``` [ale](https://github.com/dense-analysis/ale) to easily go to the next Ale syntax/lint error: ```vim nmap a (ale_next_wrap) ``` [vim-indent-guides](https://github.com/nathanaelkane/vim-indent-guides) the default mapping to toggle the plugin is (`ig`) You can also use the following commands inside Vim: :IndentGuidesEnable :IndentGuidesDisable :IndentGuidesToggle [vim-fugitive](https://github.com/tpope/vim-fugitive) to copy the link to the line of a Git repository to the clipboard: ```vim nnoremap v :.GBrowse! xnoremap v :'<'>GBrowse! ``` ### Spell checking Pressing `ss` will toggle spell checking: ```vim map ss :setlocal spell! ``` Shortcuts using `` instead of special characters: ```vim map sn ]s map sp [s map sa zg map s? z= ``` ### Running Code To run code directly from vim, press `F5`. The currently open code will execute without you having to type anything. Can be used to execute code written in C, C++, Java, Python, Go, Octave, Bash scripts and HTML. To edit how you want your code to be executed, make changes in the file `~/.vim_runtime/vimrcs/extended.vim` ### Cope Query `:help cope` if you are unsure what cope is. It's super useful! When you search with `Ack.vim`, display your results in cope by doing: `cc` To go to the next search result do: `n` To go to the previous search results do: `p` Cope mappings: ```vim map cc :botright cope map co ggVGy:tabnew:set syntax=qfpgg map n :cn map p :cp ``` ## How to uninstall Just do following: * Remove `~/.vim_runtime` * Remove any lines that reference `.vim_runtime` in your `~/.vimrc` ## Looking for a remote-first job? Maintaining this Vim configuration isn't my day job. Daily I am the founder/CEO of [Doist](https://doist.com/). You could come and help us build the workplace of the future while living a balanced life (anywhere in the world 🌍🌎🌏). PS: Using Vim isn't a requirement 😄 ================================================ FILE: autoload/pathogen.vim ================================================ " pathogen.vim - path option manipulation " Maintainer: Tim Pope " Version: 2.3 " 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. if exists("g:loaded_pathogen") || &cp finish endif let g:loaded_pathogen = 1 " Point of entry for basic default usage. Give a relative path to invoke " pathogen#interpose() (defaults to "bundle/{}"), or an absolute path to invoke " pathogen#surround(). Curly braces are expanded with pathogen#expand(): " "bundle/{}" finds all subdirectories inside "bundle" inside all directories " in the runtime path. function! pathogen#infect(...) abort for path in a:0 ? filter(reverse(copy(a:000)), 'type(v:val) == type("")') : ['bundle/{}'] if path =~# '^\%({\=[$~\\/]\|{\=\w:[\\/]\).*[{}*]' call pathogen#surround(path) elseif path =~# '^\%([$~\\/]\|\w:[\\/]\)' call s:warn('Change pathogen#infect('.string(path).') to pathogen#infect('.string(path.'/{}').')') call pathogen#surround(path . '/{}') elseif path =~# '[{}*]' call pathogen#interpose(path) else call s:warn('Change pathogen#infect('.string(path).') to pathogen#infect('.string(path.'/{}').')') call pathogen#interpose(path . '/{}') endif endfor call pathogen#cycle_filetype() if pathogen#is_disabled($MYVIMRC) return 'finish' endif return '' endfunction " Split a path into a list. function! pathogen#split(path) abort if type(a:path) == type([]) | return a:path | endif if empty(a:path) | return [] | endif let split = split(a:path,'\\\@]','\\&','') endif endfunction " 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 " Section: Deprecated function! s:warn(msg) abort echohl WarningMsg echomsg a:msg echohl NONE endfunction " Prepend all subdirectories of path to the rtp, and append all 'after' " directories in those subdirectories. Deprecated. function! pathogen#runtime_prepend_subdirectories(path) abort call s:warn('Change pathogen#runtime_prepend_subdirectories('.string(a:path).') to pathogen#infect('.string(a:path.'/{}').')') return pathogen#surround(a:path . pathogen#slash() . '{}') endfunction function! pathogen#incubate(...) abort let name = a:0 ? a:1 : 'bundle/{}' call s:warn('Change pathogen#incubate('.(a:0 ? string(a:1) : '').') to pathogen#infect('.string(name).')') return pathogen#interpose(name) endfunction " Deprecated alias for pathogen#interpose(). function! pathogen#runtime_append_all_bundles(...) abort if a:0 call s:warn('Change pathogen#runtime_append_all_bundles('.string(a:1).') to pathogen#infect('.string(a:1.'/{}').')') else call s:warn('Change pathogen#runtime_append_all_bundles() to pathogen#infect()') endif return pathogen#interpose(a:0 ? a:1 . '/{}' : 'bundle/{}') endfunction if exists(':Vedit') finish endif let s:vopen_warning = 0 function! s:find(count,cmd,file,lcd) 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 function! s:Findcomplete(A,L,P) let sep = pathogen#slash() 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 command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Ve :execute s:find(,'edit',,0) command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vedit :execute s:find(,'edit',,0) command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vopen :execute s:find(,'edit',,1) command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vsplit :execute s:find(,'split',,1) command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vvsplit :execute s:find(,'vsplit',,1) command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vtabedit :execute s:find(,'tabedit',,1) command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vpedit :execute s:find(,'pedit',,1) command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vread :execute s:find(,'read',,1) " vim:set et sw=2 foldmethod=expr foldexpr=getline(v\:lnum)=~'^\"\ Section\:'?'>1'\:getline(v\:lnum)=~#'^fu'?'a1'\:getline(v\:lnum)=~#'^endf'?'s1'\:'=': ================================================ FILE: install_awesome_parameterized.sh ================================================ #!/bin/bash set -e echo 'Installing Awesome Vim from '$1 cd $1 VIMRC="\" DO NOT EDIT THIS FILE \" Add your own customizations in $1/my_configs.vim set runtimepath+=$1 source $1/vimrcs/basic.vim source $1/vimrcs/filetypes.vim source $1/vimrcs/plugins_config.vim source $1/vimrcs/extended.vim try source $1/my_configs.vim catch endtry" if [ "$2" = "--all" ]; then USERS=$(ls -l /home | awk '{if(NR>1)print $9}') for user in $USERS; do homepath=$(eval echo "~$user") IFS='' echo $VIMRC > ${homepath}/.vimrc unset IFS echo "Installed the Ultimate Vim configuration for user $user successfully! Enjoy :-)" done echo "Installed the Ultimate Vim configuration successfully! Enjoy :-)" exit 0 else SELECTED_USERS=${@:2} echo "Selected users: $SELECTED_USERS" for user in $SELECTED_USERS; do homepath=$(eval echo "~$user") IFS='' echo $VIMRC > ${homepath}/.vimrc unset IFS echo "Installed the Ultimate Vim configuration for user $user successfully! Enjoy :-)" done exit 0 fi ================================================ FILE: install_awesome_vimrc.sh ================================================ #!/bin/sh set -e cd ~/.vim_runtime echo '" DO NOT EDIT THIS FILE " Add your own customizations in ~/.vim_runtime/my_configs.vim set runtimepath+=~/.vim_runtime source ~/.vim_runtime/vimrcs/basic.vim source ~/.vim_runtime/vimrcs/filetypes.vim source ~/.vim_runtime/vimrcs/plugins_config.vim source ~/.vim_runtime/vimrcs/extended.vim try source ~/.vim_runtime/my_configs.vim catch endtry' > ~/.vimrc echo "Installed the Ultimate Vim configuration successfully! Enjoy :-)" ================================================ FILE: install_basic_vimrc.sh ================================================ #!/bin/sh set -e cd ~/.vim_runtime cat ~/.vim_runtime/vimrcs/basic.vim > ~/.vimrc echo "Installed the Basic Vim configuration successfully! Enjoy :-)" ================================================ FILE: sources_forked/peaksea/colors/peaksea.vim ================================================ " Vim color file --- psc (peak sea color) "Lite version" " Maintainer: Pan, Shi Zhu " URL: http://vim.sourceforge.net/scripts/script.php?script_id=760 " Last Change: 5 Feb 2010 " Version: 3.4 " " Comments and e-mails are welcomed, thanks. " " The peaksea color is simply a colorscheme with the default settings of " the original ps_color. Lite version means there's no custom settings " and fancy features such as integration with reloaded.vim " " The full version of ps_color.vim will be maintained until Vim 8. " By then there will be only the lite version: peaksea.vim " " Note: Please set the background option in your .vimrc and/or .gvimrc " " It is much better *not* to set 'background' option inside " a colorscheme file. because ":set background" improperly " may cause colorscheme be sourced twice " " Color Scheme Overview: " :ru syntax/hitest.vim " " Relevant Help: " :h highlight-groups " :h psc-cterm-color-table " " Colors Order: " #rrggbb " hi clear if exists("syntax_on") syntax reset endif let g:colors_name = "peaksea" " I don't want to abuse folding, but here folding is used to avoid confusion. if &background=='light' " for background=light {{{2 " LIGHT COLOR DEFINE START hi Normal guifg=#000000 guibg=#e0e0e0 gui=NONE hi Search guifg=White guibg=DarkRed gui=NONE hi Visual guifg=NONE guibg=#a6caf0 gui=NONE hi Cursor guifg=#f0f0f0 guibg=#008000 gui=NONE " The idea of CursorIM is pretty good, however, the feature is still buggy " in the current version (Vim 7.0). " The following line will be kept commented until the bug fixed. " " hi CursorIM guifg=#f0f0f0 guibg=#800080 hi Special guifg=#907000 guibg=NONE gui=NONE hi Comment guifg=#606000 guibg=NONE gui=NONE hi Number guifg=#907000 guibg=NONE gui=NONE hi Constant guifg=#007068 guibg=NONE gui=NONE hi StatusLine guifg=fg guibg=#a6caf0 gui=NONE hi LineNr guifg=#686868 guibg=NONE gui=NONE hi Question guifg=fg guibg=#d0d090 gui=NONE hi PreProc guifg=#009030 guibg=NONE gui=NONE hi Statement guifg=#2060a8 guibg=NONE gui=NONE hi Type guifg=#0850a0 guibg=NONE gui=NONE hi Todo guifg=#800000 guibg=#e0e090 gui=NONE " NOTE THIS IS IN THE WARM SECTION hi Error guifg=#c03000 guibg=NONE gui=NONE hi Identifier guifg=#a030a0 guibg=NONE gui=NONE hi ModeMsg guifg=fg guibg=#b0b0e0 gui=NONE hi VisualNOS guifg=fg guibg=#b0b0e0 gui=NONE hi SpecialKey guifg=#1050a0 guibg=NONE gui=NONE hi NonText guifg=#002090 guibg=#d0d0d0 gui=NONE hi Directory guifg=#a030a0 guibg=NONE gui=NONE hi ErrorMsg guifg=fg guibg=#f0b090 gui=NONE hi MoreMsg guifg=#489000 guibg=NONE gui=NONE hi Title guifg=#a030a0 guibg=NONE gui=NONE hi WarningMsg guifg=#b02000 guibg=NONE gui=NONE hi WildMenu guifg=fg guibg=#d0d090 gui=NONE hi Folded guifg=NONE guibg=#b0e0b0 gui=NONE hi FoldColumn guifg=fg guibg=NONE gui=NONE hi DiffAdd guifg=NONE guibg=#b0b0e0 gui=NONE hi DiffChange guifg=NONE guibg=#e0b0e0 gui=NONE hi DiffDelete guifg=#002090 guibg=#d0d0d0 gui=NONE hi DiffText guifg=NONE guibg=#c0e080 gui=NONE hi SignColumn guifg=fg guibg=#90e090 gui=NONE hi IncSearch guifg=White guibg=DarkRed gui=NONE hi StatusLineNC guifg=fg guibg=#c0c0c0 gui=NONE hi VertSplit guifg=fg guibg=#c0c0c0 gui=NONE hi Underlined guifg=#6a5acd guibg=NONE gui=underline hi Ignore guifg=bg guibg=NONE " NOTE THIS IS IN THE WARM SECTION if v:version >= 700 if has('spell') hi SpellBad guifg=NONE guibg=NONE guisp=#c03000 hi SpellCap guifg=NONE guibg=NONE guisp=#2060a8 hi SpellRare guifg=NONE guibg=NONE guisp=#a030a0 hi SpellLocal guifg=NONE guibg=NONE guisp=#007068 endif hi Pmenu guifg=fg guibg=#e0b0e0 hi PmenuSel guifg=#f0f0f0 guibg=#806060 gui=NONE hi PmenuSbar guifg=fg guibg=#c0c0c0 gui=NONE hi PmenuThumb guifg=fg guibg=#c0e080 gui=NONE hi TabLine guifg=fg guibg=#c0c0c0 gui=NONE hi TabLineFill guifg=fg guibg=#c0c0c0 gui=NONE hi TabLineSel guifg=fg guibg=NONE gui=NONE hi CursorColumn guifg=NONE guibg=#f0b090 hi CursorLine guifg=NONE guibg=NONE gui=underline hi MatchParen guifg=NONE guibg=#c0e080 endif " LIGHT COLOR DEFINE END " Vim 7 added stuffs if v:version >= 700 hi Ignore gui=NONE " the gui=undercurl guisp could only support in Vim 7 if has('spell') hi SpellBad gui=undercurl hi SpellCap gui=undercurl hi SpellRare gui=undercurl hi SpellLocal gui=undercurl endif hi TabLine gui=underline hi TabLineFill gui=underline hi CursorLine gui=underline endif " For reversed stuffs, clear the reversed prop and set the bold prop again hi IncSearch gui=bold hi StatusLine gui=bold hi StatusLineNC gui=bold hi VertSplit gui=bold hi Visual gui=bold " Enable the bold property hi Question gui=bold hi DiffText gui=bold hi Statement gui=bold hi Type gui=bold hi MoreMsg gui=bold hi ModeMsg gui=bold hi NonText gui=bold hi Title gui=bold hi DiffDelete gui=bold hi TabLineSel gui=bold " gui define for background=light end here " generally, a dumb terminal is dark, we assume the light terminal has 256 " color support. if &t_Co==8 || &t_Co==16 set t_Co=256 endif if &t_Co==256 " 256color light terminal support here hi Normal ctermfg=16 ctermbg=254 cterm=NONE " Comment/Uncomment the following line to disable/enable transparency "hi Normal ctermfg=16 ctermbg=NONE cterm=NONE hi Search ctermfg=White ctermbg=DarkRed cterm=NONE hi Visual ctermfg=NONE ctermbg=153 cterm=NONE hi Cursor ctermfg=255 ctermbg=28 cterm=NONE " hi CursorIM ctermfg=255 ctermbg=90 hi Special ctermfg=94 ctermbg=NONE cterm=NONE hi Comment ctermfg=58 ctermbg=NONE cterm=NONE hi Number ctermfg=94 ctermbg=NONE cterm=NONE hi Constant ctermfg=23 ctermbg=NONE cterm=NONE hi StatusLine ctermfg=fg ctermbg=153 cterm=NONE hi LineNr ctermfg=242 ctermbg=NONE cterm=NONE hi Question ctermfg=fg ctermbg=186 cterm=NONE hi PreProc ctermfg=29 ctermbg=NONE cterm=NONE hi Statement ctermfg=25 ctermbg=NONE cterm=NONE hi Type ctermfg=25 ctermbg=NONE cterm=NONE hi Todo ctermfg=88 ctermbg=186 cterm=NONE " NOTE THIS IS IN THE WARM SECTION hi Error ctermfg=130 ctermbg=NONE cterm=NONE hi Identifier ctermfg=133 ctermbg=NONE cterm=NONE hi ModeMsg ctermfg=fg ctermbg=146 cterm=NONE hi VisualNOS ctermfg=fg ctermbg=146 cterm=NONE hi SpecialKey ctermfg=25 ctermbg=NONE cterm=NONE hi NonText ctermfg=18 ctermbg=252 cterm=NONE " Comment/Uncomment the following line to disable/enable transparency "hi NonText ctermfg=18 ctermbg=NONE cterm=NONE hi Directory ctermfg=133 ctermbg=NONE cterm=NONE hi ErrorMsg ctermfg=fg ctermbg=216 cterm=NONE hi MoreMsg ctermfg=64 ctermbg=NONE cterm=NONE hi Title ctermfg=133 ctermbg=NONE cterm=NONE hi WarningMsg ctermfg=124 ctermbg=NONE cterm=NONE hi WildMenu ctermfg=fg ctermbg=186 cterm=NONE hi Folded ctermfg=NONE ctermbg=151 cterm=NONE hi FoldColumn ctermfg=fg ctermbg=NONE cterm=NONE hi DiffAdd ctermfg=NONE ctermbg=146 cterm=NONE hi DiffChange ctermfg=NONE ctermbg=182 cterm=NONE hi DiffDelete ctermfg=18 ctermbg=252 cterm=NONE hi DiffText ctermfg=NONE ctermbg=150 cterm=NONE hi SignColumn ctermfg=fg ctermbg=114 cterm=NONE hi IncSearch ctermfg=White ctermbg=DarkRed cterm=NONE hi StatusLineNC ctermfg=fg ctermbg=250 cterm=NONE hi VertSplit ctermfg=fg ctermbg=250 cterm=NONE hi Underlined ctermfg=62 ctermbg=NONE cterm=underline hi Ignore ctermfg=bg ctermbg=NONE " NOTE THIS IS IN THE WARM SECTION if v:version >= 700 if has('spell') " ctermsp is not supported in Vim7, we ignore it. hi SpellBad cterm=undercurl ctermbg=NONE ctermfg=130 hi SpellCap cterm=undercurl ctermbg=NONE ctermfg=25 hi SpellRare cterm=undercurl ctermbg=NONE ctermfg=133 hi SpellLocal cterm=undercurl ctermbg=NONE ctermfg=23 endif hi Pmenu ctermfg=fg ctermbg=182 hi PmenuSel ctermfg=255 ctermbg=95 cterm=NONE hi PmenuSbar ctermfg=fg ctermbg=250 cterm=NONE hi PmenuThumb ctermfg=fg ctermbg=150 cterm=NONE hi TabLine ctermfg=fg ctermbg=250 cterm=NONE hi TabLineFill ctermfg=fg ctermbg=250 cterm=NONE hi TabLineSel ctermfg=fg ctermbg=NONE cterm=NONE hi CursorColumn ctermfg=NONE ctermbg=216 hi CursorLine ctermfg=NONE ctermbg=NONE cterm=underline hi MatchParen ctermfg=NONE ctermbg=150 endif hi TabLine cterm=underline hi TabLineFill cterm=underline hi CursorLine cterm=underline " For reversed stuffs, clear the reversed prop and set the bold prop again hi IncSearch cterm=bold hi StatusLine cterm=bold hi StatusLineNC cterm=bold hi VertSplit cterm=bold hi Visual cterm=bold hi NonText cterm=bold hi Question cterm=bold hi Title cterm=bold hi DiffDelete cterm=bold hi DiffText cterm=bold hi Statement cterm=bold hi Type cterm=bold hi MoreMsg cterm=bold hi ModeMsg cterm=bold hi TabLineSel cterm=bold "hi lCursor ctermfg=bg ctermbg=fg cterm=NONE endif " t_Co==256 " }}}2 elseif &background=='dark' " for background=dark {{{2 " DARK COLOR DEFINE START hi Normal guifg=#d0d0d0 guibg=#202020 gui=NONE hi Comment guifg=#d0d090 guibg=NONE gui=NONE hi Constant guifg=#80c0e0 guibg=NONE gui=NONE hi Number guifg=#e0c060 guibg=NONE gui=NONE hi Identifier guifg=#f0c0f0 guibg=NONE gui=NONE hi Statement guifg=#c0d8f8 guibg=NONE gui=NONE hi PreProc guifg=#60f080 guibg=NONE gui=NONE hi Type guifg=#b0d0f0 guibg=NONE gui=NONE hi Special guifg=#e0c060 guibg=NONE gui=NONE hi Error guifg=#f08060 guibg=NONE gui=NONE hi Todo guifg=#800000 guibg=#d0d090 gui=NONE hi Search guifg=White guibg=DarkRed gui=NONE hi Visual guifg=#000000 guibg=#a6caf0 gui=NONE hi Cursor guifg=#000000 guibg=#00f000 gui=NONE " NOTE THIS IS IN THE COOL SECTION " hi CursorIM guifg=#000000 guibg=#f000f0 gui=NONE hi StatusLine guifg=#000000 guibg=#a6caf0 gui=NONE hi LineNr guifg=#b0b0b0 guibg=NONE gui=NONE hi Question guifg=#000000 guibg=#d0d090 gui=NONE hi ModeMsg guifg=fg guibg=#000080 gui=NONE hi VisualNOS guifg=fg guibg=#000080 gui=NONE hi SpecialKey guifg=#b0d0f0 guibg=NONE gui=NONE hi NonText guifg=#6080f0 guibg=#101010 gui=NONE hi Directory guifg=#80c0e0 guibg=NONE gui=NONE hi ErrorMsg guifg=#d0d090 guibg=#800000 gui=NONE hi MoreMsg guifg=#c0e080 guibg=NONE gui=NONE hi Title guifg=#f0c0f0 guibg=NONE gui=NONE hi WarningMsg guifg=#f08060 guibg=NONE gui=NONE hi WildMenu guifg=#000000 guibg=#d0d090 gui=NONE hi Folded guifg=#aaaaaa guibg=#333333 gui=NONE hi FoldColumn guifg=#202020 guibg=NONE gui=NONE hi DiffAdd guifg=NONE guibg=#000080 gui=NONE hi DiffChange guifg=NONE guibg=#800080 gui=NONE hi DiffDelete guifg=#6080f0 guibg=#202020 gui=NONE hi DiffText guifg=#000000 guibg=#c0e080 gui=NONE hi SignColumn guifg=#e0e0e0 guibg=#202020 gui=NONE hi IncSearch guifg=White guibg=DarkRed gui=NONE hi StatusLineNC guifg=#000000 guibg=#c0c0c0 gui=NONE hi VertSplit guifg=#000000 guibg=#c0c0c0 gui=NONE hi Underlined guifg=#80a0ff guibg=NONE gui=underline hi Ignore guifg=#000000 guibg=NONE " NOTE THIS IS IN THE COOL SECTION if v:version >= 700 if has('spell') " the guisp= could only support in Vim 7 hi SpellBad guifg=NONE guibg=NONE guisp=#f08060 hi SpellCap guifg=NONE guibg=NONE guisp=#6080f0 hi SpellRare guifg=NONE guibg=NONE guisp=#f0c0f0 hi SpellLocal guifg=NONE guibg=NONE guisp=#c0d8f8 endif hi Pmenu guifg=#dddddd guibg=#444444 gui=NONE ctermfg=NONE ctermbg=NONE cterm=NONE hi PmenuSel guifg=#000000 guibg=#ffffff gui=NONE ctermfg=NONE ctermbg=NONE cterm=NONE hi TabLine guifg=fg guibg=#008000 gui=NONE hi TabLineFill guifg=fg guibg=#008000 gui=NONE hi TabLineSel guifg=fg guibg=NONE gui=NONE hi CursorColumn guifg=NONE guibg=#800000 gui=NONE hi CursorLine guifg=NONE guibg=NONE gui=underline hi MatchParen guifg=NONE guibg=#800080 endif " DARK COLOR DEFINE END " Vim 7 added stuffs if v:version >= 700 hi Ignore gui=NONE " the gui=undercurl could only support in Vim 7 if has('spell') hi SpellBad gui=undercurl hi SpellCap gui=undercurl hi SpellRare gui=undercurl hi SpellLocal gui=undercurl endif hi TabLine gui=underline hi TabLineFill gui=underline hi Underlined gui=underline hi CursorLine gui=underline endif " gui define for background=dark end here if &t_Co==8 || &t_Co==16 " for 8-color and 16-color term hi Normal ctermfg=LightGrey ctermbg=Black hi Special ctermfg=Yellow ctermbg=bg hi Comment ctermfg=DarkYellow ctermbg=bg hi Constant ctermfg=Blue ctermbg=bg hi Number ctermfg=Yellow ctermbg=bg hi LineNr ctermfg=DarkGrey ctermbg=bg hi PreProc ctermfg=Green ctermbg=bg hi Statement ctermfg=Cyan ctermbg=bg hi Type ctermfg=Cyan ctermbg=bg hi Error ctermfg=Red ctermbg=bg hi Identifier ctermfg=Magenta ctermbg=bg hi SpecialKey ctermfg=Cyan ctermbg=bg hi NonText ctermfg=Blue ctermbg=bg hi Directory ctermfg=Blue ctermbg=bg hi MoreMsg ctermfg=Green ctermbg=bg hi Title ctermfg=Magenta ctermbg=bg hi WarningMsg ctermfg=Red ctermbg=bg hi DiffDelete ctermfg=Blue ctermbg=bg hi Search ctermfg=NONE ctermbg=DarkRed hi Visual ctermfg=Black ctermbg=DarkCyan hi Cursor ctermfg=Black ctermbg=Green hi StatusLine ctermfg=Black ctermbg=DarkCyan hi Question ctermfg=Black ctermbg=DarkYellow hi Todo ctermfg=DarkRed ctermbg=DarkYellow hi Folded ctermfg=DarkGrey ctermbg=DarkGrey hi FoldColumn ctermfg=DarkGrey ctermbg=NONE hi ModeMsg ctermfg=Grey ctermbg=DarkBlue hi VisualNOS ctermfg=Grey ctermbg=DarkBlue hi ErrorMsg ctermfg=DarkYellow ctermbg=DarkRed hi WildMenu ctermfg=Black ctermbg=DarkYellow hi SignColumn ctermfg=White ctermbg=DarkGreen hi DiffText ctermfg=Black ctermbg=DarkYellow if v:version >= 700 if has('spell') hi SpellBad ctermfg=NONE ctermbg=DarkRed hi SpellCap ctermfg=NONE ctermbg=DarkBlue hi SpellRare ctermfg=NONE ctermbg=DarkMagenta hi SpellLocal ctermfg=NONE ctermbg=DarkGreen endif hi Pmenu ctermfg=White ctermbg=DarkGrey hi PmenuSel ctermfg=Black ctermbg=White hi TabLine ctermfg=fg ctermbg=Black cterm=underline hi TabLineFill ctermfg=fg ctermbg=Black cterm=underline hi CursorColumn ctermfg=NONE ctermbg=DarkRed hi TabLineSel ctermfg=fg ctermbg=bg hi CursorLine ctermfg=NONE ctermbg=bg cterm=underline hi MatchParen ctermfg=NONE ctermbg=DarkMagenta endif if &t_Co==8 " 8 colour terminal support, this assumes 16 colour is available through " setting the 'bold' attribute, will get bright foreground colour. " However, the bright background color is not available for 8-color terms. " " You can manually set t_Co=16 in your .vimrc to see if your terminal " supports 16 colours, hi DiffText cterm=none hi Visual cterm=none hi Cursor cterm=none hi Comment cterm=none hi Todo cterm=none hi StatusLine cterm=none hi Question cterm=none hi DiffChange cterm=none hi ModeMsg cterm=none hi VisualNOS cterm=none hi ErrorMsg cterm=none hi WildMenu cterm=none hi DiffAdd cterm=none hi Folded cterm=none hi DiffDelete cterm=none hi Normal cterm=none hi PmenuThumb cterm=none hi Search cterm=bold hi Special cterm=bold hi Constant cterm=bold hi Number cterm=bold hi LineNr cterm=bold hi PreProc cterm=bold hi Statement cterm=bold hi Type cterm=bold hi Error cterm=bold hi Identifier cterm=bold hi SpecialKey cterm=bold hi NonText cterm=bold hi MoreMsg cterm=bold hi Title cterm=bold hi WarningMsg cterm=bold hi FoldColumn cterm=bold hi SignColumn cterm=bold hi Directory cterm=bold hi DiffDelete cterm=bold else " Background > 7 is only available with 16 or more colors hi WarningMsg cterm=none hi Search cterm=none hi Visual cterm=none hi Cursor cterm=none hi Special cterm=none hi Comment cterm=none hi Constant cterm=none hi Number cterm=none hi LineNr cterm=none hi PreProc cterm=none hi Todo cterm=none hi Error cterm=none hi Identifier cterm=none hi Folded cterm=none hi SpecialKey cterm=none hi Directory cterm=none hi ErrorMsg cterm=none hi Normal cterm=none hi PmenuThumb cterm=none hi WildMenu cterm=none hi FoldColumn cterm=none hi SignColumn cterm=none hi DiffAdd cterm=none hi DiffChange cterm=none hi Question cterm=none hi StatusLine cterm=none hi DiffText cterm=none hi IncSearch cterm=reverse hi StatusLineNC cterm=reverse hi VertSplit cterm=reverse " Well, well, bold font with color 0-7 is not possible. " So, the Question, StatusLine, DiffText cannot act as expected. hi Statement cterm=none hi Type cterm=none hi MoreMsg cterm=none hi ModeMsg cterm=none hi NonText cterm=none hi Title cterm=none hi VisualNOS cterm=none hi DiffDelete cterm=none hi TabLineSel cterm=none endif elseif &t_Co==256 " 256color dark terminal support here hi Normal ctermfg=252 ctermbg=234 cterm=NONE " Comment/Uncomment the following line to disable/enable transparency "hi Normal ctermfg=252 ctermbg=NONE cterm=NONE hi Comment ctermfg=186 ctermbg=NONE cterm=NONE hi Constant ctermfg=110 ctermbg=NONE cterm=NONE hi Number ctermfg=179 ctermbg=NONE cterm=NONE hi Identifier ctermfg=219 ctermbg=NONE cterm=NONE hi Statement ctermfg=153 ctermbg=NONE cterm=NONE hi PreProc ctermfg=84 ctermbg=NONE cterm=NONE hi Type ctermfg=153 ctermbg=NONE cterm=NONE hi Special ctermfg=179 ctermbg=NONE cterm=NONE hi Error ctermfg=209 ctermbg=NONE cterm=NONE hi Todo ctermfg=88 ctermbg=186 cterm=NONE hi Search ctermfg=White ctermbg=DarkRed cterm=NONE hi Visual ctermfg=16 ctermbg=153 cterm=NONE hi Cursor ctermfg=16 ctermbg=46 cterm=NONE " NOTE THIS IS IN THE COOL SECTION " hi CursorIM ctermfg=16 ctermbg=201 cterm=NONE hi StatusLine ctermfg=16 ctermbg=153 cterm=NONE hi LineNr ctermfg=249 ctermbg=NONE cterm=NONE hi Question ctermfg=16 ctermbg=186 cterm=NONE hi ModeMsg ctermfg=fg ctermbg=18 cterm=NONE hi VisualNOS ctermfg=fg ctermbg=18 cterm=NONE hi SpecialKey ctermfg=153 ctermbg=NONE cterm=NONE hi NonText ctermfg=69 ctermbg=233 cterm=NONE " Comment/Uncomment the following line to disable/enable transparency "hi NonText ctermfg=69 ctermbg=NONE cterm=NONE hi Directory ctermfg=110 ctermbg=NONE cterm=NONE hi ErrorMsg ctermfg=186 ctermbg=88 cterm=NONE hi MoreMsg ctermfg=150 ctermbg=NONE cterm=NONE hi Title ctermfg=219 ctermbg=NONE cterm=NONE hi WarningMsg ctermfg=209 ctermbg=NONE cterm=NONE hi WildMenu ctermfg=16 ctermbg=186 cterm=NONE hi Folded ctermfg=NONE ctermbg=DarkGrey cterm=NONE hi FoldColumn ctermfg=DarkGrey ctermbg=NONE cterm=NONE hi DiffAdd ctermfg=NONE ctermbg=18 cterm=NONE hi DiffChange ctermfg=NONE ctermbg=90 cterm=NONE hi DiffDelete ctermfg=69 ctermbg=234 cterm=NONE hi DiffText ctermfg=16 ctermbg=150 cterm=NONE hi SignColumn ctermfg=254 ctermbg=28 cterm=NONE hi IncSearch ctermfg=White ctermbg=DarkRed cterm=NONE hi StatusLineNC ctermfg=16 ctermbg=250 cterm=NONE hi VertSplit ctermfg=16 ctermbg=250 cterm=NONE hi Underlined ctermfg=111 ctermbg=NONE cterm=underline hi Ignore ctermfg=16 ctermbg=NONE " NOTE THIS IS IN THE COOL SECTION if v:version >= 700 if has('spell') " the ctermsp= is not supported in Vim 7 we simply ignored hi SpellBad cterm=undercurl ctermbg=NONE ctermfg=209 hi SpellCap cterm=undercurl ctermbg=NONE ctermfg=69 hi SpellRare cterm=undercurl ctermbg=NONE ctermfg=219 hi SpellLocal cterm=undercurl ctermbg=NONE ctermfg=153 endif hi Pmenu ctermfg=White ctermbg=DarkGrey hi PmenuSel ctermfg=Black ctermbg=White cterm=NONE hi TabLine ctermfg=fg ctermbg=Black cterm=NONE hi TabLineFill ctermfg=fg ctermbg=Black cterm=NONE hi TabLineSel ctermfg=fg ctermbg=NONE cterm=NONE hi CursorColumn ctermfg=NONE ctermbg=88 cterm=NONE hi CursorLine ctermfg=NONE ctermbg=NONE cterm=underline hi MatchParen ctermfg=NONE ctermbg=90 hi TabLine cterm=underline hi TabLineFill cterm=underline hi Underlined cterm=underline hi CursorLine cterm=underline endif endif " t_Co " }}}2 endif " Links: " " COLOR LINKS DEFINE START hi link String Constant " Character must be different from strings because in many languages " (especially C, C++) a 'char' variable is scalar while 'string' is pointer, " mistaken a 'char' for a 'string' will cause disaster! hi link Character Number hi link SpecialChar LineNr hi link Tag Identifier hi link cCppOut LineNr " The following are not standard hi links, " these are used by DrChip hi link Warning MoreMsg hi link Notice Constant " these are used by Calendar hi link CalToday PreProc " these are used by TagList hi link MyTagListTagName IncSearch hi link MyTagListTagScope Constant hi TabLineFill guifg=#9098a0 guibg=#111111 hi TabLine guifg=black guibg=#888888 hi TabLineSel guifg=white guibg=#202020 gui=bold " COLOR LINKS DEFINE END " vim:et:nosta:sw=2:ts=8: " vim600:fdm=marker:fdl=1: ================================================ FILE: sources_forked/set_tabline/plugin/set_tabline.vim ================================================ function! CustomizedTabLine() let s = '' let t = tabpagenr() let i = 1 while i <= tabpagenr('$') let buflist = tabpagebuflist(i) let winnr = tabpagewinnr(i) let s .= '%' . i . 'T' let s .= (i == t ? '%1*' : '%2*') let s .= ' ' let s .= i . ':' let s .= '%*' let s .= (i == t ? '%#TabLineSel#' : '%#TabLine#') let file = bufname(buflist[winnr - 1]) let file = fnamemodify(file, ':p:t') if file == '' let file = '[No Name]' endif let s .= file let s .= ' ' let i = i + 1 endwhile let s .= '%T%#TabLineFill#%=' let s .= (tabpagenr('$') > 1 ? '%999XX' : 'X') return s endfunction " Always show the tablilne set stal=2 set tabline=%!CustomizedTabLine() ================================================ FILE: sources_forked/vim-irblack-forked/README ================================================ This is a version of Infinite Red's vim theme (http://blog.infinitered.com/entries/show/8) packaged to work with Tim Pope's pathogen plugin (http://www.vim.org/scripts/script.php?script_id=2332). To use it (assuming you're using pathogen): - go to your bundle directory (.vim/bundle or .vimbundles) and clone the repo: git clone git@github.com:wgibbs/vim-irblack.git - edit your .vimrc and add: :colorscheme ir_black ================================================ FILE: sources_forked/vim-irblack-forked/colors/ir_black.vim ================================================ " ir_black color scheme " More at: http://blog.infinitered.com/entries/show/8 " ******************************************************************************** " Standard colors used in all ir_black themes: " Note, x:x:x are RGB values " " normal: #f6f3e8 " " string: #A8FF60 168:255:96 " string inner (punc, code, etc): #00A0A0 0:160:160 " number: #FF73FD 255:115:253 " comments: #7C7C7C 124:124:124 " keywords: #96CBFE 150:203:254 " operators: white " class: #FFFFB6 255:255:182 " method declaration name: #FFD2A7 255:210:167 " regular expression: #E9C062 233:192:98 " regexp alternate: #FF8000 255:128:0 " regexp alternate 2: #B18A3D 177:138:61 " variable: #C6C5FE 198:197:254 " " Misc colors: " red color (used for whatever): #FF6C60 255:108:96 " light red: #FFB6B0 255:182:176 " " brown: #E18964 good for special " " lightpurpleish: #FFCCFF " " Interface colors: " background color: black " cursor (where underscore is used): #FFA560 255:165:96 " cursor (where block is used): white " visual selection: #1D1E2C " current line: #151515 21:21:21 " search selection: #07281C 7:40:28 " line number: #3D3D3D 61:61:61 " ******************************************************************************** " The following are the preferred 16 colors for your terminal " Colors Bright Colors " Black #4E4E4E #7C7C7C " Red #FF6C60 #FFB6B0 " Green #A8FF60 #CEFFAB " Yellow #FFFFB6 #FFFFCB " Blue #96CBFE #FFFFCB " Magenta #FF73FD #FF9CFE " Cyan #C6C5FE #DFDFFE " White #EEEEEE #FFFFFF " ******************************************************************************** set background=dark hi clear if exists("syntax_on") syntax reset endif let colors_name = "ir_black" "hi Example guifg=NONE guibg=NONE gui=NONE ctermfg=NONE ctermbg=NONE cterm=NONE " General colors hi Normal guifg=#f6f3e8 guibg=black gui=NONE ctermfg=NONE ctermbg=NONE cterm=NONE hi NonText guifg=#070707 guibg=black gui=NONE ctermfg=black ctermbg=NONE cterm=NONE hi Cursor guifg=black guibg=white gui=NONE ctermfg=black ctermbg=white cterm=reverse hi LineNr guifg=#3D3D3D guibg=black gui=NONE ctermfg=darkgray ctermbg=NONE cterm=NONE hi VertSplit guifg=#202020 guibg=#202020 gui=NONE ctermfg=darkgray ctermbg=darkgray cterm=NONE hi StatusLine guifg=#CCCCCC guibg=#202020 gui=None ctermfg=white ctermbg=darkgray cterm=NONE hi StatusLineNC guifg=black guibg=#202020 gui=NONE ctermfg=blue ctermbg=darkgray cterm=NONE hi Folded guifg=#a0a8b0 guibg=#384048 gui=NONE ctermfg=NONE ctermbg=NONE cterm=NONE hi Title guifg=#f6f3e8 guibg=NONE gui=bold ctermfg=NONE ctermbg=NONE cterm=NONE hi Visual guifg=NONE guibg=DarkBlue gui=NONE ctermfg=NONE ctermbg=darkgray cterm=NONE hi SpecialKey guifg=#808080 guibg=#343434 gui=NONE ctermfg=NONE ctermbg=NONE cterm=NONE hi WildMenu guifg=white guibg=DarkRed gui=NONE ctermfg=white ctermbg=DarkRed cterm=NONE hi PmenuSbar guifg=black guibg=white gui=NONE ctermfg=black ctermbg=white cterm=NONE "hi Ignore guifg=gray guibg=black gui=NONE ctermfg=NONE ctermbg=NONE cterm=NONE hi Error guifg=NONE guibg=red gui=undercurl ctermfg=white ctermbg=red cterm=NONE guisp=#FF6C60 " undercurl color hi ErrorMsg guifg=white guibg=#FF6C60 gui=BOLD ctermfg=white ctermbg=red cterm=NONE hi WarningMsg guifg=white guibg=#FF6C60 gui=BOLD ctermfg=white ctermbg=red cterm=NONE " Message displayed in lower left, such as --INSERT-- hi ModeMsg guifg=black guibg=#C6C5FE gui=BOLD ctermfg=black ctermbg=cyan cterm=BOLD if version >= 700 " Vim 7.x specific colors hi CursorLine guifg=NONE guibg=#121212 gui=NONE ctermfg=NONE ctermbg=NONE cterm=BOLD hi CursorColumn guifg=NONE guibg=#121212 gui=NONE ctermfg=NONE ctermbg=NONE cterm=BOLD hi MatchParen guifg=#f6f3e8 guibg=#857b6f gui=BOLD ctermfg=white ctermbg=darkgray cterm=NONE hi Pmenu guifg=#f6f3e8 guibg=#444444 gui=NONE ctermfg=NONE ctermbg=NONE cterm=NONE hi PmenuSel guifg=#000000 guibg=#cae682 gui=NONE ctermfg=NONE ctermbg=NONE cterm=NONE hi Search guifg=NONE guibg=NONE gui=NONE ctermfg=NONE ctermbg=NONE cterm=NONE endif " Syntax highlighting hi Comment guifg=#7C7C7C guibg=NONE gui=NONE ctermfg=darkgray ctermbg=NONE cterm=NONE hi String guifg=#A8FF60 guibg=NONE gui=NONE ctermfg=green ctermbg=NONE cterm=NONE hi Number guifg=#FF73FD guibg=NONE gui=NONE ctermfg=magenta ctermbg=NONE cterm=NONE hi Keyword guifg=#96CBFE guibg=NONE gui=NONE ctermfg=blue ctermbg=NONE cterm=NONE hi PreProc guifg=#96CBFE guibg=NONE gui=NONE ctermfg=blue ctermbg=NONE cterm=NONE hi Conditional guifg=#6699CC guibg=NONE gui=NONE ctermfg=blue ctermbg=NONE cterm=NONE " if else end hi Todo guifg=#8f8f8f guibg=NONE gui=NONE ctermfg=red ctermbg=NONE cterm=NONE hi Constant guifg=#99CC99 guibg=NONE gui=NONE ctermfg=cyan ctermbg=NONE cterm=NONE hi Identifier guifg=#C6C5FE guibg=NONE gui=NONE ctermfg=cyan ctermbg=NONE cterm=NONE hi Function guifg=#FFD2A7 guibg=NONE gui=NONE ctermfg=brown ctermbg=NONE cterm=NONE hi Type guifg=#FFFFB6 guibg=NONE gui=NONE ctermfg=yellow ctermbg=NONE cterm=NONE hi Statement guifg=#6699CC guibg=NONE gui=NONE ctermfg=lightblue ctermbg=NONE cterm=NONE hi Special guifg=#E18964 guibg=NONE gui=NONE ctermfg=white ctermbg=NONE cterm=NONE hi Delimiter guifg=#00A0A0 guibg=NONE gui=NONE ctermfg=cyan ctermbg=NONE cterm=NONE hi Operator guifg=#6699CC guibg=NONE gui=NONE ctermfg=blue ctermbg=NONE cterm=NONE hi link Character Constant hi link Boolean Constant hi link Float Number hi link Repeat Statement hi link Label Statement hi link Exception Statement hi link Include PreProc hi link Define PreProc hi link Macro PreProc hi link PreCondit PreProc hi link StorageClass Type hi link Structure Type hi link Typedef Type hi link Tag Special hi link SpecialChar Special hi link SpecialComment Special hi link Debug Special " Special for Ruby hi rubyRegexp guifg=#B18A3D guibg=NONE gui=NONE ctermfg=brown ctermbg=NONE cterm=NONE hi rubyRegexpDelimiter guifg=#FF8000 guibg=NONE gui=NONE ctermfg=brown ctermbg=NONE cterm=NONE hi rubyEscape guifg=white guibg=NONE gui=NONE ctermfg=cyan ctermbg=NONE cterm=NONE hi rubyInterpolationDelimiter guifg=#00A0A0 guibg=NONE gui=NONE ctermfg=blue ctermbg=NONE cterm=NONE hi rubyControl guifg=#6699CC guibg=NONE gui=NONE ctermfg=blue ctermbg=NONE cterm=NONE "and break, etc "hi rubyGlobalVariable guifg=#FFCCFF guibg=NONE gui=NONE ctermfg=lightblue ctermbg=NONE cterm=NONE "yield hi rubyStringDelimiter guifg=#336633 guibg=NONE gui=NONE ctermfg=lightgreen ctermbg=NONE cterm=NONE "rubyInclude "rubySharpBang "rubyAccess "rubyPredefinedVariable "rubyBoolean "rubyClassVariable "rubyBeginEnd "rubyRepeatModifier "hi link rubyArrayDelimiter Special " [ , , ] "rubyCurlyBlock { , , } hi link rubyClass Keyword hi link rubyModule Keyword hi link rubyKeyword Keyword hi link rubyOperator Operator hi link rubyIdentifier Identifier hi link rubyInstanceVariable Identifier hi link rubyGlobalVariable Identifier hi link rubyClassVariable Identifier hi link rubyConstant Type " Special for Java " hi link javaClassDecl Type hi link javaScopeDecl Identifier hi link javaCommentTitle javaDocSeeTag hi link javaDocTags javaDocSeeTag hi link javaDocParam javaDocSeeTag hi link javaDocSeeTagParam javaDocSeeTag hi javaDocSeeTag guifg=#CCCCCC guibg=NONE gui=NONE ctermfg=darkgray ctermbg=NONE cterm=NONE hi javaDocSeeTag guifg=#CCCCCC guibg=NONE gui=NONE ctermfg=darkgray ctermbg=NONE cterm=NONE "hi javaClassDecl guifg=#CCFFCC guibg=NONE gui=NONE ctermfg=white ctermbg=NONE cterm=NONE " Special for XML hi link xmlTag Keyword hi link xmlTagName Conditional hi link xmlEndTag Identifier " Special for HTML hi link htmlTag Keyword hi link htmlTagName Conditional hi link htmlEndTag Identifier " Special for Javascript hi link javaScriptNumber Number " Special for Python "hi link pythonEscape Keyword " Special for CSharp hi link csXmlTag Keyword " Amix customizations " Tab line hi TabLineFill guifg=#000000 guibg=#000000 gui=NONE hi TabLine guifg=black guibg=#888888 gui=NONE hi TabLineSel guifg=white guibg=#000000 gui=bold " Search higlights hi Search guifg=White guibg=DarkRed gui=NONE ================================================ FILE: sources_forked/vim-peepopen/README ================================================ ================================================ FILE: sources_forked/vim-peepopen/README.md ================================================ vim-peepopen ============= A plugin for the Vim text editor. PeepOpen provides fuzzy search of filenames and paths in a programming project. Installation ------------ Get the PeepOpen.app and open it at least once to approve the Mac OS X security dialog. Standard: Copy `peepopen.vim` to your `~/.vim/plugin` directory. With Tim Pope's [Pathogen](http://github.com/tpope/vim-pathogen): Copy the entire `vim-peepopen` plugin directory to your `~/.vim/bundle` directory. Usage ----- `p` opens the current project directory with the PeepOpen application. Use the [vim-rooter](https://github.com/airblade/vim-rooter) plugin for automatic assignment of the current working directory for projects stored in Git. (Leader is mapped to '\' by default) ### Options Automatically quit PeepOpen when Vim exits. `let p:peepopen_quit = 1` Credits ------- - Initial Vim Plugin by [Andrew Stewart](http://www.airbladesoftware.com/). - Some plugin boilerplate from [Rein Henrichs](http://reinh.com/). ================================================ FILE: sources_forked/vim-peepopen/plugin/peepopen.vim ================================================ " plugin/peepopen.vim " Author: Geoffrey Grosenbach " License: MIT License " Install this file as plugin/peepopen.vim. " If you prefer Command-T, use this snippet in your .gvimrc: " if has("gui_macvim") " macmenu &File.New\ Tab key= " map PeepOpen " end " ============================================================================ " Exit quickly when: " - this plugin was already loaded (or disabled) " - when 'compatible' is set if &cp || exists("g:peepopen_loaded") && g:peepopen_loaded finish endif let g:peepopen_loaded = 1 let s:save_cpo = &cpo set cpo&vim if !exists('g:peepopen_quit') let g:peepopen_quit = 0 endif function s:LaunchPeepOpenViaVim() silent exe "!open -a PeepOpen " . shellescape(getcwd()) redraw! endfunction function s:QuitPeepOpenViaVim() silent exe '!ps ax | grep PeepOpen | grep -v grep | awk "{ print $1 }" | xargs kill -QUIT' endfunction command! PeepOpen :call LaunchPeepOpenViaVim() command! PeepQuit :call QuitPeepOpenViaVim() if has('autocmd') && exists('g:peepopen_quit') && g:peepopen_quit au VimLeave * :call QuitPeepOpenViaVim() endif noremap ``` blocks in html files. ## CoffeeScript in Haml CoffeeScript is highlighted within the `:coffeescript` filter in haml files: ```haml :coffeescript console.log "hullo" ``` At this time, coffee indenting doesn't work in these blocks. ## Custom Autocmds You can [define commands][autocmd-explain] to be ran automatically on these custom events. In all cases, the name of the command running the event (`CoffeeCompile`, `CoffeeWatch`, or `CoffeeRun`) is matched by the [`{pat}`][autocmd] argument. You can match all commands with a `*` or only specific commands by separating them with a comma: `CoffeeCompile,CoffeeWatch`. [autocmd-explain]: http://vimdoc.sourceforge.net/htmldoc/usr_40.html#40.3 [autocmd]: http://vimdoc.sourceforge.net/htmldoc/autocmd.html#:autocmd #### CoffeeBufNew CoffeeBufNew is ran when a new scratch buffer is created. It's called from the new buffer, so it can be used to do additional set up. ```vim augroup CoffeeBufNew autocmd User * set wrap augroup END ``` *Used By*: CoffeeCompile, CoffeeWatch, CoffeeRun #### CoffeeBufUpdate CoffeeBufUpdate is ran when a scratch buffer is updated with output from `coffee`. It's called from the scratch buffer, so it can be used to alter the compiled output. ```vim " Switch back to the source buffer after updating. augroup CoffeeBufUpdate autocmd User CoffeeCompile,CoffeeRun exec bufwinnr(b:coffee_src_buf) 'wincmd w' augroup END ``` For example, to strip off the "Generated by" comment on the first line, put this in your vimrc: ```vim function! s:RemoveGeneratedBy() " If there was an error compiling, there's no comment to remove. if v:shell_error return endif " Save cursor position. let pos = getpos('.') " Remove first line. set modifiable 1 delete _ set nomodifiable " Restore cursor position. call setpos('.', pos) endfunction augroup CoffeeBufUpdate autocmd User CoffeeCompile,CoffeeWatch call s:RemoveGeneratedBy() augroup END ``` *Used By*: CoffeeCompile, CoffeeWatch, CoffeeRun ## Configuration Variables This is the full list of configuration variables available, with example settings and default values. Use these in your vimrc to control the default behavior. #### coffee\_indent\_keep\_current By default, the indent function matches the indent of the previous line if it doesn't find a reason to indent or outdent. To change this behavior so it instead keeps the [current indent of the cursor][98], use let coffee_indent_keep_current = 1 [98]: https://github.com/kchmck/vim-coffee-script/pull/98 *Default*: `unlet coffee_indent_keep_current` Note that if you change this after a coffee file has been loaded, you'll have to reload the indent script for the change to take effect: unlet b:did_indent | runtime indent/coffee.vim #### coffee\_compiler Path to the `coffee` executable used by the `Coffee` commands: let coffee_compiler = '/usr/bin/coffee' *Default*: `'coffee'` (search `$PATH` for executable) #### coffee\_make\_options Options to pass to `coffee` with `:make`: let coffee_make_options = '--bare' *Default*: `''` (nothing) Note that `coffee_make_options` is embedded into `'makeprg'`, so `:compiler coffee` must be ran after changing `coffee_make_options` for the changes to take effect. #### coffee\_cake Path to the `cake` executable: let coffee_cake = '/opt/bin/cake' *Default*: `'cake'` (search `$PATH` for executable) #### coffee\_cake\_options Options to pass to `cake` with `:make`: let coffee_cake_options = 'build' *Default*: `''` (nothing) #### coffee\_linter Path to the `coffeelint` executable: let coffee_linter = '/opt/bin/coffeelint' *Default*: `'coffeelint'` (search `$PATH` for executable) #### coffee\_lint\_options Options to pass to `coffeelint`: let coffee_lint_options = '-f lint.json' *Default*: `''` (nothing) #### coffee\_compile\_vert Open the CoffeeCompile buffer with a vertical split instead of a horizontal one: let coffee_compile_vert = 1 *Default*: `unlet coffee_compile_vert` #### coffee\_watch\_vert Open the CoffeeWatch buffer with a vertical split instead of a horizontal one: let coffee_watch_vert = 1 *Default*: `unlet coffee_watch_vert` #### coffee\_run\_vert Open the CoffeeRun buffer with a vertical split instead of a horizontal one: let coffee_run_vert = 1 *Default*: `unlet coffee_run_vert` ## Configure Syntax Highlighting Add these lines to your vimrc to disable the relevant syntax group. #### Disable trailing whitespace error Trailing whitespace is highlighted as an error by default. This can be disabled with: hi link coffeeSpaceError NONE #### Disable trailing semicolon error Trailing semicolons are considered an error (for help transitioning from JavaScript.) This can be disabled with: hi link coffeeSemicolonError NONE #### Disable reserved words error Reserved words like `function` and `var` are highlighted as an error where they're not allowed in CoffeeScript. This can be disabled with: hi link coffeeReservedError NONE ## Tune Vim for CoffeeScript Changing these core settings can make vim more CoffeeScript friendly. #### Fold by indentation Folding by indentation works well for CoffeeScript functions and classes: ![Folding](http://i.imgur.com/gDgUBdO.png) To fold by indentation in CoffeeScript files, add this line to your vimrc: autocmd BufNewFile,BufReadPost *.coffee setl foldmethod=indent nofoldenable With this, folding is disabled by default but can be quickly toggled per-file by hitting `zi`. To enable folding by default, remove `nofoldenable`: autocmd BufNewFile,BufReadPost *.coffee setl foldmethod=indent #### Two-space indentation To get standard two-space indentation in CoffeeScript files, add this line to your vimrc: autocmd BufNewFile,BufReadPost *.coffee setl shiftwidth=2 expandtab ================================================ FILE: sources_non_forked/vim-coffee-script/Thanks.md ================================================ Thanks to all bug reporters, and special thanks to those who have contributed code: Brian Egan (brianegan): Initial compiling support Ches Martin (ches): Initial vim docs Chris Hoffman (cehoffman): Add new keywoards from, to, and do Highlight the - in negative integers Add here regex highlighting, increase fold level for here docs David Wilhelm (bigfish): CoffeeRun command Jay Adkisson (jayferd): Support for eco templates Karl Guertin (grayrest) Cakefiles are coffeescript Maciej Konieczny (narfdotpl): Fix funny typo Matt Sacks (mattsa): Javascript omni-completion coffee_compile_vert option Nick Stenning (nickstenning): Fold by indentation for coffeescript Simon Lipp (sloonz): Trailing spaces are not error on lines containing only spaces Stéphan Kochen (stephank): Initial HTML CoffeeScript highlighting Sven Felix Oberquelle (Svelix): Haml CoffeeScript highlighting Wei Dai (clvv): Fix the use of Vim built-in make command. ================================================ FILE: sources_non_forked/vim-coffee-script/Todo.md ================================================ - Don't highlight bad operator combinations ================================================ FILE: sources_non_forked/vim-coffee-script/after/indent/html.vim ================================================ " Language: CoffeeScript " Maintainer: Mick Koch " URL: http://github.com/kchmck/vim-coffee-script " License: WTFPL " Load the coffee and html indent functions. silent! unlet b:did_indent runtime indent/coffee.vim let s:coffeeIndentExpr = &l:indentexpr " Load html last so it can overwrite coffee settings. silent! unlet b:did_indent runtime indent/html.vim let s:htmlIndentExpr = &l:indentexpr " Inject our wrapper indent function. setlocal indentexpr=GetCoffeeHtmlIndent(v:lnum) function! GetCoffeeHtmlIndent(curlinenum) " See if we're inside a coffeescript block. let scriptlnum = searchpair('', 'bWn') let prevlnum = prevnonblank(a:curlinenum) " If we're in the script block and the previous line isn't the script tag " itself, use coffee indenting. if scriptlnum && scriptlnum != prevlnum exec 'return ' s:coffeeIndentExpr endif " Otherwise use html indenting. exec 'return ' s:htmlIndentExpr endfunction ================================================ FILE: sources_non_forked/vim-coffee-script/after/syntax/haml.vim ================================================ " Language: CoffeeScript " Maintainer: Sven Felix Oberquelle " URL: http://github.com/kchmck/vim-coffee-script " License: WTFPL if exists('b:current_syntax') let s:current_syntax_save = b:current_syntax endif " Inherit coffee from html so coffeeComment isn't redefined and given higher " priority than hamlInterpolation. syn cluster hamlCoffeescript contains=@htmlCoffeeScript syn region hamlCoffeescriptFilter matchgroup=hamlFilter \ start="^\z(\s*\):coffee\z(script\)\?\s*$" \ end="^\%(\z1 \| *$\)\@!" \ contains=@hamlCoffeeScript,hamlInterpolation \ keepend if exists('s:current_syntax_save') let b:current_syntax = s:current_syntax_save unlet s:current_syntax_save endif ================================================ FILE: sources_non_forked/vim-coffee-script/after/syntax/html.vim ================================================ " Language: CoffeeScript " Maintainer: Mick Koch " URL: http://github.com/kchmck/vim-coffee-script " License: WTFPL if exists('b:current_syntax') let s:current_syntax_save = b:current_syntax endif " Syntax highlighting for text/coffeescript script tags syn include @htmlCoffeeScript syntax/coffee.vim syn region coffeeScript start=##me=s-1 keepend \ contains=@htmlCoffeeScript,htmlScriptTag,@htmlPreproc \ containedin=htmlHead if exists('s:current_syntax_save') let b:current_syntax = s:current_syntax_save unlet s:current_syntax_save endif ================================================ FILE: sources_non_forked/vim-coffee-script/autoload/coffee.vim ================================================ " Language: CoffeeScript " Maintainer: Mick Koch " URL: http://github.com/kchmck/vim-coffee-script " License: WTFPL " Set up some common global/buffer variables. function! coffee#CoffeeSetUpVariables() " Path to coffee executable if !exists('g:coffee_compiler') let g:coffee_compiler = 'coffee' endif " Options passed to coffee with make if !exists('g:coffee_make_options') let g:coffee_make_options = '' endif " Path to cake executable if !exists('g:coffee_cake') let g:coffee_cake = 'cake' endif " Extra options passed to cake if !exists('g:coffee_cake_options') let g:coffee_cake_options = '' endif " Path to coffeelint executable if !exists('g:coffee_linter') let g:coffee_linter = 'coffeelint' endif " Options passed to CoffeeLint if !exists('g:coffee_lint_options') let g:coffee_lint_options = '' endif " Pass the litcoffee flag to tools in this buffer if a litcoffee file is open. " Let the variable be overwritten so it can be updated if a different filetype " is set. if &filetype == 'litcoffee' let b:coffee_litcoffee = '--literate' else let b:coffee_litcoffee = '' endif endfunction function! coffee#CoffeeSetUpErrorFormat() CompilerSet errorformat=Error:\ In\ %f\\,\ %m\ on\ line\ %l, \Error:\ In\ %f\\,\ Parse\ error\ on\ line\ %l:\ %m, \SyntaxError:\ In\ %f\\,\ %m, \%f:%l:%c:\ error:\ %m, \%-G%.%# endfunction ================================================ FILE: sources_non_forked/vim-coffee-script/compiler/cake.vim ================================================ " Language: CoffeeScript " Maintainer: Mick Koch " URL: http://github.com/kchmck/vim-coffee-script " License: WTFPL if exists('current_compiler') finish endif let current_compiler = 'cake' call coffee#CoffeeSetUpVariables() exec 'CompilerSet makeprg=' . escape(g:coffee_cake . ' ' . \ g:coffee_cake_options . ' $*', ' ') call coffee#CoffeeSetUpErrorFormat() ================================================ FILE: sources_non_forked/vim-coffee-script/compiler/coffee.vim ================================================ " Language: CoffeeScript " Maintainer: Mick Koch " URL: http://github.com/kchmck/vim-coffee-script " License: WTFPL " All this is needed to support compiling filenames with spaces, quotes, and " such. The filename is escaped and embedded into the `makeprg` setting. " " Because of this, `makeprg` must be updated on every file rename. And because " of that, `CompilerSet` can't be used because it doesn't exist when the " rename autocmd is ran. So, we have to do some checks to see whether `compiler` " was called locally or globally, and respect that in the rest of the script. if exists('current_compiler') finish endif let current_compiler = 'coffee' call coffee#CoffeeSetUpVariables() " Pattern to check if coffee is the compiler let s:pat = '^' . current_compiler " Get a `makeprg` for the current filename. function! s:GetMakePrg() return g:coffee_compiler . \ ' -c' . \ ' ' . b:coffee_litcoffee . \ ' ' . g:coffee_make_options . \ ' $*' . \ ' ' . fnameescape(expand('%')) endfunction " Set `makeprg` and return 1 if coffee is still the compiler, else return 0. function! s:SetMakePrg() if &l:makeprg =~ s:pat let &l:makeprg = s:GetMakePrg() elseif &g:makeprg =~ s:pat let &g:makeprg = s:GetMakePrg() else return 0 endif return 1 endfunction " Set a dummy compiler so we can check whether to set locally or globally. exec 'CompilerSet makeprg=' . current_compiler " Then actually set the compiler. call s:SetMakePrg() call coffee#CoffeeSetUpErrorFormat() function! s:CoffeeMakeDeprecated(bang, args) echoerr 'CoffeeMake is deprecated! Please use :make instead, its behavior ' . \ 'is identical.' sleep 5 exec 'make' . a:bang a:args endfunction " Compile the current file. command! -bang -bar -nargs=* CoffeeMake \ call s:CoffeeMakeDeprecated(, ) " Set `makeprg` on rename since we embed the filename in the setting. augroup CoffeeUpdateMakePrg autocmd! " Update `makeprg` if coffee is still the compiler, else stop running this " function. function! s:UpdateMakePrg() if !s:SetMakePrg() autocmd! CoffeeUpdateMakePrg endif endfunction " Set autocmd locally if compiler was set locally. if &l:makeprg =~ s:pat autocmd BufWritePre,BufFilePost call s:UpdateMakePrg() else autocmd BufWritePre,BufFilePost call s:UpdateMakePrg() endif augroup END ================================================ FILE: sources_non_forked/vim-coffee-script/doc/coffee-script.txt ================================================ Please see the project readme for up-to-date docs: https://github.com/kchmck/vim-coffee-script vim:tw=78:ts=8:ft=help:norl: ================================================ FILE: sources_non_forked/vim-coffee-script/ftdetect/coffee.vim ================================================ " Language: CoffeeScript " Maintainer: Mick Koch " URL: http://github.com/kchmck/vim-coffee-script " License: WTFPL autocmd BufNewFile,BufRead *.coffee set filetype=coffee autocmd BufNewFile,BufRead *Cakefile set filetype=coffee autocmd BufNewFile,BufRead *.coffeekup,*.ck set filetype=coffee autocmd BufNewFile,BufRead *._coffee set filetype=coffee autocmd BufNewFile,BufRead *.cson set filetype=coffee function! s:DetectCoffee() if getline(1) =~ '^#!.*\' set filetype=coffee endif endfunction autocmd BufNewFile,BufRead * call s:DetectCoffee() ================================================ FILE: sources_non_forked/vim-coffee-script/ftdetect/vim-literate-coffeescript.vim ================================================ " Language: Literate CoffeeScript " Maintainer: Michael Smith " URL: https://github.com/mintplant/vim-literate-coffeescript " License: MIT autocmd BufNewFile,BufRead *.litcoffee set filetype=litcoffee autocmd BufNewFile,BufRead *.coffee.md set filetype=litcoffee ================================================ FILE: sources_non_forked/vim-coffee-script/ftplugin/coffee.vim ================================================ " Language: CoffeeScript " Maintainer: Mick Koch " URL: http://github.com/kchmck/vim-coffee-script " License: WTFPL if exists('b:did_ftplugin') finish endif let b:did_ftplugin = 1 call coffee#CoffeeSetUpVariables() setlocal formatoptions-=t formatoptions+=croql setlocal comments=:# commentstring=#\ %s setlocal omnifunc=javascriptcomplete#CompleteJS setlocal suffixesadd+=.coffee " Create custom augroups. augroup CoffeeBufUpdate | augroup END augroup CoffeeBufNew | augroup END " Enable coffee compiler if a compiler isn't set already. if !len(&l:makeprg) compiler coffee endif " Switch to the window for buf. function! s:SwitchWindow(buf) exec bufwinnr(a:buf) 'wincmd w' endfunction " Create a new scratch buffer and return the bufnr of it. After the function " returns, vim remains in the scratch buffer so more set up can be done. function! s:ScratchBufBuild(src, vert, size) if a:size <= 0 if a:vert let size = winwidth(bufwinnr(a:src)) / 2 else let size = winheight(bufwinnr(a:src)) / 2 endif endif if a:vert vertical belowright new exec 'vertical resize' size else belowright new exec 'resize' size endif setlocal bufhidden=wipe buftype=nofile nobuflisted noswapfile nomodifiable nnoremap q :hide return bufnr('%') endfunction " Replace buffer contents with text and delete the last empty line. function! s:ScratchBufUpdate(buf, text) " Move to the scratch buffer. call s:SwitchWindow(a:buf) " Double check we're in the scratch buffer before overwriting. if bufnr('%') != a:buf throw 'unable to change to scratch buffer' endif setlocal modifiable silent exec '% delete _' silent put! =a:text silent exec '$ delete _' setlocal nomodifiable endfunction " Parse the output of coffee into a qflist entry for src buffer. function! s:ParseCoffeeError(output, src, startline) " Coffee error is always on first line? let match = matchlist(a:output, \ '^\(\f\+\|\[stdin\]\):\(\d\):\(\d\): error: \(.\{-}\)' . "\n") if !len(match) return endif " Consider the line number from coffee as relative and add it to the beginning " line number of the range the command was called on, then subtract one for " zero-based relativity. call setqflist([{'bufnr': a:src, 'lnum': a:startline + str2nr(match[2]) - 1, \ 'type': 'E', 'col': str2nr(match[3]), 'text': match[4]}], 'r') endfunction " Reset source buffer variables. function! s:CoffeeCompileResetVars() " Variables defined in source buffer: " b:coffee_compile_buf: bufnr of output buffer " Variables defined in output buffer: " b:coffee_src_buf: bufnr of source buffer " b:coffee_compile_pos: previous cursor position in output buffer let b:coffee_compile_buf = -1 endfunction function! s:CoffeeWatchResetVars() " Variables defined in source buffer: " b:coffee_watch_buf: bufnr of output buffer " Variables defined in output buffer: " b:coffee_src_buf: bufnr of source buffer " b:coffee_watch_pos: previous cursor position in output buffer let b:coffee_watch_buf = -1 endfunction function! s:CoffeeRunResetVars() " Variables defined in CoffeeRun source buffer: " b:coffee_run_buf: bufnr of output buffer " Variables defined in CoffeeRun output buffer: " b:coffee_src_buf: bufnr of source buffer " b:coffee_run_pos: previous cursor position in output buffer let b:coffee_run_buf = -1 endfunction " Clean things up in the source buffers. function! s:CoffeeCompileClose() " Switch to the source buffer if not already in it. silent! call s:SwitchWindow(b:coffee_src_buf) call s:CoffeeCompileResetVars() endfunction function! s:CoffeeWatchClose() silent! call s:SwitchWindow(b:coffee_src_buf) silent! autocmd! CoffeeAuWatch * call s:CoffeeWatchResetVars() endfunction function! s:CoffeeRunClose() silent! call s:SwitchWindow(b:coffee_src_buf) call s:CoffeeRunResetVars() endfunction " Compile the lines between startline and endline and put the result into buf. function! s:CoffeeCompileToBuf(buf, startline, endline) let src = bufnr('%') let input = join(getline(a:startline, a:endline), "\n") " Coffee doesn't like empty input. if !len(input) " Function should still return within output buffer. call s:SwitchWindow(a:buf) return endif " Pipe lines into coffee. let output = system(g:coffee_compiler . \ ' -scb' . \ ' ' . b:coffee_litcoffee . \ ' 2>&1', input) " Paste output into output buffer. call s:ScratchBufUpdate(a:buf, output) " Highlight as JavaScript if there were no compile errors. if v:shell_error call s:ParseCoffeeError(output, src, a:startline) setlocal filetype= else " Clear the quickfix list. call setqflist([], 'r') setlocal filetype=javascript endif endfunction " Peek at compiled CoffeeScript in a scratch buffer. We handle ranges like this " to prevent the cursor from being moved (and its position saved) before the " function is called. function! s:CoffeeCompile(startline, endline, args) if a:args =~ '\' echoerr 'CoffeeCompile watch is deprecated! Please use CoffeeWatch instead' sleep 5 call s:CoffeeWatch(a:args) return endif " Switch to the source buffer if not already in it. silent! call s:SwitchWindow(b:coffee_src_buf) " Bail if not in source buffer. if !exists('b:coffee_compile_buf') return endif " Build the output buffer if it doesn't exist. if bufwinnr(b:coffee_compile_buf) == -1 let src = bufnr('%') let vert = exists('g:coffee_compile_vert') || a:args =~ '\' let size = str2nr(matchstr(a:args, '\<\d\+\>')) " Build the output buffer and save the source bufnr. let buf = s:ScratchBufBuild(src, vert, size) let b:coffee_src_buf = src " Set the buffer name. exec 'silent! file [CoffeeCompile ' . src . ']' " Clean up the source buffer when the output buffer is closed. autocmd BufWipeout call s:CoffeeCompileClose() " Save the cursor when leaving the output buffer. autocmd BufLeave let b:coffee_compile_pos = getpos('.') " Run user-defined commands on new buffer. silent doautocmd CoffeeBufNew User CoffeeCompile " Switch back to the source buffer and save the output bufnr. This also " triggers BufLeave above. call s:SwitchWindow(src) let b:coffee_compile_buf = buf endif " Fill the scratch buffer. call s:CoffeeCompileToBuf(b:coffee_compile_buf, a:startline, a:endline) " Reset cursor to previous position. call setpos('.', b:coffee_compile_pos) " Run any user-defined commands on the scratch buffer. silent doautocmd CoffeeBufUpdate User CoffeeCompile endfunction " Update the scratch buffer and switch back to the source buffer. function! s:CoffeeWatchUpdate() call s:CoffeeCompileToBuf(b:coffee_watch_buf, 1, '$') call setpos('.', b:coffee_watch_pos) silent doautocmd CoffeeBufUpdate User CoffeeWatch call s:SwitchWindow(b:coffee_src_buf) endfunction " Continually compile a source buffer. function! s:CoffeeWatch(args) silent! call s:SwitchWindow(b:coffee_src_buf) if !exists('b:coffee_watch_buf') return endif if bufwinnr(b:coffee_watch_buf) == -1 let src = bufnr('%') let vert = exists('g:coffee_watch_vert') || a:args =~ '\' let size = str2nr(matchstr(a:args, '\<\d\+\>')) let buf = s:ScratchBufBuild(src, vert, size) let b:coffee_src_buf = src exec 'silent! file [CoffeeWatch ' . src . ']' autocmd BufWipeout call s:CoffeeWatchClose() autocmd BufLeave let b:coffee_watch_pos = getpos('.') silent doautocmd CoffeeBufNew User CoffeeWatch call s:SwitchWindow(src) let b:coffee_watch_buf = buf endif " Make sure only one watch autocmd is defined on this buffer. silent! autocmd! CoffeeAuWatch * augroup CoffeeAuWatch autocmd InsertLeave call s:CoffeeWatchUpdate() autocmd BufWritePost call s:CoffeeWatchUpdate() augroup END call s:CoffeeWatchUpdate() endfunction " Run a snippet of CoffeeScript between startline and endline. function! s:CoffeeRun(startline, endline, args) silent! call s:SwitchWindow(b:coffee_src_buf) if !exists('b:coffee_run_buf') return endif if bufwinnr(b:coffee_run_buf) == -1 let src = bufnr('%') let buf = s:ScratchBufBuild(src, exists('g:coffee_run_vert'), 0) let b:coffee_src_buf = src exec 'silent! file [CoffeeRun ' . src . ']' autocmd BufWipeout call s:CoffeeRunClose() autocmd BufLeave let b:coffee_run_pos = getpos('.') silent doautocmd CoffeeBufNew User CoffeeRun call s:SwitchWindow(src) let b:coffee_run_buf = buf endif if a:startline == 1 && a:endline == line('$') let output = system(g:coffee_compiler . \ ' ' . b:coffee_litcoffee . \ ' ' . fnameescape(expand('%')) . \ ' ' . a:args) else let input = join(getline(a:startline, a:endline), "\n") if !len(input) return endif let output = system(g:coffee_compiler . \ ' -s' . \ ' ' . b:coffee_litcoffee . \ ' ' . a:args, input) endif call s:ScratchBufUpdate(b:coffee_run_buf, output) call setpos('.', b:coffee_run_pos) silent doautocmd CoffeeBufUpdate User CoffeeRun endfunction " Run coffeelint on a file, and add any errors between startline and endline " to the quickfix list. function! s:CoffeeLint(startline, endline, bang, args) let input = join(getline(a:startline, a:endline), "\n") if !len(input) return endif let output = system(g:coffee_linter . \ ' -s --reporter csv' . \ ' ' . b:coffee_litcoffee . \ ' ' . g:coffee_lint_options . \ ' ' . a:args . \ ' 2>&1', input) " Convert output into an array and strip off the csv header. let lines = split(output, "\n")[1:] let buf = bufnr('%') let qflist = [] for line in lines let match = matchlist(line, '^stdin,\(\d\+\),\d*,\(error\|warn\),\(.\+\)$') " Ignore unmatched lines. if !len(match) continue endif " The 'type' will result in either 'E' or 'W'. call add(qflist, {'bufnr': buf, 'lnum': a:startline + str2nr(match[1]) - 1, \ 'type': toupper(match[2][0]), 'text': match[3]}) endfor " Replace the quicklist with our items. call setqflist(qflist, 'r') " If not given a bang, jump to first error. if !len(a:bang) silent! cc 1 endif endfunction " Complete arguments for Coffee* commands. function! s:CoffeeComplete(cmd, cmdline, cursor) let args = ['vertical'] " If no partial command, return all possibilities. if !len(a:cmd) return args endif let pat = '^' . a:cmd for arg in args if arg =~ pat return [arg] endif endfor endfunction " Set initial state variables if they don't exist if !exists('b:coffee_compile_buf') call s:CoffeeCompileResetVars() endif if !exists('b:coffee_watch_buf') call s:CoffeeWatchResetVars() endif if !exists('b:coffee_run_buf') call s:CoffeeRunResetVars() endif command! -buffer -range=% -bar -nargs=* -complete=customlist,s:CoffeeComplete \ CoffeeCompile call s:CoffeeCompile(, , ) command! -buffer -bar -nargs=* -complete=customlist,s:CoffeeComplete \ CoffeeWatch call s:CoffeeWatch() command! -buffer -range=% -bar -nargs=* CoffeeRun \ call s:CoffeeRun(, , ) command! -buffer -range=% -bang -bar -nargs=* CoffeeLint \ call s:CoffeeLint(, , , ) ================================================ FILE: sources_non_forked/vim-coffee-script/ftplugin/litcoffee.vim ================================================ runtime ftplugin/coffee.vim ================================================ FILE: sources_non_forked/vim-coffee-script/indent/coffee.vim ================================================ " Language: CoffeeScript " Maintainer: Mick Koch " URL: http://github.com/kchmck/vim-coffee-script " License: WTFPL if exists('b:did_indent') finish endif let b:did_indent = 1 setlocal autoindent setlocal indentexpr=GetCoffeeIndent(v:lnum) " Make sure GetCoffeeIndent is run when these are typed so they can be " indented or outdented. setlocal indentkeys+=0],0),0.,=else,=when,=catch,=finally " If no indenting or outdenting is needed, either keep the indent of the cursor " (use autoindent) or match the indent of the previous line. if exists('g:coffee_indent_keep_current') let s:DEFAULT_LEVEL = '-1' else let s:DEFAULT_LEVEL = 'indent(prevnlnum)' endif " Only define the function once. if exists('*GetCoffeeIndent') finish endif " Keywords that begin a block let s:BEGIN_BLOCK_KEYWORD = '\C^\%(if\|unless\|else\|for\|while\|until\|' \ . 'loop\|switch\|when\|try\|catch\|finally\|' \ . 'class\)\>\%(\s*:\)\@!' " An expression that uses the result of a statement let s:COMPOUND_EXPRESSION = '\C\%([^-]-\|[^+]+\|[^/]/\|[:=*%&|^<>]\)\s*' \ . '\%(if\|unless\|for\|while\|until\|loop\|switch\|' \ . 'try\|class\)\>' " Combine the two above let s:BEGIN_BLOCK = s:BEGIN_BLOCK_KEYWORD . '\|' . s:COMPOUND_EXPRESSION " Operators that begin a block but also count as a continuation let s:BEGIN_BLOCK_OP = '[([{:=]$' " Begins a function block let s:FUNCTION = '[-=]>$' " Operators that continue a line onto the next line let s:CONTINUATION_OP = '\C\%(\<\%(is\|isnt\|and\|or\)\>\|' \ . '[^-]-\|[^+]+\|[^-=]>\|[^.]\.\|[<*/%&|^,]\)$' " Ancestor operators that prevent continuation indenting let s:CONTINUATION = s:CONTINUATION_OP . '\|' . s:BEGIN_BLOCK_OP " A closing bracket by itself on a line followed by a continuation let s:BRACKET_CONTINUATION = '^\s*[}\])]\s*' . s:CONTINUATION_OP " A continuation dot access let s:DOT_ACCESS = '^\.' " Keywords that break out of a block let s:BREAK_BLOCK_OP = '\C^\%(return\|break\|continue\|throw\)\>' " A condition attached to the end of a statement let s:POSTFIX_CONDITION = '\C\S\s\+\zs\<\%(if\|unless\|when\|while\|until\)\>' " A then contained in brackets let s:CONTAINED_THEN = '\C[(\[].\{-}\.\{-\}[)\]]' " An else with a condition attached let s:ELSE_COND = '\C^\s*else\s\+\<\%(if\|unless\)\>' " A single-line else statement (without a condition attached) let s:SINGLE_LINE_ELSE = '\C^else\s\+\%(\<\%(if\|unless\)\>\)\@!' " Pairs of starting and ending keywords, with an initial pattern to match let s:KEYWORD_PAIRS = [ \ ['\C^else\>', '\C\<\%(if\|unless\|when\|else\s\+\%(if\|unless\)\)\>', \ '\C\'], \ ['\C^catch\>', '\C\', '\C\'], \ ['\C^finally\>', '\C\', '\C\'] \] " Pairs of starting and ending brackets let s:BRACKET_PAIRS = {']': '\[', '}': '{', ')': '('} " Max lines to look back for a match let s:MAX_LOOKBACK = 50 " Syntax names for strings let s:SYNTAX_STRING = 'coffee\%(String\|AssignString\|Embed\|Regex\|Heregex\|' \ . 'Heredoc\)' " Syntax names for comments let s:SYNTAX_COMMENT = 'coffee\%(Comment\|BlockComment\|HeregexComment\)' " Syntax names for strings and comments let s:SYNTAX_STRING_COMMENT = s:SYNTAX_STRING . '\|' . s:SYNTAX_COMMENT " Compatibility code for shiftwidth() as recommended by the docs, but modified " so there isn't as much of a penalty if shiftwidth() exists. if exists('*shiftwidth') let s:ShiftWidth = function('shiftwidth') else function! s:ShiftWidth() return &shiftwidth endfunction endif " Get the linked syntax name of a character. function! s:SyntaxName(lnum, col) return synIDattr(synID(a:lnum, a:col, 1), 'name') endfunction " Check if a character is in a comment. function! s:IsComment(lnum, col) return s:SyntaxName(a:lnum, a:col) =~ s:SYNTAX_COMMENT endfunction " Check if a character is in a string. function! s:IsString(lnum, col) return s:SyntaxName(a:lnum, a:col) =~ s:SYNTAX_STRING endfunction " Check if a character is in a comment or string. function! s:IsCommentOrString(lnum, col) return s:SyntaxName(a:lnum, a:col) =~ s:SYNTAX_STRING_COMMENT endfunction " Search a line for a regex until one is found outside a string or comment. function! s:SearchCode(lnum, regex) " Start at the first column and look for an initial match (including at the " cursor.) call cursor(a:lnum, 1) let pos = search(a:regex, 'c', a:lnum) while pos if !s:IsCommentOrString(a:lnum, col('.')) return 1 endif " Move to the match and continue searching (don't accept matches at the " cursor.) let pos = search(a:regex, '', a:lnum) endwhile return 0 endfunction " Search for the nearest previous line that isn't a comment. function! s:GetPrevNormalLine(startlnum) let curlnum = a:startlnum while curlnum let curlnum = prevnonblank(curlnum - 1) " Return the line if the first non-whitespace character isn't a comment. if !s:IsComment(curlnum, indent(curlnum) + 1) return curlnum endif endwhile return 0 endfunction function! s:SearchPair(startlnum, lookback, skip, open, close) " Go to the first column so a:close will be matched even if it's at the " beginning of the line. call cursor(a:startlnum, 1) return searchpair(a:open, '', a:close, 'bnW', a:skip, max([1, a:lookback])) endfunction " Skip if a match " - is in a string or comment " - is a single-line statement that isn't immediately " adjacent " - has a postfix condition and isn't an else statement or compound " expression function! s:ShouldSkip(startlnum, lnum, col) return s:IsCommentOrString(a:lnum, a:col) || \ s:SearchCode(a:lnum, '\C\') && a:startlnum - a:lnum > 1 || \ s:SearchCode(a:lnum, s:POSTFIX_CONDITION) && \ getline(a:lnum) !~ s:ELSE_COND && \ !s:SearchCode(a:lnum, s:COMPOUND_EXPRESSION) endfunction " Search for the nearest and farthest match for a keyword pair. function! s:SearchMatchingKeyword(startlnum, open, close) let skip = 's:ShouldSkip(' . a:startlnum . ", line('.'), line('.'))" " Search for the nearest match. let nearestlnum = s:SearchPair(a:startlnum, a:startlnum - s:MAX_LOOKBACK, \ skip, a:open, a:close) if !nearestlnum return [] endif " Find the nearest previous line with indent less than or equal to startlnum. let ind = indent(a:startlnum) let lookback = s:GetPrevNormalLine(a:startlnum) while lookback && indent(lookback) > ind let lookback = s:GetPrevNormalLine(lookback) endwhile " Search for the farthest match. If there are no other matches, then the " nearest match is also the farthest one. let matchlnum = nearestlnum while matchlnum let lnum = matchlnum let matchlnum = s:SearchPair(matchlnum, lookback, skip, a:open, a:close) endwhile return [nearestlnum, lnum] endfunction " Strip a line of a trailing comment and surrounding whitespace. function! s:GetTrimmedLine(lnum) " Try to find a comment starting at the first column. call cursor(a:lnum, 1) let pos = search('#', 'c', a:lnum) " Keep searching until a comment is found or search returns 0. while pos if s:IsComment(a:lnum, col('.')) break endif let pos = search('#', '', a:lnum) endwhile if !pos " No comment was found so use the whole line. let line = getline(a:lnum) else " Subtract 1 to get to the column before the comment and another 1 for " column indexing -> zero-based indexing. let line = getline(a:lnum)[:col('.') - 2] endif return substitute(substitute(line, '^\s\+', '', ''), \ '\s\+$', '', '') endfunction " Get the indent policy when no special rules are used. function! s:GetDefaultPolicy(curlnum) " Check whether equalprg is being ran on existing lines. if strlen(getline(a:curlnum)) == indent(a:curlnum) " If not indenting an existing line, use the default policy. return s:DEFAULT_LEVEL else " Otherwise let autoindent determine what to do with an existing line. return '-1' endif endfunction function! GetCoffeeIndent(curlnum) " Get the previous non-blank line (may be a comment.) let prevlnum = prevnonblank(a:curlnum - 1) " Bail if there's no code before. if !prevlnum return -1 endif " Bail if inside a multiline string. if s:IsString(a:curlnum, 1) let prevnlnum = prevlnum exec 'return' s:GetDefaultPolicy(a:curlnum) endif " Get the code part of the current line. let curline = s:GetTrimmedLine(a:curlnum) " Get the previous non-comment line. let prevnlnum = s:GetPrevNormalLine(a:curlnum) " Check if the current line is the closing bracket in a bracket pair. if has_key(s:BRACKET_PAIRS, curline[0]) " Search for a matching opening bracket. let matchlnum = s:SearchPair(a:curlnum, a:curlnum - s:MAX_LOOKBACK, \ "s:IsCommentOrString(line('.'), col('.'))", \ s:BRACKET_PAIRS[curline[0]], curline[0]) if matchlnum " Match the indent of the opening bracket. return indent(matchlnum) else " No opening bracket found (bad syntax), so bail. exec 'return' s:GetDefaultPolicy(a:curlnum) endif endif " Check if the current line is the closing keyword in a keyword pair. for pair in s:KEYWORD_PAIRS if curline =~ pair[0] " Find the nearest and farthest matches within the same indent level. let matches = s:SearchMatchingKeyword(a:curlnum, pair[1], pair[2]) if len(matches) " Don't force indenting/outdenting as long as line is already lined up " with a valid match return max([min([indent(a:curlnum), indent(matches[0])]), \ indent(matches[1])]) else " No starting keyword found (bad syntax), so bail. exec 'return' s:GetDefaultPolicy(a:curlnum) endif endif endfor " Check if the current line is a `when` and not the first in a switch block. if curline =~ '\C^when\>' && !s:SearchCode(prevnlnum, '\C\') " Look back for a `when`. while prevnlnum if getline(prevnlnum) =~ '\C^\s*when\>' " Indent to match the found `when`, but don't force indenting (for when " indenting nested switch blocks.) return min([indent(a:curlnum), indent(prevnlnum)]) endif let prevnlnum = s:GetPrevNormalLine(prevnlnum) endwhile " No matching `when` found (bad syntax), so bail. exec 'return' s:GetDefaultPolicy(a:curlnum) endif " If the previous line is a comment, use its indentation, but don't force " indenting. if prevlnum != prevnlnum return min([indent(a:curlnum), indent(prevlnum)]) endif let prevline = s:GetTrimmedLine(prevnlnum) " Always indent after these operators. if prevline =~ s:BEGIN_BLOCK_OP return indent(prevnlnum) + s:ShiftWidth() endif " Indent if the previous line starts a function block, but don't force " indenting if the line is non-blank (for empty function bodies.) if prevline =~ s:FUNCTION if strlen(getline(a:curlnum)) > indent(a:curlnum) return min([indent(prevnlnum) + s:ShiftWidth(), indent(a:curlnum)]) else return indent(prevnlnum) + s:ShiftWidth() endif endif " Check if continuation indenting is needed. If the line ends in a slash, make " sure it isn't a regex. if prevline =~ s:CONTINUATION_OP && \ !(prevline =~ '/$' && s:IsString(prevnlnum, col([prevnlnum, '$']) - 1)) " Don't indent if the continuation follows a closing bracket. if prevline =~ s:BRACKET_CONTINUATION exec 'return' s:GetDefaultPolicy(a:curlnum) endif let prevprevnlnum = s:GetPrevNormalLine(prevnlnum) " Don't indent if not the first continuation. if prevprevnlnum && s:GetTrimmedLine(prevprevnlnum) =~ s:CONTINUATION exec 'return' s:GetDefaultPolicy(a:curlnum) endif " Continuation indenting seems to vary between programmers, so if the line " is non-blank, don't override the indentation if strlen(getline(a:curlnum)) > indent(a:curlnum) exec 'return' s:GetDefaultPolicy(a:curlnum) endif " Otherwise indent a level. return indent(prevnlnum) + s:ShiftWidth() endif " Check if the previous line starts with a keyword that begins a block. if prevline =~ s:BEGIN_BLOCK " Indent if the current line doesn't start with `then` and the previous line " isn't a single-line statement. if curline !~ '\C^\' && !s:SearchCode(prevnlnum, '\C\') && \ prevline !~ s:SINGLE_LINE_ELSE return indent(prevnlnum) + s:ShiftWidth() else exec 'return' s:GetDefaultPolicy(a:curlnum) endif endif " Indent a dot access if it's the first. if curline =~ s:DOT_ACCESS if prevline !~ s:DOT_ACCESS return indent(prevnlnum) + s:ShiftWidth() else exec 'return' s:GetDefaultPolicy(a:curlnum) endif endif " Outdent if a keyword breaks out of a block as long as it doesn't have a " postfix condition (and the postfix condition isn't a single-line statement.) if prevline =~ s:BREAK_BLOCK_OP if !s:SearchCode(prevnlnum, s:POSTFIX_CONDITION) || \ s:SearchCode(prevnlnum, '\C\') && \ !s:SearchCode(prevnlnum, s:CONTAINED_THEN) " Don't force indenting. return min([indent(a:curlnum), indent(prevnlnum) - s:ShiftWidth()]) else exec 'return' s:GetDefaultPolicy(a:curlnum) endif endif " Check if inside brackets. let matchlnum = s:SearchPair(a:curlnum, a:curlnum - s:MAX_LOOKBACK, \ "s:IsCommentOrString(line('.'), col('.'))", \ '\[\|(\|{', '\]\|)\|}') " If inside brackets, indent relative to the brackets, but don't outdent an " already indented line. if matchlnum return max([indent(a:curlnum), indent(matchlnum) + s:ShiftWidth()]) endif " No special rules applied, so use the default policy. exec 'return' s:GetDefaultPolicy(a:curlnum) endfunction ================================================ FILE: sources_non_forked/vim-coffee-script/indent/litcoffee.vim ================================================ if exists('b:did_indent') finish endif runtime! indent/coffee.vim let b:did_indent = 1 setlocal indentexpr=GetLitCoffeeIndent() if exists('*GetLitCoffeeIndent') finish endif function GetLitCoffeeIndent() if searchpair('^ \|\t', '', '$', 'bWnm') > 0 return GetCoffeeIndent(v:lnum) else return -1 endif endfunc ================================================ FILE: sources_non_forked/vim-coffee-script/syntax/coffee.vim ================================================ " Language: CoffeeScript " Maintainer: Mick Koch " URL: http://github.com/kchmck/vim-coffee-script " License: WTFPL " Bail if our syntax is already loaded. if exists('b:current_syntax') && b:current_syntax == 'coffee' finish endif " Include JavaScript for coffeeEmbed. syn include @coffeeJS syntax/javascript.vim silent! unlet b:current_syntax " Highlight long strings. syntax sync fromstart " These are `matches` instead of `keywords` because vim's highlighting " priority for keywords is higher than matches. This causes keywords to be " highlighted inside matches, even if a match says it shouldn't contain them -- " like with coffeeAssign and coffeeDot. syn match coffeeStatement /\<\%(return\|break\|continue\|throw\)\>/ display hi def link coffeeStatement Statement syn match coffeeRepeat /\<\%(for\|while\|until\|loop\)\>/ display hi def link coffeeRepeat Repeat syn match coffeeConditional /\<\%(if\|else\|unless\|switch\|when\|then\)\>/ \ display hi def link coffeeConditional Conditional syn match coffeeException /\<\%(try\|catch\|finally\)\>/ display hi def link coffeeException Exception syn match coffeeKeyword /\<\%(new\|in\|of\|from\|by\|and\|or\|not\|is\|isnt\|class\|extends\|super\|do\|yield\|debugger\|import\|export\|default\|await\)\>/ \ display " The `own` keyword is only a keyword after `for`. syn match coffeeKeyword /\/ contained containedin=coffeeRepeat \ display hi def link coffeeKeyword Keyword syn match coffeeOperator /\<\%(instanceof\|typeof\|delete\)\>/ display hi def link coffeeOperator Operator " The first case matches symbol operators only if they have an operand before. syn match coffeeExtendedOp /\%(\S\s*\)\@<=[+\-*/%&|\^=!<>?.]\{-1,}\|[-=]>\|--\|++\|:/ \ display syn match coffeeExtendedOp /\<\%(and\|or\)=/ display hi def link coffeeExtendedOp coffeeOperator " This is separate from `coffeeExtendedOp` to help differentiate commas from " dots. syn match coffeeSpecialOp /[,;]/ display hi def link coffeeSpecialOp SpecialChar syn match coffeeBoolean /\<\%(true\|on\|yes\|false\|off\|no\)\>/ display hi def link coffeeBoolean Boolean syn match coffeeGlobal /\<\%(null\|undefined\)\>/ display hi def link coffeeGlobal Type " A special variable syn match coffeeSpecialVar /\<\%(this\|prototype\|arguments\)\>/ display hi def link coffeeSpecialVar Special " An @-variable syn match coffeeSpecialIdent /@\%(\%(\I\|\$\)\%(\i\|\$\)*\)\?/ display hi def link coffeeSpecialIdent Identifier " A class-like name that starts with a capital letter syn match coffeeObject /\<\u\w*\>/ display hi def link coffeeObject Structure " A constant-like name in SCREAMING_CAPS syn match coffeeConstant /\<\u[A-Z0-9_]\+\>/ display hi def link coffeeConstant Constant " A variable name syn cluster coffeeIdentifier contains=coffeeSpecialVar,coffeeSpecialIdent, \ coffeeObject,coffeeConstant " A non-interpolated string syn cluster coffeeBasicString contains=@Spell,coffeeEscape " An interpolated string syn cluster coffeeInterpString contains=@coffeeBasicString,coffeeInterp " Regular strings syn region coffeeString start=/"/ skip=/\\\\\|\\"/ end=/"/ \ contains=@coffeeInterpString syn region coffeeString start=/'/ skip=/\\\\\|\\'/ end=/'/ \ contains=@coffeeBasicString hi def link coffeeString String " A integer, including a leading plus or minus syn match coffeeNumber /\%(\i\|\$\)\@/ display syn match coffeeNumber /\<0[bB][01]\+\>/ display syn match coffeeNumber /\<0[oO][0-7]\+\>/ display syn match coffeeNumber /\<\%(Infinity\|NaN\)\>/ display hi def link coffeeNumber Number " A floating-point number, including a leading plus or minus syn match coffeeFloat /\%(\i\|\$\)\@/ \ display hi def link coffeeReservedError Error " A normal object assignment syn match coffeeObjAssign /@\?\%(\I\|\$\)\%(\i\|\$\)*\s*\ze::\@!/ contains=@coffeeIdentifier display hi def link coffeeObjAssign Identifier syn keyword coffeeTodo TODO FIXME XXX contained hi def link coffeeTodo Todo syn match coffeeComment /#.*/ contains=@Spell,coffeeTodo hi def link coffeeComment Comment syn region coffeeBlockComment start=/####\@!/ end=/###/ \ contains=@Spell,coffeeTodo hi def link coffeeBlockComment coffeeComment " A comment in a heregex syn region coffeeHeregexComment start=/#/ end=/\ze\/\/\/\|$/ contained \ contains=@Spell,coffeeTodo hi def link coffeeHeregexComment coffeeComment " Embedded JavaScript syn region coffeeEmbed matchgroup=coffeeEmbedDelim \ start=/`/ skip=/\\\\\|\\`/ end=/`/ keepend \ contains=@coffeeJS hi def link coffeeEmbedDelim Delimiter syn region coffeeInterp matchgroup=coffeeInterpDelim start=/#{/ end=/}/ contained \ contains=@coffeeAll hi def link coffeeInterpDelim PreProc " A string escape sequence syn match coffeeEscape /\\\d\d\d\|\\x\x\{2\}\|\\u\x\{4\}\|\\./ contained display hi def link coffeeEscape SpecialChar " A regex -- must not follow a parenthesis, number, or identifier, and must not " be followed by a number syn region coffeeRegex start=#\%(\%()\|\%(\i\|\$\)\@ " URL: https://github.com/mintplant/vim-literate-coffeescript " License: MIT if exists('b:current_syntax') && b:current_syntax == 'litcoffee' finish endif syn include @markdown syntax/markdown.vim syn include @coffee syntax/coffee.vim " Partition the file into notCoffee and inlineCoffee. Each line will match " exactly one of these regions. notCoffee matches with a zero-width " look-behind. syn region notCoffee start='^\%( \|\t\)\@> #{ == { { { } } } == } << " " >> #{ == { abc: { def: 42 } } == } << " ================================================ FILE: sources_non_forked/vim-coffee-script/test/test-ops.coffee ================================================ # Various operators abc instanceof def typeof abc delete abc abc::def abc + def abc - def abc * def abc / def abc % def abc & def abc | def abc ^ def abc >> def abc << def abc >>> def abc ? def abc && def abc and def abc || def abc or def abc += def abc -= def abc *= def abc /= def abc %= def abc &= def abc |= def abc ^= def abc >>= def abc <<= def abc >>>= def abc ?= def abc &&= def abc ||= def abc and= def abc or= def abc.def.ghi abc?.def?.ghi abc < def abc > def abc = def abc == def abc != def abc <= def abc >= def abc++ abc-- ++abc --abc # Nested operators abc[def] = ghi abc[def[ghi: jkl]] = 42 @abc[def] = ghi abc["#{def = 42}"] = 42 abc["#{def.ghi = 42}"] = 42 abc["#{def[ghi] = 42}"] = 42 abc["#{def['ghi']}"] = 42 # Object assignments abc = def: 123 DEF: 123 @def: 123 Def: 123 'def': 123 42: 123 # Operators shouldn't be highlighted vector= wand= abc+++ abc--- abc ** def abc &&& def abc ^^ def abc ===== def abc <==== def abc >==== def abc +== def abc =^= def ================================================ FILE: sources_non_forked/vim-coffee-script/test/test-reserved.coffee ================================================ # Should be an error function = 42 var = 42 # Shouldn't be an error abc.with = 42 function: 42 var: 42 # Keywords shouldn't be highlighted abc.function abc.do abc.break abc.true abc::function abc::do abc::break abc::true abc:: function abc. function # Numbers should be highlighted def.42 def .42 def::42 ================================================ FILE: sources_non_forked/vim-coffee-script/test/test.coffee.md ================================================ The **Scope** class regulates lexical scoping within CoffeeScript. As you generate code, you create a tree of scopes in the same shape as the nested function bodies. Each scope knows about the variables declared within it, and has a reference to its parent enclosing scope. In this way, we know which variables are new and need to be declared with `var`, and which are shared with external scopes. Import the helpers we plan to use. {extend, last} = require './helpers' exports.Scope = class Scope The `root` is the top-level **Scope** object for a given file. @root: null Initialize a scope with its parent, for lookups up the chain, as well as a reference to the **Block** node it belongs to, which is where it should declare its variables, and a reference to the function that it belongs to. constructor: (@parent, @expressions, @method) -> @variables = [{name: 'arguments', type: 'arguments'}] @positions = {} Scope.root = this unless @parent Adds a new variable or overrides an existing one. add: (name, type, immediate) -> return @parent.add name, type, immediate if @shared and not immediate if Object::hasOwnProperty.call @positions, name @variables[@positions[name]].type = type else @positions[name] = @variables.push({name, type}) - 1 When `super` is called, we need to find the name of the current method we're in, so that we know how to invoke the same method of the parent class. This can get complicated if super is being called from an inner function. `namedMethod` will walk up the scope tree until it either finds the first function object that has a name filled in, or bottoms out. namedMethod: -> return @method if @method.name or !@parent @parent.namedMethod() Look up a variable name in lexical scope, and declare it if it does not already exist. find: (name) -> return yes if @check name @add name, 'var' no Reserve a variable name as originating from a function parameter for this scope. No `var` required for internal references. parameter: (name) -> return if @shared and @parent.check name, yes @add name, 'param' Just check to see if a variable has already been declared, without reserving, walks up to the root scope. check: (name) -> !!(@type(name) or @parent?.check(name)) Generate a temporary variable name at the given index. temporary: (name, index) -> if name.length > 1 '_' + name + if index > 1 then index - 1 else '' else '_' + (index + parseInt name, 36).toString(36).replace /\d/g, 'a' Gets the type of a variable. type: (name) -> return v.type for v in @variables when v.name is name null If we need to store an intermediate result, find an available name for a compiler-generated variable. `_var`, `_var2`, and so on... freeVariable: (name, reserve=true) -> index = 0 index++ while @check((temp = @temporary name, index)) @add temp, 'var', yes if reserve temp Ensure that an assignment is made at the top of this scope (or at the top-level scope, if requested). assign: (name, value) -> @add name, {value, assigned: yes}, yes @hasAssignments = yes Does this scope have any declared variables? hasDeclarations: -> !!@declaredVariables().length Return the list of variables first declared in this scope. declaredVariables: -> realVars = [] tempVars = [] for v in @variables when v.type is 'var' (if v.name.charAt(0) is '_' then tempVars else realVars).push v.name realVars.sort().concat tempVars.sort() Return the list of assignments that are supposed to be made at the top of this scope. assignedVariables: -> "#{v.name} = #{v.type.value}" for v in @variables when v.type.assigned ================================================ FILE: sources_non_forked/vim-coffee-script/test/test.haml ================================================ :coffeescript class Hello # test ================================================ FILE: sources_non_forked/vim-coffee-script/test/test.html ================================================ ================================================ FILE: sources_non_forked/vim-coffee-script/test/test.litcoffee ================================================ The **Scope** class regulates lexical scoping within CoffeeScript. As you generate code, you create a tree of scopes in the same shape as the nested function bodies. Each scope knows about the variables declared within it, and has a reference to its parent enclosing scope. In this way, we know which variables are new and need to be declared with `var`, and which are shared with external scopes. Import the helpers we plan to use. {extend, last} = require './helpers' exports.Scope = class Scope The `root` is the top-level **Scope** object for a given file. @root: null Initialize a scope with its parent, for lookups up the chain, as well as a reference to the **Block** node it belongs to, which is where it should declare its variables, and a reference to the function that it belongs to. constructor: (@parent, @expressions, @method) -> @variables = [{name: 'arguments', type: 'arguments'}] @positions = {} Scope.root = this unless @parent Adds a new variable or overrides an existing one. add: (name, type, immediate) -> return @parent.add name, type, immediate if @shared and not immediate if Object::hasOwnProperty.call @positions, name @variables[@positions[name]].type = type else @positions[name] = @variables.push({name, type}) - 1 When `super` is called, we need to find the name of the current method we're in, so that we know how to invoke the same method of the parent class. This can get complicated if super is being called from an inner function. `namedMethod` will walk up the scope tree until it either finds the first function object that has a name filled in, or bottoms out. namedMethod: -> return @method if @method.name or !@parent @parent.namedMethod() Look up a variable name in lexical scope, and declare it if it does not already exist. find: (name) -> return yes if @check name @add name, 'var' no Reserve a variable name as originating from a function parameter for this scope. No `var` required for internal references. parameter: (name) -> return if @shared and @parent.check name, yes @add name, 'param' Just check to see if a variable has already been declared, without reserving, walks up to the root scope. check: (name) -> !!(@type(name) or @parent?.check(name)) Generate a temporary variable name at the given index. temporary: (name, index) -> if name.length > 1 '_' + name + if index > 1 then index - 1 else '' else '_' + (index + parseInt name, 36).toString(36).replace /\d/g, 'a' Gets the type of a variable. type: (name) -> return v.type for v in @variables when v.name is name null If we need to store an intermediate result, find an available name for a compiler-generated variable. `_var`, `_var2`, and so on... freeVariable: (name, reserve=true) -> index = 0 index++ while @check((temp = @temporary name, index)) @add temp, 'var', yes if reserve temp Ensure that an assignment is made at the top of this scope (or at the top-level scope, if requested). assign: (name, value) -> @add name, {value, assigned: yes}, yes @hasAssignments = yes Does this scope have any declared variables? hasDeclarations: -> !!@declaredVariables().length Return the list of variables first declared in this scope. declaredVariables: -> realVars = [] tempVars = [] for v in @variables when v.type is 'var' (if v.name.charAt(0) is '_' then tempVars else realVars).push v.name realVars.sort().concat tempVars.sort() Return the list of assignments that are supposed to be made at the top of this scope. assignedVariables: -> "#{v.name} = #{v.type.value}" for v in @variables when v.type.assigned ================================================ FILE: sources_non_forked/vim-colors-solarized/README.mkd ================================================ --- Title: Solarized Colorscheme for Vim Description: Precision colors for machines and people Author: Ethan Schoonover Colors: light yellow Created: 2011 Mar 15 Modified: 2011 Apr 16 --- Solarized Colorscheme for Vim ============================= Developed by Ethan Schoonover Visit the [Solarized homepage] ------------------------------ See the [Solarized homepage] for screenshots, details and colorscheme versions for Vim, Mutt, popular terminal emulators and other applications. Screenshots ----------- ![solarized dark](https://github.com/altercation/solarized/raw/master/img/solarized-vim.png) Downloads --------- If you have come across this colorscheme via the [Vim-only repository] on github, or the [vim.org script] page see the link above to the Solarized homepage or visit the main [Solarized repository]. The [Vim-only repository] is kept in sync with the main [Solarized repository] and is for installation convenience only (with [Pathogen] or [Vundle], for instance). Issues, bug reports, changelogs are centralized at the main [Solarized repository]. [Solarized homepage]: http://ethanschoonover.com/solarized [Solarized repository]: https://github.com/altercation/solarized [Vim-only repository]: https://github.com/altercation/vim-colors-solarized [vimorg-script]: http://vim.org/script [Pathogen]: https://github.com/tpope/vim-pathogen [Vundle]: https://github.com/gmarik/vundle Installation ------------ ### Option 1: Manual installation 1. Move `solarized.vim` to your `.vim/colors` directory. After downloading the vim script or package: $ cd vim-colors-solarized/colors $ mv solarized.vim ~/.vim/colors/ ### Option 2: Pathogen installation ***(recommended)*** 1. Download and install Tim Pope's [Pathogen]. 2. Next, move or clone the `vim-colors-solarized` directory so that it is a subdirectory of the `.vim/bundle` directory. a. **Clone:** $ cd ~/.vim/bundle $ git clone git://github.com/altercation/vim-colors-solarized.git b. **Move:** In the parent directory of vim-colors-solarized: $ mv vim-colors-solarized ~/.vim/bundle/ ### Modify .vimrc After either Option 1 or Option 2 above, put the following two lines in your .vimrc: syntax enable set background=dark colorscheme solarized or, for the light background mode of Solarized: syntax enable set background=light colorscheme solarized I like to have a different background in GUI and terminal modes, so I can use the following if-then. However, I find vim's background autodetection to be pretty good and, at least with MacVim, I can leave this background value assignment out entirely and get the same results. if has('gui_running') set background=light else set background=dark endif See the [Solarized homepage] for screenshots which will help you select either the light or dark background. ### IMPORTANT NOTE FOR TERMINAL USERS: If you are going to use Solarized in Terminal mode (i.e. not in a GUI version like gvim or macvim), **please please please** consider setting your terminal emulator's colorscheme to used the Solarized palette. I've included palettes for some popular terminal emulator as well as Xdefaults in the official Solarized download available from [Solarized homepage]. If you use Solarized *without* these colors, Solarized will need to be told to degrade its colorscheme to a set compatible with the limited 256 terminal palette (whereas by using the terminal's 16 ansi color values, you can set the correct, specific values for the Solarized palette). If you do use the custom terminal colors, solarized.vim should work out of the box for you. If you are using a terminal emulator that supports 256 colors and don't want to use the custom Solarized terminal colors, you will need to use the degraded 256 colorscheme. To do so, simply add the following line *before* the `colorschem solarized` line: let g:solarized_termcolors=256 Again, I recommend just changing your terminal colors to Solarized values either manually or via one of the many terminal schemes available for import. Advanced Configuration ---------------------- Solarized will work out of the box with just the two lines specified above but does include several other options that can be set in your .vimrc file. Set these in your vimrc file prior to calling the colorscheme. " option name default optional ------------------------------------------------ g:solarized_termcolors= 16 | 256 g:solarized_termtrans = 0 | 1 g:solarized_degrade = 0 | 1 g:solarized_bold = 1 | 0 g:solarized_underline = 1 | 0 g:solarized_italic = 1 | 0 g:solarized_contrast = "normal"| "high" or "low" g:solarized_visibility= "normal"| "high" or "low" ------------------------------------------------ ### Option Details * g:solarized_termcolors This is set to *16* by default, meaning that Solarized will attempt to use the standard 16 colors of your terminal emulator. You will need to set those colors to the correct Solarized values either manually or by importing one of the many colorscheme available for popular terminal emulators and Xdefaults. * g:solarized_termtrans If you use a terminal emulator with a transparent background and Solarized isn't displaying the background color transparently, set this to 1 and Solarized will use the default (transparent) background of the terminal emulator. *urxvt* required this in my testing; iTerm2 did not. Note that on Mac OS X Terminal.app, solarized_termtrans is set to 1 by default as this is almost always the best option. The only exception to this is if the working terminfo file supports 256 colors (xterm-256color). * g:solarized_degrade For test purposes only; forces Solarized to use the 256 degraded color mode to test the approximate color values for accuracy. * g:solarized_bold | g:solarized_underline | g:solarized_italic If you wish to stop Solarized from displaying bold, underlined or italicized typefaces, simply assign a zero value to the appropriate variable, for example: `let g:solarized_italic=0` * g:solarized_contrast Stick with normal! It's been carefully tested. Setting this option to high or low does use the same Solarized palette but simply shifts some values up or down in order to expand or compress the tonal range displayed. * g:solarized_visibility Special characters such as trailing whitespace, tabs, newlines, when displayed using `:set list` can be set to one of three levels depending on your needs. Default value is `normal` with `high` and `low` options. Toggle Background Function -------------------------- Solarized comes with a Toggle Background plugin that by default will map to if that mapping is available. If it is not available you will need to either map the function manually or change your current mapping to something else. To set your own mapping in your .vimrc file, simply add the following line to support normal, insert and visual mode usage, changing the "" value to the key or key combination you wish to use: call togglebg#map("") Note that you'll want to use a single function key or equivalent if you want the plugin to work in all modes (normal, insert, visual). Code Notes ---------- Use folding to view the `solarized.vim` script with `foldmethod=marker` turned on. I have attempted to modularize the creation of Vim colorschemes in this script and, while it could be refactored further, it should be a good foundation for the creation of any color scheme. By simply changing the sixteen values in the GUI section and testing in gvim (or mvim) you can rapidly prototype new colorschemes without diving into the weeds of line-item editing each syntax highlight declaration. The Values ---------- L\*a\*b values are canonical (White D65, Reference D50), other values are matched in sRGB space. SOLARIZED HEX 16/8 TERMCOL XTERM/HEX L*A*B sRGB HSB --------- ------- ---- ------- ----------- ---------- ----------- ----------- base03 #002b36 8/4 brblack 234 #1c1c1c 15 -12 -12 0 43 54 193 100 21 base02 #073642 0/4 black 235 #262626 20 -12 -12 7 54 66 192 90 26 base01 #586e75 10/7 brgreen 240 #4e4e4e 45 -07 -07 88 110 117 194 25 46 base00 #657b83 11/7 bryellow 241 #585858 50 -07 -07 101 123 131 195 23 51 base0 #839496 12/6 brblue 244 #808080 60 -06 -03 131 148 150 186 13 59 base1 #93a1a1 14/4 brcyan 245 #8a8a8a 65 -05 -02 147 161 161 180 9 63 base2 #eee8d5 7/7 white 254 #d7d7af 92 -00 10 238 232 213 44 11 93 base3 #fdf6e3 15/7 brwhite 230 #ffffd7 97 00 10 253 246 227 44 10 99 yellow #b58900 3/3 yellow 136 #af8700 60 10 65 181 137 0 45 100 71 orange #cb4b16 9/3 brred 166 #d75f00 50 50 55 203 75 22 18 89 80 red #dc322f 1/1 red 160 #d70000 50 65 45 220 50 47 1 79 86 magenta #d33682 5/5 magenta 125 #af005f 50 65 -05 211 54 130 331 74 83 violet #6c71c4 13/5 brmagenta 61 #5f5faf 50 15 -45 108 113 196 237 45 77 blue #268bd2 4/4 blue 33 #0087ff 55 -10 -45 38 139 210 205 82 82 cyan #2aa198 6/6 cyan 37 #00afaf 60 -35 -05 42 161 152 175 74 63 green #859900 2/2 green 64 #5f8700 60 -20 65 133 153 0 68 100 60 License ------- Copyright (c) 2011 Ethan Schoonover Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ================================================ FILE: sources_non_forked/vim-colors-solarized/autoload/togglebg.vim ================================================ " Toggle Background " Modified: 2011 Apr 29 " Maintainer: Ethan Schoonover " License: OSI approved MIT license if exists("g:loaded_togglebg") finish endif let g:loaded_togglebg = 1 " noremap is a bit misleading here if you are unused to vim mapping. " in fact, there is remapping, but only of script locally defined remaps, in " this case TogBG. The endsnippet snippet scriptsrc "HTML endsnippet snippet select "Select Box" w endsnippet snippet small "" w $1 endsnippet snippet span "" w ${0:${VISUAL}} endsnippet snippet span# " with ID & class" w ${0:${VISUAL}} endsnippet snippet span. " with class" w ${0:${VISUAL}} endsnippet snippet strong "" w $1 endsnippet snippet style "HTML endsnippet snippet sub "" w $1 endsnippet snippet sup "" w $1 endsnippet snippet table "HTML " w
${0:${VISUAL}}
endsnippet snippet tbody "" $1 endsnippet snippet td "table cell" w ${0:${VISUAL}} endsnippet snippet template "