Some code cleanup.

Author: mattdeboard

elixir-smie.el

@@ -200,30 +200,39 @@ Return non-nil if any line breaks were skipped."
                    (block nil
                      (while
                          (and
+                          ;; Cursor is not at the end of the buffer...
                           (not (= (point) (point-max)))
+                          ;; ...and the current token is not an empty string...
                           (not (string= "" token))
+                          ;; ...nor a newline nor a semicolon.
                           (not (or (string= "\n" token) (string= ";" token))))
                        (setq token (elixir-smie-next-token-no-lookaround t nil))
+                       ;; If we're at the top level and the token is "->",
+                       ;; return t
                        (cond ((and (= level 0) (string= "->" token))
                               (return t))
+                             ;; If token is "do" or "fn", increment level
                              ((find token '("do" "fn") :test 'string=)
                               (incf level))
+                             ;; If token is "end", decrement level
                              ((string= token "end")
                               (decf level)))))))
                ;; Scan behind:
                (let (token)
                  (save-excursion
                    (block nil
                      (while
-                         (and (not (= (point) (point-min)))
-                              (not (string= "" token))
-                              (not (string= "do" token))
-                              (not (string= "fn" token)))
+                         (and
+                          ;; Cursor is not at the beginning of buffer...
+                          (not (= (point) (point-min)))
+                          ;; ...and token is neither empty string, nor "do"/"fn"
+                          (not (string= "" token))
+                          (not (string= "do" token))
+                          (not (string= "fn" token)))
                        (setq token (elixir-smie-next-token-no-lookaround nil nil))
                        (when (string= "->" token)
                          (return t)))
-                     (when (or (string= token "do"))
-                       t)))))
+                     (when (string= token "do") t)))))
           "MATCH-STATEMENT-DELIMITER"
         current-token))))
 
@@ -310,15 +319,14 @@ Return non-nil if any line breaks were skipped."
     (`(:after . "end") 0)
     (`(:after . ,(or `"do"))
      elixir-smie-indent-basic)
-    (`(:list-intro . ,(or `"do"))
-     t)))
+    (`(:list-intro . ,(or `"do")) t)))
 
 (define-minor-mode elixir-smie-mode
   "SMIE-based indentation and syntax for Elixir"
   nil nil nil nil
   (set (make-local-variable 'comment-start) "# ")
   (set (make-local-variable 'comment-end) "")
-  (smie-setup elixir-smie-grammar 'elixir-smie-rules ; 'verbose-elixir-smie-rules
+  (smie-setup elixir-smie-grammar 'elixir-smie-rules
               :forward-token 'elixir-smie-forward-token
               :backward-token 'elixir-smie-backward-token))
 

test/elixir-mode-indentation-tests.el

@@ -11,18 +11,19 @@
            (insert indented)
            (should (equal indented ,expected-output)))))))
 
-(elixir-def-indentation-test indents-use-dot-module-newline
-    (:expected-result :failed) ; #41
-  "
-defmodule Foo do
+;; Expected test failures indicates that the code tested by that test case is
+;; indeed broken. My intention is that while working on a specific problem,
+;; the failure expectation will be removed so that we know when the test case
+;; passes.
+(elixir-def-indentation-test indents-use-dot-module-newline ()
+  "defmodule Foo do
 use GenServer.Behaviour
 
 def foobar do
 if true, do: IO.puts \"yay\"
 end
 end"
-  "
-defmodule Foo do
+  "defmodule Foo do
   use GenServer.Behaviour
 
   def foobar do
@@ -125,7 +126,7 @@ defmodule FooBar do
 end")
 
 (elixir-def-indentation-test indents-after-empty-line
-    (:expected-result :failed)
+    (:expected-result :failed) ; #18
   "
 a = 2