spacemacs/layers/+lang/clojure

Clojure layer

• Description
  • Features:
• Install
  • Layer
  • Pretty Symbols
  • Enabling sayid or clj-refactor
  • Starting Clojure manually (outside of Emacs)
    • Quick Start with boot
    • Quick Start with lein
    • More details
• Usage
  • Cheatsheet
  • Linting
  • Structuraly safe editing
• Key bindings
  • Working with clojure files (barfage, slurpage & more)
  • Leader
    • Documentation
    • Evaluation
    • Goto
    • REPL
    • Tests
    • Toggles
    • Debugging
    • Refactoring
    • Reformatting
    • Profiling
  • CIDER Buffers
    • cider-repl-mode
    • stacktrace-mode
    • inspector-mode
    • test-report-mode
  • Sayid Buffers
    • sayid-mode
    • sayid-traced-mode
    • sayid-pprint
• Development Notes
  • Indentation

Description

This layer adds support for Clojure language using CIDER.

Features:

• REPL via CIDER
• Code formatting via CIDER using Cljfmt
• Refactoring via clj-refactor
• Linting via squiggly-clojure
• Aligning of code forms via clojure-mode
• Debugging with sayid
• Clojure cheatsheet
• Structuraly safe editing using optional evil-cleverparens

Install

Layer

To use this configuration layer, add it to your ~/.spacemacs. You will need to add clojure to the existing dotspacemacs-configuration-layers list in this file.

Pretty Symbols

Pretty symbols for anonymous functions, set literals and partial, like (λ [a] (+ a 5)), ƒ(+ % 5), ∈{2 4 6} and Ƥ.

To enable this feature, add the following snippet to the dotspacemacs/user-config section of your ~/.spacemacs file:

  (setq clojure-enable-fancify-symbols t)

Or set this variable when loading the configuration layer:

  (setq-default dotspacemacs-configuration-layers
  '((clojure :variables clojure-enable-fancify-symbols t)))

Enabling sayid or clj-refactor

The packages sayid (Clojure debugger) and clj-refactor (automatic refactorings) are disabled by default. To enable them, add a `:variables` option when enabling the `clojure` layer, specifying `clojure-enable-sayid`, or `clojure-enable-clj-refactor`, or both.

In your Spacemacs configuration:

  ;; before
  dotspacemacs-configuration-layers
  '(...
    clojure
    )

  ;; after
  dotspacemacs-configuration-layers
  '(...
    (clojure :variables
             clojure-enable-sayid t
             clojure-enable-clj-refactor t)
    )

Enabling either of these packages will cause extra nREPL middleware to be injected when jacking in CIDER.

Starting Clojure manually (outside of Emacs)

CIDER communicates with your Clojure process through nREPL, and for CIDER to function correctly extra nREPL middleware needs to be present (cider/cider-nrepl). The same is true for clj-refactor (refactor-nrepl), and for sayid (com.billpiel/sayid).

When starting the Clojure process through cider (`cider-jack-in` and friends) this will be handled automatically, and so most users should be able to just run SPC m s i to connect to the CIDER REPL and skip the rest of this section.

If you are running an older version of CIDER (0.10 or older), or if you are starting the Clojure process yourself outside of Emacs, then you need to make sure the necessary dependencies are present, and the necessary nREPL middlewares are enabled.

Quick Start with boot

• Install boot 2.8.2 or newer (see https://github.com/boot-clj/boot#user-content-install)

• Create a file ~/.boot/profile.boot with the following content:

    (require 'boot.repl)
  
    (swap! boot.repl/*default-dependencies* conj
           ;; When running an older version of CIDER (pre 0.18), use the
           ;; version that best matches M-x cider-version. For versions since
           ;; 0.18.0 use whatever version is the most recent.
           '[cider/cider-nrepl "0.21.1"]
  
           ;; Only necessary when using clj-refactor
           '[refactor-nrepl "2.4.0"]
  
           ;; Only necessary when using sayid
           '[com.billpiel/sayid "0.0.17"])
  
    (swap! boot.repl/*default-middleware* conj
           'cider.nrepl/cider-middleware
           'refactor-nrepl.middleware/wrap-refactor
           'com.billpiel.sayid.nrepl-middleware/wrap-sayid)

Quick Start with lein

• Install lein version 2.9.0 or newer (see https://leiningen.org/#install)

• Create a file ~/.lein/profiles.clj with the following content:

    {:repl
     {:plugins [;; When running an older version of CIDER (pre 0.18), use the
                ;; version that best matches M-x cider-version. For versions since
                ;; 0.18.0 use whatever version is the most recent.
                [cider/cider-nrepl "0.21.1"]
  
                ;; Only necessary when using clj-refactor
                [refactor-nrepl "2.4.0"]
  
                ;; Only necessary when using sayid
                [com.billpiel/sayid "0.0.17"]]
  
      :dependencies [[nrepl "0.4.5"]]
  
      :repl-options
      {:nrepl-middleware [cider.nrepl/cider-middleware
                          refactor-nrepl.middleware/wrap-refactor ;; clj-refactor
                          com.billpiel.sayid.nrepl-middleware/wrap-sayid ;; sayid
                          ]}}}

More details

More info regarding installation of nREPL middleware can be found here:

• CIDER: CIDER installation (official docs)
• clj-refactor: refactor-nrepl

Usage

Cheatsheet

This layers installs the clojure-cheatsheet package which embeds this useful cheatsheet into Emacs.

Type SPC m h c to display the cheatsheet then type in some terms (space separated) to narrow down the list. For example, try typing in sort map to see some functions that deal with sorting maps.

Linting

Linting works via flycheck and disabled by default. You can enable it like this:

  (setq clojure-enable-linters t)

Make sure to read the warnings section. If you have a problem peek into debugging and bug reporting then try to reproduce in the sample project. NOTE: With the default linter configs you should add org.clojure/core.typed to the development dependencies.

Structuraly safe editing

This layer adds support for evil-cleverparens which allows to safely edit lisp code by keeping the s-expressions balanced.

By default this mode is not activated. You can turn it on locally on the active buffer with SPC m T s (s for safe).

To turn it on automatically for all clojure buffers call the following function in your dotspacemacs/user-config function:

  (spacemacs/toggle-evil-safe-lisp-structural-editing-on-register-hook-clojure-mode)

or to enable it for all supported modes:

  (spacemacs/toggle-evil-safe-lisp-structural-editing-on-register-hooks)

When enabled the symbol 🆂 should be displayed in the mode-line.

Key bindings

Working with clojure files (barfage, slurpage & more)

Spacemacs comes with a special lisp-state for working with lisp code that supports slurpage, barfage and more tools you'll likely want when working with lisp.

As this state works the same for all files, the documentation is in global DOCUMENTATION.org. In general, use SPC k to interact with the lisp-state.

Leader

Documentation

Key binding	Description
SPC m h a	cider apropos
SPC m h c	clojure cheatsheet
SPC m h g	cider grimoire
SPC m h h	cider doc
SPC m h j	cider javadoc
SPC m h n	cider browse namespace
SPC m h N	cider browse all namespaces

Evaluation

Key binding	Description
SPC m e ;	eval sexp and show result as comment
SPC m e b	eval buffer
SPC m e e	eval last sexp
SPC m e f	eval function at point
SPC m e r	eval region
SPC m e m	cider macroexpand 1
SPC m e M	cider macroexpand all
SPC m e p	print last sexp (clojure interaction mode only)
SPC m e P	eval last sexp and pretty print result in separate buffer
SPC m e u	Undefine a symbol from the current namespace
SPC m e w	eval last sexp and replace with result

Goto

Key binding	Description
SPC m g b	go back
SPC m g C	browse classpath
SPC m g g	goto var
SPC m g e	goto error
SPC m g n	goto namespace
SPC m g r	goto resource
SPC m g s	browse spec
SPC m g S	browse all specs

REPL

Key binding	Description
SPC m ,	handle shortcut (cider-repl-handle-shortcut)
SPC m s b	send and eval buffer in REPL
SPC m s B	send and eval buffer and switch to REPL in insert state
SPC m s c	connect to REPL (cider-connect) or clear repl buffer (cider-repl-clear-buffer)
SPC m s C	clear REPL (cider-find-and-clear-repl-output)
SPC m s e	send and eval last sexp in REPL
SPC m s E	send and eval last sexp and switch to REPL in insert state
SPC m s f	send and eval function in REPL
SPC m s F	send and eval function and switch to REPL in insert state
SPC m s i	start REPL (cider-jack-in)
SPC m s I	start clojurescript REPL (cider-jack-in-clojurescript)
SPC m s n	send and eval ns form in REPL
SPC m s N	send and eval ns form and switch to REPL in insert state
SPC m s q	kill REPL (cider-quit)
SPC m s o	switch to other repl instance (cider-repl-switch-to-other)
SPC m s r	send and eval region in REPL
SPC m s R	send and eval region and switch to REPL in insert state
SPC m s s	switch to REPL or jump to last file or last clj buffer from repl (cider-repl)
SPC m s x	refresh REPL
SPC m s X	restart REPL

Tests

Key binding	Description
SPC m t a	run all tests in namespace
SPC m t r	re-run test failures for namespace
SPC m t t	run test at point

Toggles

Key binding	Description
SPC m T e	toggle englighten mode
SPC m T f	toggle REPL font-locking
SPC m T i	toggle indentation style
SPC m T p	toggle REPL pretty-printing
SPC m T t	toggle auto test mode

Debugging

Key binding	Description
SPC m d !	reload traces and clear sayid workspace
SPC m d b	instrument expression at point
SPC m d c	clear workspace trace log
SPC m d e	display last stacktrace
SPC m d E	one time display of value at cursor
SPC m d f	query form at point
SPC m d h	show sayid help (key bindings may not be accurate)
SPC m d i	inspect expression at point
SPC m d r	reload namespaces
SPC m d s	show what is currently traced
SPC m d S	show what is currently traced in current namespace
SPC m d t b	trace current file's namespace
SPC m d t d	disable existing trace on current function
SPC m d t D	disable existing trace on all functions
SPC m d t e	enable existing trace on current function
SPC m d t E	enable existing trace on all functions
SPC m d t K	remove all traces
SPC m d t n	create inner trace on function
SPC m d t o	create outer trace on function
SPC m d t p	trace namespaces by regex
SPC m d t r	remove trace on function
SPC m d t y	recursively trace every namespace in given dir
SPC m d v	inspect expression at point
SPC m d V	set the view
SPC m d w	open sayid workspace window
SPC m d x	clear workspace traces and log

Refactoring

The following refactoring key bindings are enabled by default in clojure-mode:

Key binding	Description
SPC m r c i	cycle between if and if-not forms
SPC m r c p	cycle privacy of defn and def forms
SPC m r c (	convert coll to list
SPC m r c '	convert coll to quoted list
SPC m r c {	convert coll to map
SPC m r c #	convert coll to set
SPC m r c [	convert coll to vector
SPC m r t f	rewrite the following form to use the -> (thread first) macro.
SPC m r t l	rewrite the following form to use the ->> (thread last) macro.
SPC m r t h	thread another form into the surrounding threading macro
SPC m r u a	unwind all steps of surrounding threading macro
SPC m r u w	unwind threading macro one step at a time

The following refactorings require cljr-refactor to be enabled and generally depend on a connected CIDER session.

Key binding	Description
SPC m r ?	describe refactoring
SPC m r a d	add declaration
SPC m r a i	add import to ns
SPC m r a m	add missing libspec
SPC m r a p	add project dependency
SPC m r a r	add require to ns
SPC m r a u	add use to ns
SPC m r c :	toggle between keyword and string
SPC m r c n	clean ns
SPC m r d k	destructure keys
SPC m r e c	extract constant
SPC m r e d	extract definition
SPC m r e f	extract function
SPC m r e l	expand let
SPC m r f u	find usages
SPC m r f e	create fn from example
SPC m r h d	hotload dependency
SPC m r i l	introduce let
SPC m r i s	inline symbol
SPC m r m f	move form
SPC m r m l	move to let
SPC m r p c	project clean
SPC m r p f	promote function
SPC m r r d	remove debug fns
SPC m r r f	rename file
SPC m r r l	remove let
SPC m r r r	remove unused requires
SPC m r r s	rename symbol
SPC m r r u	replace use
SPC m r s n	sort ns
SPC m r s p	sort project dependencies
SPC m r s r	stop referring
SPC m r s c	show changelog
SPC m r u p	update project dependencies

Reformatting

Key binding	Description
SPC m f b or SPC m =	reformat current buffer
SPC m f l	realign current form

Profiling

Key binding	Description
SPC m p +	profile samples
SPC m p c	clear profile
SPC m p n	toggle profile ns
SPC m p s	profile summary
SPC m p S	summary for all
SPC m p t	toggle profile
SPC m p v	is variable profiled

CIDER Buffers

In general, q should always quit the popped up buffer.

cider-repl-mode

Key binding	Description
C-j	next input
C-k	previous input

stacktrace-mode

Key binding	Description
C-j	next cause
C-k	previous cause
TAB	cycle current cause
0	cycle all causes
1	cycle cause 1
2	cycle cause 2
3	cycle cause 3
4	cycle cause 4
5	cycle cause 5
a	toggle all
c	toggle clj
d	toggle duplicates
J	toggle java
r	toggle repl
T	toggle tooling

inspector-mode

Key binding	Description
TAB	next inspectable object
Shift-TAB	previous inspectable object
RET	inspect object
L	pop to the parent object
n	next page in paginated view
N	previous page in paginated view
r	refresh
s	set a new page size

test-report-mode

Key binding	Description
C-j	next result
C-k	previous result
RET	jump to test
d	ediff test result
e	show stacktrace
r	rerun failed tests
t	run test
T	run tests

Sayid Buffers

sayid-mode

Key binding	Description
Shift-Backspace	forward buffer state
enter	pop to function
d	def value to $s/*
f	query for calls to function
F	query to calls to function with modifier
i	show only this instance
I	show only this instance with modifier
L or Backspace	previous buffer state
n	jump to next call
N	jump to previous call
P	pretty print value
C	clear workspace trace log
e	generate instance expression and put in kill ring
H	display help (key bindings may not be accurate)
w	show full workspace trace
C-s v	toggle view
C-s V	set view

sayid-traced-mode

Key binding	Description
backspace	go back to trace overview
enter	drill into ns at point
e	enable trace
E	enable all traces
d	disable trace
D	disable all traces
h	display help (key bindings may not be accurate)
i	apply inner trace to function at point
o	apply outer trace to function at point
r	remove trace at point

sayid-pprint

Key binding	Description
enter	show path in minibuffer
i	enter child node
o	enter parent node
n	enter next sibling node
p	enter previous sibling node

Development Notes

Indentation

With a new functionality of Cider to read the custom indentation rules from the var's metadata, it is better for consistency reasons to not add the custom indentation rules to Spacemacs, but to add them to the metadata of those specific vars.