@@ -23,6 +23,8 @@ (autoload 'scala-mode "scala-mode-auto" nil t) (add-to-list 'auto-mode-alist '("\\.scala" . scala-mode)) +(setq default-tab-width 2) + (server-start) (add-to-list 'load-path (expand-file-name "~/.emacs.d/cnixon/yasnippet")) cnixon.el @@ -21,6 +21,7 @@ ;;; Code: (eval-when-compile (require 'cl)) +(require 'ruby-mode) ;; User definable variables @@ -54,13 +55,16 @@ line itself." :group 'haml) (defvar haml-indent-function 'haml-indent-p - "This function should look at the current line and return true -if the next line could be nested within this line.") + "This function should look at the current line and return t +if the next line could be nested within this line. + +The function can also return a positive integer to indicate +a specific level to which the current line could be indented.") (defvar haml-block-openers - `("^ *\\([%\\.#][^ \t]*\\)\\(\\[.*\\]\\)?\\({.*}\\)?\\(\\[.*\\]\\)?[ \t]*$" - "^ *[-=].*do[ \t]*\\(|.*|[ \t]*\\)?$" - ,(concat "^ *-[ \t]*\\(" + `("^ *\\([%\\.#][a-z0-9_:\\-]*\\)+\\({.*}\\)?\\(\\[.*\\]\\)?[><]*[ \t]*$" + "^ *[&!]?[-=~].*do[ \t]*\\(|.*|[ \t]*\\)?$" + ,(concat "^ *[&!]?[-=~][ \t]*\\(" (regexp-opt '("if" "unless" "while" "until" "else" "begin" "elsif" "rescue" "ensure" "when")) "\\)") @@ -73,40 +77,127 @@ text nested beneath them.") ;; Font lock (defun haml-nested-regexp (re) - (concat "^\\( *\\)" re "\n\\(?:\\(?:\\1 .*\\| *\\)\n\\)*")) + (concat "^\\( *\\)" re "\\(\n\\(?:\\(?:\\1 .*\\| *\\)\n\\)*\\(?:\\1 .*\\| *\\)?\\)?")) (defconst haml-font-lock-keywords - `((,(haml-nested-regexp "-#.*") 0 font-lock-comment-face) + `((,(haml-nested-regexp "\\(?:-#\\|/\\).*") 0 font-lock-comment-face) (,(haml-nested-regexp ":\\w+") 0 font-lock-string-face) - ("^ *\\(\t\\)" 1 'haml-tab-face) - ("^!!!.*" 0 font-lock-constant-face) - ("\\('[^']*'\\)" 1 font-lock-string-face append) - ("\\(\"[^\"]*\"\\)" 1 font-lock-string-face append) - ("@[a-z0-9_]+" 0 font-lock-variable-name-face append) - ("| *$" 0 font-lock-string-face) - ("^[ \t]*\\(/.*\\)$" 1 font-lock-comment-face append) - ("^ *\\(#[a-z0-9_]+\/?\\)" 1 font-lock-keyword-face) - ("^ *\\(\\.[a-z0-9_]+\/?\\)" 1 font-lock-type-face) - ("^ *\\(%[a-z0-9_]+\/?\\)" 1 font-lock-function-name-face) - ("^ *\\(#[a-z0-9_]+\/?\\)" (1 font-lock-keyword-face) - ("\\.[a-z0-9_]+" nil nil (0 font-lock-type-face))) - ("^ *\\(\\.[a-z0-9_]+\/?\\)" (1 font-lock-type-face) - ("\\.[a-z0-9_]+" nil nil (0 font-lock-type-face))) - ("^ *\\(\\.[a-z0-9_]+\/?\\)" (1 font-lock-type-face) - ("\\#[a-z0-9_]+" nil nil (0 font-lock-keyword-face))) - ("^ *\\(%[a-z0-9_]+\/?\\)" (1 font-lock-function-name-face) - ("\\.[a-z0-9_]+" nil nil (0 font-lock-type-face))) - ("^ *\\(%[a-z0-9_]+\/?\\)" (1 font-lock-function-name-face) - ("\\#[a-z0-9_]+" nil nil (0 font-lock-keyword-face))) - ("^ *\\([~=-] .*\\)" 1 font-lock-preprocessor-face prepend) - ("^ *[\\.#%a-z0-9_]+\\([~=-] .*\\)" 1 font-lock-preprocessor-face prepend) - ("^ *[\\.#%a-z0-9_]+\\({[^}]+}\\)" 1 font-lock-preprocessor-face prepend) - ("^ *[\\.#%a-z0-9_]+\\(\\[[^]]+\\]\\)" 1 font-lock-preprocessor-face prepend))) - -(defconst haml-filter-re "^ *\\(:\\)\\w+") -(defconst haml-comment-re "^ *\\(-\\)\\#") - -(defun* haml-extend-region () + (haml-highlight-interpolation 1 font-lock-variable-name-face prepend) + (haml-highlight-ruby-tag 1 font-lock-preprocessor-face) + (haml-highlight-ruby-script 1 font-lock-preprocessor-face) + ("^ *\\(\t\\)" 1 'haml-tab-face) + ("^!!!.*" 0 font-lock-constant-face) + ("| *$" 0 font-lock-string-face))) + +(defconst haml-filter-re "^ *:\\w+") +(defconst haml-comment-re "^ *\\(?:-\\#\\|/\\)") + +(defun haml-fontify-region-as-ruby (beg end) + "Use Ruby's font-lock variables to fontify the region between BEG and END." + (save-excursion + (save-match-data + (let ((font-lock-keywords ruby-font-lock-keywords) + (font-lock-syntactic-keywords ruby-font-lock-syntactic-keywords) + font-lock-keywords-only + font-lock-extend-region-functions + font-lock-keywords-case-fold-search) + ;; font-lock-fontify-region apparently isn't inclusive, + ;; so we have to move the beginning back one char + (font-lock-fontify-region (- beg 1) end))))) + +(defun haml-highlight-ruby-script (limit) + "Highlight a Ruby script expression (-, =, or ~)." + (when (re-search-forward "^ *\\(-\\|[&!]?[=~]\\) \\(.*\\)$" limit t) + (haml-fontify-region-as-ruby (match-beginning 2) (match-end 2)))) + +(defun haml-highlight-ruby-tag (limit) + "Highlight Ruby code within a Haml tag. + +This highlights the tag attributes and object refs of the tag, +as well as the script expression (-, =, or ~) following the tag. + +For example, this will highlight all of the following: + %p{:foo => 'bar'} + %p[@bar] + %p= 'baz' + %p{:foo => 'bar'}[@bar]= 'baz'" + (when (re-search-forward "^ *[%.#]" limit t) + (let ((eol (save-excursion (end-of-line) (point)))) + (forward-char -1) + + ;; Highlight tag, classes, and ids + (while (looking-at "[.#%][a-z0-9_:\\-]*") + (put-text-property (match-beginning 0) (match-end 0) 'face + (case (char-after) + (?% font-lock-function-name-face) + (?# font-lock-keyword-face) + (?. font-lock-type-face))) + (goto-char (match-end 0))) + + ;; Highlight obj refs + (when (eq (char-after) ?\[) + (let ((beg (point))) + (haml-limited-forward-sexp eol) + (haml-fontify-region-as-ruby beg (point)))) + + ;; Highlight attr hashes + (when (eq (char-after) ?\{) + (let ((beg (point))) + (haml-limited-forward-sexp eol) + + ;; Check for multiline + (while (and (eolp) (eq (char-before) ?,) (not (eobp))) + (forward-line) + (let ((eol (save-excursion (end-of-line) (point)))) + ;; If no sexps are closed, + ;; we're still continuing a multiline hash + (if (>= (car (parse-partial-sexp (point) eol)) 0) + (end-of-line) + ;; If sexps have been closed, + ;; set the point at the end of the total sexp + (goto-char beg) + (haml-limited-forward-sexp eol)))) + + (haml-fontify-region-as-ruby (+ 1 beg) (point)))) + + ;; Move past end chars + (when (looking-at "[<>&!]+") (goto-char (match-end 0))) + ;; Highlight script + (if (looking-at "\\([=~]\\) \\(.*\\)$") + (haml-fontify-region-as-ruby (match-beginning 2) (match-end 2)) + ;; Give font-lock something to highlight + (forward-char -1) + (looking-at "\\(\\)")) + t))) + +(defun haml-highlight-interpolation (limit) + "Highlight Ruby interpolation (#{foo})." + (when (re-search-forward "\\(#{\\)" limit t) + (save-match-data + (forward-char -1) + (let ((beg (point))) + (haml-limited-forward-sexp limit) + (haml-fontify-region-as-ruby (+ 1 beg) (point))) + + (when (eq (char-before) ?}) + (put-text-property (- (point) 1) (point) + 'face font-lock-variable-name-face)) + t))) + +(defun haml-limited-forward-sexp (limit &optional arg) + "Move forward using `forward-sexp' or to limit, +whichever comes first." + (let (forward-sexp-function) + (condition-case err + (save-restriction + (narrow-to-region (point) limit) + (forward-sexp arg)) + (scan-error + (unless (equal (nth 1 err) "Unbalanced parentheses") + (signal 'scan-error (cdr err))) + (goto-char limit))))) + +(defun* haml-extend-region-filters-comments () "Extend the font-lock region to encompass filters and comments." (let ((old-beg font-lock-beg) (old-end font-lock-end)) @@ -115,7 +206,7 @@ text nested beneath them.") (beginning-of-line) (unless (or (looking-at haml-filter-re) (looking-at haml-comment-re)) - (return-from haml-extend-region)) + (return-from haml-extend-region-filters-comments)) (setq font-lock-beg (point)) (haml-forward-sexp) (beginning-of-line) @@ -123,6 +214,38 @@ text nested beneath them.") (or (/= old-beg font-lock-beg) (/= old-end font-lock-end)))) +(defun* haml-extend-region-multiline-hashes () + "Extend the font-lock region to encompass multiline attribute hashes." + (let ((old-beg font-lock-beg) + (old-end font-lock-end)) + (save-excursion + (goto-char font-lock-beg) + (let ((attr-props (haml-parse-multiline-attr-hash)) + multiline-end) + (when attr-props + (setq font-lock-beg (cdr (assq 'point attr-props))) + + (end-of-line) + ;; Move through multiline attrs + (when (eq (char-before) ?,) + (save-excursion + (while (progn (end-of-line) (eq (char-before) ?,) (not (eobp))) + (forward-line)) + + (forward-line -1) + (end-of-line) + (setq multiline-end (point)))) + + (goto-char (+ (cdr (assq 'point attr-props)) + (cdr (assq 'hash-indent attr-props)) + -1)) + (haml-limited-forward-sexp + (or multiline-end + (save-excursion (end-of-line) (point)))) + (setq font-lock-end (max font-lock-end (point)))))) + (or (/= old-beg font-lock-beg) + (/= old-end font-lock-end)))) + ;; Mode setup @@ -152,14 +275,15 @@ text nested beneath them.") \\{haml-mode-map}" (set-syntax-table haml-mode-syntax-table) - (add-to-list 'font-lock-extend-region-functions 'haml-extend-region) + (add-to-list 'font-lock-extend-region-functions 'haml-extend-region-filters-comments) + (add-to-list 'font-lock-extend-region-functions 'haml-extend-region-multiline-hashes) (set (make-local-variable 'font-lock-multiline) t) (set (make-local-variable 'indent-line-function) 'haml-indent-line) (set (make-local-variable 'indent-region-function) 'haml-indent-region) (set (make-local-variable 'parse-sexp-lookup-properties) t) (setq comment-start "-#") (setq indent-tabs-mode nil) - (setq font-lock-defaults '((haml-font-lock-keywords) nil t))) + (setq font-lock-defaults '((haml-font-lock-keywords) t t))) ;; Useful functions @@ -313,21 +437,60 @@ character of the next line." ;; Indentation and electric keys -(defun haml-indent-p () - "Returns true if the current line can have lines nested beneath it." +(defun* haml-indent-p () + "Returns t if the current line can have lines nested beneath it." + (let ((attr-props (haml-parse-multiline-attr-hash))) + (when attr-props + (end-of-line) + (return-from haml-indent-p + (if (eq (char-before) ?,) (cdr (assq 'hash-indent attr-props)) + (beginning-of-line) + (list (+ (cdr (assq 'indent attr-props)) haml-indent-offset) nil))))) (loop for opener in haml-block-openers if (looking-at opener) return t finally return nil)) +(defun* haml-parse-multiline-attr-hash () + "Parses a multiline attribute hash, and returns +an alist with the following keys: + +INDENT is the indentation of the line beginning the hash. + +HASH-INDENT is the indentation of the first character +within the attribute hash. + +POINT is the character position at the beginning of the line +beginning the hash." + (save-excursion + (while t + (beginning-of-line) + (if (looking-at "^ *\\(?:[.#%][a-z0-9_:\\-]+\\)+{") + (progn + (goto-char (- (match-end 0) 1)) + (haml-limited-forward-sexp (save-excursion (end-of-line) (point))) + (return-from haml-parse-multiline-attr-hash + (if (eq (char-before) ?,) + `((indent . ,(current-indentation)) + (hash-indent . ,(- (match-end 0) (match-beginning 0))) + (point . ,(match-beginning 0))) + nil))) + (forward-line -1) + (end-of-line) + (when (not (eq (char-before) ?,)) + (return-from haml-parse-multiline-attr-hash nil)))))) + (defun haml-compute-indentation () "Calculate the maximum sensible indentation for the current line." (save-excursion (beginning-of-line) - (if (bobp) 0 + (if (bobp) (list 0 nil) (haml-forward-through-whitespace t) - (+ (current-indentation) - (if (funcall haml-indent-function) haml-indent-offset - 0))))) + (let ((indent (funcall haml-indent-function))) + (cond + ((consp indent) indent) + ((integerp indent) (list indent t)) + (indent (list (+ (current-indentation) haml-indent-offset) nil)) + (t (list (current-indentation) nil))))))) (defun haml-indent-region (start end) "Indent each nonblank line in the region. @@ -345,7 +508,7 @@ between possible indentations." (next-line-column (if (and (equal last-command this-command) (/= (current-indentation) 0)) (* (/ (- (current-indentation) 1) haml-indent-offset) haml-indent-offset) - (haml-compute-indentation)))) + (car (haml-compute-indentation))))) (while (< (point) end) (setq this-line-column next-line-column current-column (current-indentation)) @@ -368,20 +531,18 @@ The first time this command is used, the line will be indented to the maximum sensible indentation. Each immediately subsequent usage will back-dent the line by `haml-indent-offset' spaces. On reaching column 0, it will cycle back to the maximum sensible indentation." - ;; TODO: pressing tab to bring the point to the first non-whitespace - ;; char marks the buffer as modified even though it doesn't change anything (interactive "*") (let ((ci (current-indentation)) - (cc (current-column)) - (need (haml-compute-indentation))) - (save-excursion - (beginning-of-line) - (delete-horizontal-space) - (if (and (equal last-command this-command) (/= ci 0)) - (indent-to (* (/ (- ci 1) haml-indent-offset) haml-indent-offset)) - (indent-to need))) - (if (< (current-column) (current-indentation)) - (forward-to-indentation 0)))) + (cc (current-column))) + (destructuring-bind (need strict) (haml-compute-indentation) + (save-excursion + (beginning-of-line) + (delete-horizontal-space) + (if (and (not strict) (equal last-command this-command) (/= ci 0)) + (indent-to (* (/ (- ci 1) haml-indent-offset) haml-indent-offset)) + (indent-to need)))) + (when (< (current-column) (current-indentation)) + (forward-to-indentation 0)))) (defun haml-reindent-region-by (n) "Add N spaces to the beginning of each line in the region. elpa-to-submit/haml-mode.el 54a23a562df5058f94fbebb2c7d1acff93c674a8 Clinton R. Nixon crnixon@gmail.com http://github.com/crnixon/emacs-starter-kit/commit/16508722d829f3481f231e7e45aed3e336ad4c39 16508722d829f3481f231e7e45aed3e336ad4c39 2009-07-04T10:30:31-07:00 2009-07-04T10:30:31-07:00 replaced haml-mode with new version d538a39be3c59a408ac5478acd8b40d65e21de09 Clinton R. Nixon crnixon@gmail.com