my-emacs-d/elpa/clojure-mode-20160803.140/clojure-mode.el

2005 lines
76 KiB
EmacsLisp
Raw Normal View History

2016-09-22 16:37:03 +00:00
;;; clojure-mode.el --- Major mode for Clojure code -*- lexical-binding: t; -*-
;; Copyright © 2007-2016 Jeffrey Chu, Lennart Staflin, Phil Hagelberg
;; Copyright © 2013-2016 Bozhidar Batsov, Artur Malabarba
;;
;; Authors: Jeffrey Chu <jochu0@gmail.com>
;; Lennart Staflin <lenst@lysator.liu.se>
;; Phil Hagelberg <technomancy@gmail.com>
;; Bozhidar Batsov <bozhidar@batsov.com>
;; Artur Malabarba <bruce.connor.am@gmail.com>
;; URL: http://github.com/clojure-emacs/clojure-mode
;; Package-Version: 20160803.140
;; Keywords: languages clojure clojurescript lisp
;; Version: 5.5.2
;; Package-Requires: ((emacs "24.3"))
;; This file is not part of GNU Emacs.
;;; Commentary:
;; Provides font-lock, indentation, navigation and basic refactoring for the
;; Clojure programming language (http://clojure.org).
;; Using clojure-mode with paredit or smartparens is highly recommended.
;; Here are some example configurations:
;; ;; require or autoload paredit-mode
;; (add-hook 'clojure-mode-hook #'paredit-mode)
;; ;; require or autoload smartparens
;; (add-hook 'clojure-mode-hook #'smartparens-strict-mode)
;; See inf-clojure (http://github.com/clojure-emacs/inf-clojure) for
;; basic interaction with Clojure subprocesses.
;; See CIDER (http://github.com/clojure-emacs/cider) for
;; better interaction with subprocesses via nREPL.
;;; License:
;; This program is free software; you can redistribute it and/or
;; modify it under the terms of the GNU General Public License
;; as published by the Free Software Foundation; either version 3
;; of the License, or (at your option) any later version.
;;
;; This program is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;; GNU General Public License for more details.
;;
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs; see the file COPYING. If not, write to the
;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
;; Boston, MA 02110-1301, USA.
;;; Code:
(eval-when-compile
(defvar calculate-lisp-indent-last-sexp)
(defvar font-lock-beg)
(defvar font-lock-end)
(defvar paredit-space-for-delimiter-predicates)
(defvar paredit-version)
(defvar paredit-mode))
(require 'cl-lib)
(require 'imenu)
(require 'newcomment)
(require 'align)
(declare-function lisp-fill-paragraph "lisp-mode" (&optional justify))
(defgroup clojure nil
"Major mode for editing Clojure code."
:prefix "clojure-"
:group 'languages
:link '(url-link :tag "Github" "https://github.com/clojure-emacs/clojure-mode")
:link '(emacs-commentary-link :tag "Commentary" "clojure-mode"))
(defconst clojure-mode-version "5.5.2"
"The current version of `clojure-mode'.")
(defface clojure-keyword-face
'((t (:inherit font-lock-constant-face)))
"Face used to font-lock Clojure keywords (:something)."
:package-version '(clojure-mode . "3.0.0"))
(defface clojure-character-face
'((t (:inherit font-lock-string-face)))
"Face used to font-lock Clojure character literals."
:package-version '(clojure-mode . "3.0.0"))
(defface clojure-interop-method-face
'((t (:inherit font-lock-preprocessor-face)))
"Face used to font-lock interop method names (camelCase)."
:package-version '(clojure-mode . "3.0.0"))
(defcustom clojure-indent-style :always-align
"Indentation style to use for function forms and macro forms.
There are two cases of interest configured by this variable.
- Case (A) is when at least one function argument is on the same
line as the function name.
- Case (B) is the opposite (no arguments are on the same line as
the function name). Note that the body of macros is not
affected by this variable, it is always indented by
`lisp-body-indent' (default 2) spaces.
Note that this variable configures the indentation of function
forms (and function-like macros), it does not affect macros that
already use special indentation rules.
The possible values for this variable are keywords indicating how
to indent function forms.
`:always-align' - Follow the same rules as `lisp-mode'. All
args are vertically aligned with the first arg in case (A),
and vertically aligned with the function name in case (B).
For instance:
(reduce merge
some-coll)
(reduce
merge
some-coll)
`:always-indent' - All args are indented like a macro body.
(reduce merge
some-coll)
(reduce
merge
some-coll)
`:align-arguments' - Case (A) is indented like `lisp', and
case (B) is indented like a macro body.
(reduce merge
some-coll)
(reduce
merge
some-coll)"
:safe #'keywordp
:type '(choice (const :tag "Same as `lisp-mode'" :always-align)
(const :tag "Indent like a macro body" :always-indent)
(const :tag "Indent like a macro body unless first arg is on the same line"
:align-arguments))
:package-version '(clojure-mode . "5.2.0"))
(define-obsolete-variable-alias 'clojure-defun-style-default-indent
'clojure-indent-style "5.2.0")
(defcustom clojure-use-backtracking-indent t
"When non-nil, enable context sensitive indentation."
:type 'boolean
:safe 'booleanp)
(defcustom clojure-max-backtracking 3
"Maximum amount to backtrack up a list to check for context."
:type 'integer
:safe 'integerp)
(defcustom clojure-docstring-fill-column fill-column
"Value of `fill-column' to use when filling a docstring."
:type 'integer
:safe 'integerp)
(defcustom clojure-docstring-fill-prefix-width 2
"Width of `fill-prefix' when filling a docstring.
The default value conforms with the de facto convention for
Clojure docstrings, aligning the second line with the opening
double quotes on the third column."
:type 'integer
:safe 'integerp)
(defcustom clojure-omit-space-between-tag-and-delimiters '(?\[ ?\{)
"Allowed opening delimiter characters after a reader literal tag.
For example, \[ is allowed in :db/id[:db.part/user]."
:type '(set (const :tag "[" ?\[)
(const :tag "{" ?\{)
(const :tag "(" ?\()
(const :tag "\"" ?\"))
:safe (lambda (value)
(and (listp value)
(cl-every 'characterp value))))
(defcustom clojure-build-tool-files '("project.clj" "build.boot" "build.gradle")
"A list of files, which identify a Clojure project's root.
Out-of-the box clojure-mode understands lein, boot and gradle."
:type '(repeat string)
:package-version '(clojure-mode . "5.0.0")
:safe (lambda (value)
(and (listp value)
(cl-every 'stringp value))))
(defvar clojure-mode-map
(let ((map (make-sparse-keymap)))
(define-key map (kbd "C-:") #'clojure-toggle-keyword-string)
(define-key map (kbd "C-c SPC") #'clojure-align)
(define-key map (kbd "C-c C-r C-t") #'clojure-thread)
(define-key map (kbd "C-c C-r t") #'clojure-thread)
(define-key map (kbd "C-c C-r C-u") #'clojure-unwind)
(define-key map (kbd "C-c C-r u") #'clojure-unwind)
(define-key map (kbd "C-c C-r C-f") #'clojure-thread-first-all)
(define-key map (kbd "C-c C-r f") #'clojure-thread-first-all)
(define-key map (kbd "C-c C-r C-l") #'clojure-thread-last-all)
(define-key map (kbd "C-c C-r l") #'clojure-thread-last-all)
(define-key map (kbd "C-c C-r C-a") #'clojure-unwind-all)
(define-key map (kbd "C-c C-r a") #'clojure-unwind-all)
(define-key map (kbd "C-c C-r C-p") #'clojure-cycle-privacy)
(define-key map (kbd "C-c C-r p") #'clojure-cycle-privacy)
(define-key map (kbd "C-c C-r C-(") #'clojure-convert-collection-to-list)
(define-key map (kbd "C-c C-r (") #'clojure-convert-collection-to-list)
(define-key map (kbd "C-c C-r C-'") #'clojure-convert-collection-to-quoted-list)
(define-key map (kbd "C-c C-r '") #'clojure-convert-collection-to-quoted-list)
(define-key map (kbd "C-c C-r C-{") #'clojure-convert-collection-to-map)
(define-key map (kbd "C-c C-r {") #'clojure-convert-collection-to-map)
(define-key map (kbd "C-c C-r C-[") #'clojure-convert-collection-to-vector)
(define-key map (kbd "C-c C-r [") #'clojure-convert-collection-to-vector)
(define-key map (kbd "C-c C-r C-#") #'clojure-convert-collection-to-set)
(define-key map (kbd "C-c C-r #") #'clojure-convert-collection-to-set)
(define-key map (kbd "C-c C-r C-i") #'clojure-cycle-if)
(define-key map (kbd "C-c C-r i") #'clojure-cycle-if)
(define-key map (kbd "C-c C-r n i") #'clojure-insert-ns-form)
(define-key map (kbd "C-c C-r n h") #'clojure-insert-ns-form-at-point)
(define-key map (kbd "C-c C-r n u") #'clojure-update-ns)
(define-key map (kbd "C-c C-r n s") #'clojure-sort-ns)
(easy-menu-define clojure-mode-menu map "Clojure Mode Menu"
'("Clojure"
["Toggle between string & keyword" clojure-toggle-keyword-string]
["Align expression" clojure-align]
["Cycle privacy" clojure-cycle-privacy]
["Cycle if, if-not" clojure-cycle-if]
("ns forms"
["Insert ns form at the top" clojure-insert-ns-form]
["Insert ns form here" clojure-insert-ns-form-at-point]
["Update ns form" clojure-update-ns]
["Sort ns form" clojure-sort-ns])
("Convert collection"
["Convert to list" clojure-convert-collection-to-list]
["Convert to quoted list" clojure-convert-collection-to-quoted-list]
["Convert to map" clojure-convert-collection-to-map]
["Convert to vector" clojure-convert-collection-to-vector]
["Convert to set" clojure-convert-collection-to-set])
("Refactor -> and ->>"
["Thread once more" clojure-thread]
["Fully thread a form with ->" clojure-thread-first-all]
["Fully thread a form with ->>" clojure-thread-last-all]
"--"
["Unwind once" clojure-unwind]
["Fully unwind a threading macro" clojure-unwind-all])
"--"
["Clojure-mode version" clojure-mode-display-version]))
map)
"Keymap for Clojure mode.")
(defvar clojure-mode-syntax-table
(let ((table (copy-syntax-table emacs-lisp-mode-syntax-table)))
(modify-syntax-entry ?\{ "(}" table)
(modify-syntax-entry ?\} "){" table)
(modify-syntax-entry ?\[ "(]" table)
(modify-syntax-entry ?\] ")[" table)
(modify-syntax-entry ?? "_ p" table) ; ? is a prefix outside symbols
(modify-syntax-entry ?# "_ p" table) ; # is allowed inside keywords (#399)
(modify-syntax-entry ?~ "'" table)
(modify-syntax-entry ?^ "'" table)
(modify-syntax-entry ?@ "'" table)
table)
"Syntax table for Clojure mode.
Inherits from `emacs-lisp-mode-syntax-table'.")
(defconst clojure--prettify-symbols-alist
'(("fn" . )))
(defvar-local clojure-expected-ns-function nil
"The function used to determine the expected namespace of a file.
`clojure-mode' ships a basic function named `clojure-expected-ns'
that does basic heuristics to figure this out.
CIDER provides a more complex version which does classpath analysis.")
(defun clojure-mode-display-version ()
"Display the current `clojure-mode-version' in the minibuffer."
(interactive)
(message "clojure-mode (version %s)" clojure-mode-version))
(defun clojure-space-for-delimiter-p (endp delim)
"Prevent paredit from inserting useless spaces.
See `paredit-space-for-delimiter-predicates' for the meaning of
ENDP and DELIM."
(or endp
(not (memq delim '(?\" ?{ ?\( )))
(not (or (derived-mode-p 'clojure-mode)
(derived-mode-p 'cider-repl-mode)))
(save-excursion
(backward-char)
(cond ((eq (char-after) ?#)
(and (not (bobp))
(or (char-equal ?w (char-syntax (char-before)))
(char-equal ?_ (char-syntax (char-before))))))
((and (eq delim ?\()
(eq (char-after) ??)
(eq (char-before) ?#))
nil)
(t)))))
(defun clojure-no-space-after-tag (endp delimiter)
"Prevent inserting a space after a reader-literal tag?
When a reader-literal tag is followed be an opening delimiter
listed in `clojure-omit-space-between-tag-and-delimiters', this
function returns t.
This allows you to write things like #db/id[:db.part/user]
without inserting a space between the tag and the opening
bracket.
See `paredit-space-for-delimiter-predicates' for the meaning of
ENDP and DELIMITER."
(if endp
t
(or (not (member delimiter clojure-omit-space-between-tag-and-delimiters))
(save-excursion
(let ((orig-point (point)))
(not (and (re-search-backward
"#\\([a-zA-Z0-9._-]+/\\)?[a-zA-Z0-9._-]+"
(line-beginning-position)
t)
(= orig-point (match-end 0)))))))))
(declare-function paredit-open-curly "ext:paredit")
(declare-function paredit-close-curly "ext:paredit")
(defun clojure-paredit-setup (&optional keymap)
"Make \"paredit-mode\" play nice with `clojure-mode'.
If an optional KEYMAP is passed the changes are applied to it,
instead of to `clojure-mode-map'."
(when (>= paredit-version 21)
(let ((keymap (or keymap clojure-mode-map)))
(define-key keymap "{" #'paredit-open-curly)
(define-key keymap "}" #'paredit-close-curly))
(add-to-list 'paredit-space-for-delimiter-predicates
#'clojure-space-for-delimiter-p)
(add-to-list 'paredit-space-for-delimiter-predicates
#'clojure-no-space-after-tag)))
(defun clojure-mode-variables ()
"Set up initial buffer-local variables for Clojure mode."
(add-to-list 'imenu-generic-expression '(nil clojure-match-next-def 0))
(setq-local indent-tabs-mode nil)
(setq-local paragraph-ignore-fill-prefix t)
(setq-local outline-regexp ";;;\\(;* [^ \t\n]\\)\\|(")
(setq-local outline-level 'lisp-outline-level)
(setq-local comment-start ";")
(setq-local comment-start-skip ";+ *")
(setq-local comment-add 1) ; default to `;;' in comment-region
(setq-local comment-column 40)
(setq-local comment-use-syntax t)
(setq-local multibyte-syntax-as-symbol t)
(setq-local electric-pair-skip-whitespace 'chomp)
(setq-local electric-pair-open-newline-between-pairs nil)
(setq-local fill-paragraph-function #'clojure-fill-paragraph)
(setq-local adaptive-fill-function #'clojure-adaptive-fill-function)
(setq-local normal-auto-fill-function #'clojure-auto-fill-function)
(setq-local comment-start-skip
"\\(\\(^\\|[^\\\\\n]\\)\\(\\\\\\\\\\)*\\)\\(;+\\|#|\\) *")
(setq-local indent-line-function #'clojure-indent-line)
(setq-local indent-region-function #'clojure-indent-region)
(setq-local lisp-indent-function #'clojure-indent-function)
(setq-local lisp-doc-string-elt-property 'clojure-doc-string-elt)
(setq-local clojure-expected-ns-function #'clojure-expected-ns)
(setq-local parse-sexp-ignore-comments t)
(setq-local prettify-symbols-alist clojure--prettify-symbols-alist)
(setq-local open-paren-in-column-0-is-defun-start nil))
;;;###autoload
(define-derived-mode clojure-mode prog-mode "Clojure"
"Major mode for editing Clojure code.
\\{clojure-mode-map}"
(clojure-mode-variables)
(clojure-font-lock-setup)
(add-hook 'paredit-mode-hook #'clojure-paredit-setup))
(defcustom clojure-verify-major-mode t
"If non-nil, warn when activating the wrong major-mode."
:type 'boolean
:safe #'booleanp
:package-version '(clojure-mode "5.3.0"))
(defun clojure--check-wrong-major-mode ()
"Check if the current major-mode matches the file extension.
If it doesn't, issue a warning if `clojure-verify-major-mode' is
non-nil."
(when (and clojure-verify-major-mode
(stringp (buffer-file-name)))
(let* ((case-fold-search t)
(problem (cond ((and (string-match "\\.clj\\'" (buffer-file-name))
(not (eq major-mode 'clojure-mode)))
'clojure-mode)
((and (string-match "\\.cljs\\'" (buffer-file-name))
(not (eq major-mode 'clojurescript-mode)))
'clojurescript-mode)
((and (string-match "\\.cljc\\'" (buffer-file-name))
(not (eq major-mode 'clojurec-mode)))
'clojurec-mode)
((and (string-match "\\.cljx\\'" (buffer-file-name))
(not (eq major-mode 'clojurex-mode)))
'clojurex-mode))))
(when problem
(message "[WARNING] %s activated `%s' instead of `%s' in this buffer.
This could cause problems.
\(See `clojure-verify-major-mode' to disable this message.)"
(if (eq major-mode real-this-command)
"You have"
"Something in your configuration")
major-mode
problem)))))
(add-hook 'clojure-mode-hook #'clojure--check-wrong-major-mode)
(defsubst clojure-in-docstring-p ()
"Check whether point is in a docstring."
(eq (get-text-property (point) 'face) 'font-lock-doc-face))
(defsubst clojure-docstring-fill-prefix ()
"The prefix string used by `clojure-fill-paragraph'.
It is simply `clojure-docstring-fill-prefix-width' number of spaces."
(make-string clojure-docstring-fill-prefix-width ? ))
(defun clojure-adaptive-fill-function ()
"Clojure adaptive fill function.
This only takes care of filling docstring correctly."
(when (clojure-in-docstring-p)
(clojure-docstring-fill-prefix)))
(defun clojure-fill-paragraph (&optional justify)
"Like `fill-paragraph', but can handle Clojure docstrings.
If JUSTIFY is non-nil, justify as well as fill the paragraph."
(if (clojure-in-docstring-p)
(let ((paragraph-start
(concat paragraph-start
"\\|\\s-*\\([(;:\"[]\\|~@\\|`(\\|#'(\\)"))
(paragraph-separate
(concat paragraph-separate "\\|\\s-*\".*[,\\.]$"))
(fill-column (or clojure-docstring-fill-column fill-column))
(fill-prefix (clojure-docstring-fill-prefix)))
(fill-paragraph justify))
(let ((paragraph-start (concat paragraph-start
"\\|\\s-*\\([(;:\"[]\\|`(\\|#'(\\)"))
(paragraph-separate
(concat paragraph-separate "\\|\\s-*\".*[,\\.[]$")))
(or (fill-comment-paragraph justify)
(fill-paragraph justify))
;; Always return `t'
t)))
(defun clojure-auto-fill-function ()
"Clojure auto-fill function."
;; Check if auto-filling is meaningful.
(let ((fc (current-fill-column)))
(when (and fc (> (current-column) fc))
(let ((fill-column (if (clojure-in-docstring-p)
clojure-docstring-fill-column
fill-column))
(fill-prefix (clojure-adaptive-fill-function)))
(do-auto-fill)))))
;;; #_ comments font-locking
;; Code heavily borrowed from Slime.
;; https://github.com/slime/slime/blob/master/contrib/slime-fontifying-fu.el#L186
(defvar clojure--comment-macro-regexp
(rx "#_" (* " ") (group-n 1 (not (any " "))))
"Regexp matching the start of a comment sexp.
The beginning of match-group 1 should be before the sexp to be
marked as a comment. The end of sexp is found with
`clojure-forward-logical-sexp'.
By default, this only applies to code after the `#_' reader
macro. In order to also font-lock the `(comment ...)' macro as a
comment, you can set the value to:
\"#_ *\\\\(?1:[^ ]\\\\)\\\\|\\\\(?1:(comment\\\\_>\\\\)\"")
(defun clojure--search-comment-macro-internal (limit)
(when (search-forward-regexp clojure--comment-macro-regexp limit t)
(let* ((md (match-data))
(start (match-beginning 1))
(state (syntax-ppss start)))
;; inside string or comment?
(if (or (nth 3 state)
(nth 4 state))
(clojure--search-comment-macro-internal limit)
(goto-char start)
(clojure-forward-logical-sexp 1)
;; Data for (match-end 1).
(setf (elt md 3) (point))
(set-match-data md)
t))))
(defun clojure--search-comment-macro (limit)
"Find comment macros and set the match data.
Search from point up to LIMIT. The region that should be
considered a comment is between `(match-beginning 1)'
and `(match-end 1)'."
(let ((result 'retry))
(while (and (eq result 'retry) (<= (point) limit))
(condition-case nil
(setq result (clojure--search-comment-macro-internal limit))
(end-of-file (setq result nil))
(scan-error (setq result 'retry))))
result))
;;; General font-locking
(defun clojure-match-next-def ()
"Scans the buffer backwards for the next \"top-level\" definition.
Called by `imenu--generic-function'."
;; we have to take into account namespace-definition forms
;; e.g. s/defn
(when (re-search-backward "^(\\([a-z0-9.-]+/\\)?def\\sw*" nil t)
(save-excursion
(let (found?
(start (point)))
(down-list)
(forward-sexp)
(while (not found?)
(forward-sexp)
(or (if (char-equal ?[ (char-after (point)))
(backward-sexp))
(if (char-equal ?) (char-after (point)))
(backward-sexp)))
(cl-destructuring-bind (def-beg . def-end) (bounds-of-thing-at-point 'sexp)
(if (char-equal ?^ (char-after def-beg))
(progn (forward-sexp) (backward-sexp))
(setq found? t)
(set-match-data (list def-beg def-end)))))
(goto-char start)))))
(eval-and-compile
(defconst clojure--sym-forbidden-rest-chars "][\";\'@\\^`~\(\)\{\}\\,\s\t\n\r"
"A list of chars that a Clojure symbol cannot contain.
See definition of 'macros': URL `http://git.io/vRGLD'.")
(defconst clojure--sym-forbidden-1st-chars (concat clojure--sym-forbidden-rest-chars "0-9:")
"A list of chars that a Clojure symbol cannot start with.
See the for-loop: URL `http://git.io/vRGTj' lines: URL
`http://git.io/vRGIh', URL `http://git.io/vRGLE' and value
definition of 'macros': URL `http://git.io/vRGLD'.")
(defconst clojure--sym-regexp
(concat "[^" clojure--sym-forbidden-1st-chars "][^" clojure--sym-forbidden-rest-chars "]*")
"A regexp matching a Clojure symbol or namespace alias.
Matches the rule `clojure--sym-forbidden-1st-chars' followed by
any number of matches of `clojure--sym-forbidden-rest-chars'."))
(defconst clojure-font-lock-keywords
(eval-when-compile
`( ;; Top-level variable definition
(,(concat "(\\(?:clojure.core/\\)?\\("
(regexp-opt '("def" "defonce"))
;; variable declarations
"\\)\\>"
;; Any whitespace
"[ \r\n\t]*"
;; Possibly type or metadata
"\\(?:#?^\\(?:{[^}]*}\\|\\sw+\\)[ \r\n\t]*\\)*"
"\\(\\sw+\\)?")
(1 font-lock-keyword-face)
(2 font-lock-variable-name-face nil t))
;; Type definition
(,(concat "(\\(?:clojure.core/\\)?\\("
(regexp-opt '("defstruct" "deftype" "defprotocol"
"defrecord"))
;; type declarations
"\\)\\>"
;; Any whitespace
"[ \r\n\t]*"
;; Possibly type or metadata
"\\(?:#?^\\(?:{[^}]*}\\|\\sw+\\)[ \r\n\t]*\\)*"
"\\(\\sw+\\)?")
(1 font-lock-keyword-face)
(2 font-lock-type-face nil t))
;; Function definition (anything that starts with def and is not
;; listed above)
(,(concat "(\\(?:" clojure--sym-regexp "/\\)?"
"\\(def[^ \r\n\t]*\\)"
;; Function declarations
"\\>"
;; Any whitespace
"[ \r\n\t]*"
;; Possibly type or metadata
"\\(?:#?^\\(?:{[^}]*}\\|\\sw+\\)[ \r\n\t]*\\)*"
"\\(\\sw+\\)?")
(1 font-lock-keyword-face)
(2 font-lock-function-name-face nil t))
;; (fn name? args ...)
(,(concat "(\\(?:clojure.core/\\)?\\(fn\\)[ \t]+"
;; Possibly type
"\\(?:#?^\\sw+[ \t]*\\)?"
;; Possibly name
"\\(\\sw+\\)?" )
(1 font-lock-keyword-face)
(2 font-lock-function-name-face nil t))
;; lambda arguments - %, %&, %1, %2, etc
("\\<%[&1-9]?" (0 font-lock-variable-name-face))
;; Special forms
(,(concat
"("
(regexp-opt
'("def" "do" "if" "let" "let*" "var" "fn" "fn*" "loop" "loop*"
"recur" "throw" "try" "catch" "finally"
"set!" "new" "."
"monitor-enter" "monitor-exit" "quote") t)
"\\>")
1 font-lock-keyword-face)
;; Built-in binding and flow of control forms
(,(concat
"(\\(?:clojure.core/\\)?"
(regexp-opt
'("letfn" "case" "cond" "cond->" "cond->>" "condp"
"for" "when" "when-not" "when-let" "when-first" "when-some"
"if-let" "if-not" "if-some"
".." "->" "->>" "as->" "doto" "and" "or"
"dosync" "doseq" "dotimes" "dorun" "doall"
"ns" "in-ns"
"with-open" "with-local-vars" "binding"
"with-redefs" "with-redefs-fn"
"declare") t)
"\\>")
1 font-lock-keyword-face)
;; Macros similar to let, when, and while
(,(rx symbol-start
(or "let" "when" "while") "-"
(1+ (or (syntax word) (syntax symbol)))
symbol-end)
0 font-lock-keyword-face)
(,(concat
"\\<"
(regexp-opt
'("*1" "*2" "*3" "*agent*"
"*allow-unresolved-vars*" "*assert*" "*clojure-version*"
"*command-line-args*" "*compile-files*"
"*compile-path*" "*data-readers*" "*default-data-reader-fn*"
"*e" "*err*" "*file*" "*flush-on-newline*"
"*in*" "*macro-meta*" "*math-context*" "*ns*" "*out*"
"*print-dup*" "*print-length*" "*print-level*"
"*print-meta*" "*print-readably*"
"*read-eval*" "*source-path*"
"*unchecked-math*"
"*use-context-classloader*" "*warn-on-reflection*")
t)
"\\>")
0 font-lock-builtin-face)
;; Dynamic variables - *something* or @*something*
("\\(?:\\<\\|/\\)@?\\(\\*[a-z-]*\\*\\)\\>" 1 font-lock-variable-name-face)
;; Global constants - nil, true, false
(,(concat
"\\<"
(regexp-opt
'("true" "false" "nil") t)
"\\>")
0 font-lock-constant-face)
;; Character literals - \1, \a, \newline, \u0000
("\\\\\\([[:punct:]]\\|[a-z0-9]+\\>\\)" 0 'clojure-character-face)
;; foo/ Foo/ @Foo/ /FooBar
(,(concat "\\(?:\\<:?\\|\\.\\)@?\\(" clojure--sym-regexp "\\)\\(/\\)")
(1 font-lock-type-face) (2 'default))
;; Constant values (keywords), including as metadata e.g. ^:static
("\\<^?\\(:\\(\\sw\\|\\s_\\)+\\(\\>\\|\\_>\\)\\)" 1 'clojure-keyword-face append)
;; Java interop highlighting
;; CONST SOME_CONST (optionally prefixed by /)
("\\(?:\\<\\|/\\)\\([A-Z]+\\|\\([A-Z]+_[A-Z1-9_]+\\)\\)\\>" 1 font-lock-constant-face)
;; .foo .barBaz .qux01 .-flibble .-flibbleWobble
("\\<\\.-?[a-z][a-zA-Z0-9]*\\>" 0 'clojure-interop-method-face)
;; Foo Bar$Baz Qux_ World_OpenUDP Foo. Babylon15.
("\\(?:\\<\\|\\.\\|/\\|#?^\\)\\([A-Z][a-zA-Z0-9_]*[a-zA-Z0-9$_]+\\.?\\>\\)" 1 font-lock-type-face)
;; foo.bar.baz
("\\<^?\\([a-z][a-z0-9_-]+\\.\\([a-z][a-z0-9_-]*\\.?\\)+\\)" 1 font-lock-type-face)
;; (ns namespace) - special handling for single segment namespaces
(,(concat "(\\<ns\\>[ \r\n\t]*"
;; Possibly metadata
"\\(?:\\^?{[^}]+}[ \r\n\t]*\\)*"
;; namespace
"\\([a-z0-9-]+\\)")
(1 font-lock-type-face nil t))
;; fooBar
("\\(?:\\<\\|/\\)\\([a-z]+[A-Z]+[a-zA-Z0-9$]*\\>\\)" 1 'clojure-interop-method-face)
;; #_ and (comment ...) macros.
(clojure--search-comment-macro 1 font-lock-comment-face t)
;; Highlight `code` marks, just like `elisp'.
(,(rx "`" (group-n 1 (optional "#'")
(+ (or (syntax symbol) (syntax word)))) "`")
(1 'font-lock-constant-face prepend))
;; Highlight escaped characters in strings.
(clojure-font-lock-escaped-chars 0 'bold prepend)
;; Highlight grouping constructs in regular expressions
(clojure-font-lock-regexp-groups
(1 'font-lock-regexp-grouping-construct prepend))))
"Default expressions to highlight in Clojure mode.")
(defun clojure-font-lock-syntactic-face-function (state)
"Find and highlight text with a Clojure-friendly syntax table.
This function is passed to `font-lock-syntactic-face-function',
which is called with a single parameter, STATE (which is, in
turn, returned by `parse-partial-sexp' at the beginning of the
highlighted region)."
(if (nth 3 state)
;; This might be a (doc)string or a |...| symbol.
(let ((startpos (nth 8 state)))
(if (eq (char-after startpos) ?|)
;; This is not a string, but a |...| symbol.
nil
(let* ((listbeg (nth 1 state))
(firstsym (and listbeg
(save-excursion
(goto-char listbeg)
(and (looking-at "([ \t\n]*\\(\\(\\sw\\|\\s_\\)+\\)")
(match-string 1)))))
(docelt (and firstsym
(function-get (intern-soft firstsym)
lisp-doc-string-elt-property))))
(if (and docelt
;; It's a string in a form that can have a docstring.
;; Check whether it's in docstring position.
(save-excursion
(when (functionp docelt)
(goto-char (match-end 1))
(setq docelt (funcall docelt)))
(goto-char listbeg)
(forward-char 1)
(condition-case nil
(while (and (> docelt 0) (< (point) startpos)
(progn (forward-sexp 1) t))
;; ignore metadata and type hints
(unless (looking-at "[ \n\t]*\\(\\^[A-Z:].+\\|\\^?{.+\\)")
(setq docelt (1- docelt))))
(error nil))
(and (zerop docelt) (<= (point) startpos)
(progn (forward-comment (point-max)) t)
(= (point) (nth 8 state)))))
font-lock-doc-face
font-lock-string-face))))
font-lock-comment-face))
(defun clojure-font-lock-setup ()
"Configures font-lock for editing Clojure code."
(setq-local font-lock-multiline t)
(add-to-list 'font-lock-extend-region-functions
#'clojure-font-lock-extend-region-def t)
(setq font-lock-defaults
'(clojure-font-lock-keywords ; keywords
nil nil
(("+-*/.<>=!?$%_&:" . "w")) ; syntax alist
nil
(font-lock-mark-block-function . mark-defun)
(font-lock-syntactic-face-function
. clojure-font-lock-syntactic-face-function))))
(defun clojure-font-lock-def-at-point (point)
"Range between the top-most def* and the fourth element after POINT.
Note that this means that there is no guarantee of proper font
locking in def* forms that are not at top level."
(goto-char point)
(condition-case nil
(beginning-of-defun)
(error nil))
(let ((beg-def (point)))
(when (and (not (= point beg-def))
(looking-at "(def"))
(condition-case nil
(progn
;; move forward as much as possible until failure (or success)
(forward-char)
(dotimes (_ 4)
(forward-sexp)))
(error nil))
(cons beg-def (point)))))
(defun clojure-font-lock-extend-region-def ()
"Set region boundaries to include the first four elements of def* forms."
(let ((changed nil))
(let ((def (clojure-font-lock-def-at-point font-lock-beg)))
(when def
(cl-destructuring-bind (def-beg . def-end) def
(when (and (< def-beg font-lock-beg)
(< font-lock-beg def-end))
(setq font-lock-beg def-beg
changed t)))))
(let ((def (clojure-font-lock-def-at-point font-lock-end)))
(when def
(cl-destructuring-bind (def-beg . def-end) def
(when (and (< def-beg font-lock-end)
(< font-lock-end def-end))
(setq font-lock-end def-end
changed t)))))
changed))
(defun clojure--font-locked-as-string-p (&optional regexp)
"Non-nil if the char before point is font-locked as a string.
If REGEXP is non-nil, also check whether current string is
preceeded by a #."
(let ((face (get-text-property (1- (point)) 'face)))
(and (or (and (listp face)
(memq 'font-lock-string-face face))
(eq 'font-lock-string-face face))
(or (clojure-string-start t)
(unless regexp
(clojure-string-start nil))))))
(defun clojure-font-lock-escaped-chars (bound)
"Highlight \escaped chars in strings.
BOUND denotes a buffer position to limit the search."
(let ((found nil))
(while (and (not found)
(re-search-forward "\\\\." bound t))
(setq found (clojure--font-locked-as-string-p)))
found))
(defun clojure-font-lock-regexp-groups (bound)
"Highlight grouping constructs in regular expression.
BOUND denotes the maximum number of characters (relative to the
point) to check."
(let ((found nil))
(while (and (not found)
(re-search-forward (eval-when-compile
(concat
;; A group may start using several alternatives:
"\\(\\(?:"
;; 1. (? special groups
"(\\?\\(?:"
;; a) non-capturing group (?:X)
;; b) independent non-capturing group (?>X)
;; c) zero-width positive lookahead (?=X)
;; d) zero-width negative lookahead (?!X)
"[:=!>]\\|"
;; e) zero-width positive lookbehind (?<=X)
;; f) zero-width negative lookbehind (?<!X)
"<[=!]\\|"
;; g) named capturing group (?<name>X)
"<[[:alnum:]]+>"
"\\)\\|" ;; end of special groups
;; 2. normal capturing groups (
;; 3. we also highlight alternative
;; separarators |, and closing parens )
"[|()]"
"\\)\\)"))
bound t))
(setq found (clojure--font-locked-as-string-p 'regexp)))
found))
;; Docstring positions
(put 'ns 'clojure-doc-string-elt 2)
(put 'def 'clojure-doc-string-elt 2)
(put 'defn 'clojure-doc-string-elt 2)
(put 'defn- 'clojure-doc-string-elt 2)
(put 'defmulti 'clojure-doc-string-elt 2)
(put 'defmacro 'clojure-doc-string-elt 2)
(put 'definline 'clojure-doc-string-elt 2)
(put 'defprotocol 'clojure-doc-string-elt 2)
;;; Vertical alignment
(defcustom clojure-align-forms-automatically nil
"If non-nil, vertically align some forms automatically.
Automatically means it is done as part of indenting code. This
applies to binding forms (`clojure-align-binding-forms'), to cond
forms (`clojure-align-cond-forms') and to map literals. For
instance, selecting a map a hitting \\<clojure-mode-map>`\\[indent-for-tab-command]'
will align the values like this:
{:some-key 10
:key2 20}"
:package-version '(clojure-mode . "5.1")
:safe #'booleanp
:type 'boolean)
(defcustom clojure-align-binding-forms
'("let" "when-let" "when-some" "if-let" "if-some" "binding" "loop"
"doseq" "for" "with-open" "with-local-vars" "with-redefs")
"List of strings matching forms that have binding forms."
:package-version '(clojure-mode . "5.1")
:safe #'listp
:type '(repeat string))
(defcustom clojure-align-cond-forms '("condp" "cond" "cond->" "cond->>" "case" "are")
"List of strings identifying cond-like forms."
:package-version '(clojure-mode . "5.1")
:safe #'listp
:type '(repeat string))
(defun clojure--position-for-alignment ()
"Non-nil if the sexp around point should be automatically aligned.
This function expects to be called immediately after an
open-brace or after the function symbol in a function call.
First check if the sexp around point is a map literal, or is a
call to one of the vars listed in `clojure-align-cond-forms'. If
it isn't, return nil. If it is, return non-nil and place point
immediately before the forms that should be aligned.
For instance, in a map literal point is left immediately before
the first key; while, in a let-binding, point is left inside the
binding vector and immediately before the first binding
construct."
;; Are we in a map?
(or (and (eq (char-before) ?{)
(not (eq (char-before (1- (point))) ?\#)))
;; Are we in a cond form?
(let* ((fun (car (member (thing-at-point 'symbol) clojure-align-cond-forms)))
(method (and fun (clojure--get-indent-method fun)))
;; The number of special arguments in the cond form is
;; the number of sexps we skip before aligning.
(skip (cond ((numberp method) method)
((null method) 0)
((sequencep method) (elt method 0)))))
(when (and fun (numberp skip))
(clojure-forward-logical-sexp skip)
(comment-forward (point-max))
fun)) ; Return non-nil (the var name).
;; Are we in a let-like form?
(when (member (thing-at-point 'symbol)
clojure-align-binding-forms)
;; Position inside the binding vector.
(clojure-forward-logical-sexp)
(backward-sexp)
(when (eq (char-after) ?\[)
(forward-char 1)
(comment-forward (point-max))
;; Return non-nil.
t))))
(defun clojure--find-sexp-to-align (end)
"Non-nil if there's a sexp ahead to be aligned before END.
Place point as in `clojure--position-for-alignment'."
;; Look for a relevant sexp.
(let ((found))
(while (and (not found)
(search-forward-regexp
(concat "{\\|(" (regexp-opt
(append clojure-align-binding-forms
clojure-align-cond-forms)
'symbols))
end 'noerror))
(let ((ppss (syntax-ppss)))
;; If we're in a string or comment.
(unless (or (elt ppss 3)
(elt ppss 4))
;; Only stop looking if we successfully position
;; the point.
(setq found (clojure--position-for-alignment)))))
found))
(defun clojure--search-whitespace-after-next-sexp (&optional bound _noerror)
"Move point after all whitespace after the next sexp.
Set the match data group 1 to be this region of whitespace and
return point."
(unwind-protect
(ignore-errors
(clojure-forward-logical-sexp 1)
(search-forward-regexp "\\([,\s\t]*\\)" bound)
(pcase (syntax-after (point))
;; End-of-line, try again on next line.
(`(12) (clojure--search-whitespace-after-next-sexp bound))
;; Closing paren, stop here.
(`(5 . ,_) nil)
;; Anything else is something to align.
(_ (point))))
(when (and bound (> (point) bound))
(goto-char bound))))
(defun clojure-align (beg end)
"Vertically align the contents of the sexp around point.
If region is active, align it. Otherwise, align everything in the
current \"top-level\" sexp.
When called from lisp code align everything between BEG and END."
(interactive (if (use-region-p)
(list (region-beginning) (region-end))
(save-excursion
(let ((end (progn (end-of-defun)
(point))))
(clojure-backward-logical-sexp)
(list (point) end)))))
(setq end (copy-marker end))
(save-excursion
(goto-char beg)
(while (clojure--find-sexp-to-align end)
(let ((sexp-end (save-excursion
(backward-up-list)
(forward-sexp 1)
(point-marker)))
(clojure-align-forms-automatically nil)
(count 1))
;; For some bizarre reason, we need to `align-region' once for each
;; group.
(save-excursion
(while (search-forward-regexp "^ *\n" sexp-end 'noerror)
(cl-incf count)))
(dotimes (_ count)
(align-region (point) sexp-end nil
'((clojure-align (regexp . clojure--search-whitespace-after-next-sexp)
(group . 1)
(separate . "^ *$")
(repeat . t)))
nil))
;; Reindent after aligning because of #360.
(indent-region (point) sexp-end)))))
;;; Indentation
(defun clojure-indent-region (beg end)
"Like `indent-region', but also maybe align forms.
Forms between BEG and END are aligned according to
`clojure-align-forms-automatically'."
(prog1 (let ((indent-region-function nil))
(indent-region beg end))
(when clojure-align-forms-automatically
(condition-case nil
(clojure-align beg end)
(scan-error nil)))))
(defun clojure-indent-line ()
"Indent current line as Clojure code."
(if (clojure-in-docstring-p)
(save-excursion
(beginning-of-line)
(when (and (looking-at "^\\s-*")
(<= (string-width (match-string-no-properties 0))
(string-width (clojure-docstring-fill-prefix))))
(replace-match (clojure-docstring-fill-prefix))))
(lisp-indent-line)))
(defvar clojure-get-indent-function nil
"Function to get the indent spec of a symbol.
This function should take one argument, the name of the symbol as
a string. This name will be exactly as it appears in the buffer,
so it might start with a namespace alias.
This function is analogous to the `clojure-indent-function'
symbol property, and its return value should match one of the
allowed values of this property. See `clojure-indent-function'
for more information.")
(defun clojure--get-indent-method (function-name)
"Return the indent spec for the symbol named FUNCTION-NAME.
FUNCTION-NAME is a string. If it contains a `/', also try only
the part after the `/'.
Look for a spec using `clojure-get-indent-function', then try the
`clojure-indent-function' and `clojure-backtracking-indent'
symbol properties."
(or (when (functionp clojure-get-indent-function)
(funcall clojure-get-indent-function function-name))
(get (intern-soft function-name) 'clojure-indent-function)
(get (intern-soft function-name) 'clojure-backtracking-indent)
(when (string-match "/\\([^/]+\\)\\'" function-name)
(or (get (intern-soft (match-string 1 function-name))
'clojure-indent-function)
(get (intern-soft (match-string 1 function-name))
'clojure-backtracking-indent)))
(when (string-match (rx (or "let" "when" "while") (syntax symbol))
function-name)
(clojure--get-indent-method (substring (match-string 0 function-name) 0 -1)))))
(defvar clojure--current-backtracking-depth 0)
(defun clojure--find-indent-spec-backtracking ()
"Return the indent sexp that applies to the sexp at point.
Implementation function for `clojure--find-indent-spec'."
(when (and (>= clojure-max-backtracking clojure--current-backtracking-depth)
(not (looking-at "^")))
(let ((clojure--current-backtracking-depth (1+ clojure--current-backtracking-depth))
(pos 0))
;; Count how far we are from the start of the sexp.
(while (ignore-errors (clojure-backward-logical-sexp 1)
(not (or (bobp)
(eq (char-before) ?\n))))
(cl-incf pos))
(let* ((function (thing-at-point 'symbol))
(method (or (when function ;; Is there a spec here?
(clojure--get-indent-method function))
(ignore-errors
;; Otherwise look higher up.
(pcase (syntax-ppss)
(`(,(pred (< 0)) ,start . ,_)
(goto-char start)
(clojure--find-indent-spec-backtracking)))))))
(when (numberp method)
(setq method (list method)))
(pcase method
((pred functionp)
(when (= pos 0)
method))
((pred sequencep)
(pcase (length method)
(`0 nil)
(`1 (let ((head (elt method 0)))
(when (or (= pos 0) (sequencep head))
head)))
(l (if (>= pos l)
(elt method (1- l))
(elt method pos)))))
((or `defun `:defn)
(when (= pos 0)
:defn))
(_
(message "Invalid indent spec for `%s': %s" function method)
nil))))))
(defun clojure--find-indent-spec ()
"Return the indent spec that applies to current sexp.
If `clojure-use-backtracking-indent' is non-nil, also do
backtracking up to a higher-level sexp in order to find the
spec."
(if clojure-use-backtracking-indent
(save-excursion
(clojure--find-indent-spec-backtracking))
(let ((function (thing-at-point 'symbol)))
(clojure--get-indent-method function))))
(defun clojure--normal-indent (last-sexp indent-mode)
"Return the normal indentation column for a sexp.
Point should be after the open paren of the _enclosing_ sexp, and
LAST-SEXP is the start of the previous sexp (immediately before
the sexp being indented). INDENT-MODE is any of the values
accepted by `clojure-indent-style'."
(goto-char last-sexp)
(forward-sexp 1)
(clojure-backward-logical-sexp 1)
(let ((last-sexp-start nil))
(if (ignore-errors
;; `backward-sexp' until we reach the start of a sexp that is the
;; first of its line (the start of the enclosing sexp).
(while (string-match
"[^[:blank:]]"
(buffer-substring (line-beginning-position) (point)))
(setq last-sexp-start (prog1 (point)
(forward-sexp -1))))
t)
;; Here we have found an arg before the arg we're indenting which is at
;; the start of a line. Every mode simply aligns on this case.
(current-column)
;; Here we have reached the start of the enclosing sexp (point is now at
;; the function name), so the behaviour depends on INDENT-MODE and on
;; whether there's also an argument on this line (case A or B).
(let ((case-a ; The meaning of case-a is explained in `clojure-indent-style'.
(and last-sexp-start
(< last-sexp-start (line-end-position)))))
(cond
;; For compatibility with the old `clojure-defun-style-default-indent', any
;; value other than these 3 is equivalent to `always-body'.
((not (memq indent-mode '(:always-align :align-arguments nil)))
(+ (current-column) lisp-body-indent -1))
;; There's an arg after the function name, so align with it.
(case-a (goto-char last-sexp-start)
(current-column))
;; Not same line.
((eq indent-mode :align-arguments)
(+ (current-column) lisp-body-indent -1))
;; Finally, just align with the function name.
(t (current-column)))))))
(defun clojure--not-function-form-p ()
"Non-nil if form at point doesn't represent a function call."
(or (member (char-after) '(?\[ ?\{))
(save-excursion ;; Catch #?@ (:cljs ...)
(skip-chars-backward "\r\n[:blank:]")
(when (eq (char-before) ?@)
(forward-char -1))
(and (eq (char-before) ?\?)
(eq (char-before (1- (point))) ?\#)))
;; Car of form is not a symbol.
(not (looking-at ".\\(?:\\sw\\|\\s_\\)"))))
;; Check the general context, and provide indentation for data structures and
;; special macros. If current form is a function (or non-special macro),
;; delegate indentation to `clojure--normal-indent'.
(defun clojure-indent-function (indent-point state)
"When indenting a line within a function call, indent properly.
INDENT-POINT is the position where the user typed TAB, or equivalent.
Point is located at the point to indent under (for default indentation);
STATE is the `parse-partial-sexp' state for that position.
If the current line is in a call to a Clojure function with a
non-nil property `clojure-indent-function', that specifies how to do
the indentation.
The property value can be
- `defun', meaning indent `defun'-style;
- an integer N, meaning indent the first N arguments specially
like ordinary function arguments and then indent any further
arguments like a body;
- a function to call just as this function was called.
If that function returns nil, that means it doesn't specify
the indentation.
- a list, which is used by `clojure-backtracking-indent'.
This function also returns nil meaning don't specify the indentation."
;; Goto to the open-paren.
(goto-char (elt state 1))
;; Maps, sets, vectors and reader conditionals.
(if (clojure--not-function-form-p)
(1+ (current-column))
;; Function or macro call.
(forward-char 1)
(let ((method (clojure--find-indent-spec))
(last-sexp calculate-lisp-indent-last-sexp)
(containing-form-column (1- (current-column))))
(pcase method
((or (pred integerp) `(,method))
(let ((pos -1))
(condition-case nil
(while (and (<= (point) indent-point)
(not (eobp)))
(clojure-forward-logical-sexp 1)
(cl-incf pos))
;; If indent-point is _after_ the last sexp in the
;; current sexp, we detect that by catching the
;; `scan-error'. In that case, we should return the
;; indentation as if there were an extra sexp at point.
(scan-error (cl-incf pos)))
(cond
;; The first non-special arg. Rigidly reduce indentation.
((= pos (1+ method))
(+ lisp-body-indent containing-form-column))
;; Further non-special args, align with the arg above.
((> pos (1+ method))
(clojure--normal-indent last-sexp :always-align))
;; Special arg. Rigidly indent with a large indentation.
(t
(+ (* 2 lisp-body-indent) containing-form-column)))))
(`:defn
(+ lisp-body-indent containing-form-column))
((pred functionp)
(funcall method indent-point state))
;; No indent spec, do the default.
(`nil
(let ((function (thing-at-point 'symbol)))
(cond
;; Preserve useful alignment of :require (and friends) in `ns' forms.
((and function (string-match "^:" function))
(clojure--normal-indent last-sexp :always-align))
;; This is should be identical to the :defn above.
((and function
(string-match "\\`\\(?:\\S +/\\)?\\(def[a-z]*\\|with-\\)"
function)
(not (string-match "\\`default" (match-string 1 function))))
(+ lisp-body-indent containing-form-column))
;; Finally, nothing special here, just respect the user's
;; preference.
(t (clojure--normal-indent last-sexp clojure-indent-style)))))))))
;;; Setting indentation
(defun put-clojure-indent (sym indent)
"Instruct `clojure-indent-function' to indent the body of SYM by INDENT."
(put sym 'clojure-indent-function indent))
(defmacro define-clojure-indent (&rest kvs)
"Call `put-clojure-indent' on a series, KVS."
`(progn
,@(mapcar (lambda (x) `(put-clojure-indent
(quote ,(car x)) ,(cadr x)))
kvs)))
(defun add-custom-clojure-indents (name value)
"Allow `clojure-defun-indents' to indent user-specified macros.
Requires the macro's NAME and a VALUE."
(custom-set-default name value)
(mapcar (lambda (x)
(put-clojure-indent x 'defun))
value))
(defcustom clojure-defun-indents nil
"List of additional symbols with defun-style indentation in Clojure.
You can use this to let Emacs indent your own macros the same way
that it indents built-in macros like with-open. This variable
only works when set via the customize interface (`setq' won't
work). To set it from Lisp code, use
(put-clojure-indent \\='some-symbol :defn)."
:type '(repeat symbol)
:set 'add-custom-clojure-indents)
(define-clojure-indent
;; built-ins
(ns 1)
(fn :defn)
(def :defn)
(defn :defn)
(bound-fn :defn)
(if 1)
(if-not 1)
(case 1)
(cond 0)
(condp 2)
(cond-> 1)
(cond->> 1)
(when 1)
(while 1)
(when-not 1)
(when-first 1)
(do 0)
(future 0)
(comment 0)
(doto 1)
(locking 1)
(proxy '(2 nil nil (:defn)))
(as-> 2)
(reify '(:defn (1)))
(deftype '(2 nil nil (:defn)))
(defrecord '(2 nil nil (:defn)))
(defprotocol '(1 (:defn)))
(definterface '(1 (:defn)))
(extend 1)
(extend-protocol '(1 :defn))
(extend-type '(1 :defn))
;; specify and specify! are from ClojureScript
(specify '(1 :defn))
(specify! '(1 :defn))
(try 0)
(catch 2)
(finally 0)
;; binding forms
(let 1)
(letfn '(1 ((:defn)) nil))
(binding 1)
(loop 1)
(for 1)
(doseq 1)
(dotimes 1)
(when-let 1)
(if-let 1)
(when-some 1)
(if-some 1)
(this-as 1) ; ClojureScript
(defmethod :defn)
;; clojure.test
(testing 1)
(deftest :defn)
(are 2)
(use-fixtures :defn)
;; core.logic
(run :defn)
(run* :defn)
(fresh :defn)
;; core.async
(alt! 0)
(alt!! 0)
(go 0)
(go-loop 1)
(thread 0))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; Better docstring filling for clojure-mode
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun clojure-string-start (&optional regex)
"Return the position of the \" that begins the string at point.
If REGEX is non-nil, return the position of the # that begins the
regex at point. If point is not inside a string or regex, return
nil."
(when (nth 3 (syntax-ppss)) ;; Are we really in a string?
(save-excursion
(save-match-data
;; Find a quote that appears immediately after whitespace,
;; beginning of line, hash, or an open paren, brace, or bracket
(re-search-backward "\\(\\s-\\|^\\|#\\|(\\|\\[\\|{\\)\\(\"\\)")
(let ((beg (match-beginning 2)))
(when beg
(if regex
(and (char-before beg) (eq ?# (char-before beg)) (1- beg))
(when (not (eq ?# (char-before beg)))
beg))))))))
(defun clojure-char-at-point ()
"Return the char at point or nil if at buffer end."
(when (not (= (point) (point-max)))
(buffer-substring-no-properties (point) (1+ (point)))))
(defun clojure-char-before-point ()
"Return the char before point or nil if at buffer beginning."
(when (not (= (point) (point-min)))
(buffer-substring-no-properties (point) (1- (point)))))
(defun clojure-toggle-keyword-string ()
"Convert the string or keyword at point to keyword or string."
(interactive)
(let ((original-point (point)))
(while (and (> (point) 1)
(not (equal "\"" (buffer-substring-no-properties (point) (+ 1 (point)))))
(not (equal ":" (buffer-substring-no-properties (point) (+ 1 (point))))))
(backward-char))
(cond
((equal 1 (point))
(error "Beginning of file reached, this was probably a mistake"))
((equal "\"" (buffer-substring-no-properties (point) (+ 1 (point))))
(insert ":" (substring (clojure-delete-and-extract-sexp) 1 -1)))
((equal ":" (buffer-substring-no-properties (point) (+ 1 (point))))
(insert "\"" (substring (clojure-delete-and-extract-sexp) 1) "\"")))
(goto-char original-point)))
(defun clojure-delete-and-extract-sexp ()
"Delete the surrounding sexp and return it."
(let ((begin (point)))
(forward-sexp)
(let ((result (buffer-substring begin (point))))
(delete-region begin (point))
result)))
(defun clojure-project-dir (&optional dir-name)
"Return the absolute path to the project's root directory.
Use `default-directory' if DIR-NAME is nil.
Return nil if not inside a project."
(let* ((dir-name (or dir-name default-directory))
(choices (delq nil
(mapcar (lambda (fname)
(locate-dominating-file dir-name fname))
clojure-build-tool-files))))
(when (> (length choices) 0)
(car (sort choices #'file-in-directory-p)))))
(defun clojure-project-relative-path (path)
"Denormalize PATH by making it relative to the project root."
(file-relative-name path (clojure-project-dir)))
;;; ns manipulation
(defun clojure-expected-ns (&optional path)
"Return the namespace matching PATH.
PATH is expected to be an absolute file path.
If PATH is nil, use the path to the file backing the current buffer."
(let* ((path (or path (file-truename (buffer-file-name))))
(relative (clojure-project-relative-path path))
(sans-file-type (substring relative 0 (- (length (file-name-extension path t)))))
(sans-file-sep (mapconcat 'identity (cdr (split-string sans-file-type "/")) "."))
(sans-underscores (replace-regexp-in-string "_" "-" sans-file-sep)))
;; Drop prefix from ns for projects with structure src/{clj,cljs,cljc}
(replace-regexp-in-string "\\`clj[scx]?\\." "" sans-underscores)))
(defun clojure-insert-ns-form-at-point ()
"Insert a namespace form at point."
(interactive)
(insert (format "(ns %s)" (funcall clojure-expected-ns-function))))
(defun clojure-insert-ns-form ()
"Insert a namespace form at the beginning of the buffer."
(interactive)
(widen)
(goto-char (point-min))
(clojure-insert-ns-form-at-point))
(defun clojure-update-ns ()
"Update the namespace of the current buffer.
Useful if a file has been renamed."
(interactive)
(let ((nsname (funcall clojure-expected-ns-function)))
(when nsname
(save-excursion
(save-match-data
(if (clojure-find-ns)
(progn (replace-match nsname nil nil nil 4)
(message "ns form updated"))
(error "Namespace not found")))))))
(defun clojure--sort-following-sexps ()
"Sort sexps between point and end of current sexp.
Comments at the start of a line are considered part of the
following sexp. Comments at the end of a line (after some other
content) are considered part of the preceding sexp."
;; Here we're after the :require/:import symbol.
(save-restriction
(narrow-to-region (point) (save-excursion
(up-list)
(1- (point))))
(skip-chars-forward "\r\n[:blank:]")
(sort-subr nil
(lambda () (skip-chars-forward "\r\n[:blank:]"))
;; Move to end of current top-level thing.
(lambda ()
(condition-case nil
(while t (up-list))
(scan-error nil))
;; We could be inside a symbol instead of a sexp.
(unless (looking-at "\\s-\\|$")
(clojure-forward-logical-sexp))
;; move past comments at the end of the line.
(search-forward-regexp "$"))
;; Move to start of ns name.
(lambda ()
(comment-forward)
(skip-chars-forward "[:blank:]\n\r[(")
(clojure-forward-logical-sexp)
(forward-sexp -1)
nil)
;; Move to end of ns name.
(lambda ()
(clojure-forward-logical-sexp)))
(goto-char (point-max))
;; Does the last line now end in a comment?
(when (nth 4 (parse-partial-sexp (point-min) (point)))
(insert "\n"))))
(defun clojure-sort-ns ()
"Internally sort each sexp inside the ns form."
(interactive)
(comment-normalize-vars)
(if (clojure-find-ns)
(save-excursion
(goto-char (match-beginning 0))
(redisplay)
(let ((beg (point))
(ns))
(forward-sexp 1)
(setq ns (buffer-substring beg (point)))
(forward-char -1)
(while (progn (forward-sexp -1)
(looking-at "(:[a-z]"))
(save-excursion
(forward-char 1)
(forward-sexp 1)
(clojure--sort-following-sexps)))
(goto-char beg)
(if (looking-at (regexp-quote ns))
(message "ns form is already sorted")
(sleep-for 0.1)
(redisplay)
(message "ns form has been sorted")
(sleep-for 0.1))))
(user-error "Namespace not found")))
(defconst clojure-namespace-name-regex
(rx line-start
"("
(zero-or-one (group (regexp "clojure.core/")))
(zero-or-one (submatch "in-"))
"ns"
(zero-or-one "+")
(one-or-more (any whitespace "\n"))
(zero-or-more (or (submatch (zero-or-one "#")
"^{"
(zero-or-more (not (any "}")))
"}")
(zero-or-more "^:"
(one-or-more (not (any whitespace)))))
(one-or-more (any whitespace "\n")))
(zero-or-one (any ":'")) ;; (in-ns 'foo) or (ns+ :user)
(group (one-or-more (not (any "()\"" whitespace))) symbol-end)))
(defun clojure-find-ns ()
"Return the namespace of the current Clojure buffer.
Return the namespace closest to point and above it. If there are
no namespaces above point, return the first one in the buffer."
(save-excursion
(save-restriction
(widen)
;; The closest ns form above point.
(when (or (re-search-backward clojure-namespace-name-regex nil t)
;; Or any form at all.
(and (goto-char (point-min))
(re-search-forward clojure-namespace-name-regex nil t)))
(match-string-no-properties 4)))))
(defconst clojure-def-type-and-name-regex
(concat "(\\(?:\\(?:\\sw\\|\\s_\\)+/\\)?"
;; Declaration
"\\(def\\(?:\\sw\\|\\s_\\)*\\)\\>"
;; Any whitespace
"[ \r\n\t]*"
;; Possibly type or metadata
"\\(?:#?^\\(?:{[^}]*}\\|\\(?:\\sw\\|\\s_\\)+\\)[ \r\n\t]*\\)*"
;; Symbol name
"\\(\\(?:\\sw\\|\\s_\\)+\\)"))
(defun clojure-find-def ()
"Find the var declaration macro and symbol name of the current form.
Returns a list pair, e.g. (\"defn\" \"abc\") or (\"deftest\" \"some-test\")."
(save-excursion
(unless (looking-at clojure-def-type-and-name-regex)
(beginning-of-defun))
(when (search-forward-regexp clojure-def-type-and-name-regex nil t)
(list (match-string-no-properties 1)
(match-string-no-properties 2)))))
;;; Sexp navigation
(defun clojure--looking-at-non-logical-sexp ()
"Return non-nil if sexp after point represents code.
Sexps that don't represent code are ^metadata or #reader.macros."
(comment-normalize-vars)
(comment-forward (point-max))
(looking-at-p "\\^\\|#[?[:alpha:]]"))
(defun clojure-forward-logical-sexp (&optional n)
"Move forward N logical sexps.
This will skip over sexps that don't represent objects, so that ^hints and
#reader.macros are considered part of the following sexp."
(interactive "p")
(unless n (setq n 1))
(if (< n 0)
(clojure-backward-logical-sexp (- n))
(let ((forward-sexp-function nil))
(while (> n 0)
(while (clojure--looking-at-non-logical-sexp)
(forward-sexp 1))
;; The actual sexp
(forward-sexp 1)
(skip-chars-forward ",")
(setq n (1- n))))))
(defun clojure-backward-logical-sexp (&optional n)
"Move backward N logical sexps.
This will skip over sexps that don't represent objects, so that ^hints and
#reader.macros are considered part of the following sexp."
(interactive "p")
(unless n (setq n 1))
(if (< n 0)
(clojure-forward-logical-sexp (- n))
(let ((forward-sexp-function nil))
(while (> n 0)
;; The actual sexp
(backward-sexp 1)
;; Non-logical sexps.
(while (and (not (bobp))
(ignore-errors
(save-excursion
(backward-sexp 1)
(clojure--looking-at-non-logical-sexp))))
(backward-sexp 1))
(setq n (1- n))))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; Refactoring support
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Threading macros related
(defcustom clojure-thread-all-but-last nil
"Non-nil means do not thread the last expression.
This means that `clojure-thread-first-all' and
`clojure-thread-last-all' not thread the deepest sexp inside the
current sexp."
:package-version '(clojure-mode . "5.4.0")
:safe #'booleanp
:type 'boolean)
(defun clojure--maybe-unjoin-line ()
"Undo a `join-line' done by a threading command."
(when (get-text-property (point) 'clojure-thread-line-joined)
(remove-text-properties (point) (1+ (point)) '(clojure-thread-line-joined t))
(insert "\n")))
(defun clojure--unwind-last ()
(forward-sexp)
(save-excursion
(let ((beg (point))
(contents (clojure-delete-and-extract-sexp)))
(when (looking-at " *\n")
(join-line 'following))
(clojure--ensure-parens-around-function-names)
(let* ((sexp-beg-line (line-number-at-pos))
(sexp-end-line (progn (forward-sexp)
(line-number-at-pos)))
(multiline-sexp-p (not (= sexp-beg-line sexp-end-line))))
(down-list -1)
(if multiline-sexp-p
(insert "\n")
;; `clojure--maybe-unjoin-line' only works when unwinding sexps that were
;; threaded in the same Emacs session, but it also catches cases that
;; `multiline-sexp-p' doesn't.
(clojure--maybe-unjoin-line))
(insert contents))))
(forward-char))
(defun clojure--ensure-parens-around-function-names ()
(clojure--looking-at-non-logical-sexp)
(unless (looking-at "(")
(insert-parentheses 1)
(backward-up-list)))
(defun clojure--unwind-first ()
"Unwind a thread first macro once.
Point must be between the opening paren and the -> symbol."
(forward-sexp)
(save-excursion
(let ((contents (clojure-delete-and-extract-sexp)))
(when (looking-at " *\n")
(join-line 'following))
(clojure--ensure-parens-around-function-names)
(down-list)
(forward-sexp)
(insert contents)
(forward-sexp -1)
(clojure--maybe-unjoin-line)))
(forward-char))
(defun clojure--pop-out-of-threading ()
(save-excursion
(down-list 2)
(backward-up-list)
(raise-sexp)))
(defun clojure--nothing-more-to-unwind ()
(save-excursion
(let ((beg (point)))
(forward-sexp)
(down-list -1)
(backward-sexp 2) ;; the last sexp, the threading macro
(when (looking-back "(\\s-*" (line-beginning-position))
(backward-up-list)) ;; and the paren
(= beg (point)))))
(defun clojure--fix-sexp-whitespace (&optional move-out)
(save-excursion
(when move-out (backward-up-list))
(let ((sexp (bounds-of-thing-at-point 'sexp)))
(clojure-indent-region (car sexp) (cdr sexp))
(delete-trailing-whitespace (car sexp) (cdr sexp)))))
;;;###autoload
(defun clojure-unwind ()
"Unwind thread at point or above point by one level.
Return nil if there are no more levels to unwind."
(interactive)
(save-excursion
(let ((limit (save-excursion
(beginning-of-defun)
(point))))
(ignore-errors
(when (looking-at "(")
(forward-char 1)
(forward-sexp 1)))
(search-backward-regexp "([^-]*->" limit)
(if (clojure--nothing-more-to-unwind)
(progn (clojure--pop-out-of-threading)
(clojure--fix-sexp-whitespace)
nil)
(down-list)
(prog1 (cond
((looking-at "[^-]*->\\_>") (clojure--unwind-first))
((looking-at "[^-]*->>\\_>") (clojure--unwind-last)))
(clojure--fix-sexp-whitespace 'move-out))
t))))
;;;###autoload
(defun clojure-unwind-all ()
"Fully unwind thread at point or above point."
(interactive)
(while (clojure-unwind)))
(defun clojure--remove-superfluous-parens ()
(when (looking-at "([^ )]+)")
(delete-pair)))
(defun clojure--thread-first ()
(down-list)
(forward-symbol 1)
(unless (looking-at ")")
(let ((contents (clojure-delete-and-extract-sexp)))
(backward-up-list)
(just-one-space 0)
(save-excursion
(insert contents "\n")
(clojure--remove-superfluous-parens))
(when (looking-at "\\s-*\n")
(join-line 'following)
(forward-char 1)
(put-text-property (point) (1+ (point))
'clojure-thread-line-joined t))
t)))
(defun clojure--thread-last ()
(forward-sexp 2)
(down-list -1)
(backward-sexp)
(unless (eq (char-before) ?\()
(let ((contents (clojure-delete-and-extract-sexp)))
(just-one-space 0)
(backward-up-list)
(insert contents "\n")
(clojure--remove-superfluous-parens)
;; cljr #255 Fix dangling parens
(forward-sexp)
(when (looking-back "^\\s-*\\()+\\)\\s-*" (line-beginning-position))
(let ((pos (match-beginning 1)))
(put-text-property pos (1+ pos) 'clojure-thread-line-joined t))
(join-line))
t)))
(defun clojure--threadable-p ()
(save-excursion
(forward-symbol 1)
(looking-at "[\n\r\t ]*(")))
;;;###autoload
(defun clojure-thread ()
"Thread by one more level an existing threading macro."
(interactive)
(ignore-errors
(when (looking-at "(")
(forward-char 1)
(forward-sexp 1)))
(search-backward-regexp "([^-]*->")
(down-list)
(when (clojure--threadable-p)
(prog1 (cond
((looking-at "[^-]*->\\_>") (clojure--thread-first))
((looking-at "[^-]*->>\\_>") (clojure--thread-last)))
(clojure--fix-sexp-whitespace 'move-out))))
(defun clojure--thread-all (first-or-last-thread but-last)
(save-excursion
(insert-parentheses 1)
(insert first-or-last-thread))
(while (save-excursion (clojure-thread)))
(when (or but-last clojure-thread-all-but-last)
(clojure-unwind)))
;;;###autoload
(defun clojure-thread-first-all (but-last)
"Fully thread the form at point using ->.
When BUT-LAST is passed the last expression is not threaded."
(interactive "P")
(clojure--thread-all "-> " but-last))
;;;###autoload
(defun clojure-thread-last-all (but-last)
"Fully thread the form at point using ->>.
When BUT-LAST is passed the last expression is not threaded."
(interactive "P")
(clojure--thread-all "->> " but-last))
;;; Cycling stuff
(defcustom clojure-use-metadata-for-privacy nil
"If nil, `clojure-cycle-privacy' will use (defn- f []).
If t, it will use (defn ^:private f [])."
:package-version '(clojure-mode . "5.5.0")
:safe #'booleanp
:type 'boolean)
;;;###autoload
(defun clojure-cycle-privacy ()
"Make public the current private def, or vice-versa.
See: https://github.com/clojure-emacs/clj-refactor.el/wiki/cljr-cycle-privacy"
(interactive)
(save-excursion
(ignore-errors (forward-char 7))
(search-backward-regexp "(defn?\\(-\\| ^:private\\)?\\_>")
(if (match-string 1)
(replace-match "" nil nil nil 1)
(goto-char (match-end 0))
(insert (if (or clojure-use-metadata-for-privacy
(equal (match-string 0) "(def"))
" ^:private"
"-")))))
(defun clojure--convert-collection (coll-open coll-close)
"Convert the collection at (point) by unwrapping it an wrapping it between COLL-OPEN and COLL-CLOSE."
(save-excursion
(while (and
(not (bobp))
(not (looking-at "(\\|{\\|\\[")))
(backward-char))
(when (or (eq ?\# (char-before))
(eq ?\' (char-before)))
(delete-char -1))
(when (and (bobp)
(not (memq (char-after) '(?\{ ?\( ?\[))))
(user-error "Beginning of file reached, collection is not found"))
(insert coll-open (substring (clojure-delete-and-extract-sexp) 1 -1) coll-close)))
;;;###autoload
(defun clojure-convert-collection-to-list ()
"Convert collection at (point) to list."
(interactive)
(clojure--convert-collection "(" ")"))
;;;###autoload
(defun clojure-convert-collection-to-quoted-list ()
"Convert collection at (point) to quoted list."
(interactive)
(clojure--convert-collection "'(" ")"))
;;;###autoload
(defun clojure-convert-collection-to-map ()
"Convert collection at (point) to map."
(interactive)
(clojure--convert-collection "{" "}"))
;;;###autoload
(defun clojure-convert-collection-to-vector ()
"Convert collection at (point) to vector."
(interactive)
(clojure--convert-collection "[" "]"))
;;;###autoload
(defun clojure-convert-collection-to-set ()
"Convert collection at (point) to set."
(interactive)
(clojure--convert-collection "#{" "}"))
(defun clojure--goto-if ()
(when (in-string-p)
(while (or (not (looking-at "("))
(in-string-p))
(backward-char)))
(while (not (looking-at "\\((if \\)\\|\\((if-not \\)"))
(condition-case nil
(backward-up-list)
(scan-error (user-error "No if or if-not found")))))
;;;###autoload
(defun clojure-cycle-if ()
"Change a surrounding if to if-not, or vice-versa.
See: https://github.com/clojure-emacs/clj-refactor.el/wiki/cljr-cycle-if"
(interactive)
(save-excursion
(clojure--goto-if)
(cond
((looking-at "(if-not")
(forward-char 3)
(delete-char 4)
(forward-sexp 2)
(transpose-sexps 1))
((looking-at "(if")
(forward-char 3)
(insert "-not")
(forward-sexp 2)
(transpose-sexps 1)))))
;;; ClojureScript
(defconst clojurescript-font-lock-keywords
(eval-when-compile
`(;; ClojureScript built-ins
(,(concat "(\\(?:\.*/\\)?"
(regexp-opt '("js-obj" "js-delete" "clj->js" "js->clj"))
"\\>")
0 font-lock-builtin-face)))
"Additional font-locking for `clojurescrip-mode'.")
;;;###autoload
(define-derived-mode clojurescript-mode clojure-mode "ClojureScript"
"Major mode for editing ClojureScript code.
\\{clojurescript-mode-map}"
(font-lock-add-keywords nil clojurescript-font-lock-keywords))
;;;###autoload
(define-derived-mode clojurec-mode clojure-mode "ClojureC"
"Major mode for editing ClojureC code.
\\{clojurec-mode-map}")
(defconst clojurex-font-lock-keywords
;; cljx annotations (#+clj and #+cljs)
'(("#\\+cljs?\\>" 0 font-lock-preprocessor-face))
"Additional font-locking for `clojurex-mode'.")
;;;###autoload
(define-derived-mode clojurex-mode clojure-mode "ClojureX"
"Major mode for editing ClojureX code.
\\{clojurex-mode-map}"
(font-lock-add-keywords nil clojurex-font-lock-keywords))
;;;###autoload
(progn
(add-to-list 'auto-mode-alist
'("\\.\\(clj\\|dtm\\|edn\\)\\'" . clojure-mode))
(add-to-list 'auto-mode-alist '("\\.cljc\\'" . clojurec-mode))
(add-to-list 'auto-mode-alist '("\\.cljx\\'" . clojurex-mode))
(add-to-list 'auto-mode-alist '("\\.cljs\\'" . clojurescript-mode))
;; boot build scripts are Clojure source files
(add-to-list 'auto-mode-alist '("\\(?:build\\|profile\\)\\.boot\\'" . clojure-mode)))
(provide 'clojure-mode)
;; Local Variables:
;; coding: utf-8
;; End:
;;; clojure-mode.el ends here