Browse Source

[FEATURE] Add vim configuration

Adds the vim configuration
pull/2/head
Michael Gerdemann 8 years ago
parent
commit
ce99c1321f
  1. 23
      dotfiles/.vim/after/syntax/css.vim
  2. 28
      dotfiles/.vim/after/syntax/html.vim
  3. 132
      dotfiles/.vim/autoload/pathogen.vim
  4. 0
      dotfiles/.vim/backups/.gitignore
  5. 1080
      dotfiles/.vim/bundle/clojure.vim/autoload/vimclojure.vim
  6. 108
      dotfiles/.vim/bundle/clojure.vim/autoload/vimclojure/util.vim
  7. 80
      dotfiles/.vim/bundle/clojure.vim/bin/clj
  8. 55
      dotfiles/.vim/bundle/clojure.vim/bin/clj.bat
  9. 38
      dotfiles/.vim/bundle/clojure.vim/bin/kickoff.sh
  10. 77
      dotfiles/.vim/bundle/clojure.vim/bin/ng-server
  11. 57
      dotfiles/.vim/bundle/clojure.vim/bin/ng-server.bat
  12. 394
      dotfiles/.vim/bundle/clojure.vim/doc/clojure.txt
  13. 1
      dotfiles/.vim/bundle/clojure.vim/ftdetect/clojure.vim
  14. 146
      dotfiles/.vim/bundle/clojure.vim/ftplugin/clojure.vim
  15. 544
      dotfiles/.vim/bundle/clojure.vim/ftplugin/clojure/completions-clojure.core.txt
  16. 1
      dotfiles/.vim/bundle/clojure.vim/ftplugin/clojure/completions-clojure.data.txt
  17. 13
      dotfiles/.vim/bundle/clojure.vim/ftplugin/clojure/completions-clojure.inspector.txt
  18. 2
      dotfiles/.vim/bundle/clojure.vim/ftplugin/clojure/completions-clojure.java.browse.txt
  19. 19
      dotfiles/.vim/bundle/clojure.vim/ftplugin/clojure/completions-clojure.java.io.txt
  20. 8
      dotfiles/.vim/bundle/clojure.vim/ftplugin/clojure/completions-clojure.java.javadoc.txt
  21. 4
      dotfiles/.vim/bundle/clojure.vim/ftplugin/clojure/completions-clojure.java.shell.txt
  22. 13
      dotfiles/.vim/bundle/clojure.vim/ftplugin/clojure/completions-clojure.main.txt
  23. 25
      dotfiles/.vim/bundle/clojure.vim/ftplugin/clojure/completions-clojure.pprint.txt
  24. 13
      dotfiles/.vim/bundle/clojure.vim/ftplugin/clojure/completions-clojure.repl.txt
  25. 12
      dotfiles/.vim/bundle/clojure.vim/ftplugin/clojure/completions-clojure.set.txt
  26. 5
      dotfiles/.vim/bundle/clojure.vim/ftplugin/clojure/completions-clojure.stacktrace.txt
  27. 15
      dotfiles/.vim/bundle/clojure.vim/ftplugin/clojure/completions-clojure.string.txt
  28. 2
      dotfiles/.vim/bundle/clojure.vim/ftplugin/clojure/completions-clojure.template.txt
  29. 18
      dotfiles/.vim/bundle/clojure.vim/ftplugin/clojure/completions-clojure.test.junit.txt
  30. 6
      dotfiles/.vim/bundle/clojure.vim/ftplugin/clojure/completions-clojure.test.tap.txt
  31. 35
      dotfiles/.vim/bundle/clojure.vim/ftplugin/clojure/completions-clojure.test.txt
  32. 10
      dotfiles/.vim/bundle/clojure.vim/ftplugin/clojure/completions-clojure.walk.txt
  33. 13
      dotfiles/.vim/bundle/clojure.vim/ftplugin/clojure/completions-clojure.xml.txt
  34. 27
      dotfiles/.vim/bundle/clojure.vim/ftplugin/clojure/completions-clojure.zip.txt
  35. 259
      dotfiles/.vim/bundle/clojure.vim/indent/clojure.vim
  36. 60
      dotfiles/.vim/bundle/clojure.vim/plugin/clojure.vim
  37. 356
      dotfiles/.vim/bundle/clojure.vim/syntax/clojure.vim
  38. 28
      dotfiles/.vim/bundle/cocoa.vim/after/syntax/cocoa_keywords.vim
  39. 59
      dotfiles/.vim/bundle/cocoa.vim/after/syntax/objc_enhanced.vim
  40. 215
      dotfiles/.vim/bundle/cocoa.vim/autoload/objc/cocoacomplete.vim
  41. 185
      dotfiles/.vim/bundle/cocoa.vim/autoload/objc/man.vim
  42. 124
      dotfiles/.vim/bundle/cocoa.vim/autoload/objc/method_builder.vim
  43. 115
      dotfiles/.vim/bundle/cocoa.vim/autoload/objc/method_list.vim
  44. 87
      dotfiles/.vim/bundle/cocoa.vim/autoload/objc/pum_snippet.vim
  45. 154
      dotfiles/.vim/bundle/cocoa.vim/doc/cocoa.txt
  46. 85
      dotfiles/.vim/bundle/cocoa.vim/ftplugin/objc_cocoa_mappings.vim
  47. 637
      dotfiles/.vim/bundle/cocoa.vim/lib/cocoa_indexes/classes.txt
  48. 1714
      dotfiles/.vim/bundle/cocoa.vim/lib/cocoa_indexes/constants.txt
  49. 330
      dotfiles/.vim/bundle/cocoa.vim/lib/cocoa_indexes/functions.txt
  50. BIN
      dotfiles/.vim/bundle/cocoa.vim/lib/cocoa_indexes/methods.txt.gz
  51. 105
      dotfiles/.vim/bundle/cocoa.vim/lib/cocoa_indexes/notifications.txt
  52. 222
      dotfiles/.vim/bundle/cocoa.vim/lib/cocoa_indexes/types.txt
  53. 2
      dotfiles/.vim/bundle/cocoa.vim/lib/extras/README-if-you-like
  54. 2
      dotfiles/.vim/bundle/cocoa.vim/lib/extras/README_if_you_like
  55. 94
      dotfiles/.vim/bundle/cocoa.vim/lib/extras/build_syntaxfile.py
  56. 64
      dotfiles/.vim/bundle/cocoa.vim/lib/extras/cocoa_classes.py
  57. 100
      dotfiles/.vim/bundle/cocoa.vim/lib/extras/cocoa_definitions.py
  58. 637
      dotfiles/.vim/bundle/cocoa.vim/lib/extras/cocoa_indexes/classes.txt
  59. 1714
      dotfiles/.vim/bundle/cocoa.vim/lib/extras/cocoa_indexes/constants.txt
  60. 330
      dotfiles/.vim/bundle/cocoa.vim/lib/extras/cocoa_indexes/functions.txt
  61. BIN
      dotfiles/.vim/bundle/cocoa.vim/lib/extras/cocoa_indexes/methods.txt.gz
  62. 105
      dotfiles/.vim/bundle/cocoa.vim/lib/extras/cocoa_indexes/notifications.txt
  63. 222
      dotfiles/.vim/bundle/cocoa.vim/lib/extras/cocoa_indexes/types.txt
  64. 63
      dotfiles/.vim/bundle/cocoa.vim/lib/extras/cocoa_methods.py
  65. BIN
      dotfiles/.vim/bundle/cocoa.vim/lib/extras/superclasses
  66. 47
      dotfiles/.vim/bundle/cocoa.vim/lib/extras/superclasses.m
  67. 4
      dotfiles/.vim/bundle/cocoa.vim/lib/get_methods.sh
  68. 18
      dotfiles/.vim/bundle/cocoa.vim/plugin/cocoa.vim
  69. 43
      dotfiles/.vim/bundle/histwin.vim/Makefile
  70. 277
      dotfiles/.vim/bundle/histwin.vim/README
  71. 464
      dotfiles/.vim/bundle/histwin.vim/autoload/histwin.vim
  72. 277
      dotfiles/.vim/bundle/histwin.vim/doc/histwin.txt
  73. 790
      dotfiles/.vim/bundle/histwin.vim/histwin.vba
  74. 40
      dotfiles/.vim/bundle/histwin.vim/plugin/histwinPlugin.vim
  75. 64
      dotfiles/.vim/bundle/pastie.vim/doc/pastie.txt
  76. 486
      dotfiles/.vim/bundle/pastie.vim/plugin/pastie.vim
  77. 504
      dotfiles/.vim/colors/badwolf.vim
  78. 300
      dotfiles/.vim/colors/darkburn.vim
  79. 211
      dotfiles/.vim/colors/molokai.vim
  80. 225
      dotfiles/.vim/doc/ri.txt
  81. 262
      dotfiles/.vim/doc/tags
  82. 143
      dotfiles/.vim/doc/tags-ja
  83. 21
      dotfiles/.vim/ftdetect/ruby.vim
  84. 1
      dotfiles/.vim/ftdetect/zsh-theme.vim
  85. 292
      dotfiles/.vim/ftplugin/ri.vim
  86. 8
      dotfiles/.vim/snippets/_-gf3.snippets
  87. 30
      dotfiles/.vim/snippets/css-gf3.snippets
  88. 3
      dotfiles/.vim/snippets/html-gf3.snippets
  89. 35
      dotfiles/.vim/snippets/javascript-gf3.snippets
  90. 4
      dotfiles/.vim/snippets/sass-gf3.snippets
  91. 5
      dotfiles/.vim/spell/en.utf-8.add
  92. BIN
      dotfiles/.vim/spell/en.utf-8.add.spl
  93. 0
      dotfiles/.vim/swaps/.gitignore
  94. 9
      dotfiles/.vim/syntax/git-diff.vim
  95. 4
      dotfiles/.vim/syntax/git-log.vim
  96. 19
      dotfiles/.vim/syntax/git-status.vim
  97. 77
      dotfiles/.vim/syntax/json.vim
  98. 78
      dotfiles/.vim/syntax/ri.vim
  99. 2
      dotfiles/.vim/syntax/ruby.vim
  100. 0
      dotfiles/.vim/undo/.gitignore
  101. Some files were not shown because too many files have changed in this diff Show More

