Move 'lispwords' setting to ftplugin

guns · guns · commit 5dea5ab92209 · 2014-02-16T01:19:28.000-06:00
The scheme filetype sets lispwords in its ftplugin, so we should set lispwords in our ftplugin for compatibility. This also prepares vim-clojure-static for the lispwords-global-local patch I will be sending upstream as `setlocal lispwords=` effectively resets lispwords to the global value instead of blanking it. cf. issue #43 Finally, the new setlocal syntax is compact, which Bram always appreciates.
diff --git a/clj/src/vim_clojure_static/generate.clj b/clj/src/vim_clojure_static/generate.clj
@@ -139,6 +139,25 @@
      :script   (set script)
      :block    (set block)}))
 
+(def lispwords
+  "Specially indented symbols in clojure.core and clojure.test. Please read
+   the commit message tagged `lispwords-guidelines` when adding new words to
+   this list."
+  (set/union
+    ;; Definitions
+    '#{bound-fn def definline definterface defmacro defmethod defmulti defn
+       defn- defonce defprotocol defrecord defstruct deftest deftest- deftype
+       extend extend-protocol extend-type fn ns proxy reify set-test}
+    ;; Binding forms
+    '#{as-> binding doall dorun doseq dotimes doto for if-let let letfn
+       locking loop testing when-first when-let with-bindings with-in-str
+       with-local-vars with-open with-precision with-redefs with-redefs-fn
+       with-test}
+    ;; Conditional branching
+    '#{case cond-> cond->> condp if if-not when when-not while}
+    ;; Exception handling
+    '#{catch}))
+
 ;;
 ;; Vimscript literals
 ;;
@@ -249,6 +268,10 @@
                            (fmt "script=" :script)
                            (fmt "block=" :block)])))
 
+(def vim-lispwords
+  "Vimscript literal `setlocal lispwords=` statement."
+  (str "setlocal lispwords=" (string/join \, (sort lispwords)) "\n"))
+
 (comment
   ;; Generate the vim literal definitions for pasting into the runtime files.
   (spit "tmp/clojure-defs.vim"
@@ -266,6 +289,9 @@
              vim-unicode-block-char-classes
              \newline
              generation-comment
+             vim-lispwords
+             \newline
+             generation-comment
              clojure-version-comment
              vim-completion-words))
   ;; Generate an example file with all possible character property literals.
diff --git a/ftplugin/clojure.vim b/ftplugin/clojure.vim
@@ -15,7 +15,7 @@ let b:did_ftplugin = 1
 let s:cpo_save = &cpo
 set cpo&vim
 
-let b:undo_ftplugin = 'setlocal iskeyword< define< formatoptions< comments< commentstring<'
+let b:undo_ftplugin = 'setlocal iskeyword< define< formatoptions< comments< commentstring< lispwords<'
 
 setlocal iskeyword+=?,-,*,!,+,/,=,<,>,.,:,$
 
@@ -30,6 +30,21 @@ setlocal formatoptions-=t
 setlocal comments=n:;
 setlocal commentstring=;\ %s
 
+" Specially indented symbols from clojure.core and clojure.test.
+"
+" Clojure symbols are indented in the defn style when they:
+"
+"   * Define vars and anonymous functions
+"   * Create new lexical scopes or scopes with altered environments
+"   * Create conditional branches from a predicate function or value
+"
+" The arglists for these functions are generally in the form of [x & body];
+" Functions that accept a flat list of forms do not treat the first argument
+" specially and hence are not indented specially.
+"
+" Generated from https://github.com/guns/vim-clojure-static/blob/%%RELEASE_TAG%%/clj/src/vim_clojure_static/generate.clj
+setlocal lispwords=as->,binding,bound-fn,case,catch,cond->,cond->>,condp,def,definline,definterface,defmacro,defmethod,defmulti,defn,defn-,defonce,defprotocol,defrecord,defstruct,deftest,deftest-,deftype,doall,dorun,doseq,dotimes,doto,extend,extend-protocol,extend-type,fn,for,if,if-let,if-not,let,letfn,locking,loop,ns,proxy,reify,set-test,testing,when,when-first,when-let,when-not,while,with-bindings,with-in-str,with-local-vars,with-open,with-precision,with-redefs,with-redefs-fn,with-test
+
 " Provide insert mode completions for special forms and clojure.core. As
 " 'omnifunc' is set by popular Clojure REPL client plugins, we also set
 " 'completefunc' so that the user has some form of completion available when
diff --git a/indent/clojure.vim b/indent/clojure.vim
@@ -21,7 +21,7 @@ let b:did_indent = 1
 let s:save_cpo = &cpo
 set cpo&vim
 
-let b:undo_indent = 'setlocal autoindent< smartindent< lispwords< expandtab< softtabstop< shiftwidth< indentexpr< indentkeys<'
+let b:undo_indent = 'setlocal autoindent< smartindent< expandtab< softtabstop< shiftwidth< indentexpr< indentkeys<'
 
 setlocal noautoindent nosmartindent
 setlocal softtabstop=2 shiftwidth=2 expandtab
@@ -312,85 +312,6 @@ else
 
 endif
 
-" Specially indented symbols from clojure.core and clojure.test.
-"
-" Clojure symbols are indented in the defn style when they:
-"
-"   * Define vars and anonymous functions
-"   * Create new lexical scopes or scopes with altered environments
-"   * Create conditional branches from a predicate function or value
-"
-" The arglists for these functions are generally in the form of [x & body];
-" Functions that accept a flat list of forms do not treat the first argument
-" specially and hence are not indented specially.
-
-" Definitions
-setlocal lispwords=
-setlocal lispwords+=bound-fn
-setlocal lispwords+=def
-setlocal lispwords+=definline
-setlocal lispwords+=definterface
-setlocal lispwords+=defmacro
-setlocal lispwords+=defmethod
-setlocal lispwords+=defmulti
-setlocal lispwords+=defn
-setlocal lispwords+=defn-
-setlocal lispwords+=defonce
-setlocal lispwords+=defprotocol
-setlocal lispwords+=defrecord
-setlocal lispwords+=defstruct
-setlocal lispwords+=deftest " clojure.test
-setlocal lispwords+=deftest- " clojure.test
-setlocal lispwords+=deftype
-setlocal lispwords+=extend
-setlocal lispwords+=extend-protocol
-setlocal lispwords+=extend-type
-setlocal lispwords+=fn
-setlocal lispwords+=ns
-setlocal lispwords+=proxy
-setlocal lispwords+=reify
-setlocal lispwords+=set-test " clojure.test
-
-" Binding forms
-setlocal lispwords+=as->
-setlocal lispwords+=binding
-setlocal lispwords+=doall
-setlocal lispwords+=dorun
-setlocal lispwords+=doseq
-setlocal lispwords+=dotimes
-setlocal lispwords+=doto
-setlocal lispwords+=for
-setlocal lispwords+=if-let
-setlocal lispwords+=let
-setlocal lispwords+=letfn
-setlocal lispwords+=locking
-setlocal lispwords+=loop
-setlocal lispwords+=testing " clojure.test
-setlocal lispwords+=when-first
-setlocal lispwords+=when-let
-setlocal lispwords+=with-bindings
-setlocal lispwords+=with-in-str
-setlocal lispwords+=with-local-vars
-setlocal lispwords+=with-open
-setlocal lispwords+=with-precision
-setlocal lispwords+=with-redefs
-setlocal lispwords+=with-redefs-fn
-setlocal lispwords+=with-test " clojure.test
-
-" Conditional branching
-setlocal lispwords+=case
-setlocal lispwords+=cond->
-setlocal lispwords+=cond->>
-setlocal lispwords+=condp
-setlocal lispwords+=if
-setlocal lispwords+=if-not
-setlocal lispwords+=when
-setlocal lispwords+=when-not
-setlocal lispwords+=while
-
-" Exception handling
-setlocal lispwords+=catch
-
 let &cpo = s:save_cpo
 unlet! s:save_cpo
 
