Merge pull request #363 from clojure-emacs/indent-style

bbatsov · bbatsov · commit a97afbe0a93a · 2016-01-25T14:38:49.000+02:00
Offer a third indentation style
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -6,6 +6,10 @@
 
 * [#360](https://github.com/clojure-emacs/clojure-mode/issues/360): `clojure-align` now reindents after aligning, which also fixes an issue with nested alignings.
 
+### New features
+
+* [#362](https://github.com/clojure-emacs/clojure-mode/issues/362): New custom option `clojure-indent-style` offers 3 different ways to indent code.
+
 ## 5.1.0 (04/01/2015)
 
 ### New features
diff --git a/README.md b/README.md
@@ -70,6 +70,49 @@ The default indentation rules in `clojure-mode` are derived from the
 [community Clojure Style Guide](https://github.com/bbatsov/clojure-style-guide).
 Please, refer to the guide for the general Clojure indentation rules.
 
+#### Indentation of function forms
+
+The indentation of function forms is configured by the variable
+`clojure-indent-style`. It takes three possible values:
+
+- `:always-align` (the default)
+
+```clj
+(some-function
+ 10
+ 1
+ 2)
+(some-function 10
+               1
+               2)
+```
+
+- `:always-indent`
+
+```clj
+(some-function
+  10
+  1
+  2)
+(some-function 10
+  1
+  2)
+```
+
+- `:align-arguments`
+
+```clj
+(some-function
+  10
+  1
+  2)
+(some-function 10
+               1
+               2)
+```
+
+#### Indentation of macro forms
+
 The indentation of special forms and macros with bodies is controlled via
 `put-clojure-indent`, `define-clojure-indent` and `clojure-backtracking-indent`.
 Nearly all special forms and built-in macros with bodies have special indentation
diff --git a/clojure-mode.el b/clojure-mode.el
@@ -95,11 +95,56 @@
   "Face used to font-lock interop method names (camelCase)."
   :package-version '(clojure-mode . "3.0.0"))
 
-(defcustom clojure-defun-style-default-indent nil
-  "When non-nil, use default indenting for functions and macros.
-Otherwise check `define-clojure-indent' and `put-clojure-indent'."
-  :type 'boolean
-  :safe 'booleanp)
+(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)"
+  :type '(choice (const :tag "Same as `lisp-mode'" lisp)
+                 (const :tag "Indent like a macro body" always-body)
+                 (const :tag "Indent like a macro body unless first arg is on the same line"
+                        body-unless-same-line))
+  :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."
@@ -950,25 +995,47 @@ spec."
     (let ((function (thing-at-point 'symbol)))
       (clojure--get-indent-method function))))
 
-(defun clojure--normal-indent (last-sexp)
+(defun clojure--normal-indent (last-sexp indent-mode)
   "Return the normal indentation column for a sexp.
-LAST-SEXP is the start of the previous 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))
-    (unless (ignore-errors
-              (while (string-match
-                      "[^[:blank:]]"
-                      (buffer-substring (line-beginning-position) (point)))
-                (setq last-sexp-start (prog1 (point)
-                                        (forward-sexp -1))))
-              t)
-      ;; If the last sexp was on the same line.
-      (when (and last-sexp-start
-                 (> (line-end-position) last-sexp-start))
-        (goto-char last-sexp-start)))
-    (current-column)))
+    (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."
@@ -982,6 +1049,9 @@ LAST-SEXP is the start of the previous sexp."
       ;; 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.
 
@@ -1013,6 +1083,7 @@ This function also returns nil meaning don't specify the indentation."
     ;; 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))
@@ -1028,26 +1099,35 @@ This function also returns nil meaning don't specify the indentation."
              ;; 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 calculate-lisp-indent-last-sexp))
+             (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))
-        ((and `nil
-              (guard (let ((function (thing-at-point 'sexp)))
-                       (or (and clojure-defun-style-default-indent
-                                ;; largely to preserve useful alignment of :require, etc in ns
-                                (not (string-match "^:" function)))
-                           (and (string-match "\\`\\(?:\\S +/\\)?\\(def[a-z]*\\|with-\\)"
-                                              function)
-                                (not (string-match "\\`default" (match-string 1 function))))))))
-         (+ lisp-body-indent containing-form-column))
-        (_ (clojure--normal-indent calculate-lisp-indent-last-sexp))))))
+        ;; 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 :align-arguments))
+            ;; 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)
diff --git a/test/clojure-mode-indentation-test.el b/test/clojure-mode-indentation-test.el
@@ -58,6 +58,7 @@ values of customisable variables."
   (let ((fname (intern (format "indentation/%s" description))))
     `(ert-deftest ,fname ()
        (let* ((after ,after)
+              (clojure-indent-style :always-align)
               (expected-cursor-pos (1+ (s-index-of "|" after)))
               (expected-state (delete ?| after))
               ,@var-bindings)
@@ -221,16 +222,20 @@ values of customisable variables."
 
 
 ;;; Backtracking indent
-(defmacro def-full-indent-test (name &rest forms)
+(defmacro def-full-indent-test (name &optional style &rest forms)
   "Verify that all FORMs correspond to a properly indented sexps."
   (declare (indent 1))
+  (when (stringp style)
+    (setq forms (cons style forms))
+    (setq style :always-align))
   `(ert-deftest ,(intern (format "test-backtracking-%s" name)) ()
      (progn
        ,@(mapcar (lambda (form)
                    `(with-temp-buffer
                       (clojure-mode)
                       (insert "\n" ,(replace-regexp-in-string "\n +" "\n " form))
-                      (indent-region (point-min) (point-max))
+                      (let ((clojure-indent-style ,style))
+                        (indent-region (point-min) (point-max)))
                       (should (equal (buffer-string)
                                      ,(concat "\n" form)))))
                  forms))))
@@ -403,6 +408,26 @@ x
 2
 3))")
 
+(def-full-indent-test align-arguments
+  :align-arguments
+  "(some-function
+  10
+  1
+  2)"
+  "(some-function 10
+               1
+               2)")
+
+(def-full-indent-test always-indent
+  :always-indent
+  "(some-function
+  10
+  1
+  2)"
+  "(some-function 10
+  1
+  2)")
+
 ;;; Alignment
 (defmacro def-full-align-test (name &rest forms)
   "Verify that all FORMs correspond to a properly indented sexps."