23
dotfiles/.vim/after/syntax/css.vim

@ -0,0 +1,23 @@
" Vim syntax file
" Language: CSS 3
" Maintainer: Shiao <i@shiao.org>
" Last Change: 2010 Apr 5
syn keyword cssTagName article aside audio bb canvas command datagrid
syn keyword cssTagName datalist details dialog embed figure footer
syn keyword cssTagName header hgroup keygen mark meter nav output
syn keyword cssTagName progress time ruby rt rp section time video
syn keyword cssTagName source figcaption
syn keyword cssColorProp contained opacity
syn match cssTextProp contained "\<word-wrap\>"
syn match cssTextProp contained "\<text-overflow\>"
syn match cssBoxProp contained "\<box-shadow\>"
syn match cssBoxProp contained "\<border-radius\>"
syn match cssBoxProp contained "\<border-\(\(top-left\|top-right\|bottom-right\|bottom-left\)-radius\)\>"
" firefox border-radius TODO
syn match cssBoxProp contained "-moz-border-radius\>"
syn match cssBoxProp contained "-moz-border-radius\(-\(bottomleft\|bottomright\|topright\|topleft\)\)\>"

28
dotfiles/.vim/after/syntax/html.vim

@ -0,0 +1,28 @@
" Vim syntax file
" Language: HTML (version 5)
" Maintainer: Rodrigo Machado <rcmachado@gmail.com>
" URL: http://gist.github.com/256840
" Last Change: 2010 Aug 26
" License: Public domain
" (but let me know if you liked it :) )
"
" Note: This file just adds the new tags from HTML 5
" and don't replace default html.vim syntax file
" HTML 5 tags
syn keyword htmlTagName contained article aside audio bb canvas command datagrid
syn keyword htmlTagName contained datalist details dialog embed figure footer
syn keyword htmlTagName contained header hgroup keygen mark meter nav output
syn keyword htmlTagName contained progress time ruby rt rp section time video
syn keyword htmlTagName contained source figcaption
" HTML 5 arguments
syn keyword htmlArg contained autofocus autocomplete placeholder min max step
syn keyword htmlArg contained contenteditable contextmenu draggable hidden item
syn keyword htmlArg contained itemprop list sandbox subject spellcheck
syn keyword htmlArg contained novalidate seamless pattern formtarget manifest
syn keyword htmlArg contained formaction formenctype formmethod formnovalidate
syn keyword htmlArg contained sizes scoped async reversed sandbox srcdoc
syn keyword htmlArg contained hidden role
syn match htmlArg "\<\(aria-[\-a-zA-Z0-9_]\+\)=" contained
syn match htmlArg contained "\s*data-[-a-zA-Z0-9_]\+"

132
dotfiles/.vim/autoload/pathogen.vim

@ -0,0 +1,132 @@
" pathogen.vim - path option manipulation
" Maintainer: Tim Pope <vimNOSPAM@tpope.org>
" Version: 1.2
" Install in ~/.vim/autoload (or ~\vimfiles\autoload).
"
" API is documented below.
if exists("g:loaded_pathogen") || &cp
finish
endif
let g:loaded_pathogen = 1
" Split a path into a list.
function! pathogen#split(path) abort " {{{1
if type(a:path) == type([]) | return a:path | endif
let split = split(a:path,'\\\@<!\%(\\\\\)*\zs,')
return map(split,'substitute(v:val,''\\\([\\,]\)'',''\1'',"g")')
endfunction " }}}1
" Convert a list to a path.
function! pathogen#join(...) abort " {{{1
if type(a:1) == type(1) && a:1
let i = 1
let space = ' '
else
let i = 0
let space = ''
endif
let path = ""
while i < a:0
if type(a:000[i]) == type([])
let list = a:000[i]
let j = 0
while j < len(list)
let escaped = substitute(list[j],'[,'.space.']\|\\[\,'.space.']\@=','\\&','g')
let path .= ',' . escaped
let j += 1
endwhile
else
let path .= "," . a:000[i]
endif
let i += 1
endwhile
return substitute(path,'^,','','')
endfunction " }}}1
" Convert a list to a path with escaped spaces for 'path', 'tag', etc.
function! pathogen#legacyjoin(...) abort " {{{1
return call('pathogen#join',[1] + a:000)
endfunction " }}}1
" Remove duplicates from a list.
function! pathogen#uniq(list) abort " {{{1
let i = 0
let seen = {}
while i < len(a:list)
if has_key(seen,a:list[i])
call remove(a:list,i)
else
let seen[a:list[i]] = 1
let i += 1
endif
endwhile
return a:list
endfunction " }}}1
" \ on Windows unless shellslash is set, / everywhere else.
function! pathogen#separator() abort " {{{1
return !exists("+shellslash") || &shellslash ? '/' : '\'
endfunction " }}}1
" Convenience wrapper around glob() which returns a list.
function! pathogen#glob(pattern) abort " {{{1
let files = split(glob(a:pattern),"\n")
return map(files,'substitute(v:val,"[".pathogen#separator()."/]$","","")')
endfunction "}}}1
" Like pathogen#glob(), only limit the results to directories.
function! pathogen#glob_directories(pattern) abort " {{{1
return filter(pathogen#glob(a:pattern),'isdirectory(v:val)')
endfunction "}}}1
" Prepend all subdirectories of path to the rtp, and append all after
" directories in those subdirectories.
function! pathogen#runtime_prepend_subdirectories(path) " {{{1
let sep = pathogen#separator()
let before = pathogen#glob_directories(a:path.sep."*[^~]")
let after = pathogen#glob_directories(a:path.sep."*[^~]".sep."after")
let rtp = pathogen#split(&rtp)
let path = expand(a:path)
call filter(rtp,'v:val[0:strlen(path)-1] !=# path')
let &rtp = pathogen#join(pathogen#uniq(before + rtp + after))
return &rtp
endfunction " }}}1
" For each directory in rtp, check for a subdirectory named dir. If it
" exists, add all subdirectories of that subdirectory to the rtp, immediately
" after the original directory. If no argument is given, 'bundle' is used.
" Repeated calls with the same arguments are ignored.
function! pathogen#runtime_append_all_bundles(...) " {{{1
let sep = pathogen#separator()
let name = a:0 ? a:1 : 'bundle'
if "\n".s:done_bundles =~# "\\M\n".name."\n"
return ""
endif
let s:done_bundles .= name . "\n"
let list = []
for dir in pathogen#split(&rtp)
if dir =~# '\<after$'
let list += pathogen#glob_directories(substitute(dir,'after$',name.sep.'*[^~]'.sep.'after','')) + [dir]
else
let list += [dir] + pathogen#glob_directories(dir.sep.name.sep.'*[^~]')
endif
endfor
let &rtp = pathogen#join(pathogen#uniq(list))
return 1
endfunction
let s:done_bundles = ''
" }}}1
" Invoke :helptags on all non-$VIM doc directories in runtimepath.
function! pathogen#helptags() " {{{1
for dir in pathogen#split(&rtp)
if dir[0 : strlen($VIM)-1] !=# $VIM && isdirectory(dir.'/doc') && (!filereadable(dir.'/doc/tags') || filewritable(dir.'/doc/tags'))
helptags `=dir.'/doc'`
endif
endfor
endfunction " }}}1
" vim:set ft=vim ts=8 sw=2 sts=2:

0
dotfiles/.vim/backups/.gitignore vendored

1080
dotfiles/.vim/bundle/clojure.vim/autoload/vimclojure.vim

File diff suppressed because it is too large Load Diff

108
dotfiles/.vim/bundle/clojure.vim/autoload/vimclojure/util.vim

@ -0,0 +1,108 @@
" Part of Vim filetype plugin for Clojure
" Language: Clojure
" Maintainer: Meikel Brandmeyer <mb@kotka.de>
let s:save_cpo = &cpo
set cpo&vim
function! vimclojure#util#SynIdName()
return synIDattr(synID(line("."), col("."), 0), "name")
endfunction
function! vimclojure#util#WithSaved(closure)
let v = a:closure.save()
try
let r = a:closure.f()
finally
call a:closure.restore(v)
endtry
return r
endfunction
function! s:SavePosition() dict
let [ _b, l, c, _o ] = getpos(".")
let b = bufnr("%")
return [b, l, c]
endfunction
function! s:RestorePosition(value) dict
let [b, l, c] = a:value
if bufnr("%") != b
execute b "buffer!"
endif
call setpos(".", [0, l, c, 0])
endfunction
function! vimclojure#util#WithSavedPosition(closure)
let a:closure.save = function("s:SavePosition")
let a:closure.restore = function("s:RestorePosition")
return vimclojure#util#WithSaved(a:closure)
endfunction
function! s:SaveRegister(reg)
return [a:reg, getreg(a:reg, 1), getregtype(a:reg)]
endfunction
function! s:SaveRegisters() dict
return map([self._register, "", "/", "-",
\ "0", "1", "2", "3", "4", "5", "6", "7", "8", "9"],
\ "s:SaveRegister(v:val)")
endfunction
function! s:RestoreRegisters(registers) dict
for register in a:registers
call call(function("setreg"), register)
endfor
endfunction
function! vimclojure#util#WithSavedRegister(reg, closure)
let a:closure._register = a:reg
let a:closure.save = function("s:SaveRegisters")
let a:closure.restore = function("s:RestoreRegisters")
return vimclojure#util#WithSaved(a:closure)
endfunction
function! s:SaveOption() dict
return eval("&" . self._option)
endfunction
function! s:RestoreOption(value) dict
execute "let &" . self._option . " = a:value"
endfunction
function! vimclojure#util#WithSavedOption(option, closure)
let a:closure._option = a:option
let a:closure.save = function("s:SaveOption")
let a:closure.restore = function("s:RestoreOption")
return vimclojure#util#WithSaved(a:closure)
endfunction
function! s:DoYank() dict
silent execute self.yank
return getreg(self.reg)
endfunction
function! vimclojure#util#Yank(r, how)
let closure = {
\ 'reg': a:r,
\ 'yank': a:how,
\ 'f': function("s:DoYank")
\ }
return vimclojure#util#WithSavedRegister(a:r, closure)
endfunction
function! vimclojure#util#MoveBackward()
call search('\S', 'Wb')
endfunction
function! vimclojure#util#MoveForward()
call search('\S', 'W')
endfunction
" Epilog
let &cpo = s:save_cpo

80
dotfiles/.vim/bundle/clojure.vim/bin/clj

@ -0,0 +1,80 @@
#!/bin/bash
# Copyright (c) Stephen C. Gilardi. All rights reserved. The use and
# distribution terms for this software are covered by the Eclipse Public
# License 1.0 (http://opensource.org/licenses/eclipse-1.0.php) which can be
# found in the file epl-v10.html at the root of this distribution. By
# using this software in any fashion, you are agreeing to be bound by the
# terms of this license. You must not remove this notice, or any other,
# from this software.
#
# clj-env-dir Launches Clojure, passing along command line arguments. This
# launcher can be configured using environment variables and
# makes it easy to include directories full of classpath roots
# in CLASSPATH.
#
# scgilardi (gmail)
# Created 7 January 2009
#
# Modified to read in an optional .clojure file in the current directory
# naming further items for the CLASSPATH.
#
# Meikel Brandmeyer (mb ? kotka ! de)
# Frankfurt am Main, 21.08.2009
#
# Environment variables (optional):
#
# CLOJURE_EXT Colon-delimited list of paths to directories whose top-level
# contents are (either directly or as symbolic links) jar
# files and/or directories whose paths will be in Clojure's
# classpath. The value of the CLASSPATH environment variable
# for Clojure will include these top-level paths followed by
# the previous value of CLASSPATH (if any).
# default:
# example: /usr/local/share/clojure/ext:$HOME/.clojure.d/ext
#
# CLOJURE_JAVA The command to launch a JVM instance for Clojure
# default: java
# example: /usr/local/bin/java6
#
# CLOJURE_OPTS Java options for this JVM instance
# default:
# example:"-Xms32M -Xmx128M -server"
#
# CLOJURE_MAIN The Java class to launch
# default: clojure.main
# example: clojure.contrib.repl_ln
set -o errexit
#set -o nounset
#set -o xtrace
if [ -n "${CLOJURE_EXT:-}" ]; then
OLD="$IFS"
IFS=":"
EXT="$(find -H ${CLOJURE_EXT} -mindepth 1 -maxdepth 1 -print0 | tr \\0 \:)"
IFS="$OLD"
if [ -n "${CLASSPATH:-}" ]; then
CLASSPATH="${EXT}${CLASSPATH}"
else
CLASSPATH="${EXT%:}"
fi
fi
if [ -f .clojure ]; then
for path in `cat .clojure`; do
if [ -n "${CLASSPATH:-}" ]; then
CLASSPATH="${path}:${CLASSPATH}"
else
CLASSPATH="${path%:}"
fi
done
fi
export CLASSPATH
JAVA=${CLOJURE_JAVA:-java}
OPTS=${CLOJURE_OPTS:-}
MAIN=${CLOJURE_MAIN:-clojure.main}
exec ${JAVA} ${OPTS} ${MAIN} "$@"

55
dotfiles/.vim/bundle/clojure.vim/bin/clj.bat

@ -0,0 +1,55 @@
@ECHO OFF
REM # Copyright (c) Stephen C. Gilardi. All rights reserved. The use and
REM # distribution terms for this software are covered by the Eclipse Public
REM # License 1.0 (http://opensource.org/licenses/eclipse-1.0.php) which can be
REM # found in the file epl-v10.html at the root of this distribution. By
REM # using this software in any fashion, you are agreeing to be bound by the
REM # terms of this license. You must not remove this notice, or any other,
REM # from this software.
REM #
REM # scgilardi (gmail)
REM # Created 7 January 2009
REM #
REM # Modified by Justin Johnson <justin _ honesthacker com> to run on Windows
REM # and to include a check for .clojure file in the current directory.
REM #
REM # Environment variables:
REM #
REM # Optional:
REM #
REM # CLOJURE_EXT The path to a directory containing (either directly or as
REM # symbolic links) jar files and/or directories whose paths
REM # should be in Clojure's classpath. The value of the
REM # CLASSPATH environment variable for Clojure will be a list
REM # of these paths followed by the previous value of CLASSPATH
REM # (if any).
REM #
REM # CLOJURE_JAVA The command to launch a JVM instance for Clojure
REM # default: java
REM # example: /usr/local/bin/java6
REM #
REM # CLOJURE_OPTS Java options for this JVM instance
REM # default:
REM # example:"-Xms32M -Xmx128M -server"
REM #
REM # Configuration files:
REM #
REM # Optional:
REM #
REM # .clojure A file sitting in the directory where you invoke ng-server.
REM # Each line contains a single path that should be added to the classpath.
REM #
SETLOCAL ENABLEDELAYEDEXPANSION
REM # Add all jar files from CLOJURE_EXT directory to classpath
IF DEFINED CLOJURE_EXT FOR %%E IN ("%CLOJURE_EXT%\*") DO SET CP=!CP!;%%~fE
IF NOT DEFINED CLOJURE_JAVA SET CLOJURE_JAVA=java
REM # If the current directory has a .clojure file in it, add each path
REM # in the file to the classpath.
IF EXIST .clojure FOR /F %%E IN (.clojure) DO SET CP=!CP!;%%~fE
%CLOJURE_JAVA% %CLOJURE_OPTS% -cp "%CP%" clojure.main %1 %2 %3 %4 %5 %6 %7 %8 %9

38
dotfiles/.vim/bundle/clojure.vim/bin/kickoff.sh

@ -0,0 +1,38 @@
#! /usr/bin/env bash
GRADLE_REV="0.8"
GRADLE_URL="http://dist.codehaus.org/gradle/gradle-${GRADLE_REV}-bin.zip"
GRADLE_ZIP="gradle.zip"
GRADLE_DIR="gradle-${GRADLE_REV}"
PLUGIN_REV="1.3.0"
PLUGIN_URL="http://clojars.org/repo/clojuresque/clojuresque/${PLUGIN_REV}/clojuresque-${PLUGIN_REV}.jar"
PLUGIN_JAR="clojuresque-${PLUGIN_REV}.jar"
CACHE_DIR="cache"
CACHE_GRADLE_ZIP="${CACHE_DIR}/${GRADLE_ZIP}"
CACHE_GRADLE_DIR="${CACHE_DIR}/${GRADLE_DIR}"
if [ ! -e "${CACHE_DIR}" ]; then
mkdir "${CACHE_DIR}"
fi
if [ ! -e "${CACHE_GRADLE_ZIP}" ]; then
wget ${GRADLE_URL} -O "${CACHE_GRADLE_ZIP}"
fi
if [ ! -e "${CACHE_GRADLE_DIR}" ]; then
pushd .
cd "${CACHE_DIR}"
unzip "${GRADLE_ZIP}"
popd
fi
if [ ! -e "${CACHE_PLUGIN_DIR}" ]; then
wget ${PLUGIN_URL} -O "${CACHE_GRADLE_DIR}/lib/${PLUGIN_JAR}"
fi
echo "clojure=clojuresque.ClojurePlugin" >> "${CACHE_GRADLE_DIR}/plugin.properties"
echo "Don't forget to set GRADLE_HOME!"
echo "export GRADLE_HOME=\"${CACHE_GRADLE_DIR}\""

77
dotfiles/.vim/bundle/clojure.vim/bin/ng-server

@ -0,0 +1,77 @@
#! /usr/bin/env bash
# Copyright (c) Stephen C. Gilardi. All rights reserved. The use and
# distribution terms for this software are covered by the Eclipse Public
# License 1.0 (http://opensource.org/licenses/eclipse-1.0.php) which can be
# found in the file epl-v10.html at the root of this distribution. By
# using this software in any fashion, you are agreeing to be bound by the
# terms of this license. You must not remove this notice, or any other,
# from this software.
#
# clj-env-dir Launches Clojure, passing along command line arguments. This
# launcher can be configured using environment variables and
# makes it easy to include directories full of classpath roots
# in CLASSPATH.
#
# scgilardi (gmail)
# Created 7 January 2009
#
# Modified to act as launcher for the Nailgun server and to read in an
# optional .clojure file in the current directory naming further items
# for the CLASSPATH.
#
# Meikel Brandmeyer (mb ? kotka ! de)
# Frankfurt am Main, 21.08.2009
#
# Environment variables (optional):
#
# CLOJURE_EXT Colon-delimited list of paths to directories whose top-level
# contents are (either directly or as symbolic links) jar
# files and/or directories whose paths will be in Clojure's
# classpath. The value of the CLASSPATH environment variable
# for Clojure will include these top-level paths followed by
# the previous value of CLASSPATH (if any).
# default:
# example: /usr/local/share/clojure/ext:$HOME/.clojure.d/ext
#
# CLOJURE_JAVA The command to launch a JVM instance for Clojure
# default: java
# example: /usr/local/bin/java6
#
# CLOJURE_OPTS Java options for this JVM instance
# default:
# example:"-Xms32M -Xmx128M -server"
#
# .clojure A file in the current directory. Every line names an item
# which will be added to the CLASSPATH.
set -o errexit
#set -o nounset
#set -o xtrace
if [ -n "${CLOJURE_EXT:-}" ]; then
OLD="$IFS"
IFS=":"
EXT="$(find -H ${CLOJURE_EXT} -mindepth 1 -maxdepth 1 -print0 | tr \\0 \:)"
IFS="$OLD"
if [ -n "${CLASSPATH:-}" ]; then
export CLASSPATH="${EXT}${CLASSPATH}"
else
export CLASSPATH="${EXT%:}"
fi
fi
if [ -f .clojure ]; then
for path in `cat .clojure`; do
if [ -n "${CLASSPATH:-}" ]; then
export CLASSPATH="${path}:${CLASSPATH}"
else
export CLASSPATH="${path%:}"
fi
done
fi
JAVA=${CLOJURE_JAVA:-java}
OPTS=${CLOJURE_OPTS:-}
exec ${JAVA} ${OPTS} vimclojure.nailgun.NGServer 127.0.0.1 "$@"

57
dotfiles/.vim/bundle/clojure.vim/bin/ng-server.bat

@ -0,0 +1,57 @@
@ECHO OFF
REM # Copyright (c) Stephen C. Gilardi. All rights reserved. The use and
REM # distribution terms for this software are covered by the Eclipse Public
REM # License 1.0 (http://opensource.org/licenses/eclipse-1.0.php) which can be
REM # found in the file epl-v10.html at the root of this distribution. By
REM # using this software in any fashion, you are agreeing to be bound by the
REM # terms of this license. You must not remove this notice, or any other,
REM # from this software.
REM #
REM # scgilardi (gmail)
REM # Created 7 January 2009
REM #
REM # Modified by Justin Johnson <justin _ honesthacker com> to act as Windows
REM # launcher for the Nailgun server of VimClojure, and to include a check for
REM # a .clojure file in the current directory.
REM #
REM # Environment variables:
REM #
REM # Optional:
REM #
REM # CLOJURE_EXT The path to a directory containing (either directly or as
REM # symbolic links) jar files and/or directories whose paths
REM # should be in Clojure's classpath. The value of the
REM # CLASSPATH environment variable for Clojure will be a list
REM # of these paths followed by the previous value of CLASSPATH
REM # (if any).
REM #
REM # CLOJURE_JAVA The command to launch a JVM instance for Clojure
REM # default: java
REM # example: /usr/local/bin/java6
REM #
REM # CLOJURE_OPTS Java options for this JVM instance
REM # default:
REM # example:"-Xms32M -Xmx128M -server"
REM #
REM # Configuration files:
REM #
REM # Optional:
REM #
REM # .clojure A file sitting in the directory where you invoke ng-server.
REM # Each line contains a single path that should be added to the classpath.
REM #
SETLOCAL ENABLEDELAYEDEXPANSION
REM # Add all jar files from CLOJURE_EXT directory to classpath
IF DEFINED CLOJURE_EXT FOR %%E IN ("%CLOJURE_EXT%\*") DO SET CP=!CP!;%%~fE
IF NOT DEFINED CLOJURE_JAVA SET CLOJURE_JAVA=java
REM # If the current directory has a .clojure file in it, add each path
REM # in the file to the classpath.
IF EXIST .clojure FOR /F %%E IN (.clojure) DO SET CP=!CP!;%%~fE
REM # Since we do not provide any security we at least bind only to the loopback.
%CLOJURE_JAVA% %CLOJURE_OPTS% -cp "%CP%" vimclojure.nailgun.NGServer 127.0.0.1 %1 %2 %3 %4 %5 %6 %7 %8 %9

394
dotfiles/.vim/bundle/clojure.vim/doc/clojure.txt

@ -0,0 +1,394 @@
*vimclojure.txt* *clojure.vim*
VimClojure - A Clojure Environment
==================================
Introduction
------------
VimClojure is a filetype plugin and development environment for Clojure. It
provides indenting, syntax highlighting and – if configured – interactive
features like omni completion, documentation lookup and a Repl running in a
Vim buffer.
Nailgun Server *clj-nailgun-server*
--------------
To use the interactive part you have to start the nailgun server via the jar
file. Make sure, that clojure and clojure-contrib are in your classpath and
start the vimclojure.nailgun.NGServer class. Example invocation:
>
java -cp clojure.jar:clojure-contrib.jar:vimclojure.jar vimclojure.nailgun.NGServer 127.0.0.1
<
This may look different depending on your system.
You can stop the server by invoking the nailgun client with the ng-stop
argument.
>
ng ng-stop
<
Set the vimclojure#WantNailgun variable in your vimrc.
>
let vimclojure#WantNailgun = 1
<
The actual server to connect to and the port of said server can be given
via configuration variables. The defaults are:
>
let vimclojure#NailgunServer = "127.0.0.1"
let vimclojure#NailgunPort = "2113"
<
Note: Should there be an error when executing an interactive command
and the error message goes away to quickly, you can use |:messages| to
recall the message and read it conveniently without time pressure.
VimClojure might pop up windows, like the preview window or the Repl.
The place where this is done may be controlled with the SplitPos variable.
Possible values are "left", "right", "top" and "bottom". The default is
"top".
Example:
>
let vimclojure#SplitPos = "left"
<
It is also possible to specify the size of the new window. The size is
specified in lines/columns.
>
let vimclojure#SplitSize = 10
<
Errors
------
Errors are reported in a temporary buffer. This is to make error messages
more readable. In particular when they contain stacktraces from the Java
side. However this may interfer with scripts which do not expect that a
new buffer pops up. So one can go back to the old behaviour.
>
let vimclojure#UseErrorBuffer = 0
<
Note: the error might not be shown by vim. Check the output of |:message|
for errors.
Syntax Highlighting *ft-clj-syntax*
-------------------
The clojure syntax highlighting provides several options:
>
g:vimclojure#HighlightBuiltins
If it is nonzero, then Clojure's builtin functions are
highlighted. This useful to distuingish macros and special
forms from functions. Enabled by default.
g:vimclojure#ParenRainbow
Controls the colorisation of the differing levels of
parenthesisation. If non-zero, different levels will be
colored differently. Disabled by default.
g:vimclojure#DynamicHighlighting
Uses the dynamic features of VimClojure to dynamically add
the symbols of required and used namespaces. The file needs
to be correct (ie. w/o syntax errors and on the classpath)
for this to work. If this is not the case, dynamic
highlighting is not done. Disabled by default.
<
The g:vimclojure#ParenRainbow option provides 10 levels of individual
colorisation for the parentheses. Because of the quantity of colorisation
levels, unlike non-rainbow highlighting, the rainbow mode specifies its
highlighting using ctermfg and guifg, thereby bypassing the usual colorscheme
control using standard highlighting groups. The actual highlighting used
depends on the dark/bright setting (see |'bg'|).
To customise the paren rainbow colors provide a from levels to the desired
color definitions.
>
let vimclojure#ParenRainbowColors = {
\ '1': 'guifg=green',
\ ...
\ }
<
This will be used for all settings of 'bg'. If you want to specify only
for light resp. dark backgrounds, just add "Light" resp. "Dark" to the
option name.
Indenting *ft-clj-indent*
---------
VimClojure provides the (hopefully) correct indentation rules for
the standard forms and macros. However user code might define also
forms for which the indentation should follow the indentation according
to the 'lispwords' option. The names of these forms often follow a
pattern like "defsomething" or "with-something".
By setting the fuzzy indent option, you can tell VimClojure, that you
want names beginning in "def" or "with" to be indented as if they
were included in the 'lispwords' option.
>
let vimclojure#FuzzyIndent = 1
<
This option is disabled by default.
Preview Window
--------------
Many of the below mentioned commands open the so called preview window.
It displays information obtained from the lookup functions and the omni
completion. You may close the preview window with <LocalLeader>p.
Note: The preview window sometimes doesn't not adhere to the SplitPos
variable. This is the case, eg. for omni completion. It happens when
the preview window is created by Vim and not by VimClojure itself. At
the moment, I don't know how to fix this.
Keybindings
-----------
Note: <LocalLeader> is a Vim feature. More information can be found
under the |maplocalleader| help topic.
You can redefine any key mapping using some autocommand in your .vimrc file.
All mappings use so-called Plugs. Simply prepend <Plug>Clojure to the given
Plug name and your setting will override the default mapping.
>
aucmd BufRead,BufNewFile *.clj nmap xyz <Plug>ClojureEvalToplevel
<
<LocalLeader>et *et* *EvalToplevel*
Send off the toplevel sexpression currently
containing the cursor to the Clojure server.
<LocalLeader>ef *ef* *EvalFile*
Send off the current file to the Clojure Server.
<LocalLeader>eb *eb* *EvalBlock*
Send off the the mark visual block to the
Clojure server. Obviously this mapping is only
active in visual mode.
Note: This does not check for structure.
<LocalLeader>el *el* *EvalLine*
Send off the current line to the Clojure Server.
Note: This does not check for structure.
<LocalLeader>ep *ep* *EvalParagraph*
Send off the current paragraph to the Clojure Server.
Note: This does not check for structure.
<LocalLeader>rf *rf* *RequireFile*
Require the namespace of the current file with
the :reload flag. Note: For this to work with
a remote Clojure server, the files have to put in
place before issueing the command, eg. via scp
or NFS.
<LocalLeader>rF *rF* *RequireFileAll*
Require the namespace of the current file with
the :reload-all flag. Note: For this to work with
a remote Clojure server, the files have to put in
place before issueing the command, eg. via scp
or NFS.
<LocalLeader>rt *rt* *RunTests*
Require the namespace of the filename with the
:reload flag. Then use clojure.contrib.test-is
to run the tests of the namespace via run-tests.
Note: For this to work with a remote Clojure
server, the files have to put in place before
issueing the command, eg. via scp or NFS.
<LocalLeader>me *me* *MacroExpand*
Expand the innermost sexpression currently
containing the cursor using macroexpand.
<LocalLeader>m1 *m1* *MacroExpand1*
Same as MacroExpand, but use macroexpand-1.
<LocalLeader>lw *lw* *DocLookupWord*
Lookup up the word under the cursor and print
the documentation for it via (doc).
<LocalLeader>li *li* *DocLookupInteractive*
Lookup the documentation of an arbitrary word.
The user is prompted for input.
<LocalLeader>fd *fd* *FindDoc*
Find a the documentation for a given pattern
with (find-doc). The user is prompted for input.
<LocalLeader>jw *jw* *JavadocLookupWord*
Open the javadoc for the word under the cursor
in an external browser.
<LocalLeader>ji *ji* *JavadocLookupInteractive*
Open the javadoc for an arbitrary word in an
external browser. The user is prompted for input.
<LocalLeader>sw *sw* *SourceLookupWord*
Show a read-only view of the source the word under
the cursor. For this to work, the source must be
available in the Classpath or as a file (depending
on how the source was loaded).
<LocalLeader>si *si* *SourceLookupInteractive*
Show a read-only view of the source of an arbitrary
word. For this to work, the source must be available
in the Classpath or as a file (depending on how the
source was loaded).
<LocalLeader>gw *gw* *GotoSourceWord*
Goto the source of the word under the cursor. For this
to work, the source must be available in a directory
of the |'path'| option. The directories in the
CLOJURE_SOURCE_DIRS environment variable will be added
to the |'path'| setting.
<LocalLeader>gi *gi* *GotoSourceInteractive*
Goto the source of an arbitrary word. For this to work,
the source must be available in a directory of the
|'path'| option. The directories in the
CLOJURE_SOURCE_DIRS environment variable will be added
to the |'path'| setting.
<LocalLeader>mw *mw* *MetaLookupWord*
Lookup the meta data of the word under the cursor.
<LocalLeader>mi *mi* *MetaLookupInteractive*
Lookup the meta data of an arbitrary word. The
user is prompted for input.
<LocalLeader>sr *sr* *StartRepl*
Start a new Vim Repl in a fresh buffer. There
might be multiple Repls at the same time.
<LocalLeader>sR *sR* *StartLocalRepl*
Start a new Vim Repl in a fresh buffer. Initialise
the namespace to be the namespace of the current
buffer. Note: this will 'require' the namespace!
The following key mappings are also supported if the dynamic features are
turned off.
<LocalLeader>aw *aw* *AddToLispWords*
Add the word under the cursor to the lispwords option
of the buffer. This modifies the way the form is
indented.
<LocalLeader>tr *tr* *ToggleParenRainbow*
Toggle the paren rainbow option. Note: After
toggling the default colors will be used. Not any
customised ones.
Vim Repl
--------
Start a Repl via the |sr| shortcut. At the prompt just type expressions.
Hitting enter will determine, whether the expression is complete and
will send it to the Clojure instance. In case the expression is incomplete,
eg. after "(defn foo" will result in a newline for multiline expressions.
A newline will also be inserted if you are inside of the expression. The
expression will only be submitted to the Repl when you hit enter after
the last character of the buffer. If you are inside the expression and
want to start the evaluation immediately you may use <C-CR> instead of
the plain <CR>.
Previously sent expressions may be recalled via <C-Up> and <C-Down>.
Note: sending multiple expressions will save them in the same history
entry. So playing back with <C-Up> will again send all of the contained
expressions.
If the current line starts with a repl prompt, the *^* command moves to
the end of the prompt and to the beginning of the line.
The Plugs are:
- <Plug>ClojureReplEnterHook for the enter key
- <Plug>ClojureReplEvaluate for immediate evaluation (<C-CR>)
- <Plug>ClojureReplHatHook for ^ navigation
- <Plug>ClojureReplUpHistory for going backwards in history (<C-Up>)
- <Plug>ClojureReplDownHistory for going forwards in history (<C-Down>)
The following convenience commands are provided:
- ,close - close the Repl and free the Repl resources in the server process
- ,st - print a stack trace of *e as with clojure.contrib.stacktrace
- ,ct - print a cause trace of *e as with clojure.contrib.stacktrace
- ,toggle-pprint - toggle pretty-printing of evaluated values
You can also start a Repl with the :ClojureRepl command. This command works
regardless of the type of the current buffer, while the shortcuts only work in
Clojure buffers.
Pretty Printing
---------------
In case Tom Faulhaber's cl-format package is available in the Classpath
it will be used for pretty printing, eg. of macroexpansions. The Repl
can be told to use pretty printing via a global Var.
>
(set! vimclojure.repl/*print-pretty* true)
<
Omni Completion
---------------
VimClojure supports omni completion for Clojure code. Hitting <C-X><C-O> in
insert mode will try to provide completions for the item in front of the
cursor.
The completion tries to be somewhat intelligent in what it completes.
- a word starting with an upper case letter will be completed to an
imported class.
Str<C-x><C-o> => String, StringBuilder, ...
- a word containing dots will be completed to a namespace.
c.c<C-x><C-o> => clojure.core, clojure.contrib.repl-utils, ...
- everything else will be completed to a Var, an alias or namespace.
- a word containing a slash will be handled differently
- if the word starts with an upper case letter, will complete
static fields of the given class
String/va<C-x><C-o> => String/valueOf
- otherwise it is treated as a namespace or alias
clojure.core/re<C-x><C-o> => clojure.core/read, ...
The completion uses certain characters to split the matching. This are
hyphens and (for namespaces) dots. So r-s<C-x><C-o> matches read-string.
Note: Completion of symbols and keywords is also provided via the <C-N>
functionality of Vim.
Known Issues
------------
There seems to be a race condition in nailgun. At the moment there is
no solution to this problem. In case you get errors with valid looking
input for vim, please contact me.
License
-------
Copyright (c) 2008-2011 Meikel Brandmeyer, Frankfurt am Main
All rights reserved.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
==============================================================================
.. vim: set ft=help norl ts=8 tw=78 et :

1
dotfiles/.vim/bundle/clojure.vim/ftdetect/clojure.vim

@ -0,0 +1 @@
au BufNewFile,BufRead *.clj set filetype=clojure

146
dotfiles/.vim/bundle/clojure.vim/ftplugin/clojure.vim

@ -0,0 +1,146 @@
" Vim filetype plugin file
" Language: Clojure
" Maintainer: Meikel Brandmeyer <mb@kotka.de>
" Only do this when not done yet for this buffer
if exists("b:did_ftplugin")
finish
endif
let b:did_ftplugin = 1
let s:cpo_save = &cpo
set cpo&vim
let b:undo_ftplugin = "setlocal fo< com< cms< cpt< isk< def<"
setlocal iskeyword+=?,-,*,!,+,/,=,<,>,.,:
setlocal define=^\\s*(def\\(-\\|n\\|n-\\|macro\\|struct\\|multi\\)?
" Set 'formatoptions' to break comment lines but not other lines,
" and insert the comment leader when hitting <CR> or using "o".
setlocal formatoptions-=t formatoptions+=croql
setlocal commentstring=;%s
" Set 'comments' to format dashed lists in comments.
setlocal comments=sO:;\ -,mO:;\ \ ,n:;
" Take all directories of the CLOJURE_SOURCE_DIRS environment variable
" and add them to the path option.
if has("win32") || has("win64")
let s:delim = ";"
else
let s:delim = ":"
endif
for dir in split($CLOJURE_SOURCE_DIRS, s:delim)
call vimclojure#AddPathToOption(dir . "/**", 'path')
endfor
" When the matchit plugin is loaded, this makes the % command skip parens and
" braces in comments.
let b:match_words = &matchpairs
let b:match_skip = 's:comment\|string\|character'
" Win32 can filter files in the browse dialog
if has("gui_win32") && !exists("b:browsefilter")
let b:browsefilter = "Clojure Source Files (*.clj)\t*.clj\n" .
\ "Jave Source Files (*.java)\t*.java\n" .
\ "All Files (*.*)\t*.*\n"
endif
for ns in [ "clojure.core", "clojure.inspector", "clojure.java.browse",
\ "clojure.java.io", "clojure.java.javadoc", "clojure.java.shell",
\ "clojure.main", "clojure.pprint", "clojure.repl", "clojure.set",
\ "clojure.stacktrace", "clojure.string", "clojure.template",
\ "clojure.test", "clojure.test.tap", "clojure.test.junit",
\ "clojure.walk", "clojure.xml", "clojure.zip" ]
call vimclojure#AddCompletions(ns)
endfor
" Define toplevel folding if desired.
function! ClojureGetFoldingLevelWorker() dict
execute self.lineno
if vimclojure#util#SynIdName() =~ 'clojureParen\d' && vimclojure#util#Yank('l', 'normal! "lyl') == '('
return 1
endif
if searchpairpos('(', '', ')', 'bWr', 'vimclojure#util#SynIdName() !~ "clojureParen\\d"') != [0, 0]
return 1
endif
return 0
endfunction
function! ClojureGetFoldingLevel(lineno)
let closure = {
\ 'lineno' : a:lineno,
\ 'f' : function("ClojureGetFoldingLevelWorker")
\ }
return vimclojure#WithSavedPosition(closure)
endfunction
" Disabled for now. Too slow (and naive).
if exists("g:clj_want_folding") && g:clj_want_folding == 1 && 0 == 1
setlocal foldexpr=ClojureGetFoldingLevel(v:lnum)
setlocal foldmethod=expr
endif
try
call vimclojure#InitBuffer()
catch /.*/
" We swallow a failure here. It means most likely that the
" server is not running.
echohl WarningMsg
echomsg v:exception
echohl None
endtry
call vimclojure#MapPlug("n", "aw", "AddToLispWords")
call vimclojure#MapPlug("n", "tr", "ToggleParenRainbow")
call vimclojure#MapPlug("n", "lw", "DocLookupWord")
call vimclojure#MapPlug("n", "li", "DocLookupInteractive")
call vimclojure#MapPlug("n", "jw", "JavadocLookupWord")
call vimclojure#MapPlug("n", "ji", "JavadocLookupInteractive")
call vimclojure#MapPlug("n", "fd", "FindDoc")
call vimclojure#MapPlug("n", "mw", "MetaLookupWord")
call vimclojure#MapPlug("n", "mi", "MetaLookupInteractive")
call vimclojure#MapPlug("n", "sw", "SourceLookupWord")
call vimclojure#MapPlug("n", "si", "SourceLookupInteractive")
call vimclojure#MapPlug("n", "gw", "GotoSourceWord")
call vimclojure#MapPlug("n", "gi", "GotoSourceInteractive")
call vimclojure#MapPlug("n", "rf", "RequireFile")
call vimclojure#MapPlug("n", "rF", "RequireFileAll")
call vimclojure#MapPlug("n", "rt", "RunTests")
call vimclojure#MapPlug("n", "me", "MacroExpand")
call vimclojure#MapPlug("n", "m1", "MacroExpand1")
call vimclojure#MapPlug("n", "ef", "EvalFile")
call vimclojure#MapPlug("n", "el", "EvalLine")
call vimclojure#MapPlug("v", "eb", "EvalBlock")
call vimclojure#MapPlug("n", "et", "EvalToplevel")
call vimclojure#MapPlug("n", "ep", "EvalParagraph")
call vimclojure#MapPlug("n", "sr", "StartRepl")
call vimclojure#MapPlug("n", "sR", "StartLocalRepl")
if exists("b:vimclojure_namespace")
setlocal omnifunc=vimclojure#OmniCompletion
augroup VimClojure
autocmd CursorMovedI <buffer> if pumvisible() == 0 | pclose | endif
augroup END
endif
call vimclojure#MapPlug("n", "p", "CloseResultBuffer")
let &cpo = s:cpo_save

544
dotfiles/.vim/bundle/clojure.vim/ftplugin/clojure/completions-clojure.core.txt

@ -0,0 +1,544 @@
*agent*
*allow-unresolved-vars*
*assert*
*clojure-version*
*command-line-args*
*compile-files*
*compile-path*
*err*
*file*
*flush-on-newline*
*fn-loader*
*in*
*math-context*
*ns*
*out*
*print-dup*
*print-length*
*print-level*
*print-meta*
*print-readably*
*read-eval*
*source-path*
*unchecked-math*
*use-context-classloader*
*verbose-defrecords*
*warn-on-reflection*
->>
-cache-protocol-fn
-reset-methods
EMPTY-NODE
accessor
aclone
add-classpath
add-watch
agent
agent-error
agent-errors
aget
alength
alias
all-ns
alter
alter-meta!
alter-var-root
amap
ancestors
and
apply
areduce
array-map
aset
aset-boolean
aset-byte
aset-char
aset-double
aset-float
aset-int
aset-long
aset-short
assert
assoc
assoc!
assoc-in
associative?
atom
await
await-for
await1
bases
bean
bigdec
bigint
biginteger
binding
bit-and
bit-and-not
bit-clear
bit-flip
bit-not
bit-or
bit-set
bit-shift-left
bit-shift-right
bit-test
bit-xor
boolean
boolean-array
booleans
bound-fn
bound-fn*
bound?
butlast
byte
byte-array
bytes
case
cast
char
char-array
char-escape-string
char-name-string
char?
chars
chunk
chunk-append
chunk-buffer
chunk-cons
chunk-first
chunk-next
chunk-rest
chunked-seq?
class
class?
clear-agent-errors
clojure-version
coll?
comment
commute
comp
comparator
compare
compare-and-set!
compile
complement
concat
cond
condp
conj
conj!
cons
constantly
construct-proxy
contains?
count
counted?
create-ns
create-struct
cycle
dec
dec'
decimal?
declare
definline
definterface
defmacro
defmethod
defmulti
defn
defn-
defonce
defprotocol
defrecord
defstruct
deftype
delay
delay?
deliver
denominator
deref
derive
descendants
destructure
disj
disj!
dissoc
dissoc!
distinct
distinct?
doall
dorun
doseq
dosync
dotimes
doto
double
double-array
doubles
drop
drop-last
drop-while
empty
empty?
ensure
enumeration-seq
error-handler
error-mode
eval
even?
every-pred
every?
extend
extend-protocol
extend-type
extenders
extends?
false?
ffirst
file-seq
filter
find
find-keyword
find-ns
find-protocol-impl
find-protocol-method
find-var
first
flatten
float
float-array
float?
floats
flush
fn?
fnext
fnil
for
force
format
frequencies
future
future-call
future-cancel
future-cancelled?
future-done?
future?
gen-class
gen-interface
gensym
get
get-in
get-method
get-proxy-class
get-thread-bindings
get-validator
group-by
hash
hash-combine
hash-map
hash-set
identical?
identity
if-let
if-not
ifn?
import
in-ns
inc
inc'
init-proxy
instance?
int
int-array
integer?
interleave
intern
interpose
into
into-array
ints
io!
isa?
iterate
iterator-seq
juxt
keep
keep-indexed
key
keys
keyword
keyword?
last
lazy-cat
lazy-seq
let
letfn
line-seq
list
list*
list?
load
load-file
load-reader
load-string
loaded-libs
locking
long
long-array
longs
loop
macroexpand
macroexpand-1
make-array
make-hierarchy
map
map-indexed
map?
mapcat
max
max-key
memfn
memoize
merge
merge-with
meta
method-sig
methods
min
min-key
mod
munge
name
namespace
namespace-munge
neg?
newline
next
nfirst
nil?
nnext
not
not-any?
not-empty
not-every?
not=
ns-aliases
ns-imports
ns-interns
ns-map
ns-name
ns-publics
ns-refers
ns-resolve
ns-unalias
ns-unmap
nth
nthnext
num
number?
numerator
object-array
odd?
parents
partial
partition
partition-all
partition-by
pcalls
peek
persistent!
pmap
pop
pop!
pop-thread-bindings
pos?
pr-str
prefer-method
prefers
primitives-classnames
print
print-ctor
print-dup
print-method