├── vim ├── bundle │ ├── tube │ │ ├── autoload │ │ │ ├── tube │ │ │ │ ├── __init__.py │ │ │ │ ├── utils │ │ │ │ │ ├── __init__.py │ │ │ │ │ ├── v.pyc │ │ │ │ │ ├── misc.pyc │ │ │ │ │ ├── __init__.pyc │ │ │ │ │ ├── settings.pyc │ │ │ │ │ ├── v.py │ │ │ │ │ └── settings.py │ │ │ │ ├── core.pyc │ │ │ │ └── __init__.pyc │ │ │ └── applescript │ │ │ │ ├── terminal.scpt │ │ │ │ └── iterm.scpt │ │ ├── LICENSE.txt │ │ ├── doc │ │ │ └── tags │ │ └── CHANGELOG.md │ ├── vim-go │ │ ├── .gitignore │ │ ├── templates │ │ │ └── hello_world.go │ │ ├── t │ │ │ └── fixtures │ │ │ │ └── src │ │ │ │ ├── pkg1 │ │ │ │ ├── sample_test.go │ │ │ │ ├── sample.out │ │ │ │ └── sample.go │ │ │ │ ├── buildfail │ │ │ │ ├── sample_test.go │ │ │ │ └── sample.go │ │ │ │ ├── parsefail │ │ │ │ ├── sample_test.go │ │ │ │ └── sample.go │ │ │ │ ├── failtest │ │ │ │ ├── sample_test.go │ │ │ │ └── sample.go │ │ │ │ └── buildtestfail │ │ │ │ ├── sample.go │ │ │ │ └── sample_test.go │ │ ├── ftplugin │ │ │ ├── gohtmltmpl.vim │ │ │ ├── asm.vim │ │ │ └── go │ │ │ │ ├── snippets.vim │ │ │ │ └── tagbar.vim │ │ ├── addon-info.json │ │ ├── Rakefile │ │ ├── syntax │ │ │ ├── vimgo.vim │ │ │ ├── gohtmltmpl.vim │ │ │ └── godefstack.vim │ │ ├── autoload │ │ │ └── go │ │ │ │ ├── alternate.vim │ │ │ │ └── template.vim │ │ ├── indent │ │ │ └── gohtmltmpl.vim │ │ └── ftdetect │ │ │ └── gofiletype.vim │ ├── snippets │ │ ├── UltiSnips │ │ │ ├── xhtml.snippets │ │ │ ├── htmldjango.snippets │ │ │ ├── zsh.snippets │ │ │ ├── xml.snippets │ │ │ ├── json.snippets │ │ │ ├── snippets.snippets │ │ │ ├── twig.snippets │ │ │ ├── php │ │ │ │ └── phpunit.snippets │ │ │ ├── help.snippets │ │ │ ├── html_minimal.snippets │ │ │ ├── lua.snippets │ │ │ ├── README │ │ │ ├── bindzone.snippets │ │ │ ├── tcl.snippets │ │ │ ├── markdown.snippets │ │ │ ├── texmath.snippets │ │ │ ├── vim.snippets │ │ │ ├── cpp.snippets │ │ │ ├── haskell.snippets │ │ │ └── mako.snippets │ │ ├── snippets │ │ │ ├── javascript_jquery.snippets │ │ │ ├── po.snippets │ │ │ ├── make.snippets │ │ │ ├── ledger.snippets │ │ │ ├── snippets.snippets │ │ │ ├── dosini.snippets │ │ │ ├── lua.snippets │ │ │ ├── diff.snippets │ │ │ ├── textile.snippets │ │ │ ├── apache.snippets │ │ │ ├── javascript.d3.snippets │ │ │ ├── haml.snippets │ │ │ ├── sql.snippets │ │ │ ├── mako.snippets │ │ │ ├── slim.snippets │ │ │ ├── cmake.snippets │ │ │ ├── htmltornado.snippets │ │ │ ├── vim.snippets │ │ │ ├── falcon.snippets │ │ │ ├── openfoam.snippets │ │ │ ├── zsh.snippets │ │ │ ├── rst.snippets │ │ │ ├── progress.snippets │ │ │ ├── dart.snippets │ │ │ └── autoit.snippets │ │ ├── addon-info.json │ │ ├── AUTHORS │ │ ├── autoload │ │ │ └── vim_snippets.vim │ │ └── LICENSE │ ├── Dockerfile │ │ ├── .gitignore │ │ ├── vim-dockerfile-example.png │ │ ├── ftdetect │ │ │ └── Dockerfile.vim │ │ ├── Makefile │ │ ├── LICENSE │ │ ├── README.md │ │ └── snippets │ │ │ └── Dockerfile.snippets │ ├── multiple-cursors │ │ ├── .gitignore │ │ ├── .rspec │ │ ├── Gemfile │ │ ├── assets │ │ │ ├── example1.gif │ │ │ ├── example2.gif │ │ │ ├── example3.gif │ │ │ └── example4.gif │ │ ├── .travis.yml │ │ ├── Rakefile │ │ ├── CONTRIBUTING.md │ │ ├── Gemfile.lock │ │ ├── spec │ │ │ └── spec_helper.rb │ │ └── MIT-LICENSE.txt │ ├── snipmate │ │ ├── ftplugin │ │ │ ├── snippets.vim │ │ │ ├── snippet.vim │ │ │ └── html_snip_helper.vim │ │ ├── plugin │ │ │ └── snipMateInterface.vim │ │ ├── syntax │ │ │ ├── snippet.vim │ │ │ └── snippets.vim │ │ ├── addon-info.json │ │ └── doc │ │ │ └── tags │ ├── syntastic │ │ ├── _assets │ │ │ └── screenshot_1.png │ │ ├── LICENCE │ │ ├── syntax_checkers │ │ │ ├── python │ │ │ │ ├── py3kwarn.vim │ │ │ │ ├── python.vim │ │ │ │ ├── flake8.vim │ │ │ │ ├── pep8.vim │ │ │ │ └── pep257.vim │ │ │ ├── haskell │ │ │ │ └── hlint.vim │ │ │ ├── scss │ │ │ │ ├── sass.vim │ │ │ │ └── scss_lint.vim │ │ │ ├── xslt │ │ │ │ └── xmllint.vim │ │ │ ├── perl │ │ │ │ └── podchecker.vim │ │ │ ├── docbk │ │ │ │ └── xmllint.vim │ │ │ ├── cpp │ │ │ │ ├── ycm.vim │ │ │ │ └── oclint.vim │ │ │ ├── objc │ │ │ │ ├── ycm.vim │ │ │ │ └── oclint.vim │ │ │ ├── objcpp │ │ │ │ ├── ycm.vim │ │ │ │ └── oclint.vim │ │ │ ├── css │ │ │ │ └── phpcs.vim │ │ │ ├── typescript │ │ │ │ └── tsc.vim │ │ │ ├── sh │ │ │ │ ├── shellcheck.vim │ │ │ │ └── checkbashisms.vim │ │ │ ├── less │ │ │ │ ├── less-lint.coffee │ │ │ │ └── less-lint.js │ │ │ ├── vhdl │ │ │ │ └── ghdl.vim │ │ │ ├── zsh │ │ │ │ └── zsh.vim │ │ │ ├── hss │ │ │ │ └── hss.vim │ │ │ ├── c │ │ │ │ └── ycm.vim │ │ │ ├── go │ │ │ │ ├── golint.vim │ │ │ │ └── gofmt.vim │ │ │ ├── cs │ │ │ │ └── mcs.vim │ │ │ ├── llvm │ │ │ │ └── llvm.vim │ │ │ ├── tex │ │ │ │ └── lacheck.vim │ │ │ ├── chef │ │ │ │ └── foodcritic.vim │ │ │ ├── coq │ │ │ │ └── coqtop.vim │ │ │ ├── nroff │ │ │ │ └── mandoc.vim │ │ │ ├── ruby │ │ │ │ ├── rubylint.vim │ │ │ │ └── macruby.vim │ │ │ ├── dustjs │ │ │ │ └── swiffer.vim │ │ │ ├── json │ │ │ │ ├── jsonval.vim │ │ │ │ └── jsonlint.vim │ │ │ ├── matlab │ │ │ │ └── mlint.vim │ │ │ ├── cucumber │ │ │ │ └── cucumber.vim │ │ │ ├── rust │ │ │ │ └── rustc.vim │ │ │ ├── verilog │ │ │ │ └── verilator.vim │ │ │ ├── twig │ │ │ │ └── twiglint.vim │ │ │ ├── co │ │ │ │ └── coco.vim │ │ │ ├── nasm │ │ │ │ └── nasm.vim │ │ │ ├── coffee │ │ │ │ └── coffeelint.vim │ │ │ ├── handlebars │ │ │ │ └── handlebars.vim │ │ │ ├── tcl │ │ │ │ └── nagelfar.vim │ │ │ ├── scala │ │ │ │ └── scalac.vim │ │ │ └── php │ │ │ │ └── phpcs.vim │ │ └── plugin │ │ │ └── syntastic │ │ │ └── autoloclist.vim │ ├── vim-colors-solarized │ │ ├── bitmaps │ │ │ └── togglebg.png │ │ └── doc │ │ │ └── tags │ ├── twig │ │ ├── ftdetect │ │ │ └── twig.vim │ │ ├── vim-twig-addon-info.txt │ │ ├── ftplugin │ │ │ └── twig.vim │ │ ├── README.markdown │ │ └── snippets │ │ │ └── twig.snippets │ ├── powerline │ │ └── autoload │ │ │ ├── Powerline │ │ │ ├── Segments │ │ │ │ ├── ft_man.vim │ │ │ │ ├── hgrev.vim │ │ │ │ ├── fugitive.vim │ │ │ │ ├── rvm.vim │ │ │ │ ├── virtualenv.vim │ │ │ │ ├── syntastic.vim │ │ │ │ ├── tagbar.vim │ │ │ │ └── ctrlp.vim │ │ │ ├── Functions │ │ │ │ ├── fugitive.vim │ │ │ │ ├── ft_man.vim │ │ │ │ ├── hgrev.vim │ │ │ │ └── syntastic.vim │ │ │ └── Matches.vim │ │ │ └── Pl │ │ │ ├── Match.vim │ │ │ └── Mod.vim │ ├── gundo │ │ ├── README │ │ ├── plugin │ │ │ └── gundo.vim │ │ ├── README.markdown │ │ └── doc │ │ │ └── tags │ ├── addon_mw_utils │ │ ├── doc │ │ │ ├── cached_file_contents.txt │ │ │ ├── tags │ │ │ ├── tiny_cmd.txt │ │ │ └── funcref.txt │ │ ├── autoload │ │ │ ├── tiny_cmd.vim │ │ │ ├── env_reload.vim │ │ │ ├── buf_utils.vim │ │ │ └── glob.vim │ │ └── vim-addon-mw-utils-addon-info.txt │ ├── tlib │ │ ├── addon-info.json │ │ ├── autoload │ │ │ ├── tlib.vim │ │ │ ├── tlib │ │ │ │ ├── autocmdgroup.vim │ │ │ │ ├── fixes.vim │ │ │ │ ├── map.vim │ │ │ │ ├── type.vim │ │ │ │ ├── Test.vim │ │ │ │ ├── TestChild.vim │ │ │ │ ├── number.vim │ │ │ │ ├── hook.vim │ │ │ │ ├── grep.vim │ │ │ │ ├── normal.vim │ │ │ │ ├── textobjects.vim │ │ │ │ ├── url.vim │ │ │ │ ├── tab.vim │ │ │ │ └── syntax.vim │ │ │ └── tinykeymap │ │ │ │ └── map │ │ │ │ └── para_move.vim │ │ ├── spec │ │ │ └── tlib │ │ │ │ ├── rx.vim │ │ │ │ ├── url.vim │ │ │ │ ├── string.vim │ │ │ │ └── var.vim │ │ ├── README │ │ └── etc │ │ │ └── tpl_tlib.txt │ ├── numbers-vim │ │ └── doc │ │ │ └── tags │ └── surround │ │ └── doc │ │ └── tags └── vimrc.tiny ├── .gitignore ├── Pictures ├── vim.jpg ├── share │ ├── in.png │ └── t.png └── language │ ├── de.png │ ├── en.png │ ├── fr.png │ └── it.png ├── sublivimrc.sh ├── uninstall ├── swipe_lines.vimrc └── installer.sh /vim/bundle/tube/autoload/tube/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /vim/bundle/vim-go/.gitignore: -------------------------------------------------------------------------------- 1 | doc/tags 2 | -------------------------------------------------------------------------------- /vim/bundle/snippets/UltiSnips/xhtml.snippets: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /vim/bundle/tube/autoload/tube/utils/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /vim/bundle/Dockerfile/.gitignore: -------------------------------------------------------------------------------- 1 | *.swp 2 | *.swo 3 | -------------------------------------------------------------------------------- /vim/bundle/multiple-cursors/.gitignore: -------------------------------------------------------------------------------- 1 | /doc/tags 2 | -------------------------------------------------------------------------------- /vim/bundle/multiple-cursors/.rspec: -------------------------------------------------------------------------------- 1 | --color 2 | --format d 3 | -------------------------------------------------------------------------------- /vim/bundle/snipmate/ftplugin/snippets.vim: -------------------------------------------------------------------------------- 1 | runtime! ftplugin/snippet.vim 2 | -------------------------------------------------------------------------------- /vim/bundle/snippets/UltiSnips/htmldjango.snippets: -------------------------------------------------------------------------------- 1 | extends html, django 2 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | config_perso 2 | vim/bundle/ctrlp.vim/doc/tags 3 | vim/.netrwhist 4 | -------------------------------------------------------------------------------- /vim/bundle/snippets/snippets/javascript_jquery.snippets: -------------------------------------------------------------------------------- 1 | javascript-jquery.snippets -------------------------------------------------------------------------------- /Pictures/vim.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/reversTeam/Sublivim/HEAD/Pictures/vim.jpg -------------------------------------------------------------------------------- /Pictures/share/in.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/reversTeam/Sublivim/HEAD/Pictures/share/in.png -------------------------------------------------------------------------------- /Pictures/share/t.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/reversTeam/Sublivim/HEAD/Pictures/share/t.png -------------------------------------------------------------------------------- /Pictures/language/de.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/reversTeam/Sublivim/HEAD/Pictures/language/de.png -------------------------------------------------------------------------------- /Pictures/language/en.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/reversTeam/Sublivim/HEAD/Pictures/language/en.png -------------------------------------------------------------------------------- /Pictures/language/fr.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/reversTeam/Sublivim/HEAD/Pictures/language/fr.png -------------------------------------------------------------------------------- /Pictures/language/it.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/reversTeam/Sublivim/HEAD/Pictures/language/it.png -------------------------------------------------------------------------------- /vim/bundle/snippets/snippets/po.snippets: -------------------------------------------------------------------------------- 1 | snippet msg 2 | msgid "${1}" 3 | msgstr "${2}" 4 | 5 | ${0} 6 | -------------------------------------------------------------------------------- /vim/bundle/snippets/snippets/make.snippets: -------------------------------------------------------------------------------- 1 | snippet ifeq 2 | ifeq (${1:cond0},${2:cond1}) 3 | ${0} 4 | endif 5 | -------------------------------------------------------------------------------- /vim/bundle/multiple-cursors/Gemfile: -------------------------------------------------------------------------------- 1 | source 'https://rubygems.org' 2 | gem 'vimrunner' 3 | gem 'rake' 4 | gem 'rspec' 5 | -------------------------------------------------------------------------------- /sublivimrc.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | [[ $- == *i* ]] && stty -ixon 3 | ~/.Sublivim/installer.sh 2> /dev/null > /dev/null 4 | -------------------------------------------------------------------------------- /vim/bundle/tube/autoload/tube/core.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/reversTeam/Sublivim/HEAD/vim/bundle/tube/autoload/tube/core.pyc -------------------------------------------------------------------------------- /vim/bundle/tube/autoload/tube/utils/v.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/reversTeam/Sublivim/HEAD/vim/bundle/tube/autoload/tube/utils/v.pyc -------------------------------------------------------------------------------- /vim/bundle/vim-go/templates/hello_world.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | fmt.Println("vim-go") 7 | } 8 | -------------------------------------------------------------------------------- /vim/bundle/tube/autoload/tube/__init__.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/reversTeam/Sublivim/HEAD/vim/bundle/tube/autoload/tube/__init__.pyc -------------------------------------------------------------------------------- /vim/bundle/tube/autoload/tube/utils/misc.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/reversTeam/Sublivim/HEAD/vim/bundle/tube/autoload/tube/utils/misc.pyc -------------------------------------------------------------------------------- /vim/bundle/snipmate/plugin/snipMateInterface.vim: -------------------------------------------------------------------------------- 1 | " some useful commands 2 | command! SnipMateOpenSnippetFiles call snipMate#OpenSnippetFiles() 3 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/_assets/screenshot_1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/reversTeam/Sublivim/HEAD/vim/bundle/syntastic/_assets/screenshot_1.png -------------------------------------------------------------------------------- /vim/bundle/Dockerfile/vim-dockerfile-example.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/reversTeam/Sublivim/HEAD/vim/bundle/Dockerfile/vim-dockerfile-example.png -------------------------------------------------------------------------------- /vim/bundle/multiple-cursors/assets/example1.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/reversTeam/Sublivim/HEAD/vim/bundle/multiple-cursors/assets/example1.gif -------------------------------------------------------------------------------- /vim/bundle/multiple-cursors/assets/example2.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/reversTeam/Sublivim/HEAD/vim/bundle/multiple-cursors/assets/example2.gif -------------------------------------------------------------------------------- /vim/bundle/multiple-cursors/assets/example3.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/reversTeam/Sublivim/HEAD/vim/bundle/multiple-cursors/assets/example3.gif -------------------------------------------------------------------------------- /vim/bundle/multiple-cursors/assets/example4.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/reversTeam/Sublivim/HEAD/vim/bundle/multiple-cursors/assets/example4.gif -------------------------------------------------------------------------------- /vim/bundle/tube/autoload/tube/utils/__init__.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/reversTeam/Sublivim/HEAD/vim/bundle/tube/autoload/tube/utils/__init__.pyc -------------------------------------------------------------------------------- /vim/bundle/tube/autoload/tube/utils/settings.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/reversTeam/Sublivim/HEAD/vim/bundle/tube/autoload/tube/utils/settings.pyc -------------------------------------------------------------------------------- /vim/bundle/vim-go/t/fixtures/src/pkg1/sample_test.go: -------------------------------------------------------------------------------- 1 | package pkg1 2 | 3 | import "testing" 4 | 5 | func TestSample(t *testing.T) { 6 | Sample() 7 | } 8 | -------------------------------------------------------------------------------- /vim/bundle/vim-colors-solarized/bitmaps/togglebg.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/reversTeam/Sublivim/HEAD/vim/bundle/vim-colors-solarized/bitmaps/togglebg.png -------------------------------------------------------------------------------- /vim/bundle/vim-go/t/fixtures/src/buildfail/sample_test.go: -------------------------------------------------------------------------------- 1 | package pkg 2 | 3 | import "testing" 4 | 5 | func TestSample(t *testing.T) { 6 | Sample() 7 | } 8 | -------------------------------------------------------------------------------- /vim/bundle/vim-go/t/fixtures/src/parsefail/sample_test.go: -------------------------------------------------------------------------------- 1 | package pkg 2 | 3 | import "testing" 4 | 5 | func TestSample(t *testing.T) { 6 | Sample() 7 | } 8 | -------------------------------------------------------------------------------- /vim/bundle/twig/ftdetect/twig.vim: -------------------------------------------------------------------------------- 1 | " Twig 2 | autocmd BufNewFile,BufRead *.twig set filetype=twig 3 | 4 | " HTML Twig 5 | autocmd BufNewFile,BufRead *.html.twig set filetype=html.twig 6 | -------------------------------------------------------------------------------- /vim/bundle/vim-go/t/fixtures/src/failtest/sample_test.go: -------------------------------------------------------------------------------- 1 | package pkg 2 | 3 | import "testing" 4 | 5 | func TestSample(t *testing.T) { 6 | Sample() 7 | t.Fatal("itwillfail") 8 | } 9 | -------------------------------------------------------------------------------- /vim/bundle/vim-go/ftplugin/gohtmltmpl.vim: -------------------------------------------------------------------------------- 1 | if exists("b:did_ftplugin") 2 | finish 3 | endif 4 | let b:did_ftplugin = 1 5 | 6 | setlocal commentstring= 7 | 8 | " vim: sw=2 ts=2 et 9 | -------------------------------------------------------------------------------- /vim/bundle/vim-go/t/fixtures/src/buildtestfail/sample.go: -------------------------------------------------------------------------------- 1 | // set gopath before 2 | //go:generate go test --coverprofile=sample.out 3 | package pkg 4 | 5 | func Sample() int { 6 | return 1 7 | } 8 | -------------------------------------------------------------------------------- /vim/bundle/snippets/snippets/ledger.snippets: -------------------------------------------------------------------------------- 1 | # Ledger 2 | snippet ent 3 | `strftime("%Y/%m/%d")` ${1:transaction} 4 | ${2:account} ${3:value} 5 | ${0:account} 6 | -------------------------------------------------------------------------------- /vim/bundle/powerline/autoload/Powerline/Segments/ft_man.vim: -------------------------------------------------------------------------------- 1 | let g:Powerline#Segments#ft_man#segments = Pl#Segment#Init(['ft_man', 2 | \ Pl#Segment#Create('filename', '%{Powerline#Functions#ft_man#GetName()}') 3 | \ ]) 4 | -------------------------------------------------------------------------------- /vim/bundle/vim-go/t/fixtures/src/pkg1/sample.out: -------------------------------------------------------------------------------- 1 | mode: set 2 | pkg1/sample.go:5.19,6.11 1 1 3 | pkg1/sample.go:11.2,11.10 1 1 4 | pkg1/sample.go:6.11,8.3 1 0 5 | pkg1/sample.go:8.3,8.18 1 1 6 | pkg1/sample.go:8.18,10.3 1 0 7 | -------------------------------------------------------------------------------- /vim/bundle/Dockerfile/ftdetect/Dockerfile.vim: -------------------------------------------------------------------------------- 1 | " Dockerfile 2 | autocmd BufRead,BufNewFile Dockerfile set ft=Dockerfile 3 | autocmd BufRead,BufNewFile Dockerfile* setf Dockerfile 4 | autocmd BufRead,BufNewFile *.dock setf Dockerfile 5 | -------------------------------------------------------------------------------- /vim/bundle/snippets/UltiSnips/zsh.snippets: -------------------------------------------------------------------------------- 1 | snippet #! "shebang" ! 2 | #!/bin/zsh 3 | 4 | endsnippet 5 | 6 | snippet !env "#!/usr/bin/env (!env)" ! 7 | #!/usr/bin/env zsh 8 | 9 | endsnippet 10 | 11 | # vim:ft=snippets: 12 | -------------------------------------------------------------------------------- /vim/bundle/multiple-cursors/.travis.yml: -------------------------------------------------------------------------------- 1 | sudo: false 2 | language: ruby 3 | 4 | addons: 5 | apt: 6 | packages: 7 | - vim-gtk 8 | 9 | before_script: 10 | - "export DISPLAY=:99.0" 11 | - "sh -e /etc/init.d/xvfb start" 12 | -------------------------------------------------------------------------------- /vim/bundle/snippets/snippets/snippets.snippets: -------------------------------------------------------------------------------- 1 | # snippets for making snippets :) 2 | snippet snip 3 | snippet ${1:trigger} 4 | ${0} 5 | snippet msnip 6 | snippet ${1:trigger} ${2:description} 7 | ${0} 8 | snippet v 9 | {VISUAL} 10 | -------------------------------------------------------------------------------- /vim/bundle/powerline/autoload/Powerline/Segments/hgrev.vim: -------------------------------------------------------------------------------- 1 | let g:Powerline#Segments#hgrev#segments = Pl#Segment#Init(['hgrev', 2 | \ (exists('hgrev_loaded')), 3 | \ Pl#Segment#Create('branch', '%{Powerline#Functions#hgrev#Status("$BRANCH")}') 4 | \ ]) 5 | -------------------------------------------------------------------------------- /vim/bundle/snippets/UltiSnips/xml.snippets: -------------------------------------------------------------------------------- 1 | snippet t "Simple tag" b 2 | <${1:tag}> 3 | ${2:content} 4 | 5 | endsnippet 6 | 7 | snippet ti "Inline tag" b 8 | <${1:tag}>${2:content} 9 | endsnippet 10 | -------------------------------------------------------------------------------- /vim/bundle/vim-go/addon-info.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "vim-go", 3 | "description": "Full featured Go (golang) support for Vim.", 4 | "author": "Fatih Arslan ", 5 | "repository" : {"type": "git", "url": "https://github.com/fatih/vim-go.git"} 6 | } 7 | -------------------------------------------------------------------------------- /vim/bundle/vim-go/t/fixtures/src/failtest/sample.go: -------------------------------------------------------------------------------- 1 | // set gopath before 2 | //go:generate go test --coverprofile=sample.out 3 | package pkg 4 | 5 | func Sample() int { 6 | if false { 7 | return 0 8 | } else if false { 9 | return 0 10 | } 11 | return 1 12 | } 13 | -------------------------------------------------------------------------------- /vim/bundle/vim-go/t/fixtures/src/pkg1/sample.go: -------------------------------------------------------------------------------- 1 | // set gopath before 2 | //go:generate go test --coverprofile=sample.out 3 | package pkg1 4 | 5 | func Sample() int { 6 | if false { 7 | return 0 8 | } else if false { 9 | return 0 10 | } 11 | return 1 12 | } 13 | -------------------------------------------------------------------------------- /vim/bundle/snipmate/ftplugin/snippet.vim: -------------------------------------------------------------------------------- 1 | command! -buffer -range=% RetabSnip ,call snipMate#RetabSnip() 2 | vnoremap :RetabSnip 3 | 4 | if !exists('g:snippet_no_indentation_settings') 5 | setlocal sw=4 6 | setlocal tabstop=4 7 | setlocal noexpandtab 8 | endif 9 | -------------------------------------------------------------------------------- /vim/bundle/powerline/autoload/Powerline/Functions/fugitive.vim: -------------------------------------------------------------------------------- 1 | function! Powerline#Functions#fugitive#GetBranch(symbol) " {{{ 2 | let ret = fugitive#statusline() 3 | 4 | let ret = substitute(ret, '\c\v\[?GIT\(([a-z0-9\-_\./:]+)\)\]?', a:symbol .' \1', 'g') 5 | 6 | return ret 7 | endfunction " }}} 8 | -------------------------------------------------------------------------------- /vim/bundle/powerline/autoload/Powerline/Segments/fugitive.vim: -------------------------------------------------------------------------------- 1 | let g:Powerline#Segments#fugitive#segments = Pl#Segment#Init(['fugitive', 2 | \ (exists('g:loaded_fugitive') && g:loaded_fugitive == 1), 3 | \ 4 | \ Pl#Segment#Create('branch', '%{Powerline#Functions#fugitive#GetBranch("$BRANCH")}') 5 | \ ]) 6 | -------------------------------------------------------------------------------- /vim/bundle/powerline/autoload/Powerline/Segments/rvm.vim: -------------------------------------------------------------------------------- 1 | let g:Powerline#Segments#rvm#segments = Pl#Segment#Init(['rvm', 2 | \ (exists('g:loaded_rvm') && g:loaded_rvm == 1), 3 | \ 4 | \ Pl#Segment#Create('string', '%{rvm#string()}'), 5 | \ Pl#Segment#Create('statusline', '%{rvm#statusline()}') 6 | \ ]) 7 | -------------------------------------------------------------------------------- /vim/bundle/vim-go/Rakefile: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env rake 2 | 3 | task :ci => [:dump, :test] 4 | 5 | task :dump do 6 | sh 'vim --version' 7 | end 8 | 9 | # Firstly, `bundle install; bundle install --deployment` 10 | # Then, `rake test` 11 | task :test do 12 | sh 'bundle exec vim-flavor test' 13 | end 14 | -------------------------------------------------------------------------------- /vim/bundle/powerline/autoload/Powerline/Segments/virtualenv.vim: -------------------------------------------------------------------------------- 1 | let g:Powerline#Segments#virtualenv#segments = Pl#Segment#Init(['virtualenv', 2 | \ has('python') && (exists('g:virtualenv_loaded') && g:virtualenv_loaded == 1), 3 | \ 4 | \ Pl#Segment#Create('statusline', '%{virtualenv#statusline()}') 5 | \ ]) 6 | -------------------------------------------------------------------------------- /vim/bundle/gundo/README: -------------------------------------------------------------------------------- 1 | This is a mirror of http://www.vim.org/scripts/script.php?script_id=3304 2 | 3 | Gundo is a Vim plugin for visualizing your undo tree to make it usable. 4 | 5 | Go to the site for more information: http://sjl.bitbucket.org/gundo.vim/ 6 | 7 | Requirements: Vim 7.3+ with Python 2.4+ support. 8 | -------------------------------------------------------------------------------- /vim/bundle/multiple-cursors/Rakefile: -------------------------------------------------------------------------------- 1 | require 'rspec/core/rake_task' 2 | 3 | RSpec::Core::RakeTask.new(:spec) do |t| 4 | t.pattern = 'spec/multiple_cursors_spec.rb' 5 | end 6 | 7 | RSpec::Core::RakeTask.new(:benchmark) do |t| 8 | t.pattern = 'spec/benchmark_spec.rb' 9 | end 10 | 11 | task :default => :spec 12 | -------------------------------------------------------------------------------- /vim/bundle/snippets/snippets/dosini.snippets: -------------------------------------------------------------------------------- 1 | snippet ec 2 | ; http://editorconfig.org 3 | 4 | root = true 5 | 6 | [*] 7 | indent_style = ${1:space_or_tab} 8 | indent_size = ${2:indent_size} 9 | end_of_line = lf 10 | charset = utf-8 11 | trim_trailing_whitespace = true 12 | insert_final_newline = true 13 | -------------------------------------------------------------------------------- /vim/bundle/vim-go/syntax/vimgo.vim: -------------------------------------------------------------------------------- 1 | if exists("b:current_syntax") 2 | finish 3 | endif 4 | 5 | let b:current_syntax = "vimgo" 6 | 7 | syn match goInterface /^\S*/ 8 | syn region goTitle start="\%1l" end=":" 9 | 10 | hi def link goInterface Type 11 | hi def link goTitle Label 12 | 13 | " vim: sw=2 ts=2 et 14 | -------------------------------------------------------------------------------- /vim/bundle/addon_mw_utils/doc/cached_file_contents.txt: -------------------------------------------------------------------------------- 1 | *cached_file_contents* read contents of a file then cache extracted data 2 | Author: Marc Weber, marco-oweber@gmx.de 3 | 4 | ----------------------------------------------------------------------- 5 | HOWTO~ 6 | 7 | see cached_file_contents#Test() 8 | -------------------------------------------------------------------------------- /vim/bundle/addon_mw_utils/doc/tags: -------------------------------------------------------------------------------- 1 | cached_file_contents cached_file_contents.txt /*cached_file_contents* 2 | faked-function-reference funcref.txt /*faked-function-reference* 3 | funcref funcref.txt /*funcref* 4 | funcref#Call funcref.txt /*funcref#Call* 5 | funcref#Function funcref.txt /*funcref#Function* 6 | tiny-cmd tiny_cmd.txt /*tiny-cmd* 7 | -------------------------------------------------------------------------------- /vim/bundle/powerline/autoload/Powerline/Segments/syntastic.vim: -------------------------------------------------------------------------------- 1 | let g:Powerline#Segments#syntastic#segments = Pl#Segment#Init(['syntastic', 2 | \ (exists('g:loaded_syntastic_plugin') && g:loaded_syntastic_plugin == 1), 3 | \ 4 | \ Pl#Segment#Create('errors', '%{Powerline#Functions#syntastic#GetErrors("$LINE")}', Pl#Segment#Modes('!N')) 5 | \ ]) 6 | -------------------------------------------------------------------------------- /vim/bundle/snipmate/ftplugin/html_snip_helper.vim: -------------------------------------------------------------------------------- 1 | " Helper function for (x)html snippets 2 | if exists('s:did_snip_helper') || &cp || !exists('loaded_snips') 3 | finish 4 | endif 5 | let s:did_snip_helper = 1 6 | 7 | " Automatically closes tag if in xhtml 8 | fun! Close() 9 | return stridx(&ft, 'xhtml') == -1 ? '' : ' /' 10 | endf 11 | -------------------------------------------------------------------------------- /vim/bundle/vim-go/syntax/gohtmltmpl.vim: -------------------------------------------------------------------------------- 1 | if exists("b:current_syntax") 2 | finish 3 | endif 4 | 5 | if !exists("main_syntax") 6 | let main_syntax = 'html' 7 | endif 8 | 9 | runtime! syntax/gotexttmpl.vim 10 | runtime! syntax/html.vim 11 | unlet b:current_syntax 12 | 13 | let b:current_syntax = "gohtmltmpl" 14 | 15 | " vim: sw=2 ts=2 et 16 | -------------------------------------------------------------------------------- /vim/bundle/snippets/UltiSnips/json.snippets: -------------------------------------------------------------------------------- 1 | snippet s "String" b 2 | "${1:key}": "${0:value}", 3 | endsnippet 4 | 5 | snippet n "number" b 6 | "${1:key}": ${0:value}, 7 | endsnippet 8 | 9 | snippet a "Array" b 10 | [ 11 | ${VISUAL}$0 12 | ], 13 | endsnippet 14 | snippet o "Object" b 15 | { 16 | ${VISUAL}$0 17 | }, 18 | endsnippet 19 | 20 | -------------------------------------------------------------------------------- /vim/bundle/snippets/addon-info.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "snipmate-snippets", 3 | "author" : "community", 4 | "maintainer" : "honza @ github & others", 5 | "repository" : {"type": "git", "url": "git://github.com/honza/snipmate-snippets.git"}, 6 | "dependencies" : { 7 | }, 8 | "description" : "community driven set of snippets for snipmate" 9 | } 10 | -------------------------------------------------------------------------------- /vim/bundle/powerline/autoload/Powerline/Functions/ft_man.vim: -------------------------------------------------------------------------------- 1 | function! Powerline#Functions#ft_man#GetName() " {{{ 2 | let matches = matchlist(getline(1), '\v^([a-zA-Z_\.\-]+)\((\d+)\)') 3 | 4 | if ! len(matches) 5 | return 'n/a' 6 | endif 7 | 8 | let file = tolower(matches[1]) 9 | let num = matches[2] 10 | 11 | return file 12 | endfunction " }}} 13 | -------------------------------------------------------------------------------- /vim/bundle/powerline/autoload/Powerline/Segments/tagbar.vim: -------------------------------------------------------------------------------- 1 | let g:Powerline#Segments#tagbar#segments = Pl#Segment#Init(['tagbar', 2 | \ (exists(':Tagbar') > 0), 3 | \ 4 | \ Pl#Segment#Create('currenttag', '%{tagbar#currenttag("%s", "")}', Pl#Segment#Modes('!N')), 5 | \ Pl#Segment#Create('fullcurrenttag', '%{tagbar#currenttag("%s", "", "f")}', Pl#Segment#Modes('!N')) 6 | \ ]) 7 | -------------------------------------------------------------------------------- /vim/bundle/tlib/addon-info.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "tlib", 3 | "version" : "dev", 4 | "author" : "Tom Link ", 5 | "maintainer" : "Tom Link ", 6 | "repository" : {"type": "git", "url": "git://github.com/tomtom/tlib_vim.git"}, 7 | "dependencies" : {}, 8 | "description" : "A library of vim functions" 9 | } 10 | -------------------------------------------------------------------------------- /vim/bundle/tlib/autoload/tlib.vim: -------------------------------------------------------------------------------- 1 | " tlib.vim 2 | " @Author: Tom Link (micathom AT gmail com?subject=[vim]) 3 | " @Website: http://www.vim.org/account/profile.php?user_id=4037 4 | " @License: GPL (see http://www.gnu.org/licenses/gpl.txt) 5 | " @Created: 2007-07-17. 6 | " @Last Change: 2013-09-25. 7 | " @Revision: 0.0.12 8 | 9 | " :nodefault: 10 | TLet g:tlib#debug = 0 11 | 12 | -------------------------------------------------------------------------------- /vim/bundle/twig/vim-twig-addon-info.txt: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "vim-twig", 3 | "version" : "0.1", 4 | "author" : "F. Gabriel Gosselin ", 5 | "maintainer" : "F. Gabriel Gosselin ", 6 | "repository": { "type" : "git", "url" : "git://github.com/beyondwords/vim-twig.git"}, 7 | "dependencies" : {}, 8 | "description" : "Support Twig template language" 9 | } 10 | -------------------------------------------------------------------------------- /vim/bundle/tube/autoload/tube/utils/v.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | tube.utils.v 4 | ~~~~~~~~~~~~ 5 | 6 | This module defines thin wrappers around vim commands and functions. 7 | """ 8 | 9 | import vim 10 | 11 | 12 | def echo(msg): 13 | """Display a simple feedback to the user via the command line.""" 14 | vim.command('echom "[tube] {0}"'.format(msg.replace('"', '\"'))) 15 | 16 | 17 | -------------------------------------------------------------------------------- /uninstall: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | 3 | SHELL_ACTIVE="${HOME}/.$(basename $SHELL)rc" 4 | 5 | cd ~ 6 | rm -rf .vimrc 7 | rm -rf .vim 8 | rm -rf .Sublivim 9 | 10 | if [ -f "$HOME/old-conf-vim.tar" ]; then 11 | tar -xf old-conf-vim.tar 12 | fi 13 | 14 | cat $SHELL_ACTIVE | grep -v ".Sublivim/sublivimrc.sh" > "${SHELL_ACTIVE}_tmp" 15 | mv "${SHELL_ACTIVE}_tmp" "${SHELL_ACTIVE}" 16 | 17 | cd - > /dev/null 2> /dev/null 18 | -------------------------------------------------------------------------------- /vim/bundle/tlib/autoload/tlib/autocmdgroup.vim: -------------------------------------------------------------------------------- 1 | " autocmdgroup.vim 2 | " @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim]) 3 | " @Website: http://www.vim.org/account/profile.php?user_id=4037 4 | " @License: GPL (see http://www.gnu.org/licenses/gpl.txt) 5 | " @Revision: 7 6 | 7 | augroup TLib 8 | autocmd! 9 | augroup END 10 | 11 | 12 | function! tlib#autocmdgroup#Init() "{{{3 13 | endf 14 | 15 | -------------------------------------------------------------------------------- /vim/bundle/tlib/autoload/tlib/fixes.vim: -------------------------------------------------------------------------------- 1 | " @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim]) 2 | " @License: GPL (see http://www.gnu.org/licenses/gpl.txt) 3 | " @Last Change: 2013-02-22. 4 | " @Revision: 3 5 | 6 | 7 | function! tlib#fixes#Winpos() "{{{3 8 | if has('gui_win32') 9 | return 'winpos '. getwinposx() .' '. getwinposy() 10 | else 11 | return '' 12 | endif 13 | endf 14 | 15 | -------------------------------------------------------------------------------- /vim/bundle/addon_mw_utils/autoload/tiny_cmd.vim: -------------------------------------------------------------------------------- 1 | " vim suffers: 2 | 3 | exec vam#DefineAndBind('s:c','g:vim_tiny_cmd', '{}') 4 | 5 | fun! tiny_cmd#Put(a) 6 | let new = get(s:c,'next',0) +1 7 | let s:c['next'] = new 8 | let s:c[new] = a:a 9 | return new 10 | endf 11 | 12 | fun! tiny_cmd#Get(nr) 13 | return s:c[a:nr] 14 | endf 15 | 16 | " Get and remove item 17 | fun! tiny_cmd#Pop(nr) 18 | let r = s:c[a:nr] | unlet s:c[a:nr] | return r 19 | endf 20 | -------------------------------------------------------------------------------- /vim/bundle/vim-go/ftplugin/asm.vim: -------------------------------------------------------------------------------- 1 | " asm.vim: Vim filetype plugin for Go assembler. 2 | 3 | if exists("b:did_ftplugin") 4 | finish 5 | endif 6 | let b:did_ftplugin = 1 7 | 8 | let b:undo_ftplugin = "setl fo< com< cms<" 9 | 10 | setlocal formatoptions-=t 11 | 12 | setlocal comments=s1:/*,mb:*,ex:*/,:// 13 | setlocal commentstring=//\ %s 14 | 15 | setlocal noexpandtab 16 | 17 | command! -nargs=0 AsmFmt call go#asmfmt#Format() 18 | 19 | " vim: sw=2 ts=2 et 20 | -------------------------------------------------------------------------------- /vim/bundle/Dockerfile/Makefile: -------------------------------------------------------------------------------- 1 | install: 2 | @echo "Installation:" 3 | @mkdir -p ~/.vim/syntax 4 | @mkdir -p ~/.vim/ftdetect 5 | @mkdir -p ~/.vim/snippets 6 | @echo " * Dirs ... success." 7 | @cp ./syntax/Dockerfile.vim ~/.vim/syntax/ 8 | @echo " * Syntax ... success." 9 | @cp ./ftdetect/Dockerfile.vim ~/.vim/ftdetect/ 10 | @echo " * Filetype ... success." 11 | @cp ./snippets/Dockerfile.snippets ~/.vim/snippets/ 12 | @echo " * Snippets ... success." 13 | -------------------------------------------------------------------------------- /vim/bundle/vim-go/t/fixtures/src/buildtestfail/sample_test.go: -------------------------------------------------------------------------------- 1 | // go1.5.3 example output: 2 | // GOPATH=`pwd`/fixtures go test --coverprofile=log.out buildtestfail 3 | // # buildtestfail 4 | // fixtures/src/buildtestfail/sample_test.go:14: undefined: IT_SHOULD_BE_BUILD_FAILED 5 | // FAIL buildtestfail [build failed] 6 | // echo $? 7 | // 2 8 | 9 | package pkg 10 | 11 | import "testing" 12 | 13 | func TestSample(t *testing.T) { 14 | IT_SHOULD_BE_BUILD_FAILED 15 | } 16 | -------------------------------------------------------------------------------- /vim/bundle/addon_mw_utils/vim-addon-mw-utils-addon-info.txt: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "vim-addon-mw-utils", 3 | "version" : "0.0", 4 | "author" : "Marc Weber ", 5 | "maintainer" : "Marc Weber ", 6 | "repository" : {"type": "git", "url": "git://github.com/MarcWeber/vim-addon-manager-known-repositories.git"}, 7 | "dependencies" : {}, 8 | "description" : "various utils such as caching interpreted contents of files or advanced glob like things" 9 | } 10 | -------------------------------------------------------------------------------- /vim/bundle/snippets/snippets/lua.snippets: -------------------------------------------------------------------------------- 1 | snippet #! 2 | #!/usr/bin/env lua 3 | $1 4 | snippet local 5 | local ${1:x} = ${0:1} 6 | snippet fun 7 | function ${1:fname}(${2:...}) 8 | ${0:-- body} 9 | end 10 | snippet for 11 | for ${1:i}=${2:1},${3:10} do 12 | ${0:print(i)} 13 | end 14 | snippet forp 15 | for ${1:i},${2:v} in pairs(${3:table_name}) do 16 | ${0:-- body} 17 | end 18 | snippet fori 19 | for ${1:i},${2:v} in ipairs(${3:table_name}) do 20 | ${0:-- body} 21 | end 22 | -------------------------------------------------------------------------------- /vim/bundle/snippets/snippets/diff.snippets: -------------------------------------------------------------------------------- 1 | # DEP-3 (http://dep.debian.net/deps/dep3/) style patch header 2 | snippet header DEP-3 style header 3 | Description: ${1} 4 | Origin: ${2:vendor|upstream|other}, ${3:url of the original patch} 5 | Bug: ${4:url in upstream bugtracker} 6 | Forwarded: ${5:no|not-needed|url} 7 | Author: ${6:`g:snips_author`} 8 | Reviewed-by: ${7:name and email} 9 | Last-Update: ${8:`strftime("%Y-%m-%d")`} 10 | Applied-Upstream: ${0:upstream version|url|commit} 11 | 12 | -------------------------------------------------------------------------------- /vim/bundle/tube/autoload/applescript/terminal.scpt: -------------------------------------------------------------------------------- 1 | -- execute_terminal.scpt 2 | -- last change: 19 Jan 2013 3 | --- 4 | -- this script require an argument that represent the command to execute 5 | 6 | on run argv 7 | 8 | set command to (item 1 of argv) 9 | 10 | tell application "Terminal" 11 | activate 12 | 13 | -- execute the command 14 | do script command in window 1 15 | 16 | end tell 17 | 18 | tell application "MacVim" to activate 19 | 20 | end run 21 | -------------------------------------------------------------------------------- /vim/bundle/twig/ftplugin/twig.vim: -------------------------------------------------------------------------------- 1 | " Vim filetype plugin 2 | " Language: Twig 3 | " Maintainer: F. Gabriel Gosselin 4 | 5 | if exists("b:did_ftplugin") 6 | finish 7 | endif 8 | 9 | runtime! ftplugin/html.vim ftplugin/html*.vim ftplugin/html/*.vim 10 | unlet! b:did_ftplugin 11 | 12 | setlocal comments=s:{#,ex:#} 13 | setlocal formatoptions+=tcqln 14 | " setlocal formatlistpat=^\\s*\\d\\+\\.\\s\\+\\\|^[-*+]\\s\\+ 15 | 16 | let b:undo_ftplugin .= "|setl cms< com< fo<" 17 | 18 | " vim:set sw=2: 19 | -------------------------------------------------------------------------------- /vim/bundle/snipmate/syntax/snippet.vim: -------------------------------------------------------------------------------- 1 | " Syntax highlighting for .snippet files (used for snipMate.vim) 2 | " Hopefully this should make snippets a bit nicer to write! 3 | syn match placeHolder '\${\d\+\(:.\{-}\)\=}' contains=snipCommand 4 | syn match tabStop '\$\d\+' 5 | syn match snipEscape '\\\\\|\\`' 6 | syn match snipCommand '\%(\\\@ 5 | 6 | Everyone is permitted to copy and distribute verbatim or modified 7 | copies of this license document, and changing it is allowed as long 8 | as the name is changed. 9 | 10 | DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE 11 | TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 12 | 13 | 0. You just DO WHAT THE FUCK YOU WANT TO. 14 | -------------------------------------------------------------------------------- /vim/bundle/multiple-cursors/CONTRIBUTING.md: -------------------------------------------------------------------------------- 1 | # Problems summary 2 | 3 | ## Expected 4 | 5 | ## Environment Information 6 | * OS: 7 | * Neovim/Vim/Gvim version: 8 | 9 | ## Provide a minimal .vimrc with less than 50 lines 10 | 11 | " Your minimal.vimrc 12 | 13 | ## Generate a logfile if appropriate 14 | 15 | 1. export NVIM_PYTHON_LOG_FILE=/tmp/log 16 | 2. export NVIM_PYTHON_LOG_LEVEL=DEBUG 17 | 3. nvim -u minimal.vimrc 18 | 4. recreate your issue 19 | 5. cat /tmp/log_{PID} 20 | 21 | ## Screen shot (if possible) 22 | 23 | ## Upload the log file 24 | -------------------------------------------------------------------------------- /vim/bundle/numbers-vim/doc/tags: -------------------------------------------------------------------------------- 1 | :NumbersDisable numbers.txt /*:NumbersDisable* 2 | :NumbersEnable numbers.txt /*:NumbersEnable* 3 | :NumbersOnOff numbers.txt /*:NumbersOnOff* 4 | :NumbersToggle numbers.txt /*:NumbersToggle* 5 | g:enable_numbers numbers.txt /*g:enable_numbers* 6 | numbers numbers.txt /*numbers* 7 | numbers-commands numbers.txt /*numbers-commands* 8 | numbers-configuration numbers.txt /*numbers-configuration* 9 | numbers-credits numbers.txt /*numbers-credits* 10 | numbers-intro numbers.txt /*numbers-intro* 11 | numbers.txt numbers.txt /*numbers.txt* 12 | -------------------------------------------------------------------------------- /vim/bundle/vim-go/t/fixtures/src/buildfail/sample.go: -------------------------------------------------------------------------------- 1 | // set gopath before 2 | //go:generate go test --coverprofile=sample.out 3 | // go1.5.3 example output: 4 | // GOPATH=`pwd`/fixtures go test --coverprofile=log.out buildfail 5 | // # buildfail 6 | // /tmp/go-build264733986/buildfail/_test/_obj_test/sample.go:7: undefined: IT_SHOULD_BE_BUILD_FAILED 7 | // /tmp/go-build264733986/buildfail/_test/_obj_test/sample.go:8: missing return at end of function 8 | // FAIL buildfail [build failed] 9 | package pkg 10 | 11 | func Sample() int { 12 | IT_SHOULD_BE_BUILD_FAILED 13 | } 14 | -------------------------------------------------------------------------------- /vim/bundle/powerline/autoload/Powerline/Functions/hgrev.vim: -------------------------------------------------------------------------------- 1 | function! Powerline#Functions#hgrev#Status(symbol) " {{{ 2 | if ! exists('*HGRev') 3 | " HGRev hasn't been loaded yet 4 | return '' 5 | endif 6 | if !exists("b:statusline_hg_status") 7 | silent execute "RefreshMercurialRev" 8 | endif 9 | let b:statusline_hg_status=HGRev() 10 | if b:statusline_hg_status != '-' 11 | let ret = "\u26A1". '' . substitute(b:statusline_hg_status, '^[^ ]*', '\1', 'g') 12 | let ret=substitute(ret,' M$','+','g') 13 | else 14 | let ret='' 15 | endif 16 | return ret 17 | endfunction " }}} 18 | -------------------------------------------------------------------------------- /vim/bundle/tlib/autoload/tinykeymap/map/para_move.vim: -------------------------------------------------------------------------------- 1 | " para_move.vim 2 | " @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim]) 3 | " @License: GPL (see http://www.gnu.org/licenses/gpl.txt) 4 | " @Created: 2012-08-28. 5 | " @Last Change: 2012-08-29. 6 | " @Revision: 3 7 | 8 | " Move paragraphs 9 | call tinykeymap#EnterMap("para_move", "gp", {'name': 'move paragraph'}) 10 | call tinykeymap#Map("para_move", "j", "silent call tlib#paragraph#Move('Down', '')") 11 | call tinykeymap#Map("para_move", "k", "silent call tlib#paragraph#Move('Up', '')") 12 | 13 | -------------------------------------------------------------------------------- /vim/bundle/addon_mw_utils/autoload/env_reload.vim: -------------------------------------------------------------------------------- 1 | " in sh/bash you can type export to get a list of environment variables 2 | " This function assigns those env vars to Vim. 3 | " Does not delete env vars yet 4 | " Example: env_reload#ReloadEnv(system("sh -c 'export'") 5 | fun! env_reload#ReloadEnv(bash_export_command_output) 6 | for i in split(a:bash_export_command_output,"\n") 7 | let m = matchlist(i, 'export \([^=]\+\)="\(.*\)"') 8 | if empty(m) | continue | endif 9 | " don't care about quoted values right now. 10 | exec 'let $'.m[1].'='.string(m[2]) 11 | endfor 12 | endf 13 | -------------------------------------------------------------------------------- /vim/bundle/snipmate/addon-info.json: -------------------------------------------------------------------------------- 1 | { 2 | "name" : "snipMate", 3 | "version" : "dev", 4 | "author" : "Michael Sanders -> original project http://github.com/msanders/snipmate.vim", 5 | "maintainer" : "Rok Garbas / Marc Weber", 6 | "repository" : {"type": "git", "url": "git://github.com/garbas/vim-snipmate.git"}, 7 | "dependencies" : { 8 | "vim-addon-mw-utils": {}, 9 | "tlib": {} 10 | }, 11 | "description" : "snipMate.vim aims to be a concise vim script that implements some of TextMate's snippets features in Vim. See README.md to learn about the features this fork adds" 12 | } 13 | -------------------------------------------------------------------------------- /vim/bundle/powerline/autoload/Powerline/Functions/syntastic.vim: -------------------------------------------------------------------------------- 1 | function! Powerline#Functions#syntastic#GetErrors(line_symbol) " {{{ 2 | if ! exists('g:syntastic_stl_format') 3 | " Syntastic hasn't been loaded yet 4 | return '' 5 | endif 6 | 7 | " Temporarily change syntastic output format 8 | let old_stl_format = g:syntastic_stl_format 9 | let g:syntastic_stl_format = '%E{ ERRORS (%e) '. a:line_symbol .' %fe }%W{ WARNINGS (%w) '. a:line_symbol .' %fw }' 10 | 11 | let ret = SyntasticStatuslineFlag() 12 | 13 | let g:syntastic_stl_format = old_stl_format 14 | 15 | return ret 16 | endfunction " }}} 17 | -------------------------------------------------------------------------------- /vim/bundle/twig/README.markdown: -------------------------------------------------------------------------------- 1 | # vim-twig 2 | 3 | ## About 4 | Supports Twig PHP templates [http://www.twig-project.org/][1] 5 | 6 | Based on Jinja2 syntax highlighting by [Armin Ronacher][2] 7 | 8 | ----- 9 | ## Installation 10 | 11 | This scripts bundles is compatible with [vim-addon-manager][3] 12 | 13 | ## Changes 14 | ### 2011-07-29 15 | - Re-based the syntax highlighting to properly support all tags 16 | - Added support for .html.twig files 17 | 18 | [1]: http://www.twig-project.org/ 19 | [2]: http://www.vim.org/scripts/script.php?script_id=1856 20 | [3]: https://github.com/MarcWeber/vim-addon-manager 21 | -------------------------------------------------------------------------------- /vim/bundle/vim-go/t/fixtures/src/parsefail/sample.go: -------------------------------------------------------------------------------- 1 | // set gopath before 2 | //go:generate go test --coverprofile=sample.out 3 | // go1.5.3 example output: 4 | // GOPATH=`pwd`/fixtures go test --coverprofile=log.out parsefail 5 | // # cover parsefail 6 | // 2016/01/17 23:59:08 cover: /home/sey/vimfiles/_vim/bundle/vim-go-coverlay/t/fixtures/src/parsefail/sample.go: /home/sey/vimfiles/_vim/bundle/vim-go-coverlay/t/fixtures/src/parsefail/sample.go:10:1: expected declaration, found 'IDENT' PARSEFAIL 7 | // FAIL parsefail [build failed] 8 | // echo $? 9 | // 2 10 | package pkg 11 | 12 | PARSEFAIL Sample() int { 13 | return 0 14 | } 15 | -------------------------------------------------------------------------------- /vim/bundle/snippets/UltiSnips/snippets.snippets: -------------------------------------------------------------------------------- 1 | ######################### 2 | # SNIPPETS for SNIPPETS # 3 | ######################### 4 | 5 | # We use a little hack so that the snippet is expanded 6 | # and parsed correctly 7 | snippet snip "Snippet definition" ! 8 | `!p snip.rv = "snippet"` ${1:Tab_trigger} "${2:Description}" ${3:!b} 9 | $0 10 | `!p snip.rv = "endsnippet"` 11 | endsnippet 12 | 13 | snippet global "Global snippet" ! 14 | `!p snip.rv = "global"` !p 15 | $0 16 | `!p snip.rv = "endglobal"` 17 | endsnippet 18 | 19 | snippet vis "${VISUAL}" i 20 | \$\{VISUAL${1:${2:default}${3:/transform/}}\} 21 | endsnippet 22 | 23 | # vim:ft=snippets: 24 | -------------------------------------------------------------------------------- /vim/bundle/surround/doc/tags: -------------------------------------------------------------------------------- 1 | cs surround.txt /*cs* 2 | ds surround.txt /*ds* 3 | i_CTRL-G_S surround.txt /*i_CTRL-G_S* 4 | i_CTRL-G_s surround.txt /*i_CTRL-G_s* 5 | surround surround.txt /*surround* 6 | surround-customizing surround.txt /*surround-customizing* 7 | surround-issues surround.txt /*surround-issues* 8 | surround-mappings surround.txt /*surround-mappings* 9 | surround-replacements surround.txt /*surround-replacements* 10 | surround-targets surround.txt /*surround-targets* 11 | surround.txt surround.txt /*surround.txt* 12 | vS surround.txt /*vS* 13 | vgS surround.txt /*vgS* 14 | yS surround.txt /*yS* 15 | ySS surround.txt /*ySS* 16 | ys surround.txt /*ys* 17 | yss surround.txt /*yss* 18 | -------------------------------------------------------------------------------- /swipe_lines.vimrc: -------------------------------------------------------------------------------- 1 | function! s:swap_lines(n1, n2) 2 | let line1 = getline(a:n1) 3 | let line2 = getline(a:n2) 4 | call setline(a:n1, line2) 5 | call setline(a:n2, line1) 6 | endfunction 7 | 8 | function! s:swap_up() 9 | let n = line('.') 10 | if n == 1 11 | return 12 | endif 13 | 14 | call s:swap_lines(n, n - 1) 15 | exec n - 1 16 | endfunction 17 | 18 | function! s:swap_down() 19 | let n = line('.') 20 | if n == line('$') 21 | return 22 | endif 23 | 24 | call s:swap_lines(n, n + 1) 25 | exec n + 1 26 | endfunction 27 | 28 | noremap :call swap_up() 29 | noremap :call swap_down() 30 | -------------------------------------------------------------------------------- /vim/bundle/addon_mw_utils/doc/tiny_cmd.txt: -------------------------------------------------------------------------------- 1 | *tiny-cmd* make long commands short so that they hopefully no longer trigger "press Enter .. [ok]" 2 | Author: Marc Weber, marco-oweber@gmx.de 3 | 4 | ----------------------------------------------------------------------- 5 | HOWTO~ 6 | 7 | Problem: > 8 | exec 'map :silent! let g:g="'.repeat('foobar ',200).'"' 9 | Now run the mapping by pressing and you notice what I'm talking about 10 | 11 | Solution (Example): 12 | 13 | 14 | Example usage: > 15 | let nr = tiny_cmd#Put('let g:g="'.repeat('foobar ',200).'"') 16 | exec 'map :exec tiny_cmd#Get('.nr.')' 17 | < 18 | Use Pop instead of Get if you use this command once only 19 | -------------------------------------------------------------------------------- /vim/vimrc.tiny: -------------------------------------------------------------------------------- 1 | " Vim configuration file, in effect when invoked as "vi". The aim of this 2 | " configuration file is to provide a Vim environment as compatible with the 3 | " original vi as possible. Note that ~/.vimrc configuration files as other 4 | " configuration files in the runtimepath are still sourced. 5 | " When Vim is invoked differently ("vim", "view", "evim", ...) this file is 6 | " _not_ sourced; /etc/vim/vimrc and/or /etc/vim/gvimrc are. 7 | 8 | " Debian system-wide default configuration Vim 9 | set runtimepath=~/.vim,/var/lib/vim/addons,/usr/share/vim/vimfiles,/usr/share/vim/vim73,/usr/share/vim/vimfiles/after,/var/lib/vim/addons/after,~/.vim/after 10 | 11 | set compatible 12 | 13 | " vim: set ft=vim: 14 | -------------------------------------------------------------------------------- /vim/bundle/tlib/autoload/tlib/map.vim: -------------------------------------------------------------------------------- 1 | " map.vim 2 | " @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim]) 3 | " @Website: http://www.vim.org/account/profile.php?user_id=4037 4 | " @License: GPL (see http://www.gnu.org/licenses/gpl.txt) 5 | " @Created: 2009-08-23. 6 | " @Last Change: 2009-08-23. 7 | " @Revision: 0.0.4 8 | 9 | let s:save_cpo = &cpo 10 | set cpo&vim 11 | 12 | 13 | " If |pumvisible()| is true, return "\". Otherwise return a:key. 14 | " For use in maps like: > 15 | " imap tlib#map#PumAccept("\") 16 | function! tlib#map#PumAccept(key) "{{{3 17 | return pumvisible() ? "\" : a:key 18 | endf 19 | 20 | 21 | 22 | let &cpo = s:save_cpo 23 | unlet s:save_cpo 24 | -------------------------------------------------------------------------------- /vim/bundle/multiple-cursors/Gemfile.lock: -------------------------------------------------------------------------------- 1 | GEM 2 | remote: https://rubygems.org/ 3 | specs: 4 | diff-lcs (1.2.5) 5 | rake (12.3.3) 6 | rspec (3.4.0) 7 | rspec-core (~> 3.4.0) 8 | rspec-expectations (~> 3.4.0) 9 | rspec-mocks (~> 3.4.0) 10 | rspec-core (3.4.1) 11 | rspec-support (~> 3.4.0) 12 | rspec-expectations (3.4.0) 13 | diff-lcs (>= 1.2.0, < 2.0) 14 | rspec-support (~> 3.4.0) 15 | rspec-mocks (3.4.0) 16 | diff-lcs (>= 1.2.0, < 2.0) 17 | rspec-support (~> 3.4.0) 18 | rspec-support (3.4.1) 19 | vimrunner (0.3.1) 20 | 21 | PLATFORMS 22 | ruby 23 | 24 | DEPENDENCIES 25 | rake 26 | rspec 27 | vimrunner 28 | 29 | BUNDLED WITH 30 | 1.10.6 31 | -------------------------------------------------------------------------------- /vim/bundle/snippets/UltiSnips/twig.snippets: -------------------------------------------------------------------------------- 1 | snippet bl "twig block" b 2 | {% block ${1} %} 3 | ${2} 4 | {% endblock $1 %} 5 | endsnippet 6 | 7 | snippet js "twig javascripts" b 8 | {% javascripts '${1}' %} 9 | 10 | {% endjavascripts %} 11 | endsnippet 12 | 13 | snippet css "twig stylesheets" b 14 | {% stylesheets '${1}' %} 15 | 16 | {% endstylesheets %} 17 | endsnippet 18 | 19 | snippet if "twig if" b 20 | {% if ${1} %} 21 | ${2} 22 | {% endif %} 23 | endsnippet 24 | 25 | snippet for "twig for" b 26 | {% for ${1} in ${2} %} 27 | ${3} 28 | {% endfor %} 29 | endsnippet 30 | 31 | snippet ext "twig extends" b 32 | {% extends ${1} %} 33 | endsnippet 34 | -------------------------------------------------------------------------------- /vim/bundle/snippets/UltiSnips/php/phpunit.snippets: -------------------------------------------------------------------------------- 1 | # sugguestion? report bugs? 2 | # please go to https://github.com/chrisyue/vim-snippets/issues 3 | snippet test "phpunit test class" b 4 | namespace `!p 5 | abspath = os.path.abspath(path) 6 | m = re.search(r'[A-Z].+(?=/)', abspath) 7 | if m: 8 | snip.rv = m.group().replace('/', '\\') 9 | `; 10 | 11 | /** 12 | * @author `whoami` 13 | */ 14 | class `!p 15 | snip.rv = re.match(r'.*(?=\.)', fn).group() 16 | ` extends \PHPUnit_Framework_TestCase 17 | { 18 | public function test${1}() 19 | { 20 | ${2} 21 | } 22 | } 23 | endsnippet 24 | 25 | snippet exp "phpunit expects" i 26 | expects($this->${1:once}()) 27 | ->method('${2}') 28 | ->with($this->equalTo(${3})${4}) 29 | ->will($this->returnValue(${5})); 30 | endsnippet 31 | -------------------------------------------------------------------------------- /vim/bundle/tube/autoload/applescript/iterm.scpt: -------------------------------------------------------------------------------- 1 | -- execute_iterm.scpt 2 | -- last change: 19 Jan 2013 3 | --- 4 | -- this script require an argument that represent the command to execute 5 | 6 | on run argv 7 | 8 | set command to (item 1 of argv) 9 | 10 | tell application "iTerm" 11 | 12 | try 13 | set mysession to current session of current terminal 14 | on error 15 | set myterm to (make new terminal) 16 | tell myterm 17 | launch session "Default" 18 | set mysession to current session 19 | end tell 20 | end try 21 | 22 | -- execute the command 23 | tell mysession 24 | write text command 25 | end tell 26 | 27 | end tell 28 | 29 | end run 30 | -------------------------------------------------------------------------------- /vim/bundle/tlib/autoload/tlib/type.vim: -------------------------------------------------------------------------------- 1 | " type.vim 2 | " @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim]) 3 | " @Website: http://www.vim.org/account/profile.php?user_id=4037 4 | " @License: GPL (see http://www.gnu.org/licenses/gpl.txt) 5 | " @Created: 2007-09-30. 6 | " @Last Change: 2010-09-27. 7 | " @Revision: 0.0.4 8 | 9 | function! tlib#type#IsNumber(expr) 10 | return type(a:expr) == 0 11 | endf 12 | 13 | function! tlib#type#IsString(expr) 14 | return type(a:expr) == 1 15 | endf 16 | 17 | function! tlib#type#IsFuncref(expr) 18 | return type(a:expr) == 2 19 | endf 20 | 21 | function! tlib#type#IsList(expr) 22 | return type(a:expr) == 3 23 | endf 24 | 25 | function! tlib#type#IsDictionary(expr) 26 | return type(a:expr) == 4 27 | endf 28 | 29 | 30 | -------------------------------------------------------------------------------- /vim/bundle/tlib/autoload/tlib/Test.vim: -------------------------------------------------------------------------------- 1 | " Test.vim -- A test class 2 | " @Author: Tom Link (micathom AT gmail com?subject=[vim]) 3 | " @Website: http://www.vim.org/account/profile.php?user_id=4037 4 | " @License: GPL (see http://www.gnu.org/licenses/gpl.txt) 5 | " @Created: 2007-05-01. 6 | " @Last Change: 2010-09-05. 7 | " @Revision: 0.1.10 8 | 9 | " :enddoc: 10 | 11 | if &cp || exists("loaded_tlib_Test_autoload") 12 | finish 13 | endif 14 | let loaded_tlib_Test_autoload = 1 15 | 16 | 17 | let s:prototype = tlib#Object#New({'_class': ['Test']}) "{{{2 18 | function! tlib#Test#New(...) "{{{3 19 | let object = s:prototype.New(a:0 >= 1 ? a:1 : {}) 20 | return object 21 | endf 22 | 23 | 24 | function! s:prototype.Dummy() dict "{{{3 25 | return 'Test.vim' 26 | endf 27 | 28 | -------------------------------------------------------------------------------- /vim/bundle/tlib/autoload/tlib/TestChild.vim: -------------------------------------------------------------------------------- 1 | " TestChild.vim 2 | " @Author: Tom Link (micathom AT gmail com?subject=[vim]) 3 | " @Website: http://www.vim.org/account/profile.php?user_id=4037 4 | " @License: GPL (see http://www.gnu.org/licenses/gpl.txt) 5 | " @Created: 2007-05-18. 6 | " @Last Change: 2010-09-05. 7 | " @Revision: 0.1.14 8 | 9 | " :enddoc: 10 | 11 | if &cp || exists("loaded_tlib_TestChild_autoload") 12 | finish 13 | endif 14 | let loaded_tlib_TestChild_autoload = 1 15 | 16 | 17 | let s:prototype = tlib#Test#New({'_class': ['TestChild']}) "{{{2 18 | function! tlib#TestChild#New(...) "{{{3 19 | let object = s:prototype.New(a:0 >= 1 ? a:1 : {}) 20 | return object 21 | endf 22 | 23 | 24 | function! s:prototype.Dummy() dict "{{{3 25 | return 'TestChild.vim' 26 | endf 27 | 28 | -------------------------------------------------------------------------------- /vim/bundle/snippets/UltiSnips/help.snippets: -------------------------------------------------------------------------------- 1 | # Snippets for VIM Help Files 2 | 3 | global !p 4 | def sec_title(snip, t): 5 | file_start = snip.fn.split('.')[0] 6 | sec_name = t[1].strip("1234567890. ").lower().replace(' ', '-') 7 | return ("*%s-%s*" % (file_start, sec_name)).rjust(78-len(t[1])) 8 | endglobal 9 | 10 | snippet sec "Section marker" b 11 | ============================================================================== 12 | ${1:SECTION}`!p snip.rv = sec_title(snip, t)` 13 | 14 | $0 15 | endsnippet 16 | 17 | snippet ssec "Sub section marker" b 18 | ${1:Subsection}`!p snip.rv = sec_title(snip, t) 19 | snip += "-"*len(t[1])` 20 | 21 | $0 22 | endsnippet 23 | 24 | snippet sssec "Subsub Section marker" b 25 | ${1:SubSubsection}:`!p snip.rv = sec_title(snip, t)` 26 | 27 | $0 28 | endsnippet 29 | 30 | # vim:ft=snippets: 31 | -------------------------------------------------------------------------------- /vim/bundle/snippets/UltiSnips/html_minimal.snippets: -------------------------------------------------------------------------------- 1 | # more can be found in snippets/html_minimal.snippets 2 | # these UltiSnips override snippets because nested placeholders are being used 3 | 4 | snippet id 5 | id="${1}"${2} 6 | endsnippet 7 | 8 | snippet idn 9 | id="${1}" name="${2:$1}" 10 | endsnippet 11 | 12 | snippet label_and_input 13 | 14 | ${8} 15 | endsnippet 16 | 17 | snippet input 18 | ${7} 23 | endsnippet 24 | 25 | snippet textarea 26 | 27 | endsnippet 28 | 29 | snippet img 30 | $3 31 | endsnippet 32 | -------------------------------------------------------------------------------- /vim/bundle/tlib/spec/tlib/rx.vim: -------------------------------------------------------------------------------- 1 | " @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim]) 2 | " @Website: http://www.vim.org/account/profile.php?user_id=4037 3 | " @License: GPL (see http://www.gnu.org/licenses/gpl.txt) 4 | " @Created: 2010-04-03. 5 | " @Last Change: 2010-04-03. 6 | " @Revision: 2 7 | 8 | let s:save_cpo = &cpo 9 | set cpo&vim 10 | 11 | 12 | 13 | SpecBegin 'title': 'tlib#rx' 14 | 15 | 16 | for c in split('^$.*+\()|{}[]~', '\zs') 17 | let s = printf('%sfoo%sbar%s', c, c, c) 18 | Should be like s, '\m^'. tlib#rx#Escape(s, 'm') .'$' 19 | Should be like s, '\M^'. tlib#rx#Escape(s, 'M') .'$' 20 | Should be like s, '\v^'. tlib#rx#Escape(s, 'v') .'$' 21 | Should be like s, '\V\^'. tlib#rx#Escape(s, 'V') .'\$' 22 | endfor 23 | 24 | 25 | 26 | let &cpo = s:save_cpo 27 | unlet s:save_cpo 28 | -------------------------------------------------------------------------------- /vim/bundle/tlib/spec/tlib/url.vim: -------------------------------------------------------------------------------- 1 | " @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim]) 2 | " @Website: http://www.vim.org/account/profile.php?user_id=4037 3 | " @License: GPL (see http://www.gnu.org/licenses/gpl.txt) 4 | " @Created: 2010-04-03. 5 | " @Last Change: 2010-04-03. 6 | " @Revision: 2 7 | 8 | let s:save_cpo = &cpo 9 | set cpo&vim 10 | 11 | 12 | 13 | SpecBegin 'title': 'tlib#url' 14 | 15 | Should be equal tlib#url#Decode('http://example.com/foo+bar%25bar'), 'http://example.com/foo bar%bar' 16 | Should be equal tlib#url#Decode('Hello%20World.%20%20Good%2c%20bye.'), 'Hello World. Good, bye.' 17 | 18 | Should be equal tlib#url#Encode('foo bar%bar'), 'foo+bar%%bar' 19 | Should be equal tlib#url#Encode('Hello World. Good, bye.'), 'Hello+World.+Good%2c+bye.' 20 | 21 | 22 | let &cpo = s:save_cpo 23 | unlet s:save_cpo 24 | -------------------------------------------------------------------------------- /vim/bundle/snippets/UltiSnips/lua.snippets: -------------------------------------------------------------------------------- 1 | ################################# 2 | # Snippets for the Lua language # 3 | ################################# 4 | snippet #! "Shebang header" b 5 | #!/usr/bin/env lua 6 | $0 7 | endsnippet 8 | 9 | snippet !fun(ction)?! "New function" br 10 | function ${1:new_function}(${2:args}) 11 | $0 12 | end 13 | endsnippet 14 | 15 | snippet forp "pair for loop" b 16 | for ${1:name},${2:val} in pairs(${3:table_name}) do 17 | $0 18 | end 19 | endsnippet 20 | 21 | snippet fori "ipair for foop" b 22 | for ${1:idx},${2:val} in ipairs(${3:table_name}) do 23 | $0 24 | end 25 | endsnippet 26 | 27 | snippet for "numeric for loop" b 28 | for ${1:i}=${2:first},${3:last}${4/^..*/(?0:,:)/}${4:step} do 29 | $0 30 | end 31 | endsnippet 32 | 33 | snippet local "local x = 1" 34 | local ${1:x} = ${0:1} 35 | endsnippet 36 | 37 | # vim:ft=snippets: 38 | -------------------------------------------------------------------------------- /vim/bundle/snippets/snippets/apache.snippets: -------------------------------------------------------------------------------- 1 | # Snippets for code blocks used oftenly in Apache files. 2 | # 3 | snippet dir 4 | 5 | DirectoryIndex ${0:index.html} 6 | Order Deny,Allow 7 | Deny from All 8 | 9 | # 10 | snippet filesmatch 11 | 12 | ${0} 13 | 14 | # 15 | snippet ifmodule 16 | 17 | ${0} 18 | 19 | # 20 | snippet limitexcept 21 | 22 | ${0} 23 | 24 | # 25 | snippet proxy 26 | 27 | ${0} 28 | 29 | # 30 | snippet virtualhost 31 | 32 | ServerAdmin ${3:webmaster@example.com} 33 | DocumentRoot ${4:/www/example.com} 34 | ServerName ${0:www.example.com} 35 | 36 | -------------------------------------------------------------------------------- /vim/bundle/multiple-cursors/spec/spec_helper.rb: -------------------------------------------------------------------------------- 1 | require 'vimrunner' 2 | require 'vimrunner/rspec' 3 | 4 | Vimrunner::RSpec.configure do |config| 5 | 6 | # Use a single Vim instance for the test suite. Set to false to use an 7 | # instance per test (slower, but can be easier to manage). 8 | config.reuse_server = false 9 | 10 | # Decide how to start a Vim instance. In this block, an instance should be 11 | # spawned and set up with anything project-specific. 12 | config.start_vim do 13 | # vim = Vimrunner.start 14 | 15 | # Or, start a GUI instance: 16 | vim = Vimrunner.start_gvim 17 | 18 | # Setup your plugin in the Vim instance 19 | plugin_path = File.expand_path('../..', __FILE__) 20 | vim.add_plugin(plugin_path, 'plugin/multiple_cursors.vim') 21 | 22 | # The returned value is the Client available in the tests. 23 | vim 24 | end 25 | end 26 | -------------------------------------------------------------------------------- /vim/bundle/snippets/snippets/javascript.d3.snippets: -------------------------------------------------------------------------------- 1 | snippet .attr 2 | .attr("${1}", ${2}) 3 | snippet .style 4 | .style("${1}", ${2}) 5 | snippet axis 6 | d3.svg.axis() 7 | .orient(${1}) 8 | .scale(${2}) 9 | snippet fd 10 | function(d) { ${1} } 11 | snippet fdi 12 | function(d, i) { ${1} } 13 | snippet marginconvention 14 | var ${1:margin} = { top: ${2:10}, right: ${3:10}, bottom: ${4:10}, left: ${5:10} }; 15 | var ${6:width} = ${7:970} - $1.left - $1.right; 16 | var ${8:height} = ${9:500} - $1.top - $1.bottom; 17 | 18 | var ${10:svg} = d3.select("${11}").append("svg") 19 | .attr("width", $6) 20 | .attr("height", $8) 21 | .append("g") 22 | .attr("transform", "translate(" + $1.left + "," + $1.top + ")") 23 | snippet nest 24 | d3.nest() 25 | .key(${1}) 26 | .entries(${2}) 27 | snippet scale 28 | d3.scale.linear() 29 | .domain(${1}) 30 | .range(${2}) 31 | -------------------------------------------------------------------------------- /vim/bundle/addon_mw_utils/autoload/buf_utils.vim: -------------------------------------------------------------------------------- 1 | " buf_identifier is either a buf_nr or a filename 2 | " If any window shows the buffer move to the buffer 3 | " If not show it in current window (by c-w s c^ you can always 4 | " reshow the last buffer 5 | " 6 | " Example: buf_utils#GotoBuf("/tmp/tfile.txt", {'create': 1}) 7 | " returns: The command which was used to switch to the buffer 8 | fun! buf_utils#GotoBuf(buf_identifier, opts) 9 | let buf_nr = bufnr(a:buf_identifier) 10 | if buf_nr == -1 && ( get(a:opts, 'create', 0) || has_key(a:opts, 'create_cmd')) 11 | exec get(a:opts,'create_cmd','e').' '.fnameescape(a:buf_identifier) 12 | return "e" 13 | else 14 | let win_nr = bufwinnr(buf_nr) 15 | if win_nr == -1 16 | exec 'b '.buf_nr 17 | return "b" 18 | else 19 | exec win_nr.'wincmd w' 20 | return "w" 21 | endif 22 | wincmd w" 23 | endif 24 | endf 25 | -------------------------------------------------------------------------------- /vim/bundle/snippets/snippets/haml.snippets: -------------------------------------------------------------------------------- 1 | snippet t 2 | %table 3 | %tr 4 | %th 5 | ${1:headers} 6 | %tr 7 | %td 8 | ${0:headers} 9 | snippet ul 10 | %ul 11 | %li 12 | ${0:item} 13 | %li 14 | snippet rp 15 | = render :partial => "${0:item}" 16 | snippet rpc 17 | = render :partial => "${1:item}", :collection => ${0:@$1s} 18 | snippet rpl 19 | = render :partial => "${1:item}", :locals => { :${2:$1} => ${0:@$1} 20 | snippet rpo 21 | = render :partial => "${1:item}", :object => ${0:@$1} 22 | snippet lt 23 | = link_to ${1:name}, ${2:dest} 24 | snippet mt 25 | = mail_to ${1:email_address}, ${2:name} 26 | snippet mts 27 | = mail_to ${1:email_address}, ${2:name}, :subject => ${3}, :body => ${4} 28 | snippet ife 29 | - if ${1:condition} 30 | ${2} 31 | - else 32 | ${0} 33 | snippet ifp 34 | - if ${1:condition}.presence? 35 | ${0} 36 | snippet ntc 37 | = number_to_currency(${1}) 38 | -------------------------------------------------------------------------------- /vim/bundle/tlib/README: -------------------------------------------------------------------------------- 1 | This library provides some utility functions. There isn't much need to 2 | install it unless another plugin requires you to do so. 3 | 4 | Most of the library is included in autoload files. No autocommands are 5 | created. With the exception of loading ../plugin/02tlib.vim at startup 6 | the library has no impact on startup time or anything else. 7 | 8 | The change-log is included at the bottom of ../plugin/02tlib.vim 9 | (move the cursor over the file name and type gfG) 10 | 11 | Demo of |tlib#input#List()|: 12 | http://vimsomnia.blogspot.com/2010/11/selecting-items-from-list-with-tlibs.html 13 | 14 | 15 | ----------------------------------------------------------------------- 16 | 17 | Status: Works for me (there may be some minor quirks) 18 | Install: See http://github.com/tomtom/vimtlib/blob/master/INSTALL.TXT 19 | See http://github.com/tomtom for related plugins. 20 | 21 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/python/py3kwarn.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: py3kwarn.vim 3 | "Description: Syntax checking plugin for syntastic.vim 4 | "Authors: Liam Curry 5 | " 6 | "============================================================================ 7 | if exists("g:loaded_syntastic_python_py3kwarn_checker") 8 | finish 9 | endif 10 | let g:loaded_syntastic_python_py3kwarn_checker=1 11 | 12 | function! SyntaxCheckers_python_py3kwarn_GetLocList() dict 13 | let makeprg = self.makeprgBuild({}) 14 | 15 | let errorformat = '%W%f:%l:%c: %m' 16 | 17 | return SyntasticMake({ 18 | \ 'makeprg': makeprg, 19 | \ 'errorformat': errorformat }) 20 | endfunction 21 | 22 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 23 | \ 'filetype': 'python', 24 | \ 'name': 'py3kwarn'}) 25 | -------------------------------------------------------------------------------- /vim/bundle/snippets/UltiSnips/README: -------------------------------------------------------------------------------- 1 | This directory contains the main scripts that come bundled with UltiSnips. 2 | 3 | Standing On The Shoulders of Giants 4 | =================================== 5 | 6 | The snippets have been collected from various other project which I want to 7 | express my gratitude for. My main source for inspiration where the following 8 | two projects: 9 | 10 | TextMate: http://svn.textmate.org/trunk/Bundles/ 11 | SnipMate: http://code.google.com/p/snipmate/ 12 | 13 | All snippets from those sources were copied and cleaned up, so that they are 14 | - not using shell script, only python (so they are cross platform compatible) 15 | - not using any feature that UltiSnips doesn't offer 16 | 17 | UltiSnips has seen contributions by various individuals. Those contributions 18 | have been merged into this collection seamlessly and without further comments. 19 | 20 | -- vim:ft=rst:nospell: 21 | 22 | -------------------------------------------------------------------------------- /vim/bundle/snippets/snippets/sql.snippets: -------------------------------------------------------------------------------- 1 | snippet tbl 2 | create table ${1:table} ( 3 | ${0:columns} 4 | ); 5 | snippet col 6 | ${1:name} ${2:type} ${3:default ''} ${0:not null} 7 | snippet ccol 8 | ${1:name} varchar2(${2:size}) ${3:default ''} ${0:not null} 9 | snippet ncol 10 | ${1:name} number ${3:default 0} ${0:not null} 11 | snippet dcol 12 | ${1:name} date ${3:default sysdate} ${0:not null} 13 | snippet ind 14 | create index ${0:$1_$2} on ${1:table}(${2:column}); 15 | snippet uind 16 | create unique index ${1:name} on ${2:table}(${0:column}); 17 | snippet tblcom 18 | comment on table ${1:table} is '${0:comment}'; 19 | snippet colcom 20 | comment on column ${1:table}.${2:column} is '${0:comment}'; 21 | snippet addcol 22 | alter table ${1:table} add (${2:column} ${0:type}); 23 | snippet seq 24 | create sequence ${1:name} start with ${2:1} increment by ${3:1} minvalue ${0:1}; 25 | snippet s* 26 | select * from ${0:table} 27 | -------------------------------------------------------------------------------- /vim/bundle/tlib/autoload/tlib/number.vim: -------------------------------------------------------------------------------- 1 | " @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim]) 2 | " @License: GPL (see http://www.gnu.org/licenses/gpl.txt) 3 | " @Revision: 14 4 | 5 | 6 | function! tlib#number#ConvertBase(num, base, ...) "{{{3 7 | let rtype = a:0 >= 1 ? a:1 : 'string' 8 | " TLogVAR a:num, a:base, rtype 9 | let rv = [] 10 | let num = 0.0 + a:num 11 | while floor(num) > 0.0 12 | let div = floor(num / a:base) 13 | let num1 = float2nr(num - a:base * div) 14 | if a:base <= 10 15 | call insert(rv, num1) 16 | elseif a:base == 16 17 | let char = "0123456789ABCDEF"[num1] 18 | call insert(rv, char) 19 | endif 20 | let num = num / a:base 21 | endwh 22 | " TLogVAR rv 23 | if rtype == 'list' 24 | return rv 25 | else 26 | return join(rv, '') 27 | endif 28 | endf 29 | 30 | 31 | -------------------------------------------------------------------------------- /vim/bundle/snippets/AUTHORS: -------------------------------------------------------------------------------- 1 | Aaron Broder 2 | Adam Folmert 3 | Alberto Pose 4 | Angel Alonso 5 | Ben Orenstein 6 | Bill Casarin 7 | Christopher Joslyn 8 | Daniel Hahler 9 | Elliot Murphy 10 | Eustaquio Rangel 11 | Henrik Nyh 12 | Honza Pokorny 13 | Iuri Fernandes Queiroz 14 | Jakub Nawalaniec 15 | James F. Herdman 16 | Jon Bernard 17 | Kozo NISHIDA 18 | Leandro Pincini 19 | Marc Weber 20 | Marcin Kulik 21 | Marjan.Hratson 22 | Micah Elliott 23 | Michael Sanders 24 | Naveed Massjouni 25 | Rob Hudson 26 | Rok Garbas 27 | Sebastian Schulze 28 | Srushti Ambekallu 29 | Stephen Tudor 30 | Steven Oliver 31 | Stuart Colville 32 | Tom Adams 33 | Zied ABID 34 | fo60213 35 | marutanm 36 | msanders 37 | Povilas Balzaravičius Pawka 38 | Dmitry Dementev 39 | Travis Holton 40 | Chrisyue 41 | Erik Westrup 42 | Matt Deacalion Stevens 43 | 44 | TODO: add contributors from github.com/SirVer/Ultisnip having contributed to 45 | github.com/SirVer/Ultisnip/UltiSnips/* files 46 | -------------------------------------------------------------------------------- /vim/bundle/snippets/autoload/vim_snippets.vim: -------------------------------------------------------------------------------- 1 | " this is well known Filename found in snipmate (and the other engines), but 2 | " rewritten and documented :) 3 | " 4 | " optional arg1: string in which to replace '$1' by filename with extension 5 | " and path dropped. Defaults to $1 6 | " optional arg2: return this value if buffer has no filename 7 | " But why not use the template in this case, too? 8 | " Doesn't make sense to me 9 | fun! vim_snippets#Filename(...) 10 | let template = get(a:000, 0, "$1") 11 | let arg2 = get(a:000, 1, "") 12 | 13 | let basename = expand('%:t:r') 14 | 15 | if basename == '' 16 | return arg2 17 | else 18 | return substitute(template, '$1', basename, 'g') 19 | endif 20 | endf 21 | 22 | " original code: 23 | " fun! Filename(...) 24 | " let filename = expand('%:t:r') 25 | " if filename == '' | return a:0 == 2 ? a:2 : '' | endif 26 | " return !a:0 || a:1 == '' ? filename : substitute(a:1, '$1', filename, 'g') 27 | " endf 28 | -------------------------------------------------------------------------------- /vim/bundle/tlib/autoload/tlib/hook.vim: -------------------------------------------------------------------------------- 1 | " hook.vim 2 | " @Author: Tom Link (micathom AT gmail com?subject=[vim]) 3 | " @Website: http://www.vim.org/account/profile.php?user_id=4037 4 | " @License: GPL (see http://www.gnu.org/licenses/gpl.txt) 5 | " @Created: 2007-08-21. 6 | " @Last Change: 2009-02-15. 7 | " @Revision: 0.0.10 8 | 9 | if &cp || exists("loaded_tlib_hook_autoload") 10 | finish 11 | endif 12 | let loaded_tlib_hook_autoload = 1 13 | 14 | 15 | " :def: function! tlib#hook#Run(hook, ?dict={}) 16 | " Execute dict[hook], w:{hook}, b:{hook}, or g:{hook} if existent. 17 | function! tlib#hook#Run(hook, ...) "{{{3 18 | TVarArg ['dict', {}] 19 | if has_key(dict, a:hook) 20 | let hook = dict[a:hook] 21 | else 22 | let hook = tlib#var#Get(a:hook, 'wbg') 23 | endif 24 | if empty(hook) 25 | return 0 26 | else 27 | let world = dict 28 | exec hook 29 | return 1 30 | endif 31 | endf 32 | 33 | 34 | -------------------------------------------------------------------------------- /vim/bundle/vim-go/syntax/godefstack.vim: -------------------------------------------------------------------------------- 1 | if exists("b:current_syntax") 2 | finish 3 | endif 4 | 5 | syn match godefStackComment '^".*' 6 | syn match godefLinePrefix '^[>\s]\s' nextgroup=godefStackEntryNumber contains=godefStackCurrentPosition 7 | syn match godefStackEntryNumber '\d\+' nextgroup=godefStackFilename skipwhite 8 | syn match godefStackCurrentPosition '>' contained 9 | syn match godefStackFilename '[^|]\+' contained nextgroup=godefStackEntryLocation 10 | syn region godefStackEntryLocation oneline start='|' end='|' contained contains=godefStackEntryLocationNumber 11 | syn match godefStackEntryLocationNumber '\d\+' contained display 12 | 13 | let b:current_syntax = "godefstack" 14 | 15 | hi def link godefStackComment Comment 16 | hi def link godefStackCurrentPosition Special 17 | hi def link godefStackFilename Directory 18 | hi def link godefStackEntryLocationNumber LineNr 19 | 20 | " vim: sw=2 ts=2 et 21 | -------------------------------------------------------------------------------- /vim/bundle/gundo/plugin/gundo.vim: -------------------------------------------------------------------------------- 1 | " ============================================================================ 2 | " File: gundo.vim 3 | " Description: vim global plugin to visualize your undo tree 4 | " Maintainer: Steve Losh 5 | " License: GPLv2+ -- look it up. 6 | " Notes: Much of this code was thiefed from Mercurial, and the rest was 7 | " heavily inspired by scratch.vim and histwin.vim. 8 | " 9 | " ============================================================================ 10 | 11 | 12 | "{{{ Init 13 | if !exists('g:gundo_debug') && (exists('g:gundo_disable') || exists('loaded_gundo') || &cp)"{{{ 14 | finish 15 | endif 16 | let loaded_gundo = 1"}}} 17 | "}}} 18 | 19 | "{{{ Misc 20 | command! -nargs=0 GundoToggle call gundo#GundoToggle() 21 | command! -nargs=0 GundoShow call gundo#GundoShow() 22 | command! -nargs=0 GundoHide call gundo#GundoHide() 23 | command! -nargs=0 GundoRenderGraph call gundo#GundoRenderGraph() 24 | "}}} 25 | -------------------------------------------------------------------------------- /vim/bundle/snippets/UltiSnips/bindzone.snippets: -------------------------------------------------------------------------------- 1 | global !p 2 | def newsoa(): 3 | import datetime 4 | now = datetime.datetime.now() 5 | # return standard SOA formatted serial for today 6 | return now.strftime("%Y%m%d00") 7 | endglobal 8 | 9 | snippet zone "Bootstrap a new Bind zonefile" b 10 | $TTL 86400 11 | @ IN SOA ${1:example.net}. ${2:hostmaster.$1}.( 12 | `!p snip.rv = newsoa()`; serial 13 | 21600; refresh every 6 hours 14 | 3600; retry after one hour 15 | 604800; expire after a week 16 | 86400 ); minimum TTL of 1 day 17 | 18 | IN NS ns01.$1. 19 | IN MX 10 mail.$1. 20 | 21 | ns01.$1 IN A 22 | mail.$1 IN A 23 | endsnippet 24 | 25 | snippet A "Insert A Record" b 26 | ${1:hostname} IN A ${2:ip} 27 | endsnippet 28 | -------------------------------------------------------------------------------- /vim/bundle/tube/autoload/tube/utils/settings.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | tube.utils.settings 4 | ~~~~~~~~~~~~~~~~~~~ 5 | 6 | This module defines various utility functions for dealing with vim variables. 7 | """ 8 | 9 | import vim 10 | 11 | 12 | prefix = 'g:tube_' 13 | 14 | 15 | def set(name, value): 16 | """To set a vim variable to a given value.""" 17 | if isinstance(value, basestring): 18 | val = "'{}'".format(value) 19 | elif isinstance(value, bool): 20 | val = 1 if value else 0 21 | else: 22 | val = value 23 | 24 | vim.command("let {} = {}".format(prefix + name, val)) 25 | 26 | 27 | def get(name, type=None): 28 | """To get the value of a vim variable.""" 29 | rawval = vim.eval(prefix + name) 30 | if type is bool: 31 | return False if rawval == '0' else True 32 | elif type is int: 33 | return int(rawval) 34 | elif type is float: 35 | return float(rawval) 36 | else: 37 | return rawval 38 | -------------------------------------------------------------------------------- /vim/bundle/powerline/autoload/Powerline/Segments/ctrlp.vim: -------------------------------------------------------------------------------- 1 | if !exists("g:Powerline#Segments#ctrlp#segments#focus ") 2 | let g:Powerline#Segments#ctrlp#segments#focus = '%{"%0"}' 3 | endif 4 | if !exists("g:Powerline#Segments#ctrlp#segments#prev ") 5 | let g:Powerline#Segments#ctrlp#segments#prev = '%-3{"%3"}' 6 | endif 7 | if !exists("g:Powerline#Segments#ctrlp#segments#next ") 8 | let g:Powerline#Segments#ctrlp#segments#next = '%-3{"%5"}' 9 | endif 10 | 11 | let g:Powerline#Segments#ctrlp#segments = Pl#Segment#Init(['ctrlp' 12 | \ , Pl#Segment#Create('focus', g:Powerline#Segments#ctrlp#segments#focus) 13 | \ , Pl#Segment#Create('byfname', '%{"%1"}') 14 | \ , Pl#Segment#Create('prev', g:Powerline#Segments#ctrlp#segments#prev) 15 | \ , Pl#Segment#Create('item', '%-9{"%4"}') 16 | \ , Pl#Segment#Create('next', g:Powerline#Segments#ctrlp#segments#next) 17 | \ , Pl#Segment#Create('marked', '%{"%6" == " <+>" ? "" : strpart("%6", 2, len("%6") - 3)}') 18 | \ 19 | \ , Pl#Segment#Create('count', '%-6{"%0"}') 20 | \ ]) 21 | -------------------------------------------------------------------------------- /vim/bundle/gundo/README.markdown: -------------------------------------------------------------------------------- 1 | 2 | Flattr this 3 | 4 | Gundo.vim is Vim plugin to visualize your Vim undo tree. 5 | 6 | Preview 7 | ------- 8 | 9 | Screencast: 10 | 11 | ### [http://screenr.com/M9l](http://screenr.com/M9l) 12 | 13 | Screenshot: 14 | 15 | gundo 16 | 17 | Requirements 18 | ------------ 19 | 20 | * Vim 7.3+ 21 | * Python support for Vim 22 | * Python 2.4+ 23 | 24 | Installation and Usage 25 | ---------------------- 26 | 27 | Check out the [project site][] for installation instructions. 28 | 29 | [project site]: http://sjl.bitbucket.org/gundo.vim/ 30 | 31 | License 32 | ------- 33 | 34 | GPLv2+, just like Mercurial. 35 | -------------------------------------------------------------------------------- /vim/bundle/snippets/UltiSnips/tcl.snippets: -------------------------------------------------------------------------------- 1 | ########################################################################### 2 | # TEXTMATE SNIPPETS # 3 | ########################################################################### 4 | snippet for "for... (for)" b 5 | for {${1:set i 0}} {${2:\$i < \$n}} {${3:incr i}} { 6 | ${4} 7 | } 8 | 9 | endsnippet 10 | 11 | snippet foreach "foreach... (foreach)" 12 | foreach ${1:var} ${2:\$list} { 13 | ${3} 14 | } 15 | 16 | endsnippet 17 | 18 | snippet if "if... (if)" b 19 | if {${1}} { 20 | ${2} 21 | } 22 | 23 | endsnippet 24 | 25 | snippet proc "proc... (proc)" b 26 | proc ${1} {${2}} \ 27 | { 28 | ${3} 29 | } 30 | 31 | endsnippet 32 | 33 | snippet switch "switch... (switch)" b 34 | switch ${1:-exact} -- ${2:\$var} { 35 | ${3:match} { 36 | ${4} 37 | } 38 | default {${5}} 39 | } 40 | 41 | endsnippet 42 | 43 | snippet wh "while... (while)" b 44 | while {${1}} { 45 | ${2} 46 | } 47 | 48 | endsnippet 49 | 50 | # vim:ft=snippets: 51 | -------------------------------------------------------------------------------- /vim/bundle/snippets/snippets/mako.snippets: -------------------------------------------------------------------------------- 1 | snippet def 2 | <%def name="${1:name}"> 3 | ${0:} 4 | 5 | snippet call 6 | <%call expr="${1:name}"> 7 | ${0:} 8 | 9 | snippet doc 10 | <%doc> 11 | ${0:} 12 | 13 | snippet text 14 | <%text> 15 | ${0:} 16 | 17 | snippet for 18 | % for ${1:i} in ${2:iter}: 19 | ${0:} 20 | % endfor 21 | snippet if if 22 | % if ${1:condition}: 23 | ${0:} 24 | % endif 25 | snippet ife if/else 26 | % if ${1:condition}: 27 | ${2:} 28 | % else: 29 | ${0:} 30 | % endif 31 | snippet try 32 | % try: 33 | ${1:} 34 | % except${2:}: 35 | ${0:pass} 36 | % endtry 37 | snippet wh 38 | % while ${1:}: 39 | ${0:} 40 | % endwhile 41 | snippet $ 42 | ${ ${0:} } 43 | snippet <% 44 | <% ${0:} %> 45 | snippet 47 | snippet inherit 48 | <%inherit file="${0:filename}" /> 49 | snippet include 50 | <%include file="${0:filename}" /> 51 | snippet namespace 52 | <%namespace file="${0:name}" /> 53 | snippet page 54 | <%page args="${0:}" /> 55 | -------------------------------------------------------------------------------- /vim/bundle/tlib/spec/tlib/string.vim: -------------------------------------------------------------------------------- 1 | " @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim]) 2 | " @Website: http://www.vim.org/account/profile.php?user_id=4037 3 | " @License: GPL (see http://www.gnu.org/licenses/gpl.txt) 4 | " @Created: 2010-04-03. 5 | " @Last Change: 2010-04-03. 6 | " @Revision: 4 7 | 8 | let s:save_cpo = &cpo 9 | set cpo&vim 10 | 11 | 12 | 13 | SpecBegin 'title': 'tlib#string' 14 | 15 | Should be equal tlib#string#RemoveBackslashes('foo bar'), 'foo bar' 16 | Should be equal tlib#string#RemoveBackslashes('foo\ bar'), 'foo bar' 17 | Should be equal tlib#string#RemoveBackslashes('foo\ \\bar'), 'foo \\bar' 18 | Should be equal tlib#string#RemoveBackslashes('foo\ \\bar', '\ '), 'foo \bar' 19 | 20 | 21 | Should be equal tlib#string#Count("fooo", "o"), 3 22 | Should be equal tlib#string#Count("***", "\\*"), 3 23 | Should be equal tlib#string#Count("***foo", "\\*"), 3 24 | Should be equal tlib#string#Count("foo***", "\\*"), 3 25 | 26 | 27 | 28 | let &cpo = s:save_cpo 29 | unlet s:save_cpo 30 | -------------------------------------------------------------------------------- /vim/bundle/powerline/autoload/Powerline/Matches.vim: -------------------------------------------------------------------------------- 1 | let g:Powerline#Matches#matches = { 2 | \ 'command_t' : Pl#Match#Add('bufname(winbufnr(a:window))', '^GoToFile$'), 3 | \ 'bt_help' : Pl#Match#Add('getwinvar(a:window, "&bt")' , '^help$'), 4 | \ 'ft_man' : Pl#Match#Add('getwinvar(a:window, "&ft")' , '^man$'), 5 | \ 'ft_qf' : Pl#Match#Add('getwinvar(a:window, "&ft")' , '^qf$'), 6 | \ 'ft_vimpager' : Pl#Match#Add('getwinvar(a:window, "&ft")' , 'vimpager'), 7 | \ 'gundo_preview' : Pl#Match#Add('bufname(winbufnr(a:window))', '^__Gundo_Preview__$'), 8 | \ 'gundo_tree' : Pl#Match#Add('bufname(winbufnr(a:window))', '^__Gundo__$'), 9 | \ 'lustyexplorer' : Pl#Match#Add('bufname(winbufnr(a:window))', '\[LustyExplorer\-Buffers\]'), 10 | \ 'minibufexplorer' : Pl#Match#Add('bufname(winbufnr(a:window))', '^\-MiniBufExplorer\-$'), 11 | \ 'tagbar' : Pl#Match#Add('getwinvar(a:window, "&ft")' , '^tagbar$'), 12 | \ 'nerdtree' : Pl#Match#Add('getwinvar(a:window, "&ft")' , '^nerdtree$'), 13 | \ } 14 | -------------------------------------------------------------------------------- /vim/bundle/powerline/autoload/Pl/Match.vim: -------------------------------------------------------------------------------- 1 | function! Pl#Match#Add(pat, expr) " {{{ 2 | return [a:pat, a:expr] 3 | endfunction " }}} 4 | function! Pl#Match#Any(...) " {{{ 5 | let matches = [] 6 | 7 | for match_name in a:000 8 | if empty(match_name) 9 | " Skip empty match parameters 10 | continue 11 | endif 12 | 13 | if has_key(g:Powerline#Matches#matches, match_name) 14 | call add(matches, g:Powerline#Matches#matches[match_name]) 15 | endif 16 | 17 | unlet! match_name 18 | endfor 19 | 20 | return ['match', 'any', matches] 21 | endfunction " }}} 22 | function! Pl#Match#Validate(theme, window) " {{{ 23 | let match = a:theme.matches[1] 24 | 25 | if match == 'none' 26 | return 0 27 | elseif match == 'any' 28 | let matches = a:theme.matches[2] 29 | 30 | if ! len(matches) 31 | " Empty match array matches everything 32 | return 1 33 | endif 34 | 35 | for [eval, re] in matches 36 | if match(eval(eval), '\v\C'. re) != -1 37 | return 1 38 | endif 39 | endfor 40 | 41 | return 0 42 | endif 43 | endfunction " }}} 44 | -------------------------------------------------------------------------------- /vim/bundle/addon_mw_utils/autoload/glob.vim: -------------------------------------------------------------------------------- 1 | exec vam#DefineAndBind('s:c','g:glob_like', '{}') 2 | 3 | " ignore vcs stuff, Don't think you want those.. 4 | let s:c['regex_ignore_directory'] = '\<\%([_.]darcs\|\.git\|.svn\|.hg\|.cvs\|.bzr\)\>' 5 | let s:c['glob_cache'] = get(s:c, 'glob_cache', {}) 6 | let s:glob_cache = s:c['glob_cache'] 7 | 8 | fun! glob#Glob(pattern, ...) 9 | let pattern = a:pattern 10 | if pattern[0] == '~' 11 | let pattern = $HOME.pattern[1:] 12 | endif 13 | let opts = a:0 > 0 ? a:1 : {} 14 | " never cache current directory. You're very likely to edit files in it. 15 | 16 | let c = getcwd() 17 | let cachable = get(opts, 'cachable', 0) && pattern[:len(c)-1] != c 18 | if cachable && has_key(s:glob_cache, pattern) 19 | return s:glob_cache[pattern] 20 | endif 21 | 22 | " FIXME: don't recurse into \.git directory (thus reimplement glob in vimL!) 23 | let r = filter(split(glob(pattern),"\n"),'v:val !~ '.string(s:c['regex_ignore_directory'])) 24 | if cachable | let s:glob_cache[pattern] = r | endif 25 | return r 26 | endf 27 | 28 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/haskell/hlint.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: hlint.vim 3 | "Description: Syntax checking plugin for syntastic.vim 4 | "Maintainer: Nicolas Wu 5 | "License: BSD 6 | "============================================================================ 7 | 8 | if exists('g:loaded_syntastic_haskell_hlint_checker') 9 | finish 10 | endif 11 | let g:loaded_syntastic_haskell_hlint_checker = 1 12 | 13 | function! SyntaxCheckers_haskell_hlint_GetLocList() dict 14 | let makeprg = self.makeprgBuild({}) 15 | 16 | let errorformat = 17 | \ '%E%f:%l:%c: Error: %m,' . 18 | \ '%W%f:%l:%c: Warning: %m,' . 19 | \ '%C%m' 20 | 21 | return SyntasticMake({ 22 | \ 'makeprg': makeprg, 23 | \ 'errorformat': errorformat, 24 | \ 'postprocess': ['compressWhitespace'] }) 25 | endfunction 26 | 27 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 28 | \ 'filetype': 'haskell', 29 | \ 'name': 'hlint'}) 30 | -------------------------------------------------------------------------------- /vim/bundle/snippets/snippets/slim.snippets: -------------------------------------------------------------------------------- 1 | # Some useful Unicode entities 2 | # ============================ 3 | # Non-Breaking Space 4 | snippet nbs 5 |   6 | # ← 7 | snippet left 8 | ← 9 | # → 10 | snippet right 11 | → 12 | # ↑ 13 | snippet up 14 | ↑ 15 | # ↓ 16 | snippet down 17 | ↓ 18 | # ↩ 19 | snippet return 20 | ↩ 21 | # ⇤ 22 | snippet backtab 23 | ⇤ 24 | # ⇥ 25 | snippet tab 26 | ⇥ 27 | # ⇧ 28 | snippet shift 29 | ⇧ 30 | # ⌃ 31 | snippet ctrl 32 | ⌃ 33 | # ⌅ 34 | snippet enter 35 | ⌅ 36 | # ⌘ 37 | snippet cmd 38 | ⌘ 39 | # ⌥ 40 | snippet option 41 | ⌥ 42 | # ⌦ 43 | snippet delete 44 | ⌦ 45 | # ⌫ 46 | snippet backspace 47 | ⌫ 48 | # ⎋ 49 | snippet esc 50 | ⎋ 51 | 52 | # Forms 53 | # ===== 54 | snippet fieldset 55 | fieldset 56 | legend ${1} 57 | 58 | # Assets 59 | # ====== 60 | snippet css 61 | link rel="stylesheet" href="${1:style.css}" type="text/css" media="${2:all}" 62 | 63 | snippet script 64 | script src="${1:script.js}" type="text/javascript" 65 | -------------------------------------------------------------------------------- /vim/bundle/snipmate/syntax/snippets.vim: -------------------------------------------------------------------------------- 1 | " Syntax highlighting for .snippets files (used for snipMate.vim) 2 | " Hopefully this should make snippets a bit nicer to write! 3 | syn match snipComment '^#.*' 4 | syn match placeHolder '\${\d\+\(:.\{-}\)\=}' contains=snipCommand 5 | syn match tabStop '\$\d\+' 6 | syn match snipEscape '\\\\\|\\`' 7 | syn match snipCommand '\%(\\\@ 22 | 23 | :so % 24 | 25 | See :help vimball for details. If you have difficulties, please make 26 | sure, you have the current version of vimball (vimscript #1502) 27 | installed. 28 | 29 | 30 | %s 31 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/scss/sass.vim: -------------------------------------------------------------------------------- 1 | 2 | "============================================================================ 3 | "File: scss.vim 4 | "Description: scss syntax checking plugin for syntastic 5 | "Maintainer: Martin Grenfell 6 | "License: This program is free software. It comes without any warranty, 7 | " to the extent permitted by applicable law. You can redistribute 8 | " it and/or modify it under the terms of the Do What The Fuck You 9 | " Want To Public License, Version 2, as published by Sam Hocevar. 10 | " See http://sam.zoy.org/wtfpl/COPYING for more details. 11 | " 12 | "============================================================================ 13 | 14 | if exists("g:loaded_syntastic_scss_sass_checker") 15 | finish 16 | endif 17 | let g:loaded_syntastic_scss_sass_checker=1 18 | 19 | runtime! syntax_checkers/sass/*.vim 20 | 21 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 22 | \ 'filetype': 'scss', 23 | \ 'name': 'sass', 24 | \ 'redirect': 'sass/sass'}) 25 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/xslt/xmllint.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: xslt.vim 3 | "Description: Syntax checking plugin for syntastic.vim 4 | "Maintainer: Sebastian Kusnier 5 | "License: This program is free software. It comes without any warranty, 6 | " to the extent permitted by applicable law. You can redistribute 7 | " it and/or modify it under the terms of the Do What The Fuck You 8 | " Want To Public License, Version 2, as published by Sam Hocevar. 9 | " See http://sam.zoy.org/wtfpl/COPYING for more details. 10 | " 11 | "============================================================================ 12 | 13 | if exists("g:loaded_syntastic_xslt_xmllint_checker") 14 | finish 15 | endif 16 | let g:loaded_syntastic_xslt_xmllint_checker=1 17 | 18 | runtime! syntax_checkers/xml/*.vim 19 | 20 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 21 | \ 'filetype': 'xslt', 22 | \ 'name': 'xmllint', 23 | \ 'redirect': 'xml/xmllint'}) 24 | -------------------------------------------------------------------------------- /vim/bundle/twig/snippets/twig.snippets: -------------------------------------------------------------------------------- 1 | # Basic Twig snippets 2 | # Maintainer: F. Gabriel Gosselin 3 | 4 | # include 5 | snippet inc 6 | {% include '${1}' %} 7 | # extend 8 | snippet ext 9 | {% extends '${1:template.html.twig}' %} 10 | # extends 11 | snippet extends 12 | {% extends '${1:template}' %}${2} 13 | # if 14 | snippet if 15 | {% if ${1} %} 16 | ${2} 17 | {% endif %} 18 | # else 19 | snippet else 20 | {% else %} 21 | ${1} 22 | # for 23 | snippet for 24 | {% for ${2:} in ${1} %} 25 | ${3}{{ $2 }} 26 | {% endfor %} 27 | # Set 28 | snippet set 29 | {% set ${1:var} = ${2:value} %}${3} 30 | # Print variable 31 | snippet }} 32 | {{ ${1} }}${2} 33 | # Single Regular execution block 34 | snippet %% 35 | {% ${1} %}${2} 36 | # Comment block 37 | snippet ## 38 | {# ${1} #}${2} 39 | # Open/close block 40 | snippet %end 41 | {% ${1:block} %}${2}{% end$1 %} 42 | # Named block 43 | snippet block 44 | {% block ${1:name} %}${2}{% endblock %} 45 | snippet f_date 46 | {{ ${1:a_date}|date("${2:m/d/Y}") }} 47 | 48 | # debug 49 | snippet debug 50 | {% debug ${1:varName} %} -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/perl/podchecker.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: podchecker.vim 3 | "Description: Syntax checking plugin for syntastic.vim 4 | "Maintainer: LCD 47 5 | "License: This program is free software. It comes without any warranty, 6 | " to the extent permitted by applicable law. You can redistribute 7 | " it and/or modify it under the terms of the Do What The Fuck You 8 | " Want To Public License, Version 2, as published by Sam Hocevar. 9 | " See http://sam.zoy.org/wtfpl/COPYING for more details. 10 | " 11 | "============================================================================ 12 | 13 | if exists("g:loaded_syntastic_perl_podchecker_checker") 14 | finish 15 | endif 16 | let g:loaded_syntastic_perl_podchecker_checker=1 17 | 18 | runtime! syntax_checkers/pod/*.vim 19 | 20 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 21 | \ 'filetype': 'perl', 22 | \ 'name': 'podchecker', 23 | \ 'redirect': 'pod/podchecker'}) 24 | -------------------------------------------------------------------------------- /vim/bundle/vim-go/autoload/go/alternate.vim: -------------------------------------------------------------------------------- 1 | " By default use edit (current buffer view) to switch 2 | if !exists("g:go_alternate_mode") 3 | let g:go_alternate_mode = "edit" 4 | endif 5 | 6 | " Test alternates between the implementation of code and the test code. 7 | function! go#alternate#Switch(bang, cmd) 8 | let file = expand('%') 9 | if empty(file) 10 | call go#util#EchoError("no buffer name") 11 | return 12 | elseif file =~# '^\f\+_test\.go$' 13 | let l:root = split(file, '_test.go$')[0] 14 | let l:alt_file = l:root . ".go" 15 | elseif file =~# '^\f\+\.go$' 16 | let l:root = split(file, ".go$")[0] 17 | let l:alt_file = l:root . '_test.go' 18 | else 19 | call go#util#EchoError("not a go file") 20 | return 21 | endif 22 | if !filereadable(alt_file) && !bufexists(alt_file) && !a:bang 23 | call go#util#EchoError("couldn't find ".alt_file) 24 | return 25 | elseif empty(a:cmd) 26 | execute ":" . g:go_alternate_mode . " " . alt_file 27 | else 28 | execute ":" . a:cmd . " " . alt_file 29 | endif 30 | endfunction 31 | 32 | " vim: sw=2 ts=2 et 33 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/docbk/xmllint.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: docbk.vim 3 | "Description: Syntax checking plugin for syntastic.vim 4 | "Maintainer: Martin Grenfell 5 | "License: This program is free software. It comes without any warranty, 6 | " to the extent permitted by applicable law. You can redistribute 7 | " it and/or modify it under the terms of the Do What The Fuck You 8 | " Want To Public License, Version 2, as published by Sam Hocevar. 9 | " See http://sam.zoy.org/wtfpl/COPYING for more details. 10 | " 11 | "============================================================================ 12 | 13 | if exists("g:loaded_syntastic_docbk_xmllint_checker") 14 | finish 15 | endif 16 | let g:loaded_syntastic_docbk_xmllint_checker=1 17 | 18 | runtime! syntax_checkers/xml/*.vim 19 | 20 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 21 | \ 'filetype': 'docbk', 22 | \ 'name': 'xmllint', 23 | \ 'redirect': 'xml/xmllint'}) 24 | -------------------------------------------------------------------------------- /vim/bundle/snippets/snippets/cmake.snippets: -------------------------------------------------------------------------------- 1 | snippet cmake 2 | CMAKE_MINIMUM_REQUIRED(VERSION 2.6) 3 | PROJECT(${1:ProjectName}) 4 | 5 | FIND_PACKAGE(${2:LIBRARY}) 6 | 7 | INCLUDE_DIRECTORIES( 8 | ${$2_INCLUDE_DIR} 9 | ) 10 | 11 | ADD_SUBDIRECTORY(${0:src}) 12 | 13 | ADD_EXECUTABLE($1) 14 | 15 | TARGET_LINK_LIBRARIES($1 16 | ${$2_LIBRARIES} 17 | ) 18 | 19 | snippet include 20 | INCLUDE_DIRECTORIES( 21 | ${${0:INCLUDE_DIR}} 22 | ) 23 | 24 | snippet find 25 | FIND_PACKAGE(${0:LIBRARY}) 26 | 27 | snippet glob 28 | FILE(GLOB ${1:SRCS} *.${0:cpp}) 29 | 30 | snippet subdir 31 | ADD_SUBDIRECTORY(${0:src}) 32 | 33 | snippet lib 34 | ADD_LIBRARY(${1:lib} ${2:STATIC} 35 | ${${0:SRCS}} 36 | ) 37 | 38 | snippet link 39 | TARGET_LINK_LIBRARIES(${1:bin} 40 | ${0:somelib} 41 | ) 42 | 43 | snippet bin 44 | ADD_EXECUTABLE(${1:bin}) 45 | 46 | snippet set 47 | SET(${1:var} ${0:val}) 48 | 49 | snippet dep 50 | ADD_DEPENDENCIES(${1:target} 51 | ${0:dep} 52 | ) 53 | 54 | snippet props 55 | SET_TARGET_PROPERTIES(${1:target} 56 | ${2:PROPERTIES} ${3:COMPILE_FLAGS} 57 | ${0:"-O3 -Wall -pedantic"} 58 | ) 59 | -------------------------------------------------------------------------------- /installer.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | SV_VERSION="0" 3 | SHELL_ACTIVE="${HOME}/.$(basename $SHELL)rc" 4 | 5 | null() { 6 | "$@" >/dev/null 2>&1 7 | } 8 | 9 | cd ~ 10 | if [ -d $HOME/.Sublivim ]; then 11 | # echo "Mise a jour du Sublivim" 12 | (cd .Sublivim && null git stash && null git pull &) 13 | else 14 | echo "Clone du depot" 15 | git clone https://github.com/reversTeam/Sublivim.git .Sublivim --progress 16 | 17 | if [ -d $HOME/.vim ] && [ -f $HOME/.vimrc ]; then 18 | echo "Sauvegarde de vos anciennes configurations Vim : ~/old-conf-vim.tar" 19 | tar -cf old-conf-vim.tar .vim .vimrc 20 | rm -rf .vim .vimrc 21 | fi 22 | 23 | echo "Installation du Sublivim" 24 | ln -s .Sublivim/vimrc $HOME/.vimrc 25 | ln -s .Sublivim/vim $HOME/.vim 26 | fi 27 | if [ ! -e ~/.Sublivim/config_perso ]; then 28 | echo "let g:syntastic_c_include_dirs = ['../../../include', '../../include','../include','./include']" > ~/.Sublivim/config_perso 29 | fi 30 | 31 | SBVRC="$HOME/.Sublivim/sublivimrc.sh" 32 | 33 | if ! cat $SHELL_ACTIVE | grep "source $SBVRC" >/dev/null; then 34 | echo "source $SBVRC" >> $SHELL_ACTIVE 35 | . $SBVRC 36 | fi 37 | 38 | null cd - 39 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/cpp/ycm.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: ycm.vim 3 | "Description: Syntax checking plugin for syntastic.vim 4 | "Maintainer: Val Markovic 5 | "License: This program is free software. It comes without any warranty, 6 | " to the extent permitted by applicable law. You can redistribute 7 | " it and/or modify it under the terms of the Do What The Fuck You 8 | " Want To Public License, Version 2, as published by Sam Hocevar. 9 | " See http://sam.zoy.org/wtfpl/COPYING for more details. 10 | " 11 | "============================================================================ 12 | 13 | if exists("g:loaded_syntastic_cpp_ycm_checker") 14 | finish 15 | endif 16 | let g:loaded_syntastic_cpp_ycm_checker = 1 17 | 18 | runtime! syntax_checkers/c/*.vim 19 | 20 | if !exists('g:loaded_youcompleteme') 21 | finish 22 | endif 23 | 24 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 25 | \ 'filetype': 'cpp', 26 | \ 'name': 'ycm', 27 | \ 'redirect': 'c/ycm'}) 28 | -------------------------------------------------------------------------------- /vim/bundle/gundo/doc/tags: -------------------------------------------------------------------------------- 1 | Gundo-contents gundo.txt /*Gundo-contents* 2 | GundoBugs gundo.txt /*GundoBugs* 3 | GundoChangelog gundo.txt /*GundoChangelog* 4 | GundoConfig gundo.txt /*GundoConfig* 5 | GundoContributing gundo.txt /*GundoContributing* 6 | GundoCredits gundo.txt /*GundoCredits* 7 | GundoIntro gundo.txt /*GundoIntro* 8 | GundoLicense gundo.txt /*GundoLicense* 9 | GundoUsage gundo.txt /*GundoUsage* 10 | gundo.txt gundo.txt /*gundo.txt* 11 | gundo_auto_preview gundo.txt /*gundo_auto_preview* 12 | gundo_close_on_revert gundo.txt /*gundo_close_on_revert* 13 | gundo_disable gundo.txt /*gundo_disable* 14 | gundo_help gundo.txt /*gundo_help* 15 | gundo_map_move_newer gundo.txt /*gundo_map_move_newer* 16 | gundo_map_move_older gundo.txt /*gundo_map_move_older* 17 | gundo_playback_delay gundo.txt /*gundo_playback_delay* 18 | gundo_preview_bottom gundo.txt /*gundo_preview_bottom* 19 | gundo_preview_height gundo.txt /*gundo_preview_height* 20 | gundo_preview_statusline gundo.txt /*gundo_preview_statusline* 21 | gundo_right gundo.txt /*gundo_right* 22 | gundo_tree_statusline gundo.txt /*gundo_tree_statusline* 23 | gundo_width gundo.txt /*gundo_width* 24 | -------------------------------------------------------------------------------- /vim/bundle/snippets/snippets/htmltornado.snippets: -------------------------------------------------------------------------------- 1 | # Generic tags 2 | 3 | snippet { 4 | {{ ${0} }} 5 | 6 | # Template tags 7 | 8 | snippet extends 9 | {% extends "${0:base.html}" %} 10 | snippet autoescape 11 | {% autoescape ${0:xhtml_escape | None} %} 12 | snippet apply 13 | {% apply ${1:function} %} 14 | ${0} 15 | {% end %} 16 | snippet block 17 | {% block ${1} %} 18 | ${0} 19 | {% end %} 20 | snippet for 21 | {% for ${1:item} in ${2} %} 22 | ${0} 23 | {% end %} 24 | snippet from 25 | {% from ${1:x} import ${0:y} %} 26 | snippet if 27 | {% if ${1:condition} %} 28 | ${0} 29 | {% end %} 30 | snippet eif 31 | {% elif ${0:condition} %} 32 | snippet el 33 | {% else %} 34 | snippet import 35 | {% import ${0:module} %} 36 | snippet include 37 | {% include "${0:filename}" %} 38 | snippet module 39 | {% module ${0:expression} %} 40 | snippet raw 41 | {% raw ${0:expression} %} 42 | snippet set 43 | {% set ${1:x} = ${0:y} %} 44 | snippet try 45 | {% try %} 46 | ${1} 47 | {% except %} 48 | ${2} 49 | {% finallly %} 50 | ${0} 51 | {% end %} 52 | snippet wh 53 | {% while ${1:condition} %} 54 | ${0} 55 | {% end %} 56 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/objc/ycm.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: ycm.vim 3 | "Description: Syntax checking plugin for syntastic.vim 4 | "Maintainer: Val Markovic 5 | "License: This program is free software. It comes without any warranty, 6 | " to the extent permitted by applicable law. You can redistribute 7 | " it and/or modify it under the terms of the Do What The Fuck You 8 | " Want To Public License, Version 2, as published by Sam Hocevar. 9 | " See http://sam.zoy.org/wtfpl/COPYING for more details. 10 | " 11 | "============================================================================ 12 | 13 | if exists("g:loaded_syntastic_objc_ycm_checker") 14 | finish 15 | endif 16 | let g:loaded_syntastic_objc_ycm_checker = 1 17 | 18 | runtime! syntax_checkers/c/*.vim 19 | 20 | if !exists('g:loaded_youcompleteme') 21 | finish 22 | endif 23 | 24 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 25 | \ 'filetype': 'objc', 26 | \ 'name': 'ycm', 27 | \ 'redirect': 'c/ycm'}) 28 | -------------------------------------------------------------------------------- /vim/bundle/tlib/autoload/tlib/grep.vim: -------------------------------------------------------------------------------- 1 | " @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim]) 2 | " @License: GPL (see http://www.gnu.org/licenses/gpl.txt) 3 | " @Last Change: 2013-10-16. 4 | " @Revision: 31 5 | 6 | 7 | function! tlib#grep#Do(cmd, rx, files) "{{{3 8 | " TLogVAR a:cmd, a:rx, a:files 9 | let files = join(map(copy(a:files), 'tlib#arg#Ex(v:val, "")'), ' ') 10 | let rx = '/'. escape(a:rx, '/') .'/j' 11 | " TLogVAR rx, files 12 | silent exec a:cmd rx files 13 | endf 14 | 15 | 16 | function! tlib#grep#LocList(rx, files) "{{{3 17 | return tlib#grep#Do('noautocmd lvimgrep', a:rx, a:files) 18 | endf 19 | 20 | 21 | function! tlib#grep#QuickFixList(rx, files) "{{{3 22 | return tlib#grep#Do('noautocmd vimgrep', a:rx, a:files) 23 | endf 24 | 25 | 26 | function! tlib#grep#List(rx, files) "{{{3 27 | call setqflist([]) 28 | call tlib#grep#Do('noautocmd vimgrepadd', a:rx, a:files) 29 | let qfl = getqflist() 30 | " TLogVAR qfl 31 | " try 32 | silent! colder 33 | " catch 34 | " call setqflist([], 'r') 35 | " endtry 36 | return qfl 37 | endf 38 | 39 | -------------------------------------------------------------------------------- /vim/bundle/snippets/LICENSE: -------------------------------------------------------------------------------- 1 | Copyright (c) 2011 see AUTHORS 2 | 3 | Permission is hereby granted, free of charge, to any person obtaining a copy of 4 | this software and associated documentation files (the "Software"), to deal in 5 | the Software without restriction, including without limitation the rights to 6 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies 7 | of the Software, and to permit persons to whom the Software is furnished to do 8 | so, subject to the following conditions: 9 | 10 | The above copyright notice and this permission notice shall be included in all 11 | copies or substantial portions of the Software. 12 | 13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 19 | SOFTWARE. 20 | 21 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/objcpp/ycm.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: ycm.vim 3 | "Description: Syntax checking plugin for syntastic.vim 4 | "Maintainer: Val Markovic 5 | "License: This program is free software. It comes without any warranty, 6 | " to the extent permitted by applicable law. You can redistribute 7 | " it and/or modify it under the terms of the Do What The Fuck You 8 | " Want To Public License, Version 2, as published by Sam Hocevar. 9 | " See http://sam.zoy.org/wtfpl/COPYING for more details. 10 | " 11 | "============================================================================ 12 | 13 | if exists("g:loaded_syntastic_objcpp_ycm_checker") 14 | finish 15 | endif 16 | let g:loaded_syntastic_objcpp_ycm_checker = 1 17 | 18 | if !exists('g:loaded_youcompleteme') 19 | finish 20 | endif 21 | 22 | runtime! syntax_checkers/c/*.vim 23 | 24 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 25 | \ 'filetype': 'objcpp', 26 | \ 'name': 'ycm', 27 | \ 'redirect': 'c/ycm'}) 28 | -------------------------------------------------------------------------------- /vim/bundle/tlib/autoload/tlib/normal.vim: -------------------------------------------------------------------------------- 1 | " normal.vim 2 | " @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim]) 3 | " @Website: http://www.vim.org/account/profile.php?user_id=4037 4 | " @License: GPL (see http://www.gnu.org/licenses/gpl.txt) 5 | " @Created: 2008-10-06. 6 | " @Last Change: 2010-09-22. 7 | " @Revision: 28 8 | 9 | let s:save_cpo = &cpo 10 | set cpo&vim 11 | 12 | 13 | " :display: tlib#normal#WithRegister(cmd, ?register='t', ?norm_cmd='norm!') 14 | " Execute a normal command while maintaining all registers. 15 | function! tlib#normal#WithRegister(cmd, ...) "{{{3 16 | TVarArg ['register', 't'], ['norm_cmd', 'norm!'] 17 | let registers = {} 18 | for reg in split('123456789'. register, '\zs') 19 | exec 'let registers[reg] = @'. reg 20 | endfor 21 | exec 'let reg = @'. register 22 | try 23 | exec norm_cmd .' '. a:cmd 24 | exec 'return @'. register 25 | finally 26 | for [reg, value] in items(registers) 27 | exec 'let @'. reg .' = value' 28 | endfor 29 | endtry 30 | endf 31 | 32 | 33 | let &cpo = s:save_cpo 34 | unlet s:save_cpo 35 | -------------------------------------------------------------------------------- /vim/bundle/vim-go/indent/gohtmltmpl.vim: -------------------------------------------------------------------------------- 1 | if exists("b:did_indent") 2 | finish 3 | endif 4 | 5 | runtime! indent/html.vim 6 | 7 | " Indent Golang HTML templates 8 | setlocal indentexpr=GetGoHTMLTmplIndent(v:lnum) 9 | setlocal indentkeys+==else,=end 10 | 11 | " Only define the function once. 12 | if exists("*GetGoHTMLTmplIndent") 13 | finish 14 | endif 15 | 16 | function! GetGoHTMLTmplIndent(lnum) 17 | " Get HTML indent 18 | if exists('*HtmlIndent') 19 | let ind = HtmlIndent() 20 | else 21 | let ind = HtmlIndentGet(a:lnum) 22 | endif 23 | 24 | " The value of a single shift-width 25 | if exists('*shiftwidth') 26 | let sw = shiftwidth() 27 | else 28 | let sw = &sw 29 | endif 30 | 31 | " If need to indent based on last line 32 | let last_line = getline(a:lnum-1) 33 | if last_line =~ '^\s*{{\s*\%(if\|else\|range\|with\|define\|block\).*}}' 34 | let ind += sw 35 | endif 36 | 37 | " End of FuncMap block 38 | let current_line = getline(a:lnum) 39 | if current_line =~ '^\s*{{\s*\%(else\|end\).*}}' 40 | let ind -= sw 41 | endif 42 | 43 | return ind 44 | endfunction 45 | 46 | " vim: sw=2 ts=2 et 47 | -------------------------------------------------------------------------------- /vim/bundle/multiple-cursors/MIT-LICENSE.txt: -------------------------------------------------------------------------------- 1 | Copyright 2013 Terry Ma 2 | 3 | Permission is hereby granted, free of charge, to any person obtaining 4 | a copy of this software and associated documentation files (the 5 | "Software"), to deal in the Software without restriction, including 6 | without limitation the rights to use, copy, modify, merge, publish, 7 | distribute, sublicense, and/or sell copies of the Software, and to 8 | permit persons to whom the Software is furnished to do so, subject to 9 | the following conditions: 10 | 11 | The above copyright notice and this permission notice shall be included 12 | in all copies or substantial portions of the Software. 13 | 14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 15 | OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 16 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 17 | IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 18 | CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 19 | TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 20 | SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 21 | -------------------------------------------------------------------------------- /vim/bundle/snippets/UltiSnips/markdown.snippets: -------------------------------------------------------------------------------- 1 | ########################################################################### 2 | # SNIPPETS for MARKDOWN # 3 | ########################################################################### 4 | 5 | ########################### 6 | # Sections and Paragraphs # 7 | ########################### 8 | snippet sec "Section" b 9 | # ${1:Section Name} # 10 | $0 11 | endsnippet 12 | 13 | snippet ssec "Sub Section" b 14 | ## ${1:Section Name} ## 15 | $0 16 | endsnippet 17 | 18 | snippet sssec "SubSub Section" b 19 | ### ${1:Section Name} ### 20 | $0 21 | endsnippet 22 | 23 | snippet par "Paragraph" b 24 | #### ${1:Paragraph Name} #### 25 | $0 26 | endsnippet 27 | 28 | snippet spar "Paragraph" b 29 | ##### ${1:Paragraph Name} ##### 30 | $0 31 | endsnippet 32 | 33 | ################ 34 | # Common stuff # 35 | ################ 36 | snippet link "Link to something" 37 | [${1:${VISUAL:Text}}](${3:http://${2:www.url.com}})$0 38 | endsnippet 39 | 40 | snippet img "Image" 41 | ![${1:pic alt}](${2:path}${3/.+/ "/}${3:opt title}${3/.+/"/})$0 42 | endsnippet 43 | 44 | # vim:ft=snippets: 45 | -------------------------------------------------------------------------------- /vim/bundle/tube/LICENSE.txt: -------------------------------------------------------------------------------- 1 | Copyright (C) 2013 Giacomo Comitti 2 | 3 | Permission is hereby granted, free of charge, to any person obtaining a copy 4 | of this software and associated documentation files (the "Software"), to deal 5 | in the Software without restriction, including without limitation the rights 6 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 7 | copies of the Software, and to permit persons to whom the Software is 8 | furnished to do so, subject to the following conditions: 9 | 10 | The above copyright notice and this permission notice shall be included in all 11 | copies or substantial portions of the Software. 12 | 13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 19 | SOFTWARE. 20 | -------------------------------------------------------------------------------- /vim/bundle/snippets/UltiSnips/texmath.snippets: -------------------------------------------------------------------------------- 1 | ############## 2 | # MATH STUFF # 3 | ############## 4 | snippet eq "Equation" b 5 | \begin{equation} 6 | $0 7 | \end{equation} 8 | endsnippet 9 | 10 | snippet eqnn "Equation without number" b 11 | \begin{equation*} 12 | $0 13 | \end{equation*} 14 | endsnippet 15 | 16 | snippet eqa "Equation array" b 17 | \begin{eqnarray} 18 | $1 & $2 & $0 19 | \end{eqnarray} 20 | endsnippet 21 | 22 | snippet eqann "Equation array without numbers" b 23 | \begin{eqnarray*} 24 | $1 & $2 & $0 25 | \end{eqnarray*} 26 | 27 | endsnippet 28 | snippet frac "Fraction" w 29 | \frac{${1:${VISUAL:nom}}}{${2:denom}} 30 | endsnippet 31 | 32 | snippet mat "Smart Matrix" 33 | \begin{${1:p/b/v/V/B/small}matrix} 34 | $0 35 | \end{$1matrix} 36 | endsnippet 37 | 38 | snippet lr( "left( right)" w 39 | \left( ${1:${VISUAL}} \right) 40 | endsnippet 41 | 42 | snippet lr| "left| right|" w 43 | \left| ${1:${VISUAL}} \right| 44 | endsnippet 45 | 46 | snippet lr{ "left\{ right\}" w 47 | \left\\{ ${1:${VISUAL}} \right\\} 48 | endsnippet 49 | 50 | snippet lr[ "left[ right]" w 51 | \left[ ${1:${VISUAL}} \right] 52 | endsnippet 53 | 54 | # vim:ft=snippets: 55 | -------------------------------------------------------------------------------- /vim/bundle/tlib/spec/tlib/var.vim: -------------------------------------------------------------------------------- 1 | " @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim]) 2 | " @Website: http://www.vim.org/account/profile.php?user_id=4037 3 | " @License: GPL (see http://www.gnu.org/licenses/gpl.txt) 4 | " @Created: 2010-04-03. 5 | " @Last Change: 2010-04-03. 6 | " @Revision: 2 7 | 8 | let s:save_cpo = &cpo 9 | set cpo&vim 10 | 11 | 12 | 13 | SpecBegin 'title': 'tlib#var' 14 | 15 | 16 | let g:foo = 1 17 | let g:bar = 2 18 | let b:bar = 3 19 | let s:bar = 4 20 | 21 | Should be equal tlib#var#Get('bar', 'bg'), 3 22 | Should be equal tlib#var#Get('bar', 'g'), 2 23 | Should be equal tlib#var#Get('foo', 'bg'), 1 24 | Should be equal tlib#var#Get('foo', 'g'), 1 25 | Should be equal tlib#var#Get('none', 'l'), '' 26 | 27 | Should be equal eval(tlib#var#EGet('bar', 'bg')), 3 28 | Should be equal eval(tlib#var#EGet('bar', 'g')), 2 29 | " Should be equal eval(tlib#var#EGet('bar', 'sg')), 4 30 | Should be equal eval(tlib#var#EGet('foo', 'bg')), 1 31 | Should be equal eval(tlib#var#EGet('foo', 'g')), 1 32 | Should be equal eval(tlib#var#EGet('none', 'l')), '' 33 | 34 | 35 | 36 | let &cpo = s:save_cpo 37 | unlet s:save_cpo 38 | -------------------------------------------------------------------------------- /vim/bundle/Dockerfile/LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2013 Eugene Kalinin 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of 6 | this software and associated documentation files (the "Software"), to deal in 7 | the Software without restriction, including without limitation the rights to 8 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of 9 | the Software, and to permit persons to whom the Software is furnished to do so, 10 | subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS 17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 21 | -------------------------------------------------------------------------------- /vim/bundle/tube/doc/tags: -------------------------------------------------------------------------------- 1 | 'tube_aliases' tube.txt /*'tube_aliases'* 2 | 'tube_always_clear_screen' tube.txt /*'tube_always_clear_screen'* 3 | 'tube_bufname_expansion' tube.txt /*'tube_bufname_expansion'* 4 | 'tube_funargs_separator' tube.txt /*'tube_funargs_separator'* 5 | 'tube_function_expansion' tube.txt /*'tube_function_expansion'* 6 | 'tube_selection_expansion' tube.txt /*'tube_selection_expansion'* 7 | 'tube_terminal' tube.txt /*'tube_terminal'* 8 | Tube tube.txt /*Tube* 9 | TubeAlias tube.txt /*TubeAlias* 10 | TubeAliasClr tube.txt /*TubeAliasClr* 11 | TubeAliases tube.txt /*TubeAliases* 12 | TubeCd tube.txt /*TubeCd* 13 | TubeClose tube.txt /*TubeClose* 14 | TubeClr tube.txt /*TubeClr* 15 | TubeInterrupt tube.txt /*TubeInterrupt* 16 | TubeLastCmd tube.txt /*TubeLastCmd* 17 | tube tube.txt /*tube* 18 | tube-changelog tube.txt /*tube-changelog* 19 | tube-commands tube.txt /*tube-commands* 20 | tube-contents tube.txt /*tube-contents* 21 | tube-credits tube.txt /*tube-credits* 22 | tube-license tube.txt /*tube-license* 23 | tube-overview tube.txt /*tube-overview* 24 | tube-settings tube.txt /*tube-settings* 25 | tube.txt tube.txt /*tube.txt* 26 | visual-tour tube.txt /*visual-tour* 27 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/css/phpcs.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: phpcs.vim 3 | "Description: Syntax checking plugin for syntastic.vim 4 | "Maintainer: LCD 47 5 | "License: This program is free software. It comes without any warranty, 6 | " to the extent permitted by applicable law. You can redistribute 7 | " it and/or modify it under the terms of the Do What The Fuck You 8 | " Want To Public License, Version 2, as published by Sam Hocevar. 9 | " See http://sam.zoy.org/wtfpl/COPYING for more details. 10 | " 11 | "============================================================================ 12 | " 13 | " See here for details of phpcs 14 | " - phpcs (see http://pear.php.net/package/PHP_CodeSniffer) 15 | " 16 | if exists("g:loaded_syntastic_css_phpcs_checker") 17 | finish 18 | endif 19 | let g:loaded_syntastic_css_phpcs_checker=1 20 | 21 | runtime! syntax_checkers/php/*.vim 22 | 23 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 24 | \ 'filetype': 'css', 25 | \ 'name': 'phpcs', 26 | \ 'redirect': 'php/phpcs'}) 27 | -------------------------------------------------------------------------------- /vim/bundle/snippets/snippets/vim.snippets: -------------------------------------------------------------------------------- 1 | snippet header 2 | " File: ${1:`expand('%:t')`} 3 | " Author: ${2:`g:snips_author`} 4 | " Description: ${3} 5 | ${0:" Last Modified: `strftime("%B %d, %Y")`} 6 | snippet guard 7 | if exists('${1:did_`vim_snippets#Filename()`}') || &cp${2: || version < 700} 8 | finish 9 | endif 10 | let $1 = 1${0} 11 | snippet f 12 | fun! ${1:`expand('%') =~ 'autoload' ? substitute(matchstr(expand('%:p'),'autoload/\zs.*\ze.vim'),'[/\\]','#','g').'#' : ''`}${2:function_name}(${3}) 13 | ${0} 14 | endf 15 | snippet t 16 | try 17 | ${1} 18 | catch ${2} 19 | ${0} 20 | endtry 21 | snippet for 22 | for ${1} in ${2} 23 | ${0} 24 | endfor 25 | snippet forkv 26 | for [${1},${2}] in items(${3}) 27 | ${0} 28 | unlet $1 $2 29 | endfor 30 | 31 | snippet wh 32 | while ${1} 33 | ${0} 34 | endw 35 | snippet if 36 | if ${1} 37 | ${0} 38 | endif 39 | snippet ife 40 | if ${1} 41 | ${2} 42 | else 43 | ${0} 44 | endif 45 | snippet au 46 | augroup ${1:AU_NAME} 47 | " this one is which you're most likely to use? 48 | autocmd ${2:BufRead,BufNewFile} ${3:*.ext,*.ext3|} ${0} 49 | augroup end 50 | snippet bun 51 | Bundle '${0}' 52 | -------------------------------------------------------------------------------- /vim/bundle/snippets/snippets/falcon.snippets: -------------------------------------------------------------------------------- 1 | snippet #! 2 | #!/usr/bin/env falcon 3 | 4 | # Import 5 | snippet imp 6 | import ${0:module} 7 | 8 | # Function 9 | snippet fun 10 | function ${2:function_name}(${3}) 11 | ${0} 12 | end 13 | 14 | # Class 15 | snippet class 16 | class ${1:class_name}(${2:class_params}) 17 | ${0:/* members/methods */} 18 | end 19 | 20 | # If 21 | snippet if 22 | if ${1:condition} 23 | ${0} 24 | end 25 | 26 | # If else 27 | snippet ife 28 | if ${1:condition} 29 | ${0} 30 | else 31 | ${1} 32 | end 33 | 34 | # If else if 35 | snippet eif 36 | elif ${1:condition} 37 | ${0} 38 | 39 | # Switch case 40 | snippet switch 41 | switch ${1:expression} 42 | case ${2:item} 43 | case ${0:item} 44 | default 45 | end 46 | 47 | # Select 48 | snippet select 49 | select ${1:variable} 50 | case ${2:TypeSpec} 51 | case ${0:TypeSpec} 52 | default 53 | end 54 | 55 | # For/in Loop 56 | snippet forin 57 | for ${1:element} in ${2:container} 58 | ${0} 59 | end 60 | 61 | # For/to Loop 62 | snippet forto 63 | for ${1:lowerbound} to ${2:upperbound} 64 | ${0} 65 | end 66 | 67 | # While Loop 68 | snippet wh 69 | while ${1:conidition} 70 | ${0} 71 | end 72 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/typescript/tsc.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: typescript.vim 3 | "Description: TypeScript syntax checker 4 | "Maintainer: Bill Casarin 5 | "============================================================================ 6 | 7 | if exists("g:loaded_syntastic_typescript_tsc_checker") 8 | finish 9 | endif 10 | let g:loaded_syntastic_typescript_tsc_checker=1 11 | 12 | function! SyntaxCheckers_typescript_tsc_GetLocList() dict 13 | let makeprg = self.makeprgBuild({ 14 | \ 'args': '--module commonjs', 15 | \ 'post_args': '--out ' . syntastic#util#DevNull() }) 16 | 17 | let errorformat = 18 | \ '%E%f %#(%l\,%c): error %m,' . 19 | \ '%E%f %#(%l\,%c): %m,' . 20 | \ '%Eerror %m,' . 21 | \ '%C%\s%\+%m' 22 | 23 | return SyntasticMake({ 24 | \ 'makeprg': makeprg, 25 | \ 'errorformat': errorformat, 26 | \ 'defaults': {'bufnr': bufnr("")}, 27 | \ 'postprocess': ['sort'] }) 28 | endfunction 29 | 30 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 31 | \ 'filetype': 'typescript', 32 | \ 'name': 'tsc'}) 33 | -------------------------------------------------------------------------------- /vim/bundle/powerline/autoload/Pl/Mod.vim: -------------------------------------------------------------------------------- 1 | let s:segment_mods = [] 2 | 3 | function! Pl#Mod#AddSegmentMod(action, properties) " {{{ 4 | call add(s:segment_mods, [a:action, a:properties]) 5 | endfunction " }}} 6 | function! Pl#Mod#ApplySegmentMods(theme) " {{{ 7 | let theme = deepcopy(a:theme) 8 | 9 | for mod in s:segment_mods 10 | let [action, properties] = mod 11 | 12 | " We have to loop through the segments instead of using index() because some 13 | " segments are lists! 14 | let target_seg_idx = -1 15 | 16 | for i in range(0, len(theme) - 1) 17 | unlet! segment 18 | let segment = theme[i] 19 | 20 | if type(segment) == type(properties.target_segment) && segment == properties.target_segment 21 | let target_seg_idx = i 22 | break 23 | endif 24 | endfor 25 | 26 | if action == 'insert_segment' 27 | " Insert segment 28 | if target_seg_idx != -1 29 | call insert(theme, properties.new_segment, (properties.where == 'before' ? target_seg_idx : target_seg_idx + 1)) 30 | endif 31 | elseif action == 'remove_segment' 32 | " Remove segment 33 | if target_seg_idx != -1 34 | call remove(theme, target_seg_idx) 35 | endif 36 | endif 37 | endfor 38 | 39 | return theme 40 | endfunction " }}} 41 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/sh/shellcheck.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: shellcheck.vim 3 | "Description: Shell script syntax/style checking plugin for syntastic.vim 4 | "============================================================================ 5 | 6 | if exists("g:loaded_syntastic_sh_shellcheck_checker") 7 | finish 8 | endif 9 | let g:loaded_syntastic_sh_shellcheck_checker = 1 10 | 11 | function! SyntaxCheckers_sh_shellcheck_GetLocList() dict 12 | let makeprg = self.makeprgBuild({ 'args': '-f gcc' }) 13 | 14 | let errorformat = 15 | \ '%f:%l:%c: %trror: %m,' . 16 | \ '%f:%l:%c: %tarning: %m,' . 17 | \ '%f:%l:%c: %tote: %m' 18 | 19 | let loclist = SyntasticMake({ 20 | \ 'makeprg': makeprg, 21 | \ 'errorformat': errorformat, 22 | \ 'returns': [0, 1] }) 23 | 24 | for e in loclist 25 | if e['type'] ==? 'n' 26 | let e['type'] = 'w' 27 | let e['subtype'] = 'Style' 28 | endif 29 | endfor 30 | 31 | return loclist 32 | endfunction 33 | 34 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 35 | \ 'filetype': 'sh', 36 | \ 'name': 'shellcheck' }) 37 | -------------------------------------------------------------------------------- /vim/bundle/snippets/UltiSnips/vim.snippets: -------------------------------------------------------------------------------- 1 | ########################################################################### 2 | # SnipMate Snippets # 3 | ########################################################################### 4 | snippet header 5 | " File: ${1:`!v expand('%:t')`} 6 | " Author: ${2:`!v g:snips_author`} 7 | " Description: ${3} 8 | ${4:" Last Modified: `!v strftime("%B %d, %Y")`} 9 | 10 | $0 11 | endsnippet 12 | 13 | snippet gvar "Global / configuration variable" 14 | if !exists("g:${1:MyUltraImportantVar}") 15 | let g:$1 = ${2:"${3:}"} 16 | endif 17 | endsnippet 18 | 19 | snippet guard 20 | if exists('${1:did_`!p snip.rv = snip.fn.replace('.','_')`}') || &cp${2: || version < 700} 21 | finish 22 | endif 23 | let $1 = 1${3} 24 | endsnippet 25 | 26 | snippet f 27 | fun ${1:function_name}(${2}) 28 | ${3} 29 | endf 30 | endsnippet 31 | 32 | snippet for 33 | for ${1} in ${2} 34 | ${3} 35 | endfor 36 | endsnippet 37 | 38 | snippet wh 39 | while ${1} 40 | ${2} 41 | endw 42 | endsnippet 43 | 44 | snippet if 45 | if ${1} 46 | ${2} 47 | endif 48 | endsnippet 49 | 50 | snippet ife 51 | if ${1} 52 | ${2} 53 | else 54 | ${3} 55 | endif 56 | endsnippet 57 | 58 | # vim:ft=snippets: 59 | -------------------------------------------------------------------------------- /vim/bundle/Dockerfile/README.md: -------------------------------------------------------------------------------- 1 | Dockerfile.vim 2 | ============== 3 | 4 | Vim syntax file for [Docker](http://docker.io/)'s [Dockerfile](http://docs.docker.com/reference/builder/) 5 | and snippets for [snipMate](http://www.vim.org/scripts/script.php?script_id=2540). 6 | 7 | Screenshot 8 | ========== 9 | 10 | Here is an example in gnome-terminal with [vim-monokai](https://github.com/sickill/vim-monokai) color scheme: 11 | 12 | 13 | ![Vim & Dockerfile.vim ](https://raw.github.com/ekalinin/Dockerfile.vim/master/vim-dockerfile-example.png) 14 | 15 | 16 | 17 | Installation 18 | ============ 19 | 20 | ```bash 21 | $ git clone https://github.com/ekalinin/Dockerfile.vim.git 22 | $ cd Dockerfile.vim 23 | $ make install 24 | ``` 25 | 26 | ####Or using Pathogen: 27 | ```bash 28 | # Clone directly into the bundle folder. 29 | git clone https://github.com/ekalinin/Dockerfile.vim.git bundle/Dockerfile 30 | ``` 31 | 32 | ####Or using Vundle: 33 | ```bash 34 | # near the top of your .vimrc 35 | Plugin 'ekalinin/Dockerfile.vim' 36 | ``` 37 | 38 | ####Or using NeoBundle: 39 | 40 | ```bash 41 | NeoBundle 'ekalinin/Dockerfile.vim' 42 | ``` 43 | 44 | License 45 | ======= 46 | 47 | See [LICENSE](https://github.com/ekalinin/Dockerfile.vim/blob/master/LICENSE) file. 48 | -------------------------------------------------------------------------------- /vim/bundle/snippets/snippets/openfoam.snippets: -------------------------------------------------------------------------------- 1 | # 0/* 2 | snippet fv 3 | type fixedValue; 4 | value uniform ${0}; 5 | snippet zg 6 | type zeroGradient; 7 | snippet sym 8 | type symmetryPlane; 9 | # system/controlDict 10 | snippet forces 11 | forces 12 | { 13 | type forces; 14 | functionObjectLibs ("libforces.so"); 15 | enabled true; 16 | outputControl ${1:timeStep}; 17 | outputInterval ${2:1}; 18 | patches (${3}); 19 | log ${4:true}; 20 | CofR (${0:0 0 0}); 21 | } 22 | # system/fvSolution 23 | # solvers 24 | snippet gamg 25 | ${1:p} 26 | { 27 | solver GAMG; 28 | tolerance 1e-${2:6}; 29 | relTol ${0:0.0}; 30 | smoother GaussSeidel; 31 | cacheAgglomeration true; 32 | nCellsInCoarsestLevel 10; 33 | agglomerator faceAreaPair; 34 | mergeLevels 1; 35 | } 36 | snippet pbicg 37 | ${1:U} 38 | { 39 | solver PBiCG; 40 | preconditioner DILU; 41 | tolerance 1e-${2:6}; 42 | relTol ${0:0.0}; 43 | } 44 | # PIMPLE 45 | snippet pimple 46 | PIMPLE 47 | { 48 | nOuterCorrectors ${1:outer}; 49 | nCorrectors ${2:inner}; 50 | nNonOrthogonalCorrectors ${3:nonOrtho}; 51 | pRefCell ${4:cell}; 52 | pRefValue ${0:value for $4}; 53 | } 54 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/less/less-lint.coffee: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env node 2 | 3 | fs = require 'fs' 4 | less = require 'less' 5 | args = process.argv.slice(1) 6 | options = {} 7 | 8 | args = args.filter (arg) -> 9 | match = arg.match(/^-I(.+)$/) 10 | if match 11 | options.paths.push(match[1]); 12 | return false 13 | 14 | match = arg.match(/^--?([a-z][\-0-9a-z]*)(?:=([^\s]+))?$/i) 15 | if match 16 | arg = match[1] 17 | else 18 | return arg 19 | 20 | switch arg 21 | when 'strict-imports' then options.strictImports = true 22 | when 'include-path' 23 | options.paths = match[2].split(if os.type().match(/Windows/) then ';' else ':') 24 | .map (p) -> 25 | if p 26 | return path.resolve(process.cwd(), p) 27 | when 'O0' then options.optimization = 0 28 | when 'O1' then options.optimization = 1 29 | when 'O2' then options.optimization = 2 30 | 31 | options.filename = args[1] 32 | 33 | parser = new(less.Parser) options 34 | 35 | fs.readFile(options.filename, 'utf-8', (err,data) -> 36 | parser.parse(data, (err, tree) -> 37 | if err 38 | less.writeError err 39 | process.exit(1) 40 | ) 41 | ) 42 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/vhdl/ghdl.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: ghdl.vim 3 | "Description: Syntax checking plugin for syntastic.vim 4 | "Maintainer: Jan Wagner 5 | "License: This program is free software. It comes without any warranty, 6 | " to the extent permitted by applicable law. You can redistribute 7 | " it and/or modify it under the terms of the Do What The Fuck You 8 | " Want To Public License, Version 2, as published by Sam Hocevar. 9 | " See http://sam.zoy.org/wtfpl/COPYING for more details. 10 | " 11 | "============================================================================ 12 | if exists("g:loaded_syntastic_vhdl_ghdl_checker") 13 | finish 14 | endif 15 | let g:loaded_syntastic_vhdl_ghdl_checker = 1 16 | 17 | function! SyntaxCheckers_vhdl_ghdl_GetLocList() dict 18 | let makeprg = self.makeprgBuild({ 'args': '-s' }) 19 | 20 | let errorformat = '%f:%l:%c: %m' 21 | 22 | return SyntasticMake({ 23 | \ 'makeprg': makeprg, 24 | \ 'errorformat': errorformat }) 25 | endfunction 26 | 27 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 28 | \ 'filetype': 'vhdl', 29 | \ 'name': 'ghdl'}) 30 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/zsh/zsh.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: zsh.vim 3 | "Description: Syntax checking plugin for syntastic.vim 4 | "Maintainer: Martin Grenfell 5 | "License: This program is free software. It comes without any warranty, 6 | " to the extent permitted by applicable law. You can redistribute 7 | " it and/or modify it under the terms of the Do What The Fuck You 8 | " Want To Public License, Version 2, as published by Sam Hocevar. 9 | " See http://sam.zoy.org/wtfpl/COPYING for more details. 10 | " 11 | "============================================================================ 12 | 13 | if exists("g:loaded_syntastic_zsh_zsh_checker") 14 | finish 15 | endif 16 | let g:loaded_syntastic_zsh_zsh_checker=1 17 | 18 | function! SyntaxCheckers_zsh_zsh_GetLocList() dict 19 | let makeprg = self.makeprgBuild({ 'args': '-n' }) 20 | 21 | let errorformat = '%f:%l: %m' 22 | 23 | return SyntasticMake({ 24 | \ 'makeprg': makeprg, 25 | \ 'errorformat': errorformat}) 26 | endfunction 27 | 28 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 29 | \ 'filetype': 'zsh', 30 | \ 'name': 'zsh'}) 31 | -------------------------------------------------------------------------------- /vim/bundle/vim-go/ftdetect/gofiletype.vim: -------------------------------------------------------------------------------- 1 | " We take care to preserve the user's fileencodings and fileformats, 2 | " because those settings are global (not buffer local), yet we want 3 | " to override them for loading Go files, which are defined to be UTF-8. 4 | let s:current_fileformats = '' 5 | let s:current_fileencodings = '' 6 | 7 | " define fileencodings to open as utf-8 encoding even if it's ascii. 8 | function! s:gofiletype_pre(type) 9 | let s:current_fileformats = &g:fileformats 10 | let s:current_fileencodings = &g:fileencodings 11 | set fileencodings=utf-8 fileformats=unix 12 | let &l:filetype = a:type 13 | endfunction 14 | 15 | " restore fileencodings as others 16 | function! s:gofiletype_post() 17 | let &g:fileformats = s:current_fileformats 18 | let &g:fileencodings = s:current_fileencodings 19 | endfunction 20 | 21 | au BufNewFile *.go setfiletype go | setlocal fileencoding=utf-8 fileformat=unix 22 | au BufRead *.go call s:gofiletype_pre("go") 23 | au BufReadPost *.go call s:gofiletype_post() 24 | 25 | au BufNewFile *.s setfiletype asm | setlocal fileencoding=utf-8 fileformat=unix 26 | au BufRead *.s call s:gofiletype_pre("asm") 27 | au BufReadPost *.s call s:gofiletype_post() 28 | 29 | au BufRead,BufNewFile *.tmpl set filetype=gohtmltmpl 30 | 31 | " vim: sw=2 ts=2 et 32 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/hss/hss.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: hss.vim 3 | "Description: Syntax checking plugin for syntastic.vim 4 | "Maintainer: Justin Donaldson (jdonaldson@gmail.com) 5 | "License: This program is free software. It comes without any warranty, 6 | " to the extent permitted by applicable law. You can redistribute 7 | " it and/or modify it under the terms of the Do What The Fuck You 8 | " Want To Public License, Version 2, as published by Sam Hocevar. 9 | " See http://sam.zoy.org/wtfpl/COPYING for more details. 10 | " 11 | "============================================================================ 12 | 13 | if exists("g:loaded_syntastic_hss_hss_checker") 14 | finish 15 | endif 16 | let g:loaded_syntastic_hss_hss_checker=1 17 | 18 | function! SyntaxCheckers_hss_hss_GetLocList() dict 19 | let makeprg = self.makeprgBuild({ 'args' : '-output ' . syntastic#util#DevNull() }) 20 | 21 | let errorformat = '%E%f:%l: %m' 22 | 23 | return SyntasticMake({ 24 | \ 'makeprg': makeprg, 25 | \ 'errorformat': errorformat }) 26 | endfunction 27 | 28 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 29 | \ 'filetype': 'hss', 30 | \ 'name': 'hss'}) 31 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/c/ycm.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: ycm.vim 3 | "Description: Syntax checking plugin for syntastic.vim 4 | "Maintainer: Val Markovic 5 | "License: This program is free software. It comes without any warranty, 6 | " to the extent permitted by applicable law. You can redistribute 7 | " it and/or modify it under the terms of the Do What The Fuck You 8 | " Want To Public License, Version 2, as published by Sam Hocevar. 9 | " See http://sam.zoy.org/wtfpl/COPYING for more details. 10 | " 11 | "============================================================================ 12 | 13 | if exists("g:loaded_syntastic_c_ycm_checker") 14 | finish 15 | endif 16 | let g:loaded_syntastic_c_ycm_checker = 1 17 | 18 | function! SyntaxCheckers_c_ycm_IsAvailable() dict 19 | return exists('g:loaded_youcompleteme') 20 | endfunction 21 | 22 | if !exists('g:loaded_youcompleteme') 23 | finish 24 | endif 25 | 26 | function! SyntaxCheckers_c_ycm_GetLocList() dict 27 | return youcompleteme#CurrentFileDiagnostics() 28 | endfunction 29 | 30 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 31 | \ 'filetype': 'c', 32 | \ 'name': 'ycm'}) 33 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/go/golint.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: golint.vim 3 | "Description: Check go syntax using 'golint' 4 | "Maintainer: Hiroshi Ioka 5 | "License: This program is free software. It comes without any warranty, 6 | " to the extent permitted by applicable law. You can redistribute 7 | " it and/or modify it under the terms of the Do What The Fuck You 8 | " Want To Public License, Version 2, as published by Sam Hocevar. 9 | " See http://sam.zoy.org/wtfpl/COPYING for more details. 10 | " 11 | "============================================================================ 12 | if exists("g:loaded_syntastic_go_golint_checker") 13 | finish 14 | endif 15 | let g:loaded_syntastic_go_golint_checker=1 16 | 17 | function! SyntaxCheckers_go_golint_GetLocList() dict 18 | let makeprg = self.makeprgBuild({}) 19 | 20 | let errorformat = '%f:%l:%c: %m,%-G%.%#' 21 | 22 | return SyntasticMake({ 23 | \ 'makeprg': makeprg, 24 | \ 'errorformat': errorformat, 25 | \ 'subtype': 'Style' }) 26 | endfunction 27 | 28 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 29 | \ 'filetype': 'go', 30 | \ 'name': 'golint'}) 31 | -------------------------------------------------------------------------------- /vim/bundle/snippets/snippets/zsh.snippets: -------------------------------------------------------------------------------- 1 | # #!/bin/zsh 2 | snippet #! 3 | #!/bin/zsh 4 | 5 | snippet if 6 | if ${1:condition}; then 7 | ${0:# statements} 8 | fi 9 | snippet ife 10 | if ${1:condition}; then 11 | ${2:# statements} 12 | else 13 | ${0:# statements} 14 | fi 15 | snippet eif 16 | elif ${1:condition} ; then 17 | ${0:# statements} 18 | snippet for 19 | for (( ${2:i} = 0; $2 < ${1:count}; $2++ )); do 20 | ${0:# statements} 21 | done 22 | snippet fori 23 | for ${1:needle} in ${2:haystack} ; do 24 | ${0:#statements} 25 | done 26 | snippet fore 27 | for ${1:item} in ${2:list}; do 28 | ${0:# statements} 29 | done 30 | snippet wh 31 | while ${1:condition}; do 32 | ${0:# statements} 33 | done 34 | snippet until 35 | until ${1:condition}; do 36 | ${0:# statements} 37 | done 38 | snippet repeat 39 | repeat ${1:integer}; do 40 | ${0:# statements} 41 | done 42 | snippet case 43 | case ${1:word} in 44 | ${2:pattern}) 45 | ${0};; 46 | esac 47 | snippet select 48 | select ${1:answer} in ${2:choices}; do 49 | ${0:# statements} 50 | done 51 | snippet ( 52 | ( ${0:#statements} ) 53 | snippet { 54 | { ${0:#statements} } 55 | snippet [ 56 | [[ ${0:test} ]] 57 | snippet always 58 | { ${1:try} } always { ${0:always} } 59 | snippet fun 60 | function ${1:name} (${2:args}) { 61 | ${0:# body} 62 | } 63 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/cs/mcs.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: cs.vim 3 | "Description: Syntax checking plugin for syntastic.vim 4 | "Maintainer: Daniel Walker 5 | "License: This program is free software. It comes without any warranty, 6 | " to the extent permitted by applicable law. You can redistribute 7 | " it and/or modify it under the terms of the Do What The Fuck You 8 | " Want To Public License, Version 2, as published by Sam Hocevar. 9 | " See http://sam.zoy.org/wtfpl/COPYING for more details. 10 | " 11 | "============================================================================ 12 | 13 | if exists("g:loaded_syntastic_cs_mcs_checker") 14 | finish 15 | endif 16 | let g:loaded_syntastic_cs_mcs_checker=1 17 | 18 | function! SyntaxCheckers_cs_mcs_GetLocList() dict 19 | let makeprg = self.makeprgBuild({ 'args': '--parse' }) 20 | 21 | let errorformat = '%f(%l\,%c): %trror %m' 22 | 23 | return SyntasticMake({ 24 | \ 'makeprg': makeprg, 25 | \ 'errorformat': errorformat, 26 | \ 'defaults': {'bufnr': bufnr("")} }) 27 | endfunction 28 | 29 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 30 | \ 'filetype': 'cs', 31 | \ 'name': 'mcs'}) 32 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/plugin/syntastic/autoloclist.vim: -------------------------------------------------------------------------------- 1 | if exists("g:loaded_syntastic_notifier_autoloclist") 2 | finish 3 | endif 4 | let g:loaded_syntastic_notifier_autoloclist = 1 5 | 6 | if !exists("g:syntastic_auto_loc_list") 7 | let g:syntastic_auto_loc_list = 2 8 | endif 9 | 10 | let g:SyntasticAutoloclistNotifier = {} 11 | 12 | " Public methods {{{1 13 | " 14 | function! g:SyntasticAutoloclistNotifier.New() 15 | let newObj = copy(self) 16 | return newObj 17 | endfunction 18 | 19 | function! g:SyntasticAutoloclistNotifier.refresh(loclist) 20 | call syntastic#log#debug(g:SyntasticDebugNotifications, 'autoloclist: refresh') 21 | call g:SyntasticAutoloclistNotifier.AutoToggle(a:loclist) 22 | endfunction 23 | 24 | function! g:SyntasticAutoloclistNotifier.AutoToggle(loclist) 25 | call syntastic#log#debug(g:SyntasticDebugNotifications, 'autoloclist: toggle') 26 | if a:loclist.hasErrorsOrWarningsToDisplay() 27 | if g:syntastic_auto_loc_list == 1 28 | call a:loclist.show() 29 | endif 30 | else 31 | if g:syntastic_auto_loc_list > 0 32 | 33 | "TODO: this will close the loc list window if one was opened by 34 | "something other than syntastic 35 | lclose 36 | endif 37 | endif 38 | endfunction 39 | 40 | " vim: set sw=4 sts=4 et fdm=marker: 41 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/python/python.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: python.vim 3 | "Description: Syntax checking plugin for syntastic.vim 4 | "Author: Artem Nezvigin 5 | " 6 | " `errorformat` derived from: 7 | " http://www.vim.org/scripts/download_script.php?src_id=1392 8 | " 9 | "============================================================================ 10 | if exists("g:loaded_syntastic_python_python_checker") 11 | finish 12 | endif 13 | let g:loaded_syntastic_python_python_checker=1 14 | 15 | function! SyntaxCheckers_python_python_GetLocList() dict 16 | let fname = "'" . escape(expand('%'), "\\'") . "'" 17 | 18 | let makeprg = self.makeprgBuild({ 19 | \ 'args': '-c', 20 | \ 'fname': syntastic#util#shescape("compile(open(" . fname . ").read(), " . fname . ", 'exec')") }) 21 | 22 | let errorformat = 23 | \ '%E File "%f"\, line %l,' . 24 | \ '%C %p^,' . 25 | \ '%C %.%#,' . 26 | \ '%Z%m,' . 27 | \ '%-G%.%#' 28 | 29 | return SyntasticMake({ 30 | \ 'makeprg': makeprg, 31 | \ 'errorformat': errorformat }) 32 | endfunction 33 | 34 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 35 | \ 'filetype': 'python', 36 | \ 'name': 'python'}) 37 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/llvm/llvm.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: llvm.vim 3 | "Description: Syntax checking plugin for syntastic.vim 4 | "Maintainer: Andrew Kelley 5 | "License: This program is free software. It comes without any warranty, 6 | " to the extent permitted by applicable law. You can redistribute 7 | " it and/or modify it under the terms of the Do What The Fuck You 8 | " Want To Public License, Version 2, as published by Sam Hocevar. 9 | " See http://sam.zoy.org/wtfpl/COPYING for more details. 10 | " 11 | "============================================================================ 12 | if exists("g:loaded_syntastic_llvm_llvm_checker") 13 | finish 14 | endif 15 | let g:loaded_syntastic_llvm_llvm_checker=1 16 | 17 | function! SyntaxCheckers_llvm_llvm_GetLocList() dict 18 | let makeprg = self.makeprgBuild({ 'args': syntastic#c#NullOutput() }) 19 | 20 | let errorformat = 'llc: %f:%l:%c: %trror: %m' 21 | 22 | return SyntasticMake({ 23 | \ 'makeprg': makeprg, 24 | \ 'errorformat': errorformat }) 25 | endfunction 26 | 27 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 28 | \ 'filetype': 'llvm', 29 | \ 'name': 'llvm', 30 | \ 'exec': 'llc'}) 31 | 32 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/tex/lacheck.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: tex.vim 3 | "Description: Syntax checking plugin for syntastic.vim 4 | "Maintainer: Martin Grenfell 5 | "License: This program is free software. It comes without any warranty, 6 | " to the extent permitted by applicable law. You can redistribute 7 | " it and/or modify it under the terms of the Do What The Fuck You 8 | " Want To Public License, Version 2, as published by Sam Hocevar. 9 | " See http://sam.zoy.org/wtfpl/COPYING for more details. 10 | " 11 | "============================================================================ 12 | 13 | if exists('g:loaded_syntastic_tex_lacheck_checker') 14 | finish 15 | endif 16 | let g:loaded_syntastic_tex_lacheck_checker=1 17 | 18 | function! SyntaxCheckers_tex_lacheck_GetLocList() dict 19 | let makeprg = self.makeprgBuild({}) 20 | 21 | let errorformat = 22 | \ '%-G** %f:,' . 23 | \ '%E"%f"\, line %l: %m' 24 | 25 | return SyntasticMake({ 26 | \ 'makeprg': makeprg, 27 | \ 'errorformat': errorformat }) 28 | endfunction 29 | 30 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 31 | \ 'filetype': 'tex', 32 | \ 'name': 'lacheck'}) 33 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/chef/foodcritic.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: foodcritic.vim 3 | "Description: Syntax checking plugin for syntastic.vim 4 | "Maintainer: Doug Ireton 5 | "License: This program is free software. It comes without any warranty, 6 | " to the extent permitted by applicable law. You can redistribute 7 | " it and/or modify it under the terms of the Do What The Fuck You 8 | " Want To Public License, Version 2, as published by Sam Hocevar. 9 | " See http://sam.zoy.org/wtfpl/COPYING for more details. 10 | " 11 | "============================================================================ 12 | 13 | if exists("g:loaded_syntastic_chef_foodcritic_checker") 14 | finish 15 | endif 16 | let g:loaded_syntastic_chef_foodcritic_checker=1 17 | 18 | function! SyntaxCheckers_chef_foodcritic_GetLocList() dict 19 | let makeprg = self.makeprgBuild({}) 20 | 21 | " FC023: Prefer conditional attributes: ./recipes/config.rb:49 22 | let errorformat = 'FC%n: %m: %f:%l' 23 | 24 | return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) 25 | endfunction 26 | 27 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 28 | \ 'filetype': 'chef', 29 | \ 'name': 'foodcritic'}) 30 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/scss/scss_lint.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: scss_lint.vim 3 | "Description: SCSS style and syntax checker plugin for Syntastic 4 | "Maintainer: Shane da Silva 5 | "License: This program is free software. It comes without any warranty, 6 | " to the extent permitted by applicable law. You can redistribute 7 | " it and/or modify it under the terms of the Do What The Fuck You 8 | " Want To Public License, Version 2, as published by Sam Hocevar. 9 | " See http://sam.zoy.org/wtfpl/COPYING for more details. 10 | "============================================================================ 11 | 12 | if exists("g:loaded_syntastic_scss_scss_lint_checker") 13 | finish 14 | endif 15 | let g:loaded_syntastic_scss_scss_lint_checker=1 16 | 17 | function! SyntaxCheckers_scss_scss_lint_GetLocList() dict 18 | let makeprg = self.makeprgBuild({}) 19 | let errorformat = '%f:%l [%t] %m' 20 | return SyntasticMake({ 21 | \ 'makeprg': makeprg, 22 | \ 'errorformat': errorformat, 23 | \ 'subtype': 'Style'}) 24 | endfunction 25 | 26 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 27 | \ 'filetype': 'scss', 28 | \ 'name': 'scss_lint', 29 | \ 'exec': 'scss-lint' }) 30 | -------------------------------------------------------------------------------- /vim/bundle/snippets/snippets/rst.snippets: -------------------------------------------------------------------------------- 1 | # rst 2 | 3 | snippet : 4 | :${1:field name}: ${0:field body} 5 | snippet * 6 | *${1:Emphasis}* ${0} 7 | snippet ** 8 | **${1:Strong emphasis}** ${0} 9 | snippet _ 10 | \`${1:hyperlink-name}\`_ 11 | .. _\`$1\`: ${0:link-block} 12 | snippet = 13 | ${1:Title} 14 | =====${2:=} 15 | ${0} 16 | snippet - 17 | ${1:Title} 18 | -----${2:-} 19 | ${0} 20 | #some directive 21 | snippet img: 22 | .. |${0:alias}| image:: ${1:img} 23 | snippet fig: 24 | .. figure:: ${1:img} 25 | :alt: ${0:alter text} 26 | 27 | $2 28 | snippet cont: 29 | .. contents:: 30 | ${0:content} 31 | snippet code: 32 | .. code:: ${1:type} 33 | 34 | ${0:write some code} 35 | snippet tip: 36 | .. tip:: 37 | ${0:my tips} 38 | snippet not: 39 | .. note:: 40 | ${0:my notes} 41 | snippet war: 42 | .. warning:: 43 | ${0:attention!} 44 | snippet imp: 45 | .. important:: 46 | ${0:this is importatnt} 47 | snippet att: 48 | .. attention:: 49 | ${0:hey!} 50 | snippet dan: 51 | .. danger:: 52 | ${0:ah!} 53 | snippet err: 54 | .. error:: 55 | ${0:Error occur} 56 | snippet cau: 57 | .. caution:: 58 | ${0:Watch out!} 59 | #Spinx only 60 | snippet sid: 61 | .. sidebar:: ${1:Title} 62 | 63 | ${0} 64 | # CJK optimize, CJK has no space between charaters 65 | snippet *c 66 | \ *${1:Emphasis}*\ ${0} 67 | snippet **c 68 | \ **${1:Strong emphasis}**\ ${0} 69 | 70 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/python/flake8.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: flake8.vim 3 | "Description: Syntax checking plugin for syntastic.vim 4 | "Authors: Sylvain Soliman 5 | " kstep 6 | " 7 | "============================================================================ 8 | if exists("g:loaded_syntastic_python_flake8_checker") 9 | finish 10 | endif 11 | let g:loaded_syntastic_python_flake8_checker=1 12 | 13 | function! SyntaxCheckers_python_flake8_GetHighlightRegex(i) 14 | return SyntaxCheckers_python_pyflakes_GetHighlightRegex(a:i) 15 | endfunction 16 | 17 | function! SyntaxCheckers_python_flake8_GetLocList() dict 18 | let makeprg = self.makeprgBuild({}) 19 | 20 | let errorformat = 21 | \ '%E%f:%l: could not compile,%-Z%p^,' . 22 | \ '%E%f:%l:%c: F%n %m,' . 23 | \ '%W%f:%l:%c: C%n %m,' . 24 | \ '%W%f:%l:%c: %.%n %m,' . 25 | \ '%W%f:%l: %.%n %m,' . 26 | \ '%-G%.%#' 27 | 28 | return SyntasticMake({ 29 | \ 'makeprg': makeprg, 30 | \ 'errorformat': errorformat }) 31 | endfunction 32 | 33 | runtime! syntax_checkers/python/pyflakes.vim 34 | 35 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 36 | \ 'filetype': 'python', 37 | \ 'name': 'flake8'}) 38 | -------------------------------------------------------------------------------- /vim/bundle/snippets/snippets/progress.snippets: -------------------------------------------------------------------------------- 1 | # Progress/OpenEdge ABL snippets 2 | # define 3 | snippet defbuf 4 | DEFINE BUFFER b_${1:TableName} FOR $1 ${0}. 5 | snippet defvar 6 | DEFINE VARIABLE ${1:VariableName} AS ${0}. 7 | snippet nl 8 | NO-LOCK 9 | snippet ne 10 | NO-ERROR 11 | snippet nle 12 | NO-LOCK NO-ERROR 13 | snippet ini 14 | INITIAL ${0:?} 15 | snippet nu 16 | NO-UNDO 17 | snippet err 18 | ERROR 19 | snippet ff 20 | FIND FIRST ${1:BufferName} 21 | ${2:WHERE $1.${3}} ${0} 22 | snippet input 23 | DEFINE INPUT PARAMETER ${1:ParamName} AS ${0}. 24 | snippet output 25 | DEFINE OUTPUT PARAMETER ${1:ParamName} AS ${0:ParamType}. 26 | snippet proc 27 | 28 | /******************************************************************************/ 29 | 30 | PROCEDURE ${1:ProcName}: 31 | 32 | ${0} 33 | 34 | END PROCEDURE. /* $1 */ 35 | 36 | /******************************************************************************/ 37 | 38 | snippet alert 39 | MESSAGE "${1:MessageContent}" ${2:Data} VIEW-AS ALERT-BOX. 40 | snippet if 41 | IF ${1:Condition} 42 | THEN ${2:Action} 43 | ${3:ELSE ${4:OtherWise}} 44 | snippet do 45 | DO${1: Clauses}: 46 | ${0} 47 | END. 48 | # datatypes 49 | snippet int 50 | INTEGER 51 | snippet char 52 | CHARACTER 53 | snippet log 54 | LOGICAL 55 | snippet dec 56 | DECIMAL 57 | snippet sep 58 | /* ------------------------------------------------------------------------- */ 59 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/coq/coqtop.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: coqtop.vim 3 | "Description: Syntax checking plugin for syntastic.vim 4 | "Maintainer: Matvey Aksenov 5 | "License: This program is free software. It comes without any warranty, 6 | " to the extent permitted by applicable law. You can redistribute 7 | " it and/or modify it under the terms of the Do What The Fuck You 8 | " Want To Public License, Version 2, as published by Sam Hocevar. 9 | " See http://sam.zoy.org/wtfpl/COPYING for more details. 10 | " 11 | "============================================================================ 12 | 13 | if exists("g:loaded_syntastic_coq_coqtop_checker") 14 | finish 15 | endif 16 | let g:loaded_syntastic_coq_coqtop_checker=1 17 | 18 | function! SyntaxCheckers_coq_coqtop_GetLocList() dict 19 | let makeprg = self.makeprgBuild({ 'args': '-noglob -batch -load-vernac-source' }) 20 | 21 | let errorformat = 22 | \ '%AFile \"%f\"\, line %l\, characters %c\-%.%#\:,'. 23 | \ '%C%m' 24 | 25 | return SyntasticMake({ 26 | \ 'makeprg': makeprg, 27 | \ 'errorformat': errorformat }) 28 | endfunction 29 | 30 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 31 | \ 'filetype': 'coq', 32 | \ 'name': 'coqtop'}) 33 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/nroff/mandoc.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: mandoc.vim 3 | "Description: Syntax checking plugin for syntastic.vim 4 | "Maintainer: LCD 47 5 | "License: This program is free software. It comes without any warranty, 6 | " to the extent permitted by applicable law. You can redistribute 7 | " it and/or modify it under the terms of the Do What The Fuck You 8 | " Want To Public License, Version 2, as published by Sam Hocevar. 9 | " See http://sam.zoy.org/wtfpl/COPYING for more details. 10 | " 11 | "============================================================================ 12 | if exists("g:loaded_syntastic_nroff_mandoc_checker") 13 | finish 14 | endif 15 | let g:loaded_syntastic_nroff_mandoc_checker=1 16 | 17 | function! SyntaxCheckers_nroff_mandoc_GetLocList() dict 18 | let makeprg = self.makeprgBuild({ 'args': '-Tlint' }) 19 | 20 | let errorformat = 21 | \ '%E%f:%l:%c: %tRROR: %m,' . 22 | \ '%W%f:%l:%c: %tARNING: %m' 23 | 24 | return SyntasticMake({ 25 | \ 'makeprg': makeprg, 26 | \ 'errorformat': errorformat, 27 | \ 'returns': [0, 2, 3, 4] }) 28 | endfunction 29 | 30 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 31 | \ 'filetype': 'nroff', 32 | \ 'name': 'mandoc'}) 33 | 34 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/ruby/rubylint.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: rubylint.vim 3 | "Description: Checks Ruby source code using ruby-lint 4 | "Maintainer: Yorick Peterse 5 | "License: This program is free software. It comes without any warranty, 6 | " to the extent permitted by applicable law. You can redistribute 7 | " it and/or modify it under the terms of the Do What The Fuck You 8 | " Want To Public License, Version 2, as published by Sam Hocevar. 9 | " See http://sam.zoy.org/wtfpl/COPYING for more details. 10 | " 11 | "============================================================================ 12 | 13 | if exists("g:loaded_syntastic_ruby_rubylint_checker") 14 | finish 15 | endif 16 | 17 | let g:loaded_syntastic_ruby_rubylint_checker = 1 18 | 19 | function! SyntaxCheckers_ruby_rubylint_GetLocList() dict 20 | let makeprg = self.makeprgBuild({ 'args': 'analyze --presenter=syntastic' }) 21 | 22 | let errorformat = '%f:%t:%l:%c: %m' 23 | 24 | return SyntasticMake({ 25 | \ 'makeprg': makeprg, 26 | \ 'errorformat': errorformat }) 27 | endfunction 28 | 29 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 30 | \ 'filetype': 'ruby', 31 | \ 'name': 'rubylint', 32 | \ 'exec': 'ruby-lint'}) 33 | 34 | " vim: set ts=4 sts=4 sw=4: 35 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/cpp/oclint.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: oclint.vim 3 | "Description: Syntax checking plugin for syntastic.vim 4 | "Maintainer: "UnCO" Lin 5 | "License: This program is free software. It comes without any warranty, 6 | " to the extent permitted by applicable law. You can redistribute 7 | " it and/or modify it under the terms of the Do What The Fuck You 8 | " Want To Public License, Version 2, as published by Sam Hocevar. 9 | " See http://sam.zoy.org/wtfpl/COPYING for more details. 10 | "============================================================================ 11 | " 12 | " The setting 'g:syntastic_oclint_config_file' allows you to define a file 13 | " that contains additional compiler arguments like include directories or 14 | " CFLAGS. The file is expected to contain one option per line. If none is 15 | " given the filename defaults to '.syntastic_oclint_config': 16 | " 17 | " let g:syntastic_oclint_config_file = '.config' 18 | 19 | if exists("g:loaded_syntastic_cpp_oclint_checker") 20 | finish 21 | endif 22 | let g:loaded_syntastic_cpp_oclint_checker = 1 23 | 24 | runtime! syntax_checkers/c/*.vim 25 | 26 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 27 | \ 'filetype': 'cpp', 28 | \ 'name': 'oclint', 29 | \ 'redirect': 'c/oclint'}) 30 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/objc/oclint.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: oclint.vim 3 | "Description: Syntax checking plugin for syntastic.vim 4 | "Maintainer: "UnCO" Lin 5 | "License: This program is free software. It comes without any warranty, 6 | " to the extent permitted by applicable law. You can redistribute 7 | " it and/or modify it under the terms of the Do What The Fuck You 8 | " Want To Public License, Version 2, as published by Sam Hocevar. 9 | " See http://sam.zoy.org/wtfpl/COPYING for more details. 10 | "============================================================================ 11 | " 12 | " The setting 'g:syntastic_oclint_config_file' allows you to define a file 13 | " that contains additional compiler arguments like include directories or 14 | " CFLAGS. The file is expected to contain one option per line. If none is 15 | " given the filename defaults to '.syntastic_oclint_config': 16 | " 17 | " let g:syntastic_oclint_config_file = '.config' 18 | 19 | if exists("g:loaded_syntastic_objc_oclint_checker") 20 | finish 21 | endif 22 | let g:loaded_syntastic_objc_oclint_checker = 1 23 | 24 | runtime! syntax_checkers/c/*.vim 25 | 26 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 27 | \ 'filetype': 'objc', 28 | \ 'name': 'oclint', 29 | \ 'redirect': 'c/oclint'}) 30 | -------------------------------------------------------------------------------- /vim/bundle/vim-go/autoload/go/template.vim: -------------------------------------------------------------------------------- 1 | let s:current_file = expand("") 2 | 3 | function! go#template#create() 4 | let l:root_dir = fnamemodify(s:current_file, ':h:h:h') 5 | 6 | let cd = exists('*haslocaldir') && haslocaldir() ? 'lcd ' : 'cd ' 7 | let dir = getcwd() 8 | execute cd . fnameescape(expand("%:p:h")) 9 | 10 | let l:package_name = go#tool#PackageName() 11 | 12 | " if we can't figure out any package name(no Go files or non Go package 13 | " files) from the directory create the template 14 | if l:package_name == -1 15 | let l:template_file = get(g:, 'go_template_file', "hello_world.go") 16 | let l:template_path = go#util#Join(l:root_dir, "templates", l:template_file) 17 | exe '0r ' . fnameescape(l:template_path) 18 | $delete _ 19 | else 20 | let l:content = printf("package %s", l:package_name) 21 | call append(0, l:content) 22 | $delete _ 23 | endif 24 | 25 | " Remove the '... [New File]' message line from the command line 26 | echon 27 | 28 | execute cd . fnameescape(dir) 29 | endfunction 30 | 31 | function! go#template#ToggleAutoCreate() 32 | if get(g:, "go_template_autocreate", 1) 33 | let g:go_template_autocreate = 0 34 | call go#util#EchoProgress("auto template create disabled") 35 | return 36 | end 37 | 38 | let g:go_template_autocreate = 1 39 | call go#util#EchoProgress("auto template create enabled") 40 | endfunction 41 | 42 | " vim: sw=2 ts=2 et 43 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/dustjs/swiffer.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: swiffer.vim 3 | "Description: Dust.js syntax checker - using swiffer 4 | "Maintainer: Steven Foote 5 | "License: This program is free software. It comes without any warranty, 6 | " to the extent permitted by applicable law. You can redistribute 7 | " it and/or modify it under the terms of the Do What The Fuck You 8 | " Want To Public License, Version 2, as published by Sam Hocevar. 9 | " See http://sam.zoy.org/wtfpl/COPYING for more details. 10 | "============================================================================ 11 | 12 | if exists("g:loaded_syntastic_dustjs_swiffer_checker") 13 | finish 14 | endif 15 | 16 | let g:loaded_syntastic_dustjs_swiffer_checker = 1 17 | 18 | function! SyntaxCheckers_dustjs_swiffer_IsAvailable() dict 19 | return executable('swiffer') 20 | endfunction 21 | 22 | function! SyntaxCheckers_dustjs_swiffer_GetLocList() dict 23 | let makeprg = self.makeprgBuild({}) 24 | 25 | let errorformat = '%E%f - Line %l\, Column %c: %m' 26 | 27 | return SyntasticMake({ 28 | \ 'makeprg': makeprg, 29 | \ 'errorformat': errorformat }) 30 | endfunction 31 | 32 | call SyntasticRegistry.CreateAndRegisterChecker({ 33 | \ 'filetype': 'dustjs', 34 | \ 'name': 'swiffer'}) 35 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/json/jsonval.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: jsonval.vim 3 | "Description: JSON syntax checker - using jsonval 4 | "Maintainer: Miller Medeiros 5 | "License: This program is free software. It comes without any warranty, 6 | " to the extent permitted by applicable law. You can redistribute 7 | " it and/or modify it under the terms of the Do What The Fuck You 8 | " Want To Public License, Version 2, as published by Sam Hocevar. 9 | " See http://sam.zoy.org/wtfpl/COPYING for more details. 10 | "============================================================================ 11 | 12 | if exists("g:loaded_syntastic_json_jsonval_checker") 13 | finish 14 | endif 15 | let g:loaded_syntastic_json_jsonval_checker=1 16 | 17 | function! SyntaxCheckers_json_jsonval_GetLocList() dict 18 | " based on https://gist.github.com/1196345 19 | let makeprg = self.makeprgBuild({}) 20 | 21 | let errorformat = 22 | \ '%E%f:\ %m\ at\ line\ %l,' . 23 | \ '%-G%.%#' 24 | 25 | return SyntasticMake({ 26 | \ 'makeprg': makeprg, 27 | \ 'errorformat': errorformat, 28 | \ 'defaults': {'bufnr': bufnr('')} }) 29 | endfunction 30 | 31 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 32 | \ 'filetype': 'json', 33 | \ 'name': 'jsonval'}) 34 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/matlab/mlint.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: matlab.vim 3 | "Description: Syntax checking plugin for syntastic.vim 4 | "Maintainer: Jason Graham 5 | "License: This program is free software. It comes without any warranty, 6 | " to the extent permitted by applicable law. You can redistribute 7 | " it and/or modify it under the terms of the Do What The Fuck You 8 | " Want To Public License, Version 2, as published by Sam Hocevar. 9 | " See http://sam.zoy.org/wtfpl/COPYING for more details. 10 | " 11 | "============================================================================ 12 | 13 | if exists("g:loaded_syntastic_matlab_mlint_checker") 14 | finish 15 | endif 16 | let g:loaded_syntastic_matlab_mlint_checker=1 17 | 18 | function! SyntaxCheckers_matlab_mlint_GetLocList() dict 19 | let makeprg = self.makeprgBuild({ 'args': '-id $*' }) 20 | 21 | let errorformat = 22 | \ 'L %l (C %c): %*[a-zA-Z0-9]: %m,'. 23 | \ 'L %l (C %c-%*[0-9]): %*[a-zA-Z0-9]: %m' 24 | 25 | return SyntasticMake({ 26 | \ 'makeprg': makeprg, 27 | \ 'errorformat': errorformat, 28 | \ 'defaults': {'bufnr': bufnr("")} }) 29 | endfunction 30 | 31 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 32 | \ 'filetype': 'matlab', 33 | \ 'name': 'mlint'}) 34 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/objcpp/oclint.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: oclint.vim 3 | "Description: Syntax checking plugin for syntastic.vim 4 | "Maintainer: "UnCO" Lin 5 | "License: This program is free software. It comes without any warranty, 6 | " to the extent permitted by applicable law. You can redistribute 7 | " it and/or modify it under the terms of the Do What The Fuck You 8 | " Want To Public License, Version 2, as published by Sam Hocevar. 9 | " See http://sam.zoy.org/wtfpl/COPYING for more details. 10 | "============================================================================ 11 | " 12 | " The setting 'g:syntastic_oclint_config_file' allows you to define a file 13 | " that contains additional compiler arguments like include directories or 14 | " CFLAGS. The file is expected to contain one option per line. If none is 15 | " given the filename defaults to '.syntastic_oclint_config': 16 | " 17 | " let g:syntastic_oclint_config_file = '.config' 18 | 19 | if exists("g:loaded_syntastic_objcpp_oclint_checker") 20 | finish 21 | endif 22 | let g:loaded_syntastic_objcpp_oclint_checker = 1 23 | 24 | runtime! syntax_checkers/c/*.vim 25 | 26 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 27 | \ 'filetype': 'objcpp', 28 | \ 'name': 'oclint', 29 | \ 'redirect': 'c/oclint'}) 30 | -------------------------------------------------------------------------------- /vim/bundle/Dockerfile/snippets/Dockerfile.snippets: -------------------------------------------------------------------------------- 1 | snippet F 2 | FROM ${1:ubuntu} 3 | snippet f 4 | FROM ${1:ubuntu} 5 | snippet M 6 | MAINTAINER ${1:name} 7 | snippet m 8 | MAINTAINER ${1:name} 9 | snippet R 10 | RUN ${1:command} 11 | snippet r 12 | RUN ${1:command} 13 | snippet C 14 | CMD ${1:command} 15 | snippet c 16 | CMD ${1:command} 17 | snippet CP 18 | COPY ${1:src} ${2:dest} 19 | snippet cp 20 | COPY ${1:src} ${2:dest} 21 | snippet EXP 22 | EXPOSE ${1:port} 23 | snippet exp 24 | EXPOSE ${1:port} 25 | snippet E 26 | ENV ${1:key} ${2:value} 27 | snippet e 28 | ENV ${1:key} ${2:value} 29 | snippet A 30 | ADD ${1:src} ${2:dst} 31 | snippet a 32 | ADD ${1:src} ${2:dst} 33 | snippet ENT 34 | ENTRYPOINT ${1:command} 35 | snippet ent 36 | ENTRYPOINT ${1:command} 37 | snippet V 38 | VOLUME ["${1:path}"] 39 | snippet v 40 | VOLUME ["${1:path}"] 41 | snippet U 42 | USER ${1:name} 43 | snippet u 44 | USER ${1:name} 45 | snippet W 46 | WORKDIR ${1:path} 47 | snippet w 48 | WORKDIR ${1:path} 49 | snippet upd 50 | # update packages 51 | RUN echo "deb http://archive.ubuntu.com/ubuntu ${1:precise} main universe" > /etc/apt/sources.list; \ 52 | apt-get update && apt-get -y upgrade; \ 53 | ${2} 54 | snippet head 55 | # ${1:Description} 56 | # 57 | # VERSION ${2:0.1.0} 58 | ${3} 59 | snippet O 60 | ONBUILD ${1} 61 | snippet o 62 | ONBUILD ${1} 63 | snippet L 64 | LABEL ${1:label}="${2:value}" 65 | snippet l 66 | LABEL ${1:label}="${2:value}" 67 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/sh/checkbashisms.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: checkbashisms.vim 3 | "Description: Shell script syntax/style checking plugin for syntastic.vim 4 | "Notes: checkbashisms.pl can be downloaded from 5 | " http://debian.inode.at/debian/pool/main/d/devscripts/ 6 | " as part of the devscripts package. 7 | "============================================================================ 8 | 9 | if exists("g:loaded_syntastic_sh_checkbashisms_checker") 10 | finish 11 | endif 12 | let g:loaded_syntastic_sh_checkbashisms_checker=1 13 | 14 | function! SyntaxCheckers_sh_checkbashisms_GetLocList() dict 15 | let makeprg = self.makeprgBuild({ 'args': '-fx' }) 16 | 17 | let errorformat = 18 | \ '%-Gscript %f is already a bash script; skipping,' . 19 | \ '%Eerror: %f: %m\, opened in line %l,' . 20 | \ '%Eerror: %f: %m,' . 21 | \ '%Ecannot open script %f for reading: %m,' . 22 | \ '%Wscript %f %m,%C%.# lines,' . 23 | \ '%Wpossible bashism in %f line %l (%m):,%C%.%#,%Z.%#,' . 24 | \ '%-G%.%#' 25 | 26 | return SyntasticMake({ 27 | \ 'makeprg': makeprg, 28 | \ 'errorformat': errorformat, 29 | \ 'subtype': 'Style' }) 30 | endfunction 31 | 32 | 33 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 34 | \ 'filetype': 'sh', 35 | \ 'name': 'checkbashisms' }) 36 | -------------------------------------------------------------------------------- /vim/bundle/tlib/autoload/tlib/textobjects.vim: -------------------------------------------------------------------------------- 1 | " textobjects.vim 2 | " @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim]) 3 | " @Website: http://www.vim.org/account/profile.php?user_id=4037 4 | " @License: GPL (see http://www.gnu.org/licenses/gpl.txt) 5 | " @Created: 2010-01-09. 6 | " @Last Change: 2010-01-10. 7 | " @Revision: 0.0.29 8 | 9 | let s:save_cpo = &cpo 10 | set cpo&vim 11 | 12 | 13 | " :tag: standard-paragraph 14 | " Select a "Standard Paragraph", i.e. a text block followed by blank 15 | " lines. Other than |ap|, the last paragraph in a document is handled 16 | " just the same. 17 | " 18 | " The |text-object| can be accessed as "sp". Example: > 19 | " 20 | " vsp ... select the current standard paragraph 21 | " 22 | " Return 1, if the paragraph is the last one in the document. 23 | function! tlib#textobjects#StandardParagraph() "{{{3 24 | if line("'}") == line('$') 25 | norm! vip 26 | return 1 27 | else 28 | norm! vap 29 | return 0 30 | endif 31 | endf 32 | 33 | 34 | function! tlib#textobjects#Init() "{{{3 35 | if !exists('s:tlib_done_textobjects') 36 | " sp ... Standard paragraph (for use as |text-objects|). 37 | vnoremap sp :call tlib#textobjects#StandardParagraph() 38 | onoremap sp :normal Vsp 39 | let s:tlib_done_textobjects = 1 40 | endif 41 | endf 42 | 43 | 44 | let &cpo = s:save_cpo 45 | unlet s:save_cpo 46 | -------------------------------------------------------------------------------- /vim/bundle/vim-colors-solarized/doc/tags: -------------------------------------------------------------------------------- 1 | 'solarized_bold' solarized.txt /*'solarized_bold'* 2 | 'solarized_contrast' solarized.txt /*'solarized_contrast'* 3 | 'solarized_degrade' solarized.txt /*'solarized_degrade'* 4 | 'solarized_hitrail' solarized.txt /*'solarized_hitrail'* 5 | 'solarized_italic' solarized.txt /*'solarized_italic'* 6 | 'solarized_menu' solarized.txt /*'solarized_menu'* 7 | 'solarized_termcolors' solarized.txt /*'solarized_termcolors'* 8 | 'solarized_termtrans' solarized.txt /*'solarized_termtrans'* 9 | 'solarized_underline' solarized.txt /*'solarized_underline'* 10 | 'solarized_visibility' solarized.txt /*'solarized_visibility'* 11 | before solarized.txt /*before* 12 | solarized solarized.txt /*solarized* 13 | solarized-colors solarized.txt /*solarized-colors* 14 | solarized-colorscheme solarized.txt /*solarized-colorscheme* 15 | solarized-help solarized.txt /*solarized-help* 16 | solarized-install solarized.txt /*solarized-install* 17 | solarized-menu solarized.txt /*solarized-menu* 18 | solarized-options solarized.txt /*solarized-options* 19 | solarized-term solarized.txt /*solarized-term* 20 | solarized-togglebg solarized.txt /*solarized-togglebg* 21 | solarized.vim solarized.txt /*solarized.vim* 22 | toggle-background solarized.txt /*toggle-background* 23 | toggle-bg solarized.txt /*toggle-bg* 24 | togglebg solarized.txt /*togglebg* 25 | urxvt solarized.txt /*urxvt* 26 | vim-colors-solarized solarized.txt /*vim-colors-solarized* 27 | without solarized.txt /*without* 28 | -------------------------------------------------------------------------------- /vim/bundle/snippets/UltiSnips/cpp.snippets: -------------------------------------------------------------------------------- 1 | ########################################################################### 2 | # TextMate Snippets # 3 | ########################################################################### 4 | snippet beginend "$1.begin(), $1.end() (beginend)" 5 | ${1:v}${1/^.*?(-)?(>)?$/(?2::(?1:>:.))/}begin(), $1${1/^.*?(-)?(>)?$/(?2::(?1:>:.))/}end() 6 | endsnippet 7 | 8 | snippet cl "class .. (class)" 9 | class ${1:`!p snip.rv = snip.basename or "name"`} 10 | { 11 | public: 12 | ${1/(\w+).*/$1/} (${2:arguments}); 13 | virtual ~${1/(\w+).*/$1/} (); 14 | 15 | private: 16 | ${0:/* data */} 17 | }; 18 | endsnippet 19 | 20 | snippet ns "namespace .. (namespace)" 21 | namespace${1/.+/ /m}${1:`!p snip.rv = snip.basename or "name"`} 22 | { 23 | $0 24 | }${1/.+/ \/* /m}$1${1/.+/ *\/ /m} 25 | endsnippet 26 | 27 | snippet readfile "read file (readF)" 28 | std::vector v; 29 | if (FILE *fp = fopen(${1:"filename"}, "r")) 30 | { 31 | char buf[1024]; 32 | while(size_t len = fread(buf, 1, sizeof(buf), fp)) 33 | v.insert(v.end(), buf, buf + len); 34 | fclose(fp); 35 | } 36 | endsnippet 37 | 38 | snippet map "std::map (map)" 39 | std::map<${1:key}, ${2:value}> map$0; 40 | endsnippet 41 | 42 | snippet vector "std::vector (v)" 43 | std::vector<${1:char}> v$0; 44 | endsnippet 45 | 46 | snippet tp "template (template)" 47 | template 48 | endsnippet 49 | 50 | # vim:ft=snippets: 51 | -------------------------------------------------------------------------------- /vim/bundle/tlib/autoload/tlib/url.vim: -------------------------------------------------------------------------------- 1 | " url.vim 2 | " @Author: Tom Link (micathom AT gmail com?subject=[vim]) 3 | " @Website: http://www.vim.org/account/profile.php?user_id=4037 4 | " @License: GPL (see http://www.gnu.org/licenses/gpl.txt) 5 | " @Created: 2007-06-30. 6 | " @Last Change: 2011-03-10. 7 | " @Revision: 0.0.28 8 | 9 | 10 | " TODO: These functions could use printf() now. 11 | 12 | " Decode an encoded URL. 13 | function! tlib#url#Decode(url) "{{{3 14 | return substitute(a:url, '\(+\|%\(%\|\x\x\)\)', '\=tlib#url#DecodeChar(submatch(1))', 'g') 15 | endf 16 | 17 | 18 | " Decode a single character. 19 | function! tlib#url#DecodeChar(char) "{{{3 20 | if a:char == '%%' 21 | return '%' 22 | elseif a:char == '+' 23 | return ' ' 24 | else 25 | return nr2char("0x".a:char[1 : -1]) 26 | endif 27 | endf 28 | 29 | 30 | " Encode a single character. 31 | function! tlib#url#EncodeChar(char) "{{{3 32 | if a:char == '%' 33 | return '%%' 34 | elseif a:char == ' ' 35 | return '+' 36 | else 37 | return printf("%%%X", char2nr(a:char)) 38 | endif 39 | endf 40 | 41 | 42 | " Encode an URL. 43 | function! tlib#url#Encode(url, ...) "{{{3 44 | TVarArg ['extrachars', ''] 45 | let rx = '\([^a-zA-Z0-9_.'. extrachars .'-]\)' 46 | " TLogVAR a:url, rx 47 | let rv = substitute(a:url, rx, '\=tlib#url#EncodeChar(submatch(1))', 'g') 48 | " TLogVAR rv 49 | return rv 50 | endf 51 | 52 | 53 | -------------------------------------------------------------------------------- /vim/bundle/addon_mw_utils/doc/funcref.txt: -------------------------------------------------------------------------------- 1 | *funcref* create lazier function references. Pass arguments to create closure 2 | like function calls 3 | Author: Marc Weber, marco-oweber@gmx.de 4 | 5 | ----------------------------------------------------------------------- 6 | HOWTO~ 7 | 8 | Use *funcref#Function* to create a special dict called 9 | *faked-function-reference* which can be called by *funcref#Call* 10 | > 11 | { 'faked_function_reference': 'file#FuncName' } 12 | < passing some arguments and / or self: > 13 | { 'faked_function_reference': 'MyFunc', 'args': [1,2], 'self' : { a object ] } 14 | < You can also create lambda like functions which will be evaled: > 15 | { 'faked_function_reference': 'return ARGS[1]' } 16 | 17 | REASONS ~ 18 | Creating a Vim funcref pointing to an autoload function will make Vim source 19 | that file. This is not lazy enough. (Seems to be no longer true? Has this changed?) 20 | 21 | A Vim function reference neither allows attaching arguments nor self. 22 | 23 | Don't care about case of variables. Normally when using Vim function 24 | references you have to use variable names starting with an upper case letter 25 | (E704) 26 | 27 | Example: ~ 28 | > 29 | let f = funcref#Function('return ARGS[0].ARGS[1].SELF["key"]',{'args':[3], 'self':{'key': 'value'} }) 30 | echo funcref#Call(f, [2]) 31 | " prints "32value" 32 | 33 | echo funcref#Call('no value') 34 | < 35 | echo funcref#Call(f, [2]) 36 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/cucumber/cucumber.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: cucumber.vim 3 | "Description: Syntax checking plugin for syntastic.vim 4 | "Maintainer: Martin Grenfell 5 | "License: This program is free software. It comes without any warranty, 6 | " to the extent permitted by applicable law. You can redistribute 7 | " it and/or modify it under the terms of the Do What The Fuck You 8 | " Want To Public License, Version 2, as published by Sam Hocevar. 9 | " See http://sam.zoy.org/wtfpl/COPYING for more details. 10 | " 11 | "============================================================================ 12 | 13 | if exists("g:loaded_syntastic_cucumber_cucumber_checker") 14 | finish 15 | endif 16 | let g:loaded_syntastic_cucumber_cucumber_checker=1 17 | 18 | function! SyntaxCheckers_cucumber_cucumber_GetLocList() dict 19 | let makeprg = self.makeprgBuild({ 'args': '--dry-run --quiet --strict --format pretty' }) 20 | 21 | let errorformat = 22 | \ '%f:%l:%c:%m,' . 23 | \ '%W %.%# (%m),' . 24 | \ '%-Z%f:%l:%.%#,'. 25 | \ '%-G%.%#' 26 | 27 | return SyntasticMake({ 28 | \ 'makeprg': makeprg, 29 | \ 'errorformat': errorformat }) 30 | endfunction 31 | 32 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 33 | \ 'filetype': 'cucumber', 34 | \ 'name': 'cucumber'}) 35 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/rust/rustc.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: rust.vim 3 | "Description: Syntax checking plugin for syntastic.vim 4 | "Maintainer: Chad Jablonski 5 | "License: This program is free software. It comes without any warranty, 6 | " to the extent permitted by applicable law. You can redistribute 7 | " it and/or modify it under the terms of the Do What The Fuck You 8 | " Want To Public License, Version 2, as published by Sam Hocevar. 9 | " See http://sam.zoy.org/wtfpl/COPYING for more details. 10 | " 11 | "============================================================================ 12 | 13 | if exists("g:loaded_syntastic_rust_rustc_checker") 14 | finish 15 | endif 16 | let g:loaded_syntastic_rust_rustc_checker=1 17 | 18 | function! SyntaxCheckers_rust_rustc_GetLocList() dict 19 | let makeprg = self.makeprgBuild({ 'args': '--parse-only' }) 20 | 21 | let errorformat = 22 | \ '%E%f:%l:%c: \\d%#:\\d%# %.%\{-}error:%.%\{-} %m,' . 23 | \ '%W%f:%l:%c: \\d%#:\\d%# %.%\{-}warning:%.%\{-} %m,' . 24 | \ '%C%f:%l %m,' . 25 | \ '%-Z%.%#' 26 | 27 | return SyntasticMake({ 28 | \ 'makeprg': makeprg, 29 | \ 'errorformat': errorformat }) 30 | endfunction 31 | 32 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 33 | \ 'filetype': 'rust', 34 | \ 'name': 'rustc'}) 35 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/verilog/verilator.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: verilator.vim 3 | "Description: Syntax checking plugin for syntastic.vim 4 | "Maintainer: Kocha 5 | "============================================================================ 6 | 7 | if exists("g:loaded_syntastic_verilog_verilator_checker") 8 | finish 9 | endif 10 | let g:loaded_syntastic_verilog_verilator_checker = 1 11 | 12 | if !exists('g:syntastic_verilog_compiler') 13 | let g:syntastic_verilog_compiler = 'verilator' 14 | endif 15 | 16 | let s:save_cpo = &cpo 17 | set cpo&vim 18 | 19 | function! SyntaxCheckers_verilog_verilator_IsAvailable() dict 20 | return executable(expand(g:syntastic_verilog_compiler)) 21 | endfunction 22 | 23 | if !exists('g:syntastic_verilog_compiler_options') 24 | let g:syntastic_verilog_compiler_options = '-Wall' 25 | endif 26 | 27 | function! SyntaxCheckers_verilog_verilator_GetLocList() dict 28 | return syntastic#c#GetLocList('verilog', 'verilator', { 29 | \ 'errorformat': 30 | \ '%%%trror-%\=%\w%#: %f:%l: %m,' . 31 | \ '%%%tarning-%\=%\w%#: %f:%l: %m', 32 | \ 'main_flags': '--lint-only' }) 33 | endfunction 34 | 35 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 36 | \ 'filetype': 'verilog', 37 | \ 'name': 'verilator'}) 38 | 39 | let &cpo = s:save_cpo 40 | unlet s:save_cpo 41 | 42 | " vim: set et sts=4 sw=4: 43 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/twig/twiglint.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: twig.vim 3 | "Description: Syntax checking plugin for syntastic.vim 4 | "Maintainer: Alexander 5 | "License: This program is free software. It comes without any warranty, 6 | " to the extent permitted by applicable law. You can redistribute 7 | " it and/or modify it under the terms of the Do What The Fuck You 8 | " Want To Public License, Version 2, as published by Sam Hocevar. 9 | " See http://sam.zoy.org/wtfpl/COPYING for more details. 10 | " 11 | "============================================================================ 12 | 13 | if exists("g:loaded_syntastic_twig_twiglint_checker") 14 | finish 15 | endif 16 | let g:loaded_syntastic_twig_twiglint_checker=1 17 | 18 | function! SyntaxCheckers_twig_twiglint_GetHighlightRegex(item) 19 | " Let's match the full line for now 20 | return '\V' 21 | endfunction 22 | 23 | function! SyntaxCheckers_twig_twiglint_GetLocList() dict 24 | let makeprg = self.makeprgBuild({ 'args': 'lint --format=csv' }) 25 | 26 | let errorformat = '"%f"\,%l\,%m' 27 | 28 | return SyntasticMake({ 29 | \ 'makeprg': makeprg, 30 | \ 'errorformat': errorformat}) 31 | endfunction 32 | 33 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 34 | \ 'filetype': 'twig', 35 | \ 'name': 'twiglint', 36 | \ 'exec': 'twig-lint'}) 37 | -------------------------------------------------------------------------------- /vim/bundle/vim-go/ftplugin/go/snippets.vim: -------------------------------------------------------------------------------- 1 | if exists("g:go_loaded_gosnippets") 2 | finish 3 | endif 4 | let g:go_loaded_gosnippets = 1 5 | 6 | " by default UltiSnips 7 | if !exists("g:go_snippet_engine") 8 | let g:go_snippet_engine = "ultisnips" 9 | endif 10 | 11 | function! s:GoUltiSnips() 12 | if globpath(&rtp, 'plugin/UltiSnips.vim') == "" 13 | return 14 | endif 15 | 16 | if !exists("g:UltiSnipsSnippetDirectories") 17 | let g:UltiSnipsSnippetDirectories = ["gosnippets/UltiSnips"] 18 | else 19 | let g:UltiSnipsSnippetDirectories += ["gosnippets/UltiSnips"] 20 | endif 21 | endfunction 22 | 23 | function! s:GoNeosnippet() 24 | if globpath(&rtp, 'plugin/neosnippet.vim') == "" 25 | return 26 | endif 27 | 28 | let g:neosnippet#enable_snipmate_compatibility = 1 29 | 30 | let gosnippets_dir = globpath(&rtp, 'gosnippets/snippets') 31 | if type(g:neosnippet#snippets_directory) == type([]) 32 | let g:neosnippet#snippets_directory += [gosnippets_dir] 33 | elseif type(g:neosnippet#snippets_directory) == type("") 34 | if strlen(g:neosnippet#snippets_directory) > 0 35 | let g:neosnippet#snippets_directory = g:neosnippet#snippets_directory . "," . gosnippets_dir 36 | else 37 | let g:neosnippet#snippets_directory = gosnippets_dir 38 | endif 39 | endif 40 | endfunction 41 | 42 | if g:go_snippet_engine == "ultisnips" 43 | call s:GoUltiSnips() 44 | elseif g:go_snippet_engine == "neosnippet" 45 | call s:GoNeosnippet() 46 | endif 47 | 48 | " vim: sw=2 ts=2 et 49 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/co/coco.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: co.vim 3 | "Description: Syntax checking plugin for syntastic.vim 4 | "Maintainer: Andrew Kelley 5 | "License: This program is free software. It comes without any warranty, 6 | " to the extent permitted by applicable law. You can redistribute 7 | " it and/or modify it under the terms of the Do What The Fuck You 8 | " Want To Public License, Version 2, as published by Sam Hocevar. 9 | " See http://sam.zoy.org/wtfpl/COPYING for more details. 10 | " 11 | "============================================================================ 12 | if exists("g:loaded_syntastic_co_coco_checker") 13 | finish 14 | endif 15 | let g:loaded_syntastic_co_coco_checker=1 16 | 17 | "bail if the user doesnt have coco installed 18 | if !executable("coco") 19 | finish 20 | endif 21 | 22 | function! SyntaxCheckers_co_coco_GetLocList() dict 23 | let makeprg = self.makeprgBuild({ 'args': '-c -o /tmp' }) 24 | 25 | let errorformat = 26 | \ '%EFailed at: %f,' . 27 | \ '%ZSyntax%trror: %m on line %l,'. 28 | \ '%EFailed at: %f,'. 29 | \ '%Z%trror: Parse error on line %l: %m' 30 | 31 | return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat }) 32 | endfunction 33 | 34 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 35 | \ 'filetype': 'co', 36 | \ 'name': 'coco'}) 37 | -------------------------------------------------------------------------------- /vim/bundle/vim-go/ftplugin/go/tagbar.vim: -------------------------------------------------------------------------------- 1 | " Check if tagbar is installed under plugins or is directly under rtp 2 | " this covers pathogen + Vundle/Bundle 3 | " 4 | " Also make sure the ctags command exists 5 | " 6 | if !executable('ctags') 7 | finish 8 | elseif globpath(&rtp, 'plugin/tagbar.vim') == "" 9 | finish 10 | endif 11 | 12 | if !exists("g:go_gotags_bin") 13 | let g:go_gotags_bin = "gotags" 14 | endif 15 | 16 | 17 | function! s:SetTagbar() 18 | let bin_path = go#path#CheckBinPath(g:go_gotags_bin) 19 | if empty(bin_path) 20 | return 21 | endif 22 | 23 | if !exists("g:tagbar_type_go") 24 | let g:tagbar_type_go = { 25 | \ 'ctagstype' : 'go', 26 | \ 'kinds' : [ 27 | \ 'p:package', 28 | \ 'i:imports', 29 | \ 'c:constants', 30 | \ 'v:variables', 31 | \ 't:types', 32 | \ 'n:interfaces', 33 | \ 'w:fields', 34 | \ 'e:embedded', 35 | \ 'm:methods', 36 | \ 'r:constructor', 37 | \ 'f:functions' 38 | \ ], 39 | \ 'sro' : '.', 40 | \ 'kind2scope' : { 41 | \ 't' : 'ctype', 42 | \ 'n' : 'ntype' 43 | \ }, 44 | \ 'scope2kind' : { 45 | \ 'ctype' : 't', 46 | \ 'ntype' : 'n' 47 | \ }, 48 | \ 'ctagsbin' : bin_path, 49 | \ 'ctagsargs' : '-sort -silent' 50 | \ } 51 | endif 52 | endfunction 53 | 54 | 55 | call s:SetTagbar() 56 | 57 | " vim: sw=2 ts=2 et 58 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/ruby/macruby.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: macruby.vim 3 | "Description: Syntax checking plugin for syntastic.vim 4 | "License: This program is free software. It comes without any warranty, 5 | " to the extent permitted by applicable law. You can redistribute 6 | " it and/or modify it under the terms of the Do What The Fuck You 7 | " Want To Public License, Version 2, as published by Sam Hocevar. 8 | " See http://sam.zoy.org/wtfpl/COPYING for more details. 9 | " 10 | "============================================================================ 11 | if exists("g:loaded_syntastic_ruby_macruby_checker") 12 | finish 13 | endif 14 | let g:loaded_syntastic_ruby_macruby_checker=1 15 | 16 | function! SyntaxCheckers_ruby_macruby_GetLocList() dict 17 | let makeprg = self.makeprgBuild({ 18 | \ 'exe': 'RUBYOPT= ' . self.getExec(), 19 | \ 'args': '-W1 -c' }) 20 | 21 | let errorformat = 22 | \ '%-GSyntax OK,'. 23 | \ '%E%f:%l: syntax error\, %m,'. 24 | \ '%Z%p^,'. 25 | \ '%W%f:%l: warning: %m,'. 26 | \ '%Z%p^,'. 27 | \ '%W%f:%l: %m,'. 28 | \ '%-C%.%#' 29 | 30 | return SyntasticMake({ 31 | \ 'makeprg': makeprg, 32 | \ 'errorformat': errorformat }) 33 | endfunction 34 | 35 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 36 | \ 'filetype': 'ruby', 37 | \ 'name': 'macruby'}) 38 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/json/jsonlint.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: jsonlint.vim 3 | "Description: JSON syntax checker - using jsonlint 4 | "Maintainer: Miller Medeiros 5 | "License: This program is free software. It comes without any warranty, 6 | " to the extent permitted by applicable law. You can redistribute 7 | " it and/or modify it under the terms of the Do What The Fuck You 8 | " Want To Public License, Version 2, as published by Sam Hocevar. 9 | " See http://sam.zoy.org/wtfpl/COPYING for more details. 10 | "============================================================================ 11 | 12 | if exists("g:loaded_syntastic_json_jsonlint_checker") 13 | finish 14 | endif 15 | let g:loaded_syntastic_json_jsonlint_checker=1 16 | 17 | function! SyntaxCheckers_json_jsonlint_GetLocList() dict 18 | let makeprg = self.makeprgBuild({ 'post_args': '--compact' }) 19 | 20 | let errorformat = 21 | \ '%ELine %l:%c,'. 22 | \ '%Z\\s%#Reason: %m,'. 23 | \ '%C%.%#,'. 24 | \ '%f: line %l\, col %c\, %m,'. 25 | \ '%-G%.%#' 26 | 27 | return SyntasticMake({ 28 | \ 'makeprg': makeprg, 29 | \ 'errorformat': errorformat, 30 | \ 'defaults': {'bufnr': bufnr('')} }) 31 | endfunction 32 | 33 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 34 | \ 'filetype': 'json', 35 | \ 'name': 'jsonlint'}) 36 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/nasm/nasm.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: nasm.vim 3 | "Description: Syntax checking plugin for syntastic.vim 4 | "Maintainer: Håvard Pettersson 5 | "License: This program is free software. It comes without any warranty, 6 | " to the extent permitted by applicable law. You can redistribute 7 | " it and/or modify it under the terms of the Do What The Fuck You 8 | " Want To Public License, Version 2, as published by Sam Hocevar. 9 | " See http://sam.zoy.org/wtfpl/COPYING for more details. 10 | " 11 | "============================================================================ 12 | if exists("g:loaded_syntastic_nasm_nasm_checker") 13 | finish 14 | endif 15 | let g:loaded_syntastic_nasm_nasm_checker=1 16 | 17 | function! SyntaxCheckers_nasm_nasm_GetLocList() dict 18 | let wd = syntastic#util#shescape(expand("%:p:h") . "/") 19 | let makeprg = self.makeprgBuild({ 20 | \ 'args': '-X gnu -f elf' . 21 | \ ' -I ' . syntastic#util#shescape(expand("%:p:h") . "/") . 22 | \ ' ' . syntastic#c#NullOutput() }) 23 | 24 | let errorformat = '%f:%l: %t%*[^:]: %m' 25 | 26 | return SyntasticMake({ 27 | \ 'makeprg': makeprg, 28 | \ 'errorformat': errorformat }) 29 | endfunction 30 | 31 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 32 | \ 'filetype': 'nasm', 33 | \ 'name': 'nasm'}) 34 | -------------------------------------------------------------------------------- /vim/bundle/snippets/snippets/dart.snippets: -------------------------------------------------------------------------------- 1 | snippet lib 2 | #library('${1}'); 3 | ${0} 4 | snippet im 5 | #import('${1}'); 6 | ${0} 7 | snippet so 8 | #source('${1}'); 9 | ${0} 10 | snippet main 11 | static void main() { 12 | ${0} 13 | } 14 | snippet st 15 | static ${0} 16 | snippet fi 17 | final ${0} 18 | snippet re 19 | return ${0} 20 | snippet br 21 | break; 22 | snippet th 23 | throw ${0} 24 | snippet cl 25 | class ${1:`vim_snippets#Filename("", "untitled")`} ${0} 26 | snippet in 27 | interface ${1:`vim_snippets#Filename("", "untitled")`} ${0} 28 | snippet imp 29 | implements ${0} 30 | snippet ext 31 | extends ${0} 32 | snippet if 33 | if (${1:true}) { 34 | ${0} 35 | } 36 | snippet ife 37 | if (${1:true}) { 38 | ${2} 39 | } else { 40 | ${0} 41 | } 42 | snippet el 43 | else 44 | snippet sw 45 | switch (${1}) { 46 | ${0} 47 | } 48 | snippet cs 49 | case ${1}: 50 | ${0} 51 | snippet de 52 | default: 53 | ${0} 54 | snippet for 55 | for (var ${2:i} = 0, len = ${1:things}.length; $2 < len; ${3:++}$2) { 56 | ${0:$1[$2]} 57 | } 58 | snippet fore 59 | for (final ${2:item} in ${1:itemList}) { 60 | ${0} 61 | } 62 | snippet wh 63 | while (${1:/* condition */}) { 64 | ${0} 65 | } 66 | snippet dowh 67 | do { 68 | ${0} 69 | } while (${0:/* condition */}); 70 | snippet as 71 | assert(${0:/* condition */}); 72 | snippet try 73 | try { 74 | ${0} 75 | } catch (${1:Exception e}) { 76 | } 77 | snippet tryf 78 | try { 79 | ${0} 80 | } catch (${1:Exception e}) { 81 | } finally { 82 | } 83 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/coffee/coffeelint.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: coffeelint.vim 3 | "Description: Syntax checking plugin for syntastic.vim 4 | "Maintainer: Lincoln Stoll 5 | "License: This program is free software. It comes without any warranty, 6 | " to the extent permitted by applicable law. You can redistribute 7 | " it and/or modify it under the terms of the Do What The Fuck You 8 | " Want To Public License, Version 2, as published by Sam Hocevar. 9 | " See http://sam.zoy.org/wtfpl/COPYING for more details. 10 | " 11 | "============================================================================ 12 | if exists("g:loaded_syntastic_coffee_coffeelint_checker") 13 | finish 14 | endif 15 | let g:loaded_syntastic_coffee_coffeelint_checker=1 16 | 17 | function! SyntaxCheckers_coffee_coffeelint_GetLocList() dict 18 | let makeprg = self.makeprgBuild({ 'args': '--csv' }) 19 | 20 | let errorformat = 21 | \ '%f\,%l\,%\d%#\,%trror\,%m,' . 22 | \ '%f\,%l\,%trror\,%m,' . 23 | \ '%f\,%l\,%\d%#\,%tarn\,%m,' . 24 | \ '%f\,%l\,%tarn\,%m' 25 | 26 | return SyntasticMake({ 27 | \ 'makeprg': makeprg, 28 | \ 'errorformat': errorformat, 29 | \ 'subtype': 'Style', 30 | \ 'returns': [0, 1] }) 31 | endfunction 32 | 33 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 34 | \ 'filetype': 'coffee', 35 | \ 'name': 'coffeelint'}) 36 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/python/pep8.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: pep8.vim 3 | "Description: Syntax checking plugin for syntastic.vim 4 | "Maintainer: LCD 47 5 | "License: This program is free software. It comes without any warranty, 6 | " to the extent permitted by applicable law. You can redistribute 7 | " it and/or modify it under the terms of the Do What The Fuck You 8 | " Want To Public License, Version 2, as published by Sam Hocevar. 9 | " See http://sam.zoy.org/wtfpl/COPYING for more details. 10 | " 11 | "============================================================================ 12 | " 13 | " For details about pep8 see: https://github.com/jcrocholl/pep8 14 | 15 | if exists("g:loaded_syntastic_python_pep8_checker") 16 | finish 17 | endif 18 | let g:loaded_syntastic_python_pep8_checker=1 19 | 20 | function! SyntaxCheckers_python_pep8_GetLocList() dict 21 | let makeprg = self.makeprgBuild({}) 22 | 23 | let errorformat = '%f:%l:%c: %m' 24 | 25 | let loclist = SyntasticMake({ 26 | \ 'makeprg': makeprg, 27 | \ 'errorformat': errorformat, 28 | \ 'subtype': 'Style' }) 29 | 30 | for e in loclist 31 | let e['type'] = e['text'] =~? '^W' ? 'W' : 'E' 32 | endfor 33 | 34 | return loclist 35 | endfunction 36 | 37 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 38 | \ 'filetype': 'python', 39 | \ 'name': 'pep8'}) 40 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/handlebars/handlebars.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: handlebars.vim 3 | "Description: Syntax checking plugin for syntastic.vim 4 | "Maintainer: Martin Grenfell 5 | "License: This program is free software. It comes without any warranty, 6 | " to the extent permitted by applicable law. You can redistribute 7 | " it and/or modify it under the terms of the Do What The Fuck You 8 | " Want To Public License, Version 2, as published by Sam Hocevar. 9 | " See http://sam.zoy.org/wtfpl/COPYING for more details. 10 | "============================================================================ 11 | if exists("g:loaded_syntastic_handlebars_handlebars_checker") 12 | finish 13 | endif 14 | let g:loaded_syntastic_handlebars_handlebars_checker=1 15 | 16 | function! SyntaxCheckers_handlebars_handlebars_GetLocList() dict 17 | let makeprg = self.makeprgBuild({ 'args': '-f ' . syntastic#util#DevNull() }) 18 | 19 | let errorformat = 20 | \ '%EError: %m on line %l:,'. 21 | \ "%EError: %m,". 22 | \ '%Z%p^,' . 23 | \ '%-G%.%#' 24 | 25 | return SyntasticMake({ 26 | \ 'makeprg': makeprg, 27 | \ 'errorformat': errorformat, 28 | \ 'defaults': {'bufnr': bufnr("")} }) 29 | endfunction 30 | 31 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 32 | \ 'filetype': 'handlebars', 33 | \ 'name': 'handlebars'}) 34 | -------------------------------------------------------------------------------- /vim/bundle/snippets/snippets/autoit.snippets: -------------------------------------------------------------------------------- 1 | snippet if 2 | If ${1:condition} Then 3 | ${0:; True code} 4 | EndIf 5 | snippet el 6 | Else 7 | ${0} 8 | snippet eif 9 | ElseIf ${1:condition} Then 10 | ${0:; True code} 11 | # If/Else block 12 | snippet ife 13 | If ${1:condition} Then 14 | ${2:; True code} 15 | Else 16 | ${0:; Else code} 17 | EndIf 18 | # If/ElseIf/Else block - because there is eif this is not really neccessary 19 | snippet ifelif 20 | If ${1:condition 1} Then 21 | ${2:; True code} 22 | ElseIf ${3:condition 2} Then 23 | ${4:; True code} 24 | Else 25 | ${0:; Else code} 26 | EndIf 27 | # Switch block 28 | snippet switch 29 | Switch (${1:condition}) 30 | Case ${2:case1}: 31 | ${3:; Case 1 code} 32 | Case Else: 33 | ${0:; Else code} 34 | EndSwitch 35 | # Select block 36 | snippet select 37 | Select (${1:condition}) 38 | Case ${2:case1}: 39 | ${3:; Case 1 code} 40 | Case Else: 41 | ${0:; Else code} 42 | EndSelect 43 | # While loop 44 | snippet wh 45 | While (${1:condition}) 46 | ${0:; code...} 47 | WEnd 48 | # For loop 49 | snippet for 50 | For ${1:n} = ${3:1} to ${2:count} 51 | ${0:; code...} 52 | Next 53 | # New Function 54 | snippet func 55 | Func ${1:fname}(${2:`indent('.') ? 'self' : ''`}): 56 | ${0:Return} 57 | EndFunc 58 | # Message box 59 | snippet msg 60 | MsgBox(${0:MsgType}, ${1:"Title"}, ${2:"Message Text"}) 61 | # Debug Message 62 | snippet debug 63 | MsgBox(0, "Debug", ${0:"Debug Message"}) 64 | # Show Variable Debug Message 65 | snippet showvar 66 | MsgBox(0, "${0:VarName}", $1) 67 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/tcl/nagelfar.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: nagelfar.vim 3 | "Description: Syntax checking plugin for syntastic.vim 4 | "Maintainer: James Pickard 5 | "License: This program is free software. It comes without any warranty, 6 | " to the extent permitted by applicable law. You can redistribute 7 | " it and/or modify it under the terms of the Do What The Fuck You 8 | " Want To Public License, Version 2, as published by Sam Hocevar. 9 | " See http://sam.zoy.org/wtfpl/COPYING for more details. 10 | "Notes: Requires nagelfar v1.1.12 or later with support for -H option. 11 | " See nagelfar homepage http://nagelfar.berlios.de/. 12 | " 13 | "============================================================================ 14 | if exists("g:loaded_syntastic_tcl_nagelfar_checker") 15 | finish 16 | endif 17 | let g:loaded_syntastic_tcl_nagelfar_checker=1 18 | 19 | function! SyntaxCheckers_tcl_nagelfar_GetLocList() dict 20 | let makeprg = self.makeprgBuild({ 'args': '-H' }) 21 | 22 | let errorformat = 23 | \ '%I%f: %l: N %m,'. 24 | \ '%f: %l: %t %m,'. 25 | \ '%-GChecking file %f' 26 | 27 | return SyntasticMake({ 28 | \ 'makeprg': makeprg, 29 | \ 'errorformat': errorformat }) 30 | endfunction 31 | 32 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 33 | \ 'filetype': 'tcl', 34 | \ 'name': 'nagelfar'}) 35 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/scala/scalac.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: scala.vim 3 | "Description: Syntax checking plugin for syntastic.vim 4 | "Maintainer: Rickey Visinski 5 | "License: This program is free software. It comes without any warranty, 6 | " to the extent permitted by applicable law. You can redistribute 7 | " it and/or modify it under the terms of the Do What The Fuck You 8 | " Want To Public License, Version 2, as published by Sam Hocevar. 9 | " See http://sam.zoy.org/wtfpl/COPYING for more details. 10 | " 11 | "============================================================================ 12 | 13 | if exists("g:loaded_syntastic_scala_scalac_checker") 14 | finish 15 | endif 16 | let g:loaded_syntastic_scala_scalac_checker=1 17 | 18 | if !exists('g:syntastic_scala_options') 19 | let g:syntastic_scala_options = '' 20 | endif 21 | 22 | function! SyntaxCheckers_scala_scalac_GetLocList() dict 23 | let makeprg = self.makeprgBuild({ 24 | \ 'args': '-Ystop-after:parser ' . g:syntastic_scala_options }) 25 | 26 | let errorformat = 27 | \ '%E%f:%l: %trror: %m,' . 28 | \ '%Z%p^,' . 29 | \ '%-G%.%#' 30 | 31 | return SyntasticMake({ 32 | \ 'makeprg': makeprg, 33 | \ 'errorformat': errorformat }) 34 | endfunction 35 | 36 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 37 | \ 'filetype': 'scala', 38 | \ 'name': 'scalac'}) 39 | -------------------------------------------------------------------------------- /vim/bundle/snippets/UltiSnips/haskell.snippets: -------------------------------------------------------------------------------- 1 | snippet ife "if ... then ... else ..." 2 | if ${1:condition} 3 | then ${2:expression} 4 | else ${3:expression} 5 | endsnippet 6 | 7 | snippet case "case ... of ..." 8 | case ${1} of 9 | ${2} -> ${3} 10 | ${4} -> ${5} 11 | endsnippet 12 | 13 | snippet :: "Type signature" 14 | ${1:name} :: ${2:Type} -> ${3:Type} 15 | endsnippet 16 | 17 | snippet => "Type constraint" 18 | (${1:Class} ${2:Type var}) => ${3:$2} 19 | endsnippet 20 | 21 | snippet def "Function definition" 22 | ${1:name} :: ${2:Type} -> ${3:Type} 23 | endsnippet 24 | 25 | snippet def[] "Function definition for list patterns" 26 | ${1:name} :: [${2:Type}] -> ${3:Type} 27 | $1 [] = ${4:undefined} 28 | $1 ${5:(x:xs)} = ${6:undefined} 29 | endsnippet 30 | 31 | snippet = "Function clause" 32 | ${1:name} ${2:pattern} = ${3:undefined} 33 | endsnippet 34 | 35 | snippet 2= "Function clause" 36 | ${1:name} ${2:pattern} = ${3:undefined} 37 | $1 ${4:pattern} = ${5:undefined} 38 | endsnippet 39 | 40 | snippet 3= "Function clause" 41 | ${1:name} ${2:pattern} = ${3:undefined} 42 | $1 ${4:pattern} = ${5:undefined} 43 | $1 ${6:pattern} = ${7:undefined} 44 | endsnippet 45 | 46 | snippet | "Guard" 47 | | ${1:predicate} = ${2:undefined} 48 | endsnippet 49 | 50 | snippet \ "Lambda expression" 51 | \ ${1:pattern} -> ${2:expression} 52 | endsnippet 53 | 54 | snippet [|] "List comprehension" 55 | [${3:foo }$1 | ${1:x} <- ${2:xs} ] 56 | endsnippet 57 | 58 | snippet let "let ... in ..." 59 | let ${1:name} = ${2:expression} 60 | in ${3:expression} 61 | endsnippet 62 | -------------------------------------------------------------------------------- /vim/bundle/snippets/UltiSnips/mako.snippets: -------------------------------------------------------------------------------- 1 | ################# 2 | # From snipmate # 3 | ################# 4 | snippet def "definition" b 5 | <%def name="${1:name}"> 6 | ${2:} 7 | 8 | endsnippet 9 | 10 | snippet call "call" b 11 | <%call expr="${1:name}"> 12 | ${2:} 13 | 14 | endsnippet 15 | 16 | snippet doc "doc" b 17 | <%doc> 18 | ${1:} 19 | 20 | endsnippet 21 | 22 | snippet text "text" b 23 | <%text> 24 | ${1:} 25 | 26 | endsnippet 27 | 28 | snippet for "for" b 29 | % for ${1:i} in ${2:iter}: 30 | ${3:} 31 | % endfor 32 | endsnippet 33 | 34 | snippet if "if " b 35 | % if ${1:condition}: 36 | ${2:} 37 | % endif 38 | endsnippet 39 | 40 | snippet if "if/else" b 41 | % if ${1:condition}: 42 | ${2:} 43 | % else: 44 | ${3:} 45 | % endif 46 | endsnippet 47 | 48 | snippet try "try" b 49 | % try: 50 | ${1:} 51 | % except${2:}: 52 | ${3:pass} 53 | % endtry 54 | endsnippet 55 | 56 | snippet wh "wh" b 57 | % while ${1:}: 58 | ${2:} 59 | % endwhile 60 | endsnippet 61 | 62 | snippet $ "$" i 63 | ${${1:}} 64 | endsnippet 65 | 66 | snippet <% "<%" b 67 | <% ${1:} %> 68 | endsnippet 69 | 70 | snippet 72 | endsnippet 73 | 74 | snippet inherit "inherit" b 75 | <%inherit file="${1:filename}" /> 76 | endsnippet 77 | 78 | snippet include "include" b 79 | <%include file="${1:filename}" /> 80 | endsnippet 81 | 82 | snippet namespace "namespace" b 83 | <%namespace file="${1:name}" /> 84 | endsnippet 85 | 86 | snippet page "page" b 87 | <%page args="${1:}" /> 88 | endsnippet 89 | 90 | # vim:ft=snippets: 91 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/go/gofmt.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: gofmt.vim 3 | "Description: Check go syntax using 'gofmt -l' 4 | "Maintainer: Brandon Thomson 5 | "License: This program is free software. It comes without any warranty, 6 | " to the extent permitted by applicable law. You can redistribute 7 | " it and/or modify it under the terms of the Do What The Fuck You 8 | " Want To Public License, Version 2, as published by Sam Hocevar. 9 | " See http://sam.zoy.org/wtfpl/COPYING for more details. 10 | " 11 | " This syntax checker does not reformat your source code. 12 | " Use a BufWritePre autocommand to that end: 13 | " autocmd FileType go autocmd BufWritePre Fmt 14 | "============================================================================ 15 | if exists("g:loaded_syntastic_go_gofmt_checker") 16 | finish 17 | endif 18 | let g:loaded_syntastic_go_gofmt_checker=1 19 | 20 | function! SyntaxCheckers_go_gofmt_GetLocList() dict 21 | let makeprg = self.makeprgBuild({ 22 | \ 'args': '-l', 23 | \ 'tail': '> ' . syntastic#util#DevNull() }) 24 | 25 | let errorformat = '%f:%l:%c: %m,%-G%.%#' 26 | 27 | return SyntasticMake({ 28 | \ 'makeprg': makeprg, 29 | \ 'errorformat': errorformat, 30 | \ 'defaults': {'type': 'e'} }) 31 | endfunction 32 | 33 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 34 | \ 'filetype': 'go', 35 | \ 'name': 'gofmt'}) 36 | -------------------------------------------------------------------------------- /vim/bundle/tlib/autoload/tlib/tab.vim: -------------------------------------------------------------------------------- 1 | " tab.vim 2 | " @Author: Tom Link (micathom AT gmail com?subject=[vim]) 3 | " @Website: http://www.vim.org/account/profile.php?user_id=4037 4 | " @License: GPL (see http://www.gnu.org/licenses/gpl.txt) 5 | " @Created: 2007-08-27. 6 | " @Last Change: 2009-02-15. 7 | " @Revision: 0.0.29 8 | 9 | if &cp || exists("loaded_tlib_tab_autoload") 10 | finish 11 | endif 12 | let loaded_tlib_tab_autoload = 1 13 | 14 | 15 | " Return a dictionary of bufnumbers => [[tabpage, winnr] ...] 16 | function! tlib#tab#BufMap() "{{{3 17 | let acc = {} 18 | for t in range(tabpagenr('$')) 19 | let bb = tabpagebuflist(t + 1) 20 | for b in range(len(bb)) 21 | let bn = bb[b] 22 | let bd = [t + 1, b + 1] 23 | if has_key(acc, bn) 24 | call add(acc[bn], bd) 25 | else 26 | let acc[bn] = [bd] 27 | endif 28 | endfor 29 | endfor 30 | return acc 31 | endf 32 | 33 | 34 | " Find a buffer's window at some tab page. 35 | function! tlib#tab#TabWinNr(buffer) "{{{3 36 | let bn = bufnr(a:buffer) 37 | let bt = tlib#tab#BufMap() 38 | let tn = tabpagenr() 39 | let wn = winnr() 40 | let bc = get(bt, bn) 41 | if !empty(bc) 42 | for [t, w] in bc 43 | if t == tn 44 | return [t, w] 45 | endif 46 | endfor 47 | return bc[0] 48 | endif 49 | endf 50 | 51 | 52 | function! tlib#tab#Set(tabnr) "{{{3 53 | exec a:tabnr .'tabnext' 54 | endf 55 | 56 | -------------------------------------------------------------------------------- /vim/bundle/tube/CHANGELOG.md: -------------------------------------------------------------------------------- 1 | # Changelog 2 | 3 | ## 2.0 4 | - Removed options: `tube_enable_shortcuts`, `tube_run_command_background`. 5 | - Removed commands: `ToggleBufnameExp`, `ToggleFunctionExp`, `ToggleSelectionExp`, `RemoveAlias`, `AddAlias`, `RemoveAllAliases`, `ReloadAliases`, `TubeToggleClearScreen`. 6 | * Renamed commands: `TubeClear` to `TubeClr`, `TubeAliasClear` to `TubeAliasClr`, `TubeLastCommand` to `TubeLastCmd`, `TubeInterruptCommand` to `TubeInterrupt`. 7 | 8 | ## 1.2 9 | * Fix issues with commas when passing arguments to injected function. Now to separate arguments is required the special sequence '^^'. 10 | + New options: `tube_funargs_separator`. 11 | 12 | ## 1.1 13 | + New feature: selection injection into the command with the `@` character. 14 | + New feature: injected functions now can accept arguments. 15 | + New options: `tube_enable_shortcuts`, `tube_selection_expansion`. 16 | + New commands: `TubeToggleSelectionExp`. 17 | + Added shortcuts for most important commands (disabled by default). 18 | * Renamed options: `tube_at_character_expansion` to `tube_bufname_expansion`. 19 | * Renamed commands: `TubeToggleExpandPercent` to `TubeToggleBufnameExp`, `TubeToggleExpandFunction` to `TubeToggleFunctionExp`. 20 | * Fix issues with backslash escaping in commands. 21 | * Minor fixes. 22 | 23 | ## 1.1.1 24 | * Fix issues with plugin feedback. 25 | 26 | ## 1.1 27 | + New feature: the result of a custom vim function can be injected into the command with the special notation `#{CustomFunction}`. 28 | * Minor fixes. 29 | 30 | ## 1.0 31 | * First release. 32 | -------------------------------------------------------------------------------- /vim/bundle/snipmate/doc/tags: -------------------------------------------------------------------------------- 1 | :SnipMateOpenSnippetFiles SnipMate.txt /*:SnipMateOpenSnippetFiles* 2 | SnipMate SnipMate.txt /*SnipMate* 3 | SnipMate-Filename() SnipMate.txt /*SnipMate-Filename()* 4 | SnipMate-author SnipMate.txt /*SnipMate-author* 5 | SnipMate-changelog SnipMate.txt /*SnipMate-changelog* 6 | SnipMate-commands SnipMate.txt /*SnipMate-commands* 7 | SnipMate-contact SnipMate.txt /*SnipMate-contact* 8 | SnipMate-description SnipMate.txt /*SnipMate-description* 9 | SnipMate-disadvantages SnipMate.txt /*SnipMate-disadvantages* 10 | SnipMate-eval SnipMate.txt /*SnipMate-eval* 11 | SnipMate-interface SnipMate.txt /*SnipMate-interface* 12 | SnipMate-license SnipMate.txt /*SnipMate-license* 13 | SnipMate-mappings SnipMate.txt /*SnipMate-mappings* 14 | SnipMate-mirrors SnipMate.txt /*SnipMate-mirrors* 15 | SnipMate-multisnip SnipMate.txt /*SnipMate-multisnip* 16 | SnipMate-options SnipMate.txt /*SnipMate-options* 17 | SnipMate-placeholders SnipMate.txt /*SnipMate-placeholders* 18 | SnipMate-scopes SnipMate.txt /*SnipMate-scopes* 19 | SnipMate-settings SnipMate.txt /*SnipMate-settings* 20 | SnipMate-snippet-sources SnipMate.txt /*SnipMate-snippet-sources* 21 | SnipMate-syntax SnipMate.txt /*SnipMate-syntax* 22 | SnipMate-tabstops SnipMate.txt /*SnipMate-tabstops* 23 | SnipMate-usage SnipMate.txt /*SnipMate-usage* 24 | SnipMate-visual SnipMate.txt /*SnipMate-visual* 25 | SnipMate.txt SnipMate.txt /*SnipMate.txt* 26 | snipMate-extends SnipMate.txt /*snipMate-extends* 27 | snippet SnipMate.txt /*snippet* 28 | snippet-syntax SnipMate.txt /*snippet-syntax* 29 | snippets SnipMate.txt /*snippets* 30 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/less/less-lint.js: -------------------------------------------------------------------------------- 1 | // Generated by CoffeeScript 1.3.3 2 | (function() { 3 | var args, fs, less, options, parser; 4 | 5 | fs = require('fs'); 6 | 7 | less = require('less'); 8 | 9 | args = process.argv.slice(1); 10 | 11 | options = {}; 12 | 13 | args = args.filter(function(arg) { 14 | var match; 15 | match = arg.match(/^-I(.+)$/); 16 | if (match) { 17 | options.paths.push(match[1]); 18 | return false; 19 | } 20 | match = arg.match(/^--?([a-z][\-0-9a-z]*)(?:=([^\s]+))?$/i); 21 | if (match) { 22 | arg = match[1]; 23 | } else { 24 | return arg; 25 | } 26 | switch (arg) { 27 | case 'strict-imports': 28 | return options.strictImports = true; 29 | case 'include-path': 30 | return options.paths = match[2].split(os.type().match(/Windows/) ? ';' : ':').map(function(p) { 31 | if (p) { 32 | return path.resolve(process.cwd(), p); 33 | } 34 | }); 35 | case 'O0': 36 | return options.optimization = 0; 37 | case 'O1': 38 | return options.optimization = 1; 39 | case 'O2': 40 | return options.optimization = 2; 41 | } 42 | }); 43 | 44 | options.filename = args[1]; 45 | 46 | parser = new less.Parser(options); 47 | 48 | fs.readFile(options.filename, 'utf-8', function(err, data) { 49 | return parser.parse(data, function(err, tree) { 50 | if (err) { 51 | less.writeError(err); 52 | return process.exit(1); 53 | } 54 | }); 55 | }); 56 | 57 | }).call(this); 58 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/python/pep257.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: pep257.vim 3 | "Description: Docstring style checking plugin for syntastic.vim 4 | "============================================================================ 5 | " 6 | " For details about pep257 see: https://github.com/GreenSteam/pep257 7 | 8 | if exists("g:loaded_syntastic_python_pep257_checker") 9 | finish 10 | endif 11 | let g:loaded_syntastic_python_pep257_checker = 1 12 | 13 | " sanity: kill empty lines here rather than munging errorformat 14 | function! SyntaxCheckers_python_pep257_Preprocess(errors) 15 | return filter(copy(a:errors), 'v:val != ""') 16 | endfunction 17 | 18 | function! SyntaxCheckers_python_pep257_GetLocList() dict 19 | let makeprg = self.makeprgBuild({}) 20 | 21 | let errorformat = 22 | \ '%E%f:%l:%c%\%.%\%.%\d%\+:%\d%\+: %m,' . 23 | \ '%E%f:%l:%c: %m,' . 24 | \ '%+C %m' 25 | 26 | let loclist = SyntasticMake({ 27 | \ 'makeprg': makeprg, 28 | \ 'errorformat': errorformat, 29 | \ 'subtype': 'Style', 30 | \ 'preprocess': 'SyntaxCheckers_python_pep257_Preprocess', 31 | \ 'postprocess': ['compressWhitespace'] }) 32 | 33 | " pep257 outputs byte offsets rather than column numbers 34 | for e in loclist 35 | let e['col'] = get(e, 'col', 0) + 1 36 | endfor 37 | 38 | return loclist 39 | endfunction 40 | 41 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 42 | \ 'filetype': 'python', 43 | \ 'name': 'pep257'}) 44 | -------------------------------------------------------------------------------- /vim/bundle/syntastic/syntax_checkers/php/phpcs.vim: -------------------------------------------------------------------------------- 1 | "============================================================================ 2 | "File: phpcs.vim 3 | "Description: Syntax checking plugin for syntastic.vim 4 | "Maintainer: Martin Grenfell 5 | "License: This program is free software. It comes without any warranty, 6 | " to the extent permitted by applicable law. You can redistribute 7 | " it and/or modify it under the terms of the Do What The Fuck You 8 | " Want To Public License, Version 2, as published by Sam Hocevar. 9 | " See http://sam.zoy.org/wtfpl/COPYING for more details. 10 | " 11 | "============================================================================ 12 | " 13 | " See here for details of phpcs 14 | " - phpcs (see http://pear.php.net/package/PHP_CodeSniffer) 15 | " 16 | if exists("g:loaded_syntastic_php_phpcs_checker") 17 | finish 18 | endif 19 | let g:loaded_syntastic_php_phpcs_checker=1 20 | 21 | function! SyntaxCheckers_php_phpcs_GetLocList() dict 22 | let makeprg = self.makeprgBuild({ 'args': '--report=csv' }) 23 | 24 | let errorformat = 25 | \ '%-GFile\,Line\,Column\,Type\,Message\,Source\,Severity,'. 26 | \ '"%f"\,%l\,%c\,%t%*[a-zA-Z]\,"%m"\,%*[a-zA-Z0-9_.-]\,%*[0-9]' 27 | 28 | return SyntasticMake({ 29 | \ 'makeprg': makeprg, 30 | \ 'errorformat': errorformat, 31 | \ 'subtype': 'Style' }) 32 | endfunction 33 | 34 | call g:SyntasticRegistry.CreateAndRegisterChecker({ 35 | \ 'filetype': 'php', 36 | \ 'name': 'phpcs'}) 37 | -------------------------------------------------------------------------------- /vim/bundle/tlib/autoload/tlib/syntax.vim: -------------------------------------------------------------------------------- 1 | " syntax.vim 2 | " @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim]) 3 | " @Website: http://www.vim.org/account/profile.php?user_id=4037 4 | " @License: GPL (see http://www.gnu.org/licenses/gpl.txt) 5 | " @Created: 2007-11-19. 6 | " @Last Change: 2009-02-15. 7 | " @Revision: 0.0.11 8 | 9 | if &cp || exists("loaded_tlib_syntax_autoload") 10 | finish 11 | endif 12 | let loaded_tlib_syntax_autoload = 1 13 | let s:save_cpo = &cpo 14 | set cpo&vim 15 | 16 | 17 | function! tlib#syntax#Collect() "{{{3 18 | let acc = {} 19 | let syn = '' 20 | for line in tlib#cmd#OutputAsList('syntax') 21 | if line =~ '^---' 22 | continue 23 | elseif line =~ '^\w' 24 | let ml = matchlist(line, '^\(\w\+\)\s\+\(xxx\s\+\(.*\)\|\(cluster.*\)\)$') 25 | if empty(ml) 26 | echoerr 'Internal error: '. string(line) 27 | else 28 | let [m_0, syn, m_1, m_def1, m_def2; m_rest] = ml 29 | let acc[syn] = [empty(m_def1) ? m_def2 : m_def1] 30 | endif 31 | else 32 | call add(acc[syn], matchstr(line, '^\s\+\zs.*$')) 33 | endif 34 | endfor 35 | return acc 36 | endf 37 | 38 | 39 | " :def: function! tlib#syntax#Names(?rx='') 40 | function! tlib#syntax#Names(...) "{{{3 41 | TVarArg 'rx' 42 | let names = keys(tlib#syntax#Collect()) 43 | if !empty(rx) 44 | call filter(names, 'v:val =~ rx') 45 | endif 46 | return names 47 | endf 48 | 49 | 50 | let &cpo = s:save_cpo 51 | unlet s:save_cpo 52 | --------------------------------------------------------------------------------