lisp/progmodes/ruby-mode.el

   1 ;;; ruby-mode.el --- Major mode for editing Ruby files
   2
   3 ;; Copyright (C) 1994-2012  Free Software Foundation, Inc.
   4
   5 ;; Authors: Yukihiro Matsumoto
   6 ;;      Nobuyoshi Nakada
   7 ;; URL: http://www.emacswiki.org/cgi-bin/wiki/RubyMode
   8 ;; Created: Fri Feb  4 14:49:13 JST 1994
   9 ;; Keywords: languages ruby
  10 ;; Version: 1.0
  11
  12 ;; This file is part of GNU Emacs.
  13
  14 ;; GNU Emacs is free software: you can redistribute it and/or modify
  15 ;; it under the terms of the GNU General Public License as published by
  16 ;; the Free Software Foundation, either version 3 of the License, or
  17 ;; (at your option) any later version.
  18
  19 ;; GNU Emacs is distributed in the hope that it will be useful,
  20 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  21 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22 ;; GNU General Public License for more details.
  23
  24 ;; You should have received a copy of the GNU General Public License
  25 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
  26
  27 ;;; Commentary:
  28
  29 ;; Provides font-locking, indentation support, and navigation for Ruby code.
  30 ;;
  31 ;; If you're installing manually, you should add this to your .emacs
  32 ;; file after putting it on your load path:
  33 ;;
  34 ;;    (autoload 'ruby-mode "ruby-mode" "Major mode for ruby files" t)
  35 ;;    (add-to-list 'auto-mode-alist '("\\.rb$" . ruby-mode))
  36 ;;    (add-to-list 'interpreter-mode-alist '("ruby" . ruby-mode))
  37 ;;
  38 ;; Still needs more docstrings; search below for TODO.
  39
  40 ;;; Code:
  41
  42 (eval-when-compile (require 'cl))
  43
  44 (defgroup ruby nil
  45   "Major mode for editing Ruby code."
  46   :prefix "ruby-"
  47   :group 'languages)
  48
  49 (defconst ruby-keyword-end-re
  50   (if (string-match "\\_>" "ruby")
  51       "\\_>"
  52     "\\>"))
  53
  54 (defconst ruby-block-beg-keywords
  55   '("class" "module" "def" "if" "unless" "case" "while" "until" "for" "begin" "do")
  56   "Keywords at the beginning of blocks.")
  57
  58 (defconst ruby-block-beg-re
  59   (regexp-opt ruby-block-beg-keywords)
  60   "Regexp to match the beginning of blocks.")
  61
  62 (defconst ruby-non-block-do-re
  63   (concat (regexp-opt '("while" "until" "for" "rescue") t) ruby-keyword-end-re)
  64   "Regexp to match keywords that nest without blocks.")
  65
  66 (defconst ruby-indent-beg-re
  67   (concat "\\(\\s *" (regexp-opt '("class" "module" "def") t) "\\)\\|"
  68           (regexp-opt '("if" "unless" "case" "while" "until" "for" "begin")))
  69   "Regexp to match where the indentation gets deeper.")
  70
  71 (defconst ruby-modifier-beg-keywords
  72   '("if" "unless" "while" "until")
  73   "Modifiers that are the same as the beginning of blocks.")
  74
  75 (defconst ruby-modifier-beg-re
  76   (regexp-opt ruby-modifier-beg-keywords)
  77   "Regexp to match modifiers same as the beginning of blocks.")
  78
  79 (defconst ruby-modifier-re
  80   (regexp-opt (cons "rescue" ruby-modifier-beg-keywords))
  81   "Regexp to match modifiers.")
  82
  83 (defconst ruby-block-mid-keywords
  84   '("then" "else" "elsif" "when" "rescue" "ensure")
  85   "Keywords where the indentation gets shallower in middle of block statements.")
  86
  87 (defconst ruby-block-mid-re
  88   (regexp-opt ruby-block-mid-keywords)
  89   "Regexp to match where the indentation gets shallower in middle of block statements.")
  90
  91 (defconst ruby-block-op-keywords
  92   '("and" "or" "not")
  93   "Regexp to match boolean keywords.")
  94
  95 (defconst ruby-block-hanging-re
  96   (regexp-opt (append ruby-modifier-beg-keywords ruby-block-op-keywords))
  97   "Regexp to match hanging block modifiers.")
  98
  99 (defconst ruby-block-end-re "\\_<end\\_>")
 100
 101 (eval-and-compile
 102   (defconst ruby-here-doc-beg-re
 103   "\\(<\\)<\\(-\\)?\\(\\([a-zA-Z0-9_]+\\)\\|[\"]\\([^\"]+\\)[\"]\\|[']\\([^']+\\)[']\\)"
 104     "Regexp to match the beginning of a heredoc."))
 105
 106 (defun ruby-here-doc-end-match ()
 107   "Return a regexp to find the end of a heredoc.
 108
 109 This should only be called after matching against `ruby-here-doc-beg-re'."
 110   (concat "^"
 111           (if (match-string 2) "[ \t]*" nil)
 112           (regexp-quote
 113            (or (match-string 4)
 114                (match-string 5)
 115                (match-string 6)))))
 116
 117 (defconst ruby-delimiter
 118   (concat "[?$/%(){}#\"'`.:]\\|<<\\|\\[\\|\\]\\|\\_<\\("
 119           ruby-block-beg-re
 120           "\\)\\_>\\|" ruby-block-end-re
 121           "\\|^=begin\\|" ruby-here-doc-beg-re))
 122
 123 (defconst ruby-negative
 124   (concat "^[ \t]*\\(\\(" ruby-block-mid-re "\\)\\>\\|"
 125           ruby-block-end-re "\\|}\\|\\]\\)")
 126   "Regexp to match where the indentation gets shallower.")
 127
 128 (defconst ruby-operator-re "[-,.+*/%&|^~=<>:]"
 129   "Regexp to match operators.")
 130
 131 (defconst ruby-symbol-chars "a-zA-Z0-9_"
 132   "List of characters that symbol names may contain.")
 133 (defconst ruby-symbol-re (concat "[" ruby-symbol-chars "]")
 134   "Regexp to match symbols.")
 135
 136 (define-abbrev-table 'ruby-mode-abbrev-table ()
 137   "Abbrev table in use in Ruby mode buffers.")
 138
 139 (defvar ruby-mode-map
 140   (let ((map (make-sparse-keymap)))
 141     (define-key map "{" 'ruby-electric-brace)
 142     (define-key map "}" 'ruby-electric-brace)
 143     (define-key map (kbd "M-C-a") 'ruby-beginning-of-defun)
 144     (define-key map (kbd "M-C-e") 'ruby-end-of-defun)
 145     (define-key map (kbd "M-C-b") 'ruby-backward-sexp)
 146     (define-key map (kbd "M-C-f") 'ruby-forward-sexp)
 147     (define-key map (kbd "M-C-p") 'ruby-beginning-of-block)
 148     (define-key map (kbd "M-C-n") 'ruby-end-of-block)
 149     (define-key map (kbd "M-C-h") 'ruby-mark-defun)
 150     (define-key map (kbd "M-C-q") 'ruby-indent-exp)
 151     (define-key map (kbd "C-M-h") 'backward-kill-word)
 152     (define-key map (kbd "C-j")   'reindent-then-newline-and-indent)
 153     (define-key map (kbd "C-m")   'newline)
 154     (define-key map (kbd "C-c C-c") 'comment-region)
 155     map)
 156   "Keymap used in Ruby mode.")
 157
 158 (defvar ruby-mode-syntax-table
 159   (let ((table (make-syntax-table)))
 160     (modify-syntax-entry ?\' "\"" table)
 161     (modify-syntax-entry ?\" "\"" table)
 162     (modify-syntax-entry ?\` "\"" table)
 163     (modify-syntax-entry ?# "<" table)
 164     (modify-syntax-entry ?\n ">" table)
 165     (modify-syntax-entry ?\\ "\\" table)
 166     (modify-syntax-entry ?$ "." table)
 167     (modify-syntax-entry ?? "_" table)
 168     (modify-syntax-entry ?_ "_" table)
 169     (modify-syntax-entry ?: "_" table)
 170     (modify-syntax-entry ?< "." table)
 171     (modify-syntax-entry ?> "." table)
 172     (modify-syntax-entry ?& "." table)
 173     (modify-syntax-entry ?| "." table)
 174     (modify-syntax-entry ?% "." table)
 175     (modify-syntax-entry ?= "." table)
 176     (modify-syntax-entry ?/ "." table)
 177     (modify-syntax-entry ?+ "." table)
 178     (modify-syntax-entry ?* "." table)
 179     (modify-syntax-entry ?- "." table)
 180     (modify-syntax-entry ?\; "." table)
 181     (modify-syntax-entry ?\( "()" table)
 182     (modify-syntax-entry ?\) ")(" table)
 183     (modify-syntax-entry ?\{ "(}" table)
 184     (modify-syntax-entry ?\} "){" table)
 185     (modify-syntax-entry ?\[ "(]" table)
 186     (modify-syntax-entry ?\] ")[" table)
 187     table)
 188   "Syntax table to use in Ruby mode.")
 189
 190 (defcustom ruby-indent-tabs-mode nil
 191   "Indentation can insert tabs in Ruby mode if this is non-nil."
 192   :type 'boolean :group 'ruby)
 193
 194 (defcustom ruby-indent-level 2
 195   "Indentation of Ruby statements."
 196   :type 'integer :group 'ruby)
 197
 198 (defcustom ruby-comment-column 32
 199   "Indentation column of comments."
 200   :type 'integer :group 'ruby)
 201
 202 (defcustom ruby-deep-arglist t
 203   "Deep indent lists in parenthesis when non-nil.
 204 Also ignores spaces after parenthesis when 'space."
 205   :group 'ruby)
 206
 207 (defcustom ruby-deep-indent-paren '(?\( ?\[ ?\] t)
 208   "Deep indent lists in parenthesis when non-nil.
 209 The value t means continuous line.
 210 Also ignores spaces after parenthesis when 'space."
 211   :group 'ruby)
 212
 213 (defcustom ruby-deep-indent-paren-style 'space
 214   "Default deep indent style."
 215   :options '(t nil space) :group 'ruby)
 216
 217 (defcustom ruby-encoding-map '((shift_jis . cp932) (shift-jis . cp932))
 218   "Alist to map encoding name from Emacs to Ruby."
 219   :group 'ruby)
 220
 221 (defcustom ruby-insert-encoding-magic-comment t
 222   "Insert a magic Emacs 'coding' comment upon save if this is non-nil."
 223   :type 'boolean :group 'ruby)
 224
 225 (defcustom ruby-use-encoding-map t
 226   "Use `ruby-encoding-map' to set encoding magic comment if this is non-nil."
 227   :type 'boolean :group 'ruby)
 228
 229 ;; Safe file variables
 230 (put 'ruby-indent-tabs-mode 'safe-local-variable 'booleanp)
 231 (put 'ruby-indent-level 'safe-local-variable 'integerp)
 232 (put 'ruby-comment-column 'safe-local-variable 'integerp)
 233 (put 'ruby-deep-arglist 'safe-local-variable 'booleanp)
 234
 235 (defun ruby-imenu-create-index-in-block (prefix beg end)
 236   "Create an imenu index of methods inside a block."
 237   (let ((index-alist '()) (case-fold-search nil)
 238         name next pos decl sing)
 239     (goto-char beg)
 240     (while (re-search-forward "^\\s *\\(\\(class\\s +\\|\\(class\\s *<<\\s *\\)\\|module\\s +\\)\\([^\(<\n ]+\\)\\|\\(def\\|alias\\)\\s +\\([^\(\n ]+\\)\\)" end t)
 241       (setq sing (match-beginning 3))
 242       (setq decl (match-string 5))
 243       (setq next (match-end 0))
 244       (setq name (or (match-string 4) (match-string 6)))
 245       (setq pos (match-beginning 0))
 246       (cond
 247        ((string= "alias" decl)
 248         (if prefix (setq name (concat prefix name)))
 249         (push (cons name pos) index-alist))
 250        ((string= "def" decl)
 251         (if prefix
 252             (setq name
 253                   (cond
 254                    ((string-match "^self\." name)
 255                     (concat (substring prefix 0 -1) (substring name 4)))
 256                   (t (concat prefix name)))))
 257         (push (cons name pos) index-alist)
 258         (ruby-accurate-end-of-block end))
 259        (t
 260         (if (string= "self" name)
 261             (if prefix (setq name (substring prefix 0 -1)))
 262           (if prefix (setq name (concat (substring prefix 0 -1) "::" name)))
 263           (push (cons name pos) index-alist))
 264         (ruby-accurate-end-of-block end)
 265         (setq beg (point))
 266         (setq index-alist
 267               (nconc (ruby-imenu-create-index-in-block
 268                       (concat name (if sing "." "#"))
 269                       next beg) index-alist))
 270         (goto-char beg))))
 271     index-alist))
 272
 273 (defun ruby-imenu-create-index ()
 274   "Create an imenu index of all methods in the buffer."
 275   (nreverse (ruby-imenu-create-index-in-block nil (point-min) nil)))
 276
 277 (defun ruby-accurate-end-of-block (&optional end)
 278   "TODO: document."
 279   (let (state
 280         (end (or end (point-max))))
 281     (while (and (setq state (apply 'ruby-parse-partial end state))
 282                 (>= (nth 2 state) 0) (< (point) end)))))
 283
 284 (defun ruby-mode-variables ()
 285   "Set up initial buffer-local variables for Ruby mode."
 286   (set-syntax-table ruby-mode-syntax-table)
 287   (setq local-abbrev-table ruby-mode-abbrev-table)
 288   (setq indent-tabs-mode ruby-indent-tabs-mode)
 289   (set (make-local-variable 'indent-line-function) 'ruby-indent-line)
 290   (set (make-local-variable 'require-final-newline) t)
 291   (set (make-local-variable 'comment-start) "# ")
 292   (set (make-local-variable 'comment-end) "")
 293   (set (make-local-variable 'comment-column) ruby-comment-column)
 294   (set (make-local-variable 'comment-start-skip) "#+ *")
 295   (set (make-local-variable 'parse-sexp-ignore-comments) t)
 296   (set (make-local-variable 'parse-sexp-lookup-properties) t)
 297   (set (make-local-variable 'paragraph-start) (concat "$\\|" page-delimiter))
 298   (set (make-local-variable 'paragraph-separate) paragraph-start)
 299   (set (make-local-variable 'paragraph-ignore-fill-prefix) t))
 300
 301 (defun ruby-mode-set-encoding ()
 302   "Insert a magic comment header with the proper encoding if necessary."
 303   (save-excursion
 304     (widen)
 305     (goto-char (point-min))
 306     (when (re-search-forward "[^\0-\177]" nil t)
 307       (goto-char (point-min))
 308       (let ((coding-system
 309              (or coding-system-for-write
 310                  buffer-file-coding-system)))
 311         (if coding-system
 312             (setq coding-system
 313                   (or (coding-system-get coding-system 'mime-charset)
 314                       (coding-system-change-eol-conversion coding-system nil))))
 315         (setq coding-system
 316               (if coding-system
 317                   (symbol-name
 318                    (or (and ruby-use-encoding-map
 319                             (cdr (assq coding-system ruby-encoding-map)))
 320                        coding-system))
 321                 "ascii-8bit"))
 322         (if (looking-at "^#!") (beginning-of-line 2))
 323         (cond ((looking-at "\\s *#.*-\*-\\s *\\(en\\)?coding\\s *:\\s *\\([-a-z0-9_]*\\)\\s *\\(;\\|-\*-\\)")
 324                (unless (string= (match-string 2) coding-system)
 325                  (goto-char (match-beginning 2))
 326                  (delete-region (point) (match-end 2))
 327                  (and (looking-at "-\*-")
 328                       (let ((n (skip-chars-backward " ")))
 329                         (cond ((= n 0) (insert "  ") (backward-char))
 330                               ((= n -1) (insert " "))
 331                               ((forward-char)))))
 332                  (insert coding-system)))
 333               ((looking-at "\\s *#.*coding\\s *[:=]"))
 334               (t (when ruby-insert-encoding-magic-comment
 335                    (insert "# -*- coding: " coding-system " -*-\n"))))))))
 336
 337 (defun ruby-current-indentation ()
 338   "Return the indentation level of current line."
 339   (save-excursion
 340     (beginning-of-line)
 341     (back-to-indentation)
 342     (current-column)))
 343
 344 (defun ruby-indent-line (&optional ignored)
 345   "Correct the indentation of the current Ruby line."
 346   (interactive)
 347   (ruby-indent-to (ruby-calculate-indent)))
 348
 349 (defun ruby-indent-to (column)
 350   "Indent the current line to COLUMN."
 351   (when column
 352     (let (shift top beg)
 353       (and (< column 0) (error "invalid nest"))
 354       (setq shift (current-column))
 355       (beginning-of-line)
 356       (setq beg (point))
 357       (back-to-indentation)
 358       (setq top (current-column))
 359       (skip-chars-backward " \t")
 360       (if (>= shift top) (setq shift (- shift top))
 361         (setq shift 0))
 362       (if (and (bolp)
 363                (= column top))
 364           (move-to-column (+ column shift))
 365         (move-to-column top)
 366         (delete-region beg (point))
 367         (beginning-of-line)
 368         (indent-to column)
 369         (move-to-column (+ column shift))))))
 370
 371 (defun ruby-special-char-p (&optional pos)
 372   "Return t if the character before POS is a special character.
 373 If omitted, POS defaults to the current point.
 374 Special characters are `?', `$', `:' when preceded by whitespace,
 375 and `\\' when preceded by `?'."
 376   (setq pos (or pos (point)))
 377   (let ((c (char-before pos)) (b (and (< (point-min) pos)
 378                                       (char-before (1- pos)))))
 379     (cond ((or (eq c ??) (eq c ?$)))
 380           ((and (eq c ?:) (or (not b) (eq (char-syntax b) ? ))))
 381           ((eq c ?\\) (eq b ??)))))
 382
 383 (defun ruby-expr-beg (&optional option)
 384   "TODO: document."
 385   (save-excursion
 386     (store-match-data nil)
 387     (let ((space (skip-chars-backward " \t")))
 388       (cond
 389        ((bolp) t)
 390        ((progn
 391           (forward-char -1)
 392           (and (looking-at "\\?")
 393                (or (eq (char-syntax (char-before (point))) ?w)
 394                    (ruby-special-char-p))))
 395         nil)
 396        ((and (eq option 'heredoc) (< space 0)) t)
 397        ((or (looking-at ruby-operator-re)
 398             (looking-at "[\\[({,;]")
 399             (and (looking-at "[!?]")
 400                  (or (not (eq option 'modifier))
 401                      (bolp)
 402                      (save-excursion (forward-char -1) (looking-at "\\Sw$"))))
 403             (and (looking-at ruby-symbol-re)
 404                  (skip-chars-backward ruby-symbol-chars)
 405                  (cond
 406                   ((looking-at (regexp-opt
 407                                 (append ruby-block-beg-keywords
 408                                         ruby-block-op-keywords
 409                                         ruby-block-mid-keywords)
 410                                 'words))
 411                    (goto-char (match-end 0))
 412                    (not (looking-at "\\s_")))
 413                   ((eq option 'expr-qstr)
 414                    (looking-at "[a-zA-Z][a-zA-z0-9_]* +%[^ \t]"))
 415                   ((eq option 'expr-re)
 416                    (looking-at "[a-zA-Z][a-zA-z0-9_]* +/[^ \t]"))
 417                   (t nil)))))))))
 418
 419 (defun ruby-forward-string (term &optional end no-error expand)
 420   "TODO: document."
 421   (let ((n 1) (c (string-to-char term))
 422         (re (if expand
 423                 (concat "[^\\]\\(\\\\\\\\\\)*\\([" term "]\\|\\(#{\\)\\)")
 424               (concat "[^\\]\\(\\\\\\\\\\)*[" term "]"))))
 425     (while (and (re-search-forward re end no-error)
 426                 (if (match-beginning 3)
 427                     (ruby-forward-string "}{" end no-error nil)
 428                   (> (setq n (if (eq (char-before (point)) c)
 429                                      (1- n) (1+ n))) 0)))
 430       (forward-char -1))
 431     (cond ((zerop n))
 432           (no-error nil)
 433           ((error "unterminated string")))))
 434
 435 (defun ruby-deep-indent-paren-p (c)
 436   "TODO: document."
 437   (cond ((listp ruby-deep-indent-paren)
 438          (let ((deep (assoc c ruby-deep-indent-paren)))
 439            (cond (deep
 440                   (or (cdr deep) ruby-deep-indent-paren-style))
 441                  ((memq c ruby-deep-indent-paren)
 442                   ruby-deep-indent-paren-style))))
 443         ((eq c ruby-deep-indent-paren) ruby-deep-indent-paren-style)
 444         ((eq c ?\( ) ruby-deep-arglist)))
 445
 446 (defun ruby-parse-partial (&optional end in-string nest depth pcol indent)
 447   "TODO: document throughout function body."
 448   (or depth (setq depth 0))
 449   (or indent (setq indent 0))
 450   (when (re-search-forward ruby-delimiter end 'move)
 451     (let ((pnt (point)) w re expand)
 452       (goto-char (match-beginning 0))
 453       (cond
 454        ((and (memq (char-before) '(?@ ?$)) (looking-at "\\sw"))
 455         (goto-char pnt))
 456        ((looking-at "[\"`]")            ;skip string
 457         (cond
 458          ((and (not (eobp))
 459                (ruby-forward-string (buffer-substring (point) (1+ (point))) end t t))
 460           nil)
 461          (t
 462           (setq in-string (point))
 463           (goto-char end))))
 464        ((looking-at "'")
 465         (cond
 466          ((and (not (eobp))
 467                (re-search-forward "[^\\]\\(\\\\\\\\\\)*'" end t))
 468           nil)
 469          (t
 470           (setq in-string (point))
 471           (goto-char end))))
 472        ((looking-at "/=")
 473         (goto-char pnt))
 474        ((looking-at "/")
 475         (cond
 476          ((and (not (eobp)) (ruby-expr-beg 'expr-re))
 477           (if (ruby-forward-string "/" end t t)
 478               nil
 479             (setq in-string (point))
 480             (goto-char end)))
 481          (t
 482           (goto-char pnt))))
 483        ((looking-at "%")
 484         (cond
 485          ((and (not (eobp))
 486                (ruby-expr-beg 'expr-qstr)
 487                (not (looking-at "%="))
 488                (looking-at "%[QqrxWw]?\\([^a-zA-Z0-9 \t\n]\\)"))
 489           (goto-char (match-beginning 1))
 490           (setq expand (not (memq (char-before) '(?q ?w))))
 491           (setq w (match-string 1))
 492           (cond
 493            ((string= w "[") (setq re "]["))
 494            ((string= w "{") (setq re "}{"))
 495            ((string= w "(") (setq re ")("))
 496            ((string= w "<") (setq re "><"))
 497            ((and expand (string= w "\\"))
 498             (setq w (concat "\\" w))))
 499           (unless (cond (re (ruby-forward-string re end t expand))
 500                         (expand (ruby-forward-string w end t t))
 501                         (t (re-search-forward
 502                             (if (string= w "\\")
 503                                 "\\\\[^\\]*\\\\"
 504                               (concat "[^\\]\\(\\\\\\\\\\)*" w))
 505                             end t)))
 506             (setq in-string (point))
 507             (goto-char end)))
 508          (t
 509           (goto-char pnt))))
 510        ((looking-at "\\?")              ;skip ?char
 511         (cond
 512          ((and (ruby-expr-beg)
 513                (looking-at "?\\(\\\\C-\\|\\\\M-\\)*\\\\?."))
 514           (goto-char (match-end 0)))
 515          (t
 516           (goto-char pnt))))
 517        ((looking-at "\\$")              ;skip $char
 518         (goto-char pnt)
 519         (forward-char 1))
 520        ((looking-at "#")                ;skip comment
 521         (forward-line 1)
 522         (goto-char (point))
 523         )
 524        ((looking-at "[\\[{(]")
 525         (let ((deep (ruby-deep-indent-paren-p (char-after))))
 526           (if (and deep (or (not (eq (char-after) ?\{)) (ruby-expr-beg)))
 527               (progn
 528                 (and (eq deep 'space) (looking-at ".\\s +[^# \t\n]")
 529                      (setq pnt (1- (match-end 0))))
 530                 (setq nest (cons (cons (char-after (point)) pnt) nest))
 531                 (setq pcol (cons (cons pnt depth) pcol))
 532                 (setq depth 0))
 533             (setq nest (cons (cons (char-after (point)) pnt) nest))
 534             (setq depth (1+ depth))))
 535         (goto-char pnt)
 536         )
 537        ((looking-at "[])}]")
 538         (if (ruby-deep-indent-paren-p (matching-paren (char-after)))
 539             (setq depth (cdr (car pcol)) pcol (cdr pcol))
 540           (setq depth (1- depth)))
 541         (setq nest (cdr nest))
 542         (goto-char pnt))
 543        ((looking-at ruby-block-end-re)
 544         (if (or (and (not (bolp))
 545                      (progn
 546                        (forward-char -1)
 547                        (setq w (char-after (point)))
 548                        (or (eq ?_ w)
 549                            (eq ?. w))))
 550                 (progn
 551                   (goto-char pnt)
 552                   (setq w (char-after (point)))
 553                   (or (eq ?_ w)
 554                       (eq ?! w)
 555                       (eq ?? w))))
 556             nil
 557           (setq nest (cdr nest))
 558           (setq depth (1- depth)))
 559         (goto-char pnt))
 560        ((looking-at "def\\s +[^(\n;]*")
 561         (if (or (bolp)
 562                 (progn
 563                   (forward-char -1)
 564                   (not (eq ?_ (char-after (point))))))
 565             (progn
 566               (setq nest (cons (cons nil pnt) nest))
 567               (setq depth (1+ depth))))
 568         (goto-char (match-end 0)))
 569        ((looking-at (concat "\\_<\\(" ruby-block-beg-re "\\)\\_>"))
 570         (and
 571          (save-match-data
 572            (or (not (looking-at (concat "do" ruby-keyword-end-re)))
 573                (save-excursion
 574                  (back-to-indentation)
 575                  (not (looking-at ruby-non-block-do-re)))))
 576          (or (bolp)
 577              (progn
 578                (forward-char -1)
 579                (setq w (char-after (point)))
 580                (not (or (eq ?_ w)
 581                         (eq ?. w)))))
 582          (goto-char pnt)
 583          (setq w (char-after (point)))
 584          (not (eq ?_ w))
 585          (not (eq ?! w))
 586          (not (eq ?? w))
 587          (skip-chars-forward " \t")
 588          (goto-char (match-beginning 0))
 589          (or (not (looking-at ruby-modifier-re))
 590              (ruby-expr-beg 'modifier))
 591          (goto-char pnt)
 592          (setq nest (cons (cons nil pnt) nest))
 593          (setq depth (1+ depth)))
 594         (goto-char pnt))
 595        ((looking-at ":\\(['\"]\\)")
 596         (goto-char (match-beginning 1))
 597         (ruby-forward-string (buffer-substring (match-beginning 1) (match-end 1)) end))
 598        ((looking-at ":\\([-,.+*/%&|^~<>]=?\\|===?\\|<=>\\|![~=]?\\)")
 599         (goto-char (match-end 0)))
 600        ((looking-at ":\\([a-zA-Z_][a-zA-Z_0-9]*[!?=]?\\)?")
 601         (goto-char (match-end 0)))
 602        ((or (looking-at "\\.\\.\\.?")
 603             (looking-at "\\.[0-9]+")
 604             (looking-at "\\.[a-zA-Z_0-9]+")
 605             (looking-at "\\."))
 606         (goto-char (match-end 0)))
 607        ((looking-at "^=begin")
 608         (if (re-search-forward "^=end" end t)
 609             (forward-line 1)
 610           (setq in-string (match-end 0))
 611           (goto-char end)))
 612        ((looking-at "<<")
 613         (cond
 614          ((and (ruby-expr-beg 'heredoc)
 615                (looking-at "<<\\(-\\)?\\(\\([\"'`]\\)\\([^\n]+?\\)\\3\\|\\(?:\\sw\\|\\s_\\)+\\)"))
 616           (setq re (regexp-quote (or (match-string 4) (match-string 2))))
 617           (if (match-beginning 1) (setq re (concat "\\s *" re)))
 618           (let* ((id-end (goto-char (match-end 0)))
 619                  (line-end-position (point-at-eol))
 620                  (state (list in-string nest depth pcol indent)))
 621             ;; parse the rest of the line
 622             (while (and (> line-end-position (point))
 623                         (setq state (apply 'ruby-parse-partial
 624                                            line-end-position state))))
 625             (setq in-string (car state)
 626                   nest (nth 1 state)
 627                   depth (nth 2 state)
 628                   pcol (nth 3 state)
 629                   indent (nth 4 state))
 630             ;; skip heredoc section
 631             (if (re-search-forward (concat "^" re "$") end 'move)
 632                 (forward-line 1)
 633               (setq in-string id-end)
 634               (goto-char end))))
 635          (t
 636           (goto-char pnt))))
 637        ((looking-at "^__END__$")
 638         (goto-char pnt))
 639        ((and (looking-at ruby-here-doc-beg-re)
 640              (boundp 'ruby-indent-point))
 641         (if (re-search-forward (ruby-here-doc-end-match)
 642                                ruby-indent-point t)
 643             (forward-line 1)
 644           (setq in-string (match-end 0))
 645           (goto-char ruby-indent-point)))
 646        (t
 647         (error (format "bad string %s"
 648                        (buffer-substring (point) pnt)
 649                        ))))))
 650   (list in-string nest depth pcol))
 651
 652 (defun ruby-parse-region (start end)
 653   "TODO: document."
 654   (let (state)
 655     (save-excursion
 656       (if start
 657           (goto-char start)
 658         (ruby-beginning-of-indent))
 659       (save-restriction
 660         (narrow-to-region (point) end)
 661         (while (and (> end (point))
 662                     (setq state (apply 'ruby-parse-partial end state))))))
 663     (list (nth 0 state)                 ; in-string
 664           (car (nth 1 state))           ; nest
 665           (nth 2 state)                 ; depth
 666           (car (car (nth 3 state)))     ; pcol
 667           ;(car (nth 5 state))          ; indent
 668           )))
 669
 670 (defun ruby-indent-size (pos nest)
 671   "Return the indentation level in spaces NEST levels deeper than POS."
 672   (+ pos (* (or nest 1) ruby-indent-level)))
 673
 674 (defun ruby-calculate-indent (&optional parse-start)
 675   "Return the proper indentation level of the current line."
 676   ;; TODO: Document body
 677   (save-excursion
 678     (beginning-of-line)
 679     (let ((ruby-indent-point (point))
 680           (case-fold-search nil)
 681           state eol begin op-end
 682           (paren (progn (skip-syntax-forward " ")
 683                         (and (char-after) (matching-paren (char-after)))))
 684           (indent 0))
 685       (if parse-start
 686           (goto-char parse-start)
 687         (ruby-beginning-of-indent)
 688         (setq parse-start (point)))
 689       (back-to-indentation)
 690       (setq indent (current-column))
 691       (setq state (ruby-parse-region parse-start ruby-indent-point))
 692       (cond
 693        ((nth 0 state)                   ; within string
 694         (setq indent nil))              ;  do nothing
 695        ((car (nth 1 state))             ; in paren
 696         (goto-char (setq begin (cdr (nth 1 state))))
 697         (let ((deep (ruby-deep-indent-paren-p (car (nth 1 state)))))
 698           (if deep
 699               (cond ((and (eq deep t) (eq (car (nth 1 state)) paren))
 700                      (skip-syntax-backward " ")
 701                      (setq indent (1- (current-column))))
 702                     ((let ((s (ruby-parse-region (point) ruby-indent-point)))
 703                        (and (nth 2 s) (> (nth 2 s) 0)
 704                             (or (goto-char (cdr (nth 1 s))) t)))
 705                      (forward-word -1)
 706                      (setq indent (ruby-indent-size (current-column)
 707                                                     (nth 2 state))))
 708                     (t
 709                      (setq indent (current-column))
 710                      (cond ((eq deep 'space))
 711                            (paren (setq indent (1- indent)))
 712                            (t (setq indent (ruby-indent-size (1- indent) 1))))))
 713             (if (nth 3 state) (goto-char (nth 3 state))
 714               (goto-char parse-start) (back-to-indentation))
 715             (setq indent (ruby-indent-size (current-column) (nth 2 state))))
 716           (and (eq (car (nth 1 state)) paren)
 717                (ruby-deep-indent-paren-p (matching-paren paren))
 718                (search-backward (char-to-string paren))
 719                (setq indent (current-column)))))
 720        ((and (nth 2 state) (> (nth 2 state) 0)) ; in nest
 721         (if (null (cdr (nth 1 state)))
 722             (error "invalid nest"))
 723         (goto-char (cdr (nth 1 state)))
 724         (forward-word -1)               ; skip back a keyword
 725         (setq begin (point))
 726         (cond
 727          ((looking-at "do\\>[^_]")      ; iter block is a special case
 728           (if (nth 3 state) (goto-char (nth 3 state))
 729             (goto-char parse-start) (back-to-indentation))
 730           (setq indent (ruby-indent-size (current-column) (nth 2 state))))
 731          (t
 732           (setq indent (+ (current-column) ruby-indent-level)))))
 733
 734        ((and (nth 2 state) (< (nth 2 state) 0)) ; in negative nest
 735         (setq indent (ruby-indent-size (current-column) (nth 2 state)))))
 736       (when indent
 737         (goto-char ruby-indent-point)
 738         (end-of-line)
 739         (setq eol (point))
 740         (beginning-of-line)
 741         (cond
 742          ((and (not (ruby-deep-indent-paren-p paren))
 743                (re-search-forward ruby-negative eol t))
 744           (and (not (eq ?_ (char-after (match-end 0))))
 745                (setq indent (- indent ruby-indent-level))))
 746          ((and
 747            (save-excursion
 748              (beginning-of-line)
 749              (not (bobp)))
 750            (or (ruby-deep-indent-paren-p t)
 751                (null (car (nth 1 state)))))
 752           ;; goto beginning of non-empty no-comment line
 753           (let (end done)
 754             (while (not done)
 755               (skip-chars-backward " \t\n")
 756               (setq end (point))
 757               (beginning-of-line)
 758               (if (re-search-forward "^\\s *#" end t)
 759                   (beginning-of-line)
 760                 (setq done t))))
 761           (end-of-line)
 762           ;; skip the comment at the end
 763           (skip-chars-backward " \t")
 764           (let (end (pos (point)))
 765             (beginning-of-line)
 766             (while (and (re-search-forward "#" pos t)
 767                         (setq end (1- (point)))
 768                         (or (ruby-special-char-p end)
 769                             (and (setq state (ruby-parse-region parse-start end))
 770                                  (nth 0 state))))
 771               (setq end nil))
 772             (goto-char (or end pos))
 773             (skip-chars-backward " \t")
 774             (setq begin (if (and end (nth 0 state)) pos (cdr (nth 1 state))))
 775             (setq state (ruby-parse-region parse-start (point))))
 776           (or (bobp) (forward-char -1))
 777           (and
 778            (or (and (looking-at ruby-symbol-re)
 779                     (skip-chars-backward ruby-symbol-chars)
 780                     (looking-at (concat "\\<\\(" ruby-block-hanging-re "\\)\\>"))
 781                     (not (eq (point) (nth 3 state)))
 782                     (save-excursion
 783                       (goto-char (match-end 0))
 784                       (not (looking-at "[a-z_]"))))
 785                (and (looking-at ruby-operator-re)
 786                     (not (ruby-special-char-p))
 787                     ;; Operator at the end of line.
 788                     (let ((c (char-after (point))))
 789                       (and
 790 ;;                     (or (null begin)
 791 ;;                         (save-excursion
 792 ;;                           (goto-char begin)
 793 ;;                           (skip-chars-forward " \t")
 794 ;;                           (not (or (eolp) (looking-at "#")
 795 ;;                                    (and (eq (car (nth 1 state)) ?{)
 796 ;;                                         (looking-at "|"))))))
 797                        ;; Not a regexp or general delimited literal.
 798                        (null (nth 0 (ruby-parse-region (or begin parse-start)
 799                                                        (point))))
 800                        (or (not (eq ?| (char-after (point))))
 801                            (save-excursion
 802                              (or (eolp) (forward-char -1))
 803                              (cond
 804                               ((search-backward "|" nil t)
 805                                (skip-chars-backward " \t\n")
 806                                (and (not (eolp))
 807                                     (progn
 808                                       (forward-char -1)
 809                                       (not (looking-at "{")))
 810                                     (progn
 811                                       (forward-word -1)
 812                                       (not (looking-at "do\\>[^_]")))))
 813                               (t t))))
 814                        (not (eq ?, c))
 815                        (setq op-end t)))))
 816            (setq indent
 817                  (cond
 818                   ((and
 819                     (null op-end)
 820                     (not (looking-at (concat "\\<\\(" ruby-block-hanging-re "\\)\\>")))
 821                     (eq (ruby-deep-indent-paren-p t) 'space)
 822                     (not (bobp)))
 823                    (widen)
 824                    (goto-char (or begin parse-start))
 825                    (skip-syntax-forward " ")
 826                    (current-column))
 827                   ((car (nth 1 state)) indent)
 828                   (t
 829                    (+ indent ruby-indent-level))))))))
 830       (goto-char ruby-indent-point)
 831       (beginning-of-line)
 832       (skip-syntax-forward " ")
 833       (if (looking-at "\\.[^.]")
 834           (+ indent ruby-indent-level)
 835         indent))))
 836
 837 (defun ruby-electric-brace (arg)
 838   "Insert a brace and re-indent the current line."
 839   (interactive "P")
 840   (self-insert-command (prefix-numeric-value arg))
 841   (ruby-indent-line t))
 842
 843 ;; TODO: Why isn't one ruby-*-of-defun written in terms of the other?
 844 (defun ruby-beginning-of-defun (&optional arg)
 845   "Move backward to the beginning of the current top-level defun.
 846 With ARG, move backward multiple defuns.  Negative ARG means
 847 move forward."
 848   (interactive "p")
 849   (and (re-search-backward (concat "^\\(" ruby-block-beg-re "\\)\\b")
 850                            nil 'move (or arg 1))
 851        (beginning-of-line)))
 852
 853 (defun ruby-end-of-defun (&optional arg)
 854   "Move forward to the end of the current top-level defun.
 855 With ARG, move forward multiple defuns.  Negative ARG means
 856 move backward."
 857   (interactive "p")
 858   (and (re-search-forward (concat "^\\(" ruby-block-end-re "\\)\\($\\|\\b[^_]\\)")
 859                           nil 'move (or arg 1))
 860        (beginning-of-line))
 861   (forward-line 1))
 862
 863 (defun ruby-beginning-of-indent ()
 864   "TODO: document"
 865   ;; I don't understand this function.
 866   ;; It seems like it should move to the line where indentation should deepen,
 867   ;; but ruby-indent-beg-re only accounts for whitespace before class, module and def,
 868   ;; so this will only match other block beginners at the beginning of the line.
 869   (and (re-search-backward (concat "^\\(" ruby-indent-beg-re "\\)\\_>") nil 'move)
 870        (beginning-of-line)))
 871
 872 (defun ruby-move-to-block (n)
 873   "Move to the beginning (N < 0) or the end (N > 0) of the current block
 874 or blocks containing the current block."
 875   ;; TODO: Make this work for n > 1,
 876   ;; make it not loop for n = 0,
 877   ;; document body
 878   (let (start pos done down)
 879     (setq start (ruby-calculate-indent))
 880     (setq down (looking-at (if (< n 0) ruby-block-end-re
 881                              (concat "\\<\\(" ruby-block-beg-re "\\)\\>"))))
 882     (while (and (not done) (not (if (< n 0) (bobp) (eobp))))
 883       (forward-line n)
 884       (cond
 885        ((looking-at "^\\s *$"))
 886        ((looking-at "^\\s *#"))
 887        ((and (> n 0) (looking-at "^=begin\\>"))
 888         (re-search-forward "^=end\\>"))
 889        ((and (< n 0) (looking-at "^=end\\>"))
 890         (re-search-backward "^=begin\\>"))
 891        (t
 892         (setq pos (current-indentation))
 893         (cond
 894          ((< start pos)
 895           (setq down t))
 896          ((and down (= pos start))
 897           (setq done t))
 898          ((> start pos)
 899           (setq done t)))))
 900       (if done
 901           (save-excursion
 902             (back-to-indentation)
 903             (if (looking-at (concat "\\<\\(" ruby-block-mid-re "\\)\\>"))
 904                 (setq done nil))))))
 905   (back-to-indentation))
 906
 907 (defun ruby-beginning-of-block (&optional arg)
 908   "Move backward to the beginning of the current block.
 909 With ARG, move up multiple blocks."
 910   (interactive "p")
 911   (ruby-move-to-block (- (or arg 1))))
 912
 913 (defun ruby-end-of-block (&optional arg)
 914   "Move forward to the end of the current block.
 915 With ARG, move out of multiple blocks."
 916   ;; Passing a value > 1 to ruby-move-to-block currently doesn't work.
 917   (interactive)
 918   (ruby-move-to-block (or arg 1)))
 919
 920 (defun ruby-forward-sexp (&optional arg)
 921   "Move forward across one balanced expression (sexp).
 922 With ARG, do it many times.  Negative ARG means move backward."
 923   ;; TODO: Document body
 924   (interactive "p")
 925   (if (and (numberp arg) (< arg 0))
 926       (ruby-backward-sexp (- arg))
 927     (let ((i (or arg 1)))
 928       (condition-case nil
 929           (while (> i 0)
 930             (skip-syntax-forward " ")
 931             (if (looking-at ",\\s *") (goto-char (match-end 0)))
 932             (cond ((looking-at "\\?\\(\\\\[CM]-\\)*\\\\?\\S ")
 933                    (goto-char (match-end 0)))
 934                   ((progn
 935                      (skip-chars-forward ",.:;|&^~=!?\\+\\-\\*")
 936                      (looking-at "\\s("))
 937                    (goto-char (scan-sexps (point) 1)))
 938                   ((and (looking-at (concat "\\<\\(" ruby-block-beg-re "\\)\\>"))
 939                         (not (eq (char-before (point)) ?.))
 940                         (not (eq (char-before (point)) ?:)))
 941                    (ruby-end-of-block)
 942                    (forward-word 1))
 943                   ((looking-at "\\(\\$\\|@@?\\)?\\sw")
 944                    (while (progn
 945                             (while (progn (forward-word 1) (looking-at "_")))
 946                             (cond ((looking-at "::") (forward-char 2) t)
 947                                   ((> (skip-chars-forward ".") 0))
 948                                   ((looking-at "\\?\\|!\\(=[~=>]\\|[^~=]\\)")
 949                                    (forward-char 1) nil)))))
 950                   ((let (state expr)
 951                      (while
 952                          (progn
 953                            (setq expr (or expr (ruby-expr-beg)
 954                                           (looking-at "%\\sw?\\Sw\\|[\"'`/]")))
 955                            (nth 1 (setq state (apply 'ruby-parse-partial nil state))))
 956                        (setq expr t)
 957                        (skip-chars-forward "<"))
 958                      (not expr))))
 959             (setq i (1- i)))
 960         ((error) (forward-word 1)))
 961       i)))
 962
 963 (defun ruby-backward-sexp (&optional arg)
 964   "Move backward across one balanced expression (sexp).
 965 With ARG, do it many times.  Negative ARG means move forward."
 966   ;; TODO: Document body
 967   (interactive "p")
 968   (if (and (numberp arg) (< arg 0))
 969       (ruby-forward-sexp (- arg))
 970     (let ((i (or arg 1)))
 971       (condition-case nil
 972           (while (> i 0)
 973             (skip-chars-backward " \t\n,.:;|&^~=!?\\+\\-\\*")
 974             (forward-char -1)
 975             (cond ((looking-at "\\s)")
 976                    (goto-char (scan-sexps (1+ (point)) -1))
 977                    (case (char-before)
 978                      (?% (forward-char -1))
 979                      ((?q ?Q ?w ?W ?r ?x)
 980                       (if (eq (char-before (1- (point))) ?%) (forward-char -2))))
 981                    nil)
 982                   ((looking-at "\\s\"\\|\\\\\\S_")
 983                    (let ((c (char-to-string (char-before (match-end 0)))))
 984                      (while (and (search-backward c)
 985                                  (eq (logand (skip-chars-backward "\\") 1)
 986                                      1))))
 987                    nil)
 988                   ((looking-at "\\s.\\|\\s\\")
 989                    (if (ruby-special-char-p) (forward-char -1)))
 990                   ((looking-at "\\s(") nil)
 991                   (t
 992                    (forward-char 1)
 993                    (while (progn (forward-word -1)
 994                                  (case (char-before)
 995                                    (?_ t)
 996                                    (?. (forward-char -1) t)
 997                                    ((?$ ?@)
 998                                     (forward-char -1)
 999                                     (and (eq (char-before) (char-after)) (forward-char -1)))
1000                                    (?:
1001                                     (forward-char -1)
1002                                     (eq (char-before) :)))))
1003                    (if (looking-at ruby-block-end-re)
1004                        (ruby-beginning-of-block))
1005                    nil))
1006             (setq i (1- i)))
1007         ((error)))
1008       i)))
1009
1010 (defun ruby-mark-defun ()
1011   "Put mark at end of this Ruby function, point at beginning."
1012   (interactive)
1013   (push-mark (point))
1014   (ruby-end-of-defun)
1015   (push-mark (point) nil t)
1016   (ruby-beginning-of-defun)
1017   (re-search-backward "^\n" (- (point) 1) t))
1018
1019 (defun ruby-indent-exp (&optional ignored)
1020   "Indent each line in the balanced expression following the point."
1021   (interactive "*P")
1022   (let ((here (point-marker)) start top column (nest t))
1023     (set-marker-insertion-type here t)
1024     (unwind-protect
1025         (progn
1026           (beginning-of-line)
1027           (setq start (point) top (current-indentation))
1028           (while (and (not (eobp))
1029                       (progn
1030                         (setq column (ruby-calculate-indent start))
1031                         (cond ((> column top)
1032                                (setq nest t))
1033                               ((and (= column top) nest)
1034                                (setq nest nil) t))))
1035             (ruby-indent-to column)
1036             (beginning-of-line 2)))
1037       (goto-char here)
1038       (set-marker here nil))))
1039
1040 (defun ruby-add-log-current-method ()
1041   "Return the current method name as a string.
1042 This string includes all namespaces.
1043
1044 For example:
1045
1046   #exit
1047   String#gsub
1048   Net::HTTP#active?
1049   File::open.
1050
1051 See `add-log-current-defun-function'."
1052   ;; TODO: Document body
1053   ;; Why does this append a period to class methods?
1054   (condition-case nil
1055       (save-excursion
1056         (let (mname mlist (indent 0))
1057           ;; get current method (or class/module)
1058           (if (re-search-backward
1059                (concat "^[ \t]*\\(def\\|class\\|module\\)[ \t]+"
1060                        "\\("
1061                        ;; \\. and :: for class method
1062                         "\\([A-Za-z_]" ruby-symbol-re "*\\|\\.\\|::" "\\)"
1063                         "+\\)")
1064                nil t)
1065               (progn
1066                 (setq mname (match-string 2))
1067                 (unless (string-equal "def" (match-string 1))
1068                   (setq mlist (list mname) mname nil))
1069                 (goto-char (match-beginning 1))
1070                 (setq indent (current-column))
1071                 (beginning-of-line)))
1072           ;; nest class/module
1073           (while (and (> indent 0)
1074                       (re-search-backward
1075                        (concat
1076                         "^[ \t]*\\(class\\|module\\)[ \t]+"
1077                         "\\([A-Z]" ruby-symbol-re "*\\)")
1078                        nil t))
1079             (goto-char (match-beginning 1))
1080             (if (< (current-column) indent)
1081                 (progn
1082                   (setq mlist (cons (match-string 2) mlist))
1083                   (setq indent (current-column))
1084                   (beginning-of-line))))
1085           (when mname
1086             (let ((mn (split-string mname "\\.\\|::")))
1087               (if (cdr mn)
1088                   (progn
1089                     (cond
1090                      ((string-equal "" (car mn))
1091                       (setq mn (cdr mn) mlist nil))
1092                      ((string-equal "self" (car mn))
1093                       (setq mn (cdr mn)))
1094                      ((let ((ml (nreverse mlist)))
1095                         (while ml
1096                           (if (string-equal (car ml) (car mn))
1097                               (setq mlist (nreverse (cdr ml)) ml nil))
1098                           (or (setq ml (cdr ml)) (nreverse mlist))))))
1099                     (if mlist
1100                         (setcdr (last mlist) mn)
1101                       (setq mlist mn))
1102                     (setq mn (last mn 2))
1103                     (setq mname (concat "." (cadr mn)))
1104                     (setcdr mn nil))
1105                 (setq mname (concat "#" mname)))))
1106           ;; generate string
1107           (if (consp mlist)
1108               (setq mlist (mapconcat (function identity) mlist "::")))
1109           (if mname
1110               (if mlist (concat mlist mname) mname)
1111             mlist)))))
1112
1113 (declare-function ruby-syntax-propertize-heredoc "ruby-mode" (limit))
1114 (declare-function ruby-syntax-general-delimiters-goto-beg "ruby-mode" ())
1115 (declare-function ruby-syntax-propertize-general-delimiters "ruby-mode" (limit))
1116
1117 (if (eval-when-compile (fboundp #'syntax-propertize-rules))
1118     ;; New code that works independently from font-lock.
1119     (progn
1120       (defun ruby-syntax-propertize-function (start end)
1121         "Syntactic keywords for Ruby mode.  See `syntax-propertize-function'."
1122         (goto-char start)
1123         (ruby-syntax-propertize-heredoc end)
1124         (ruby-syntax-general-delimiters-goto-beg)
1125         (funcall
1126          (syntax-propertize-rules
1127           ;; #{ }, #$hoge, #@foo are not comments.
1128           ("\\(#\\)[{$@]" (1 "."))
1129           ;; $' $" $` .... are variables.
1130           ;; ?' ?" ?` are ascii codes.
1131           ("\\([?$]\\)[#\"'`]"
1132            (1 (unless (save-excursion
1133                         ;; Not within a string.
1134                         (nth 3 (syntax-ppss (match-beginning 0))))
1135                 (string-to-syntax "\\"))))
1136           ;; Regexps: regexps are distinguished from division either because
1137           ;; of the keyword/symbol before them, or because of the code
1138           ;; following them.
1139           ((concat
1140             ;; Special tokens that can't be followed by a division operator.
1141             "\\(?:\\(^\\|[[=(,~?:;<>]\\|\\(?:^\\|\\s \\)"
1142             (regexp-opt '("if" "elsif" "unless" "while" "until" "when" "and"
1143                           "or" "&&" "||"
1144                           "gsub" "gsub!" "sub" "sub!" "scan" "split" "split!"))
1145             "\\)\\s *\\)?"
1146             ;; The regular expression itself.
1147             "\\(/\\)[^/\n\\\\]*\\(?:\\\\.[^/\n\\\\]*\\)*\\(/\\)"
1148             ;; Special code that cannot follow a division operator.
1149             ;; FIXME: Just because the second slash of "/foo/ do bar" can't
1150             ;; be a division, doesn't mean it can't *start* a regexp, as in
1151             ;; "x = toto/foo; if /do bar/".
1152             "\\([imxo]*\\s *\\(?:,\\|\\_<do\\_>\\)\\)?")
1153            (2 (when (or (match-beginning 1) (match-beginning 4))
1154                 (string-to-syntax "\"/")))
1155            (3 (if (or (match-beginning 1) (match-beginning 4))
1156                   (string-to-syntax "\"/")
1157                 (goto-char (match-end 2)))))
1158           ("^=en\\(d\\)\\_>" (1 "!"))
1159           ("^\\(=\\)begin\\_>" (1 "!"))
1160           ;; Handle here documents.
1161           ((concat ruby-here-doc-beg-re ".*\\(\n\\)")
1162            (7 (prog1 "\"" (ruby-syntax-propertize-heredoc end))))
1163           ;; Handle percent literals: %w(), %q{}, etc.
1164           ("\\(?:^\\|[[ \t\n<+(,=]\\)\\(%\\)[qQrswWx]?\\([[:punct:]]\\)"
1165            (1 (prog1 "|" (ruby-syntax-propertize-general-delimiters end)))))
1166          (point) end))
1167
1168       (defun ruby-syntax-propertize-heredoc (limit)
1169         (let ((ppss (syntax-ppss))
1170               (res '()))
1171           (when (eq ?\n (nth 3 ppss))
1172             (save-excursion
1173               (goto-char (nth 8 ppss))
1174               (beginning-of-line)
1175               (while (re-search-forward ruby-here-doc-beg-re
1176                                         (line-end-position) t)
1177                 (push (concat (ruby-here-doc-end-match) "\n") res)))
1178             (let ((start (point)))
1179               ;; With multiple openers on the same line, we don't know in which
1180               ;; part `start' is, so we have to go back to the beginning.
1181               (when (cdr res)
1182                 (goto-char (nth 8 ppss))
1183                 (setq res (nreverse res)))
1184               (while (and res (re-search-forward (pop res) limit 'move))
1185                 (if (null res)
1186                     (put-text-property (1- (point)) (point)
1187                                        'syntax-table (string-to-syntax "\""))))
1188               ;; Make extra sure we don't move back, lest we could fall into an
1189               ;; inf-loop.
1190               (if (< (point) start) (goto-char start))))))
1191
1192       (defun ruby-syntax-general-delimiters-goto-beg ()
1193         (let ((state (syntax-ppss)))
1194           ;; Move to the start of the literal, in case it's multiline.
1195           ;; TODO: determine the literal type more reliably here?
1196           (when (eq t (nth 3 state))
1197             (goto-char (nth 8 state))
1198             (beginning-of-line))))
1199
1200       (defun ruby-syntax-propertize-general-delimiters (limit)
1201         (goto-char (match-beginning 2))
1202         (let* ((op (char-after))
1203                (ops (char-to-string op))
1204                (cl (or (cdr (aref (syntax-table) op))
1205                        (cdr (assoc op '((?< . ?>))))))
1206                parse-sexp-lookup-properties)
1207           (ignore-errors
1208             (if cl
1209                 (progn  ; Paired delimiters.
1210                   ;; Delimiter pairs of the same kind can be nested
1211                   ;; inside the literal, as long as they are balanced.
1212                   ;; Create syntax table that ignores other characters.
1213                   (with-syntax-table (make-char-table 'syntax-table nil)
1214                     (modify-syntax-entry op (concat "(" (char-to-string cl)))
1215                     (modify-syntax-entry cl (concat ")" ops))
1216                     (modify-syntax-entry ?\\ "\\")
1217                     (save-restriction
1218                       (narrow-to-region (point) limit)
1219                       (forward-list))))  ; skip to the paired character
1220               ;; Single character delimiter.
1221               (re-search-forward (concat "[^\\]\\(?:\\\\\\\\\\)*"
1222                                          (regexp-quote ops)) limit nil))
1223             ;; If we reached here, the closing delimiter was found.
1224             (put-text-property (1- (point)) (point)
1225                                'syntax-table (string-to-syntax "|")))))
1226       )
1227
1228   ;; For Emacsen where syntax-propertize-rules is not (yet) available,
1229   ;; fallback on the old font-lock-syntactic-keywords stuff.
1230
1231   (defconst ruby-here-doc-end-re
1232     "^\\([ \t]+\\)?\\(.*\\)\\(\n\\)"
1233     "Regexp to match the end of heredocs.
1234
1235 This will actually match any line with one or more characters.
1236 It's useful in that it divides up the match string so that
1237 `ruby-here-doc-beg-match' can search for the beginning of the heredoc.")
1238
1239   (defun ruby-here-doc-beg-match ()
1240     "Return a regexp to find the beginning of a heredoc.
1241
1242 This should only be called after matching against `ruby-here-doc-end-re'."
1243     (let ((contents (concat
1244                      (regexp-quote (concat (match-string 2) (match-string 3)))
1245                      (if (string= (match-string 3) "_") "\\B" "\\b"))))
1246       (concat "<<"
1247               (let ((match (match-string 1)))
1248                 (if (and match (> (length match) 0))
1249                     (concat "\\(?:-\\([\"']?\\)\\|\\([\"']\\)"
1250                             (match-string 1) "\\)"
1251                             contents "\\(\\1\\|\\2\\)")
1252                   (concat "-?\\([\"']\\|\\)" contents "\\1"))))))
1253
1254   (defconst ruby-font-lock-syntactic-keywords
1255     `( ;; #{ }, #$hoge, #@foo are not comments
1256     ("\\(#\\)[{$@]" 1 (1 . nil))
1257     ;; the last $', $", $` in the respective string is not variable
1258     ;; the last ?', ?", ?` in the respective string is not ascii code
1259     ("\\(^\\|[\[ \t\n<+\(,=]\\)\\(['\"`]\\)\\(\\\\.\\|\\2\\|[^'\"`\n\\\\]\\)*?\\\\?[?$]\\(\\2\\)"
1260      (2 (7 . nil))
1261      (4 (7 . nil)))
1262     ;; $' $" $` .... are variables
1263     ;; ?' ?" ?` are ascii codes
1264     ("\\(^\\|[^\\\\]\\)\\(\\\\\\\\\\)*[?$]\\([#\"'`]\\)" 3 (1 . nil))
1265     ;; regexps
1266     ("\\(^\\|[[=(,~?:;<>]\\|\\(^\\|\\s \\)\\(if\\|elsif\\|unless\\|while\\|until\\|when\\|and\\|or\\|&&\\|||\\)\\|g?sub!?\\|scan\\|split!?\\)\\s *\\(/\\)[^/\n\\\\]*\\(\\\\.[^/\n\\\\]*\\)*\\(/\\)"
1267      (4 (7 . ?/))
1268      (6 (7 . ?/)))
1269     ("^=en\\(d\\)\\_>" 1 "!")
1270     ;; General delimited string.
1271     ("\\(^\\|[[ \t\n<+(,=]\\)\\(%[xrqQwW]?\\([^<[{(a-zA-Z0-9 \n]\\)[^\n\\\\]*\\(\\\\.[^\n\\\\]*\\)*\\(\\3\\)\\)"
1272      (3 "\"")
1273      (5 "\""))
1274     ("^\\(=\\)begin\\_>" 1 (ruby-comment-beg-syntax))
1275     ;; Currently, the following case is highlighted incorrectly:
1276     ;;
1277     ;;   <<FOO
1278     ;;   FOO
1279     ;;   <<BAR
1280     ;;   <<BAZ
1281     ;;   BAZ
1282     ;;   BAR
1283     ;;
1284     ;; This is because all here-doc beginnings are highlighted before any endings,
1285     ;; so although <<BAR is properly marked as a beginning, when we get to <<BAZ
1286     ;; it thinks <<BAR is part of a string so it's marked as well.
1287     ;;
1288     ;; This may be fixable by modifying ruby-in-here-doc-p to use
1289     ;; ruby-in-non-here-doc-string-p rather than syntax-ppss-context,
1290     ;; but I don't want to try that until we've got unit tests set up
1291     ;; to make sure I don't break anything else.
1292     (,(concat ruby-here-doc-beg-re ".*\\(\n\\)")
1293      ,(+ 1 (regexp-opt-depth ruby-here-doc-beg-re))
1294      (ruby-here-doc-beg-syntax))
1295     (,ruby-here-doc-end-re 3 (ruby-here-doc-end-syntax)))
1296   "Syntactic keywords for Ruby mode.  See `font-lock-syntactic-keywords'.")
1297
1298   (defun ruby-comment-beg-syntax ()
1299   "Return the syntax cell for a the first character of a =begin.
1300 See the definition of `ruby-font-lock-syntactic-keywords'.
1301
1302 This returns a comment-delimiter cell as long as the =begin
1303 isn't in a string or another comment."
1304     (when (not (nth 3 (syntax-ppss)))
1305       (string-to-syntax "!")))
1306
1307   (defun ruby-in-here-doc-p ()
1308     "Return whether or not the point is in a heredoc."
1309     (save-excursion
1310       (let ((old-point (point)) (case-fold-search nil))
1311         (beginning-of-line)
1312         (catch 'found-beg
1313           (while (re-search-backward ruby-here-doc-beg-re nil t)
1314             (if (not (or (ruby-in-ppss-context-p 'anything)
1315                          (ruby-here-doc-find-end old-point)))
1316                 (throw 'found-beg t)))))))
1317
1318   (defun ruby-here-doc-find-end (&optional limit)
1319     "Expects the point to be on a line with one or more heredoc openers.
1320 Returns the buffer position at which all heredocs on the line
1321 are terminated, or nil if they aren't terminated before the
1322 buffer position `limit' or the end of the buffer."
1323     (save-excursion
1324       (beginning-of-line)
1325       (catch 'done
1326         (let ((eol (point-at-eol))
1327               (case-fold-search nil)
1328               ;; Fake match data such that (match-end 0) is at eol
1329               (end-match-data (progn (looking-at ".*$") (match-data)))
1330               beg-match-data end-re)
1331           (while (re-search-forward ruby-here-doc-beg-re eol t)
1332             (setq beg-match-data (match-data))
1333             (setq end-re (ruby-here-doc-end-match))
1334
1335             (set-match-data end-match-data)
1336             (goto-char (match-end 0))
1337             (unless (re-search-forward end-re limit t) (throw 'done nil))
1338             (setq end-match-data (match-data))
1339
1340             (set-match-data beg-match-data)
1341             (goto-char (match-end 0)))
1342           (set-match-data end-match-data)
1343           (goto-char (match-end 0))
1344           (point)))))
1345
1346   (defun ruby-here-doc-beg-syntax ()
1347     "Return the syntax cell for a line that may begin a heredoc.
1348 See the definition of `ruby-font-lock-syntactic-keywords'.
1349
1350 This sets the syntax cell for the newline ending the line
1351 containing the heredoc beginning so that cases where multiple
1352 heredocs are started on one line are handled correctly."
1353     (save-excursion
1354       (goto-char (match-beginning 0))
1355       (unless (or (ruby-in-ppss-context-p 'non-heredoc)
1356                   (ruby-in-here-doc-p))
1357         (string-to-syntax "\""))))
1358
1359   (defun ruby-here-doc-end-syntax ()
1360     "Return the syntax cell for a line that may end a heredoc.
1361 See the definition of `ruby-font-lock-syntactic-keywords'."
1362     (let ((pss (syntax-ppss)) (case-fold-search nil))
1363       ;; If we aren't in a string, we definitely aren't ending a heredoc,
1364       ;; so we can just give up.
1365       ;; This means we aren't doing a full-document search
1366       ;; every time we enter a character.
1367       (when (ruby-in-ppss-context-p 'heredoc pss)
1368         (save-excursion
1369           (goto-char (nth 8 pss))    ; Go to the beginning of heredoc.
1370           (let ((eol (point)))
1371             (beginning-of-line)
1372             (if (and (re-search-forward (ruby-here-doc-beg-match) eol t) ; If there is a heredoc that matches this line...
1373                      (not (ruby-in-ppss-context-p 'anything)) ; And that's not inside a heredoc/string/comment...
1374                      (progn (goto-char (match-end 0)) ; And it's the last heredoc on its line...
1375                             (not (re-search-forward ruby-here-doc-beg-re eol t))))
1376                 (string-to-syntax "\"")))))))
1377
1378   (unless (functionp 'syntax-ppss)
1379     (defun syntax-ppss (&optional pos)
1380       (parse-partial-sexp (point-min) (or pos (point)))))
1381   )
1382
1383 (defun ruby-in-ppss-context-p (context &optional ppss)
1384   (let ((ppss (or ppss (syntax-ppss (point)))))
1385     (if (cond
1386          ((eq context 'anything)
1387           (or (nth 3 ppss)
1388               (nth 4 ppss)))
1389          ((eq context 'string)
1390           (nth 3 ppss))
1391          ((eq context 'heredoc)
1392           (eq ?\n (nth 3 ppss)))
1393          ((eq context 'non-heredoc)
1394           (and (ruby-in-ppss-context-p 'anything)
1395                (not (ruby-in-ppss-context-p 'heredoc))))
1396          ((eq context 'comment)
1397           (nth 4 ppss))
1398          (t
1399           (error (concat
1400                   "Internal error on `ruby-in-ppss-context-p': "
1401                   "context name `" (symbol-name context) "' is unknown"))))
1402         t)))
1403
1404 (if (featurep 'xemacs)
1405     (put 'ruby-mode 'font-lock-defaults
1406          '((ruby-font-lock-keywords)
1407            nil nil nil
1408            beginning-of-line
1409            (font-lock-syntactic-keywords
1410             . ruby-font-lock-syntactic-keywords))))
1411
1412 (defvar ruby-font-lock-syntax-table
1413   (let ((tbl (copy-syntax-table ruby-mode-syntax-table)))
1414     (modify-syntax-entry ?_ "w" tbl)
1415     tbl)
1416   "The syntax table to use for fontifying Ruby mode buffers.
1417 See `font-lock-syntax-table'.")
1418
1419 (defconst ruby-font-lock-keywords
1420   (list
1421    ;; functions
1422    '("^\\s *def\\s +\\([^( \t\n]+\\)"
1423      1 font-lock-function-name-face)
1424    ;; keywords
1425    (cons (concat
1426           "\\(^\\|[^_:.@$]\\|\\.\\.\\)\\b\\(defined\\?\\|"
1427           (regexp-opt
1428            '("alias_method"
1429              "alias"
1430              "and"
1431              "begin"
1432              "break"
1433              "case"
1434              "catch"
1435              "class"
1436              "def"
1437              "do"
1438              "elsif"
1439              "else"
1440              "fail"
1441              "ensure"
1442              "for"
1443              "end"
1444              "if"
1445              "in"
1446              "module_function"
1447              "module"
1448              "next"
1449              "not"
1450              "or"
1451              "public"
1452              "private"
1453              "protected"
1454              "raise"
1455              "redo"
1456              "rescue"
1457              "retry"
1458              "return"
1459              "then"
1460              "throw"
1461              "super"
1462              "unless"
1463              "undef"
1464              "until"
1465              "when"
1466              "while"
1467              "yield")
1468            t)
1469           "\\)"
1470           ruby-keyword-end-re)
1471          2)
1472    ;; here-doc beginnings
1473    (list ruby-here-doc-beg-re 0 'font-lock-string-face)
1474    ;; variables
1475    '("\\(^\\|[^_:.@$]\\|\\.\\.\\)\\b\\(nil\\|self\\|true\\|false\\)\\>"
1476      2 font-lock-variable-name-face)
1477    ;; variables
1478    '("\\(\\$\\([^a-zA-Z0-9 \n]\\|[0-9]\\)\\)\\W"
1479      1 font-lock-variable-name-face)
1480    '("\\(\\$\\|@\\|@@\\)\\(\\w\\|_\\)+"
1481      0 font-lock-variable-name-face)
1482    ;; constants
1483    '("\\(^\\|[^_]\\)\\b\\([A-Z]+\\(\\w\\|_\\)*\\)"
1484      2 font-lock-type-face)
1485    ;; symbols
1486    '("\\(^\\|[^:]\\)\\(:\\([-+~]@?\\|[/%&|^`]\\|\\*\\*?\\|<\\(<\\|=>?\\)?\\|>[>=]?\\|===?\\|=~\\|![~=]?\\|\\[\\]=?\\|\\(\\w\\|_\\)+\\([!?=]\\|\\b_*\\)\\|#{[^}\n\\\\]*\\(\\\\.[^}\n\\\\]*\\)*}\\)\\)"
1487      2 font-lock-reference-face)
1488    '("\\(^\\s *\\|[\[\{\(,]\\s *\\|\\sw\\s +\\)\\(\\(\\sw\\|_\\)+\\):[^:]" 2 font-lock-reference-face)
1489    ;; expression expansion
1490    '("#\\({[^}\n\\\\]*\\(\\\\.[^}\n\\\\]*\\)*}\\|\\(\\$\\|@\\|@@\\)\\(\\w\\|_\\)+\\)"
1491      0 font-lock-variable-name-face t)
1492    ;; warn lower camel case
1493                                         ;'("\\<[a-z]+[a-z0-9]*[A-Z][A-Za-z0-9]*\\([!?]?\\|\\>\\)"
1494                                         ;  0 font-lock-warning-face)
1495    )
1496   "Additional expressions to highlight in Ruby mode.")
1497
1498 ;;;###autoload
1499 (define-derived-mode ruby-mode prog-mode "Ruby"
1500   "Major mode for editing Ruby scripts.
1501 \\[ruby-indent-line] properly indents subexpressions of multi-line
1502 class, module, def, if, while, for, do, and case statements, taking
1503 nesting into account.
1504
1505 The variable `ruby-indent-level' controls the amount of indentation.
1506
1507 \\{ruby-mode-map}"
1508   (ruby-mode-variables)
1509
1510   (set (make-local-variable 'imenu-create-index-function)
1511        'ruby-imenu-create-index)
1512   (set (make-local-variable 'add-log-current-defun-function)
1513        'ruby-add-log-current-method)
1514
1515   (add-hook
1516    (cond ((boundp 'before-save-hook) 'before-save-hook)
1517          ((boundp 'write-contents-functions) 'write-contents-functions)
1518          ((boundp 'write-contents-hooks) 'write-contents-hooks))
1519    'ruby-mode-set-encoding nil 'local)
1520
1521   (set (make-local-variable 'electric-indent-chars)
1522        (append '(?\{ ?\}) electric-indent-chars))
1523
1524   (set (make-local-variable 'font-lock-defaults)
1525        '((ruby-font-lock-keywords) nil nil))
1526   (set (make-local-variable 'font-lock-keywords)
1527        ruby-font-lock-keywords)
1528   (set (make-local-variable 'font-lock-syntax-table)
1529        ruby-font-lock-syntax-table)
1530
1531   (if (eval-when-compile (fboundp 'syntax-propertize-rules))
1532       (set (make-local-variable 'syntax-propertize-function)
1533            #'ruby-syntax-propertize-function)
1534     (set (make-local-variable 'font-lock-syntactic-keywords)
1535          ruby-font-lock-syntactic-keywords)))
1536
1537 ;;; Invoke ruby-mode when appropriate
1538
1539 ;;;###autoload
1540 (add-to-list 'auto-mode-alist (cons (purecopy "\\.rb\\'") 'ruby-mode))
1541
1542 ;;;###autoload
1543 (dolist (name (list "ruby" "rbx" "jruby" "ruby1.9" "ruby1.8"))
1544   (add-to-list 'interpreter-mode-alist (cons (purecopy name) 'ruby-mode)))
1545
1546 (provide 'ruby-mode)
1547
1548 ;;; ruby-mode.el ends here