elixir-mode.el

;;; elixir-mode.el --- Major mode for editing Elixir files

;; Copyright (c) 2011 secondplanet
;; Author: Humza Yaqoob
;; URL: https://github.com/secondplanet/elixir-mode
;; Created: Mon Nov 7 2011
;; Keywords: languages elixir
;; Version: 1.0.0

;; This file is not a part of GNU Emacs.

;; 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 2, 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 this program; if not, write to the Free Software
;; Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

;;; Commentary:

;; Provides font-locking, indentation support, and navigation for Elixir programs.

;;; Code:

(require 'comint)   ; for interactive REPL
(require 'easymenu) ; for menubar features

(defconst elixir-mode-version "2.0.0"
	"Elixir mode version number.")
(defconst elixir-mode-date "2012-08-16"
	"Elixir mode version date.")

(defvar elixir-mode-hook nil)
(defvar elixir-mode-map (make-keymap)
  "Elixir mode keymap.")

(defgroup elixir nil
        "Elixir major mode."
        :group 'languages)

(defcustom elixir-compiler-command "elixirc"
        "Elixir mode command to compile code. Must be in your path."
        :type 'string
        :group 'elixir)

(defcustom elixir-iex-command "iex"
        "Elixir mode command for interactive REPL. Must be in your path."
        :type 'string
        :group 'elixir)

(defcustom elixir-mode-highlight-operators t
        "Elixir mode option for whether or not to highlight operators."
        :type 'boolean
        :group 'elixir)

(defcustom elixir-mode-cygwin-paths t
        "Elixir mode use Cygwin style paths on Windows operating systems."
        :type 'boolean
        :group 'elixir)

(defcustom elixir-mode-cygwin-prefix "/cygdrive/C"
	"Elixir mode Cygwin prefix."
	:type 'string
	:group 'elixir)
(defvar elixir-mode-debug-flag nil)
(defun elixir-mode-message (s &rest objects)
  (if elixir-mode-debug-flag
      (message s objects)))

(defvar elixir-mode-define-names '(
  "def"
  "defdelegate"
  "defimpl"
  "defmacro"
  "defmacrop"
  "defmodule"
  "defoverridable"
  "defp"
  "defprotocol"
  "defrecord"
  "destructure")
"Elixir mode def-like keywords.")
(defvar elixir-mode-keyword-names '(
  "->"
  "bc"
  "lc"
  "in"
  "inbits"
  "inlist"
  "quote"
  "unquote"
  "unquote_splicing"
  "var"
  "do"
  "after"
  "for"
  "def"
  "defdelegate"
  "defimpl"
  "defmacro"
  "defmacrop"
  "defmodule"
  "defoverridable"
  "defp"
  "defprotocol"
  "defrecord"
  "destructure"
  "alias"
  "refer"
  "require"
  "import"
  "use"
  "if"
  "true"
  "false"
  "when"
  "case"
  "cond"
  "throw"
  "then"
  "else"
  "elsif"
  "try"
  "catch"
  "rescue"
  "fn"
  "function"
  "%r"
  "%R"
  "%b"
  "%B"
  "receive"
  "end")
"Elixir mode keywords.")
(defvar elixir-mode-module-names '(
  "Behavior"
  "Binary"
  "Bitwise"
  "Builtin"
  "Elixir"
  "Code"
  "EEx"
  "Enum"
  "ExUnit"
  "Exception"
  "File"
  "GenServer"
  "Function"
  "GenServer"
  "GenTCP"
  "HashDict"
  "IO"
  "Keyword"
  "List"
  "Math"
  "Module"
  "Node"
  "OptrionParser"
  "OrdDict"
  "Port"
  "Process"
  "Record"
  "Regexp"
  "System"
  "Tuple"
  "URI"
  "UnboundMethod")
"Elixir mode modules.")
(defvar elixir-mode-builtin-names '(
  "Erlang"
  "__MODULE__"
  "__FUNCTION__"
  "__LINE__"
  "__FILE__"
  "__LOCAL__"
)
"Elixir mode builtins.")
(defvar elixir-mode-operator-names '(
  "+"
        "++"
	"<>"
	"-"
	"/"
	"*"
	"div"
	"rem"
	"=="
	"!="
	"<="
	"<"
	">="
	">"
	"==="
	"!=="
	"and"
	"or"
	"andalso"
	"orelse"
	"not"
	"&&"
	"||"
	"!"
	"."
	"#"
	"="
	":="
	"<-")
"Elixir mode operators.")
(defvar elixir-basic-offset 2)
(defvar elixir-key-label-offset 0)
(defvar elixir-match-label-offset 2)

(defvar font-lock-operator-face 'font-lock-operator-face)
(defface font-lock-operator-face
	'((((type tty) (class color)) nil)
		(((class color) (background light))
		 (:foreground "darkred"))
		(t nil))
	"For use with operators."
	:group 'font-lock-faces)

(defconst elixir-mode-font-lock-defaults
  (list
    '("#.*$" . font-lock-comment-face)                                                                                                  ; comments
    `(,(concat "^\\s *\\<" (regexp-opt elixir-mode-define-names t) "\\>\\s +\\([^( \t\n]+\\)") 2 font-lock-function-name-face)          ; methods
    `(,(concat "\\<" (regexp-opt elixir-mode-keyword-names t) "\\>") . font-lock-keyword-face)                                          ; keywords
    `(,(concat "\\<" (regexp-opt elixir-mode-builtin-names t) "\\>") . font-lock-builtin-face)                                          ; builtins
    `(,(concat "\\<" (regexp-opt elixir-mode-module-names t) "\\>") . font-lock-type-face)                                              ; core modules
    (when elixir-mode-highlight-operators `(,(concat "\\<" (regexp-opt elixir-mode-operator-names t) "\\>") . font-lock-operator-face)) ; operators
    '("\\(\\w*\\)\\s-*:?=" . font-lock-variable-name-face)                                                                              ; variables
    '("-[Rr].*[ \n\t]" . font-lock-constant-face)                                                                                       ; regexes
    '("\\<\\(true\\|false\\|nil\\)\\>" . font-lock-reference-face)                                                                           ; atoms, boolean
    '("\\w*:\s" . font-lock-reference-face)
    '(":\\w*" . font-lock-reference-face))                                                                                                   ; atoms, generic
"Highlighting for Elixir mode.")

(defun elixir-mode-takewhile (f l)
  (let ((not-done t) (n l) (ret))
    (while (and n not-done)
      (setq ret (funcall f (car n)))
      (setq n (cdr n))
      (setq not-done (car ret)))
    ret))


(defvar elixir-mode-endmark "^[ \t]*\\<end\\>")
(defvar elixir-mode-beginmark ".*\\(\\<fn.*(.*).*->\\|\\<do\\>\\)$")
(defvar elixir-mode-mbeginmark ".*\\<\\(fn\\|\\(cond\\|case\\|receive\\).*\\)[ \t\+do$")
(defvar elixir-mode-onelinermark ".*->.*\\<end\\>$")
(defvar elixir-mode-keymark "^[ \t]*\\(else\\|after\\)$")
(defvar elixir-mode-labelmark ".*->.*")

(defun elixir-mode-previous-line-last-offset ()
  "find last block + basic-offset"
  (let ((level 1))
    (progn
      (while (and (> level 0) (not (bobp)))
	(forward-line -1)
	(cond ((looking-at elixir-mode-endmark)
	       (setq level (+ level 1)))
	      ((looking-at elixir-mode-beginmark)
	       (setq level (- level 1)))))
      (cond ((bobp)
	     0)
	    (t
	     (+ (current-indentation) elixir-basic-offset))))))

(defun elixir-mode-find-type ()
  "find keyword type in (begin|end|normal|label|key)"
  (progn
    (elixir-mode-message "%s" "find-type")
    (elixir-mode-message "%s" (thing-at-point 'line))
    (cond ((looking-at elixir-mode-endmark)
	   'end)
	  ((looking-at elixir-mode-beginmark)
	   'begin)
	  ((looking-at elixir-mode-onelinermark)
	   'normal)
	  ((looking-at elixir-mode-labelmark)
	   'label)
	  ((looking-at elixir-mode-keymark)
	   'key)
	  (t
	   'normal))))

(defun elixir-mode-previous-line-offset ()
  "calc offset by previous line type in (begin|label|key|other)"
  (save-excursion
    (let ((type))
      (forward-line -1)
      (setq type (elixir-mode-find-type))
      (cond ((eq type 'begin)
	     (+ (current-indentation) elixir-basic-offset))
	    ((eq type 'label)
	     (+ (current-indentation) elixir-basic-offset))
	    ((eq type 'key)
	     (+ (- (current-indentation) elixir-key-label-offset)
		   elixir-basic-offset))
	    (t
	     (current-indentation))))))
  
(defun elixir-mode-indent-line ()
  "Indent current line as Elixir code."
  (interactive)
  (beginning-of-line)
  (let ((ttype) (poffset) (noffset))
    (save-excursion
      (setq ttype (elixir-mode-find-type))
      (setq noffset (cond ((eq ttype 'label)
			   (+ (- (elixir-mode-previous-line-last-offset)
				  elixir-basic-offset)
			      elixir-match-label-offset))
			  ((eq ttype 'key)
			   (+ (- (elixir-mode-previous-line-last-offset)
				 elixir-basic-offset)
			      elixir-key-label-offset))
			  ((eq ttype 'end)
			   (- (elixir-mode-previous-line-last-offset)
			      elixir-basic-offset))
			  ((or (eq ttype 'normal) (eq ttype 'begin))
			   (elixir-mode-previous-line-offset)))))
    (cond ((> 0 noffset) 
	   (setq noffset 0)))
    (indent-line-to noffset)))
(defun elixir-mode-cygwin-path (expanded-file-name)
        "Elixir mode get Cygwin absolute path name."
        (replace-regexp-in-string "^[a-zA-Z]:" elixir-mode-cygwin-prefix expanded-file-name t))

(defun elixir-mode-universal-path (file-name)
        "Elixir mode multi-OS path handler."
        (let ((full-file-name (expand-file-name file-name)))
                (if (and (equal system-type 'windows-nt)
                                                 elixir-mode-cygwin-paths)
                                (elixir-mode-cygwin-path full-file-name)
                                full-file-name)))

(defun elixir-mode-command-compile (file-name)
  "Elixir mode command to compile a file."
        (let ((full-file-name (elixir-mode-universal-path file-name)))
                (mapconcat 'identity (append (list elixir-compiler-command) (list full-file-name)) " ")))

(defun elixir-mode-compiled-file-name (&optional filename)
  "Elixir mode compiled filename."
        (concat (file-name-sans-extension (or filename (buffer-file-name))) ".beam"))

(defun elixir-mode-compile-file ()
  "Elixir mode compile and save current file."
  (interactive)
        (let ((compiler-output (shell-command-to-string (elixir-mode-command-compile (buffer-file-name)))))
                (when (string= compiler-output "")
                        (message "Compiled and saved as %s" (elixir-mode-compiled-file-name)))))

(defun elixir-mode-iex ()
  "Elixir mode interactive REPL."
        (interactive)
        (unless (comint-check-proc "*IEX*")
                (set-buffer
                 (apply 'make-comint "IEX"
            elixir-iex-command nil '())))
        (pop-to-buffer "*IEX*"))

(defun elixir-mode-open-modegithub ()
  "Elixir mode open GitHub page."
  (interactive)
        (browse-url "https://github.com/secondplanet/elixir-mode"))

(defun elixir-mode-open-elixir-home ()
  "Elixir mode go to language home."
  (interactive)
        (browse-url "https://github.com/josevalim/elixir#README"))

(defun elixir-mode-show-version ()
  "Elixir mode print version."
	(interactive)
	(message "%s" (concat "elixir-mode v" elixir-mode-version " " elixir-mode-date " by Humza Yaqoob")))

(defvar elixir-mode-syntax-table
  (let ((elixir-mode-syntax-table (make-syntax-table)))
    (modify-syntax-entry ?? "\\" elixir-mode-syntax-table)
    (modify-syntax-entry ?_ "w" elixir-mode-syntax-table)
;    (modify-syntax-entry ?# "<" elixir-mode-syntax-table)
;    (modify-syntax-entry ?\n ">" elixir-mode-syntax-table)
    (modify-syntax-entry ?\( "()" elixir-mode-syntax-table)
    (modify-syntax-entry ?\) ")(" elixir-mode-syntax-table)
    (modify-syntax-entry ?\{ "(}" elixir-mode-syntax-table)
    (modify-syntax-entry ?\} "){" elixir-mode-syntax-table)
    (modify-syntax-entry ?\[ "(]" elixir-mode-syntax-table)
    (modify-syntax-entry ?\] ")[" elixir-mode-syntax-table)
    (modify-syntax-entry ?\: "'" elixir-mode-syntax-table)
    elixir-mode-syntax-table)
"Elixir mode syntax table.")

(easy-menu-define elixir-mode-menu elixir-mode-map
  "Elixir mode menu."
  '("Elixir"
    ["Indent line" smie-indent-line]
    ["Compile file" elixir-mode-compile-file]
    ["IEX" elixir-mode-iex]
    "---"
    ["elixir-mode on GitHub" elixir-mode-open-modegithub]
    ["Elixir homepage" elixir-mode-open-elixirhome]
    ["About" elixir-mode-show-version]
    ))

(defun elixir-mode ()
  "Major mode for editing Elixir files."
  (interactive)
  (kill-all-local-variables)
  (set-syntax-table elixir-mode-syntax-table)
  (set (make-local-variable 'font-lock-defaults) '(elixir-mode-font-lock-defaults))
  (setq major-mode 'elixir-mode)
  (setq mode-name "Elixir")
  (set (make-local-variable 'comment-start) "# ")
  (set (make-local-variable 'comment-end) "")
  (smie-setup elixir-smie-grammar 'verbose-elixir-smie-rules ; 'elixir-smie-rules
              :forward-token 'elixir-smie-forward-token
              :backward-token 'elixir-smie-backward-token)
  (run-hooks 'elixir-mode-hook)
  (run-hooks 'prog-mode-hook))

(define-minor-mode elixir-cos-mode
        "Elixir mode toggle compile on save."
        :group 'elixir-cos :lighter " CoS"
        (cond
         (elixir-cos-mode
                (add-hook 'after-save-hook 'elixir-mode-compile-file nil t))
         (t
                (remove-hook 'after-save-hook 'elixir-mode-compile-file t))))

(require 'elixir-smie)

(provide 'elixir-mode)

;; automatically opening ex and exs in elixir-mode
;;;###autoload
(add-to-list 'auto-mode-alist '("\\.ex\\'" . elixir-mode))
;;;###autoload
(add-to-list 'auto-mode-alist '("\\.exs\\'" . elixir-mode))


;;; elixir-mode.el ends here