mirror of
https://github.com/ruby/ruby.git
synced 2022-11-09 12:17:21 -05:00
1.4.0
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@520 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
matz
parent
fcd020c830
commit
65a5162550
156 changed files with 21888 additions and 18301 deletions
5
misc/README
Normal file
5
misc/README
Normal file
|
|
@ -0,0 +1,5 @@
|
|||
README this file
|
||||
inf-ruby.el program to run ruby under emacs
|
||||
ruby-mode.el ruby mode for emacs
|
||||
rubydb2x.el ruby debugger support for emacs 19.2x or before
|
||||
rubydb3x.el ruby debugger support for emacs 19.3x or later
|
||||
322
misc/inf-ruby.el
Normal file
322
misc/inf-ruby.el
Normal file
|
|
@ -0,0 +1,322 @@
|
|||
;;; -*-Emacs-Lisp-*-
|
||||
;;;
|
||||
;;; $Id$
|
||||
;;; $Author$
|
||||
;;; $Date$
|
||||
;;;
|
||||
;;; Inferior Ruby Mode - ruby process in a buffer.
|
||||
;;; adapted from cmuscheme.el
|
||||
;;;
|
||||
;;; Usage:
|
||||
;;;
|
||||
;;; (0) check ruby-program-name variable that can run your environment.
|
||||
;;;
|
||||
;;; (1) modify .emacs to use ruby-mode
|
||||
;;; for example :
|
||||
;;;
|
||||
;;; (autoload 'ruby-mode "ruby-mode"
|
||||
;;; "Mode for editing ruby source files")
|
||||
;;; (setq auto-mode-alist
|
||||
;;; (append '(("\\.rb$" . ruby-mode)) auto-mode-alist))
|
||||
;;; (setq interpreter-mode-alist (append '(("^#!.*ruby" . ruby-mode))
|
||||
;;; interpreter-mode-alist))
|
||||
;;;
|
||||
;;; (2) set to road inf-ruby and set inf-ruby key definition in ruby-mode.
|
||||
;;;
|
||||
;;; (autoload 'run-ruby "inf-ruby"
|
||||
;;; "Run an inferior Ruby process")
|
||||
;;; (autoload 'inf-ruby-keys "inf-ruby"
|
||||
;;; "Set local key defs for inf-ruby in ruby-mode")
|
||||
;;; (add-hook 'ruby-mode-hook
|
||||
;;; '(lambda ()
|
||||
;;; (inf-ruby-keys)
|
||||
;;; ))
|
||||
;;;
|
||||
;;; HISTORY
|
||||
;;; senda - 8 Apr 1998: Created.
|
||||
;;; $Log$
|
||||
;;; Revision 1.2 1999/08/13 05:45:18 matz
|
||||
;;; 1.4.0
|
||||
;;;
|
||||
;;; Revision 1.1.1.1.2.1 1999/07/15 07:59:59 matz
|
||||
;;; 990715
|
||||
;;;
|
||||
;;; Revision 1.1.1.1 1999/01/20 04:59:36 matz
|
||||
;;; ruby 1.3 cycle
|
||||
;;;
|
||||
;;; Revision 1.1.2.1 1998/12/16 07:30:36 matz
|
||||
;;; first public release of 1.1d (pre1.2) series
|
||||
;;;
|
||||
;;; Revision 1.4 1998/05/20 02:45:58 senda
|
||||
;;; default program to irb
|
||||
;;;
|
||||
;;; Revision 1.3 1998/04/10 04:11:30 senda
|
||||
;;; modification by Matsumoto san (1.1b9_09)
|
||||
;;; remove-in-string defined
|
||||
;;; global variable :
|
||||
;;; inferior-ruby-first-prompt-pattern
|
||||
;;; inferior-ruby-prompt-pattern
|
||||
;;; defined
|
||||
;;;
|
||||
;;; Revision 1.2 1998/04/09 07:53:42 senda
|
||||
;;; remove M-C-x in inferior-ruby-mode
|
||||
;;;
|
||||
;;; Revision 1.1 1998/04/09 07:28:36 senda
|
||||
;;; Initial revision
|
||||
;;;
|
||||
;;;
|
||||
|
||||
(require 'comint)
|
||||
(require 'ruby-mode)
|
||||
|
||||
;;
|
||||
;; you may change these variables
|
||||
;;
|
||||
;(defvar ruby-program-name "rbc --noreadline"
|
||||
; "*Program invoked by the run-ruby command")
|
||||
;
|
||||
;(defvar inferior-ruby-first-prompt-pattern "^rbc0> *"
|
||||
; "first prompt regex pattern of ruby interpreter.")
|
||||
;
|
||||
;(defvar inferior-ruby-prompt-pattern "^\\(rbc.[>*\"'] *\\)+"
|
||||
; "prompt regex pattern of ruby interpreter.")
|
||||
|
||||
;;;; for irb
|
||||
(defvar ruby-program-name "irb --inf-ruby-mode"
|
||||
"*Program invoked by the run-ruby command")
|
||||
|
||||
(defvar inferior-ruby-first-prompt-pattern "^irb(.*)[0-9:]+0> *"
|
||||
"first prompt regex pattern of ruby interpreter.")
|
||||
|
||||
(defvar inferior-ruby-prompt-pattern "^\\(irb(.*)[0-9:]+[>*\"'] *\\)+"
|
||||
"prompt regex pattern of ruby interpreter.")
|
||||
|
||||
;;
|
||||
;; mode variables
|
||||
;;
|
||||
(defvar inferior-ruby-mode-hook nil
|
||||
"*Hook for customising inferior-ruby mode.")
|
||||
(defvar inferior-ruby-mode-map nil
|
||||
"*Mode map for inferior-ruby-mode")
|
||||
|
||||
(cond ((not inferior-ruby-mode-map)
|
||||
(setq inferior-ruby-mode-map
|
||||
(copy-keymap comint-mode-map))
|
||||
; (define-key inferior-ruby-mode-map "\M-\C-x" ;gnu convention
|
||||
; 'ruby-send-definition)
|
||||
; (define-key inferior-ruby-mode-map "\C-x\C-e" 'ruby-send-last-sexp)
|
||||
(define-key inferior-ruby-mode-map "\C-c\C-l" 'ruby-load-file)
|
||||
))
|
||||
|
||||
(defun inf-ruby-keys ()
|
||||
"Set local key defs for inf-ruby in ruby-mode"
|
||||
(define-key ruby-mode-map "\M-\C-x" 'ruby-send-definition)
|
||||
; (define-key ruby-mode-map "\C-x\C-e" 'ruby-send-last-sexp)
|
||||
(define-key ruby-mode-map "\C-c\C-e" 'ruby-send-definition)
|
||||
(define-key ruby-mode-map "\C-c\M-e" 'ruby-send-definition-and-go)
|
||||
(define-key ruby-mode-map "\C-c\C-r" 'ruby-send-region)
|
||||
(define-key ruby-mode-map "\C-c\M-r" 'ruby-send-region-and-go)
|
||||
(define-key ruby-mode-map "\C-c\C-z" 'switch-to-ruby)
|
||||
(define-key ruby-mode-map "\C-c\C-l" 'ruby-load-file)
|
||||
(define-key ruby-mode-map "\C-c\C-s" 'run-ruby)
|
||||
)
|
||||
|
||||
(defvar ruby-buffer nil "current ruby (actually irb) process buffer.")
|
||||
|
||||
(defun inferior-ruby-mode ()
|
||||
"Major mode for interacting with an inferior ruby (irb) process.
|
||||
|
||||
The following commands are available:
|
||||
\\{inferior-ruby-mode-map}
|
||||
|
||||
A ruby process can be fired up with M-x run-ruby.
|
||||
|
||||
Customisation: Entry to this mode runs the hooks on comint-mode-hook and
|
||||
inferior-ruby-mode-hook (in that order).
|
||||
|
||||
You can send text to the inferior ruby process from other buffers containing
|
||||
Ruby source.
|
||||
switch-to-ruby switches the current buffer to the ruby process buffer.
|
||||
ruby-send-definition sends the current definition to the ruby process.
|
||||
ruby-send-region sends the current region to the ruby process.
|
||||
|
||||
ruby-send-definition-and-go, ruby-send-region-and-go,
|
||||
switch to the ruby process buffer after sending their text.
|
||||
For information on running multiple processes in multiple buffers, see
|
||||
documentation for variable ruby-buffer.
|
||||
|
||||
Commands:
|
||||
Return after the end of the process' output sends the text from the
|
||||
end of process to point.
|
||||
Return before the end of the process' output copies the sexp ending at point
|
||||
to the end of the process' output, and sends it.
|
||||
Delete converts tabs to spaces as it moves back.
|
||||
Tab indents for ruby; with argument, shifts rest
|
||||
of expression rigidly with the current line.
|
||||
C-M-q does Tab on each line starting within following expression.
|
||||
Paragraphs are separated only by blank lines. # start comments.
|
||||
If you accidentally suspend your process, use \\[comint-continue-subjob]
|
||||
to continue it."
|
||||
(interactive)
|
||||
(comint-mode)
|
||||
;; Customise in inferior-ruby-mode-hook
|
||||
;(setq comint-prompt-regexp "^[^>\n]*>+ *")
|
||||
(setq comint-prompt-regexp inferior-ruby-prompt-pattern)
|
||||
;;(scheme-mode-variables)
|
||||
(ruby-mode-variables)
|
||||
(setq major-mode 'inferior-ruby-mode)
|
||||
(setq mode-name "Inferior Ruby")
|
||||
(setq mode-line-process '(":%s"))
|
||||
(use-local-map inferior-ruby-mode-map)
|
||||
(setq comint-input-filter (function ruby-input-filter))
|
||||
(setq comint-get-old-input (function ruby-get-old-input))
|
||||
(run-hooks 'inferior-ruby-mode-hook))
|
||||
|
||||
(defvar inferior-ruby-filter-regexp "\\`\\s *\\S ?\\S ?\\s *\\'"
|
||||
"*Input matching this regexp are not saved on the history list.
|
||||
Defaults to a regexp ignoring all inputs of 0, 1, or 2 letters.")
|
||||
|
||||
(defun ruby-input-filter (str)
|
||||
"Don't save anything matching inferior-ruby-filter-regexp"
|
||||
(not (string-match inferior-ruby-filter-regexp str)))
|
||||
|
||||
;; adapted from replace-in-string in XEmacs (subr.el)
|
||||
(defun remove-in-string (str regexp)
|
||||
"Remove all matches in STR for REGEXP and returns the new string."
|
||||
(let ((rtn-str "") (start 0) match prev-start)
|
||||
(while (setq match (string-match regexp str start))
|
||||
(setq prev-start start
|
||||
start (match-end 0)
|
||||
rtn-str (concat rtn-str (substring str prev-start match))))
|
||||
(concat rtn-str (substring str start))))
|
||||
|
||||
(defun ruby-get-old-input ()
|
||||
"Snarf the sexp ending at point"
|
||||
(save-excursion
|
||||
(let ((end (point)))
|
||||
(re-search-backward inferior-ruby-first-prompt-pattern)
|
||||
(remove-in-string (buffer-substring (point) end)
|
||||
inferior-ruby-prompt-pattern)
|
||||
)))
|
||||
|
||||
(defun ruby-args-to-list (string)
|
||||
(let ((where (string-match "[ \t]" string)))
|
||||
(cond ((null where) (list string))
|
||||
((not (= where 0))
|
||||
(cons (substring string 0 where)
|
||||
(ruby-args-to-list (substring string (+ 1 where)
|
||||
(length string)))))
|
||||
(t (let ((pos (string-match "[^ \t]" string)))
|
||||
(if (null pos)
|
||||
nil
|
||||
(ruby-args-to-list (substring string pos
|
||||
(length string)))))))))
|
||||
|
||||
(defun run-ruby (cmd)
|
||||
"Run an inferior Ruby process, input and output via buffer *ruby*.
|
||||
If there is a process already running in `*ruby*', switch to that buffer.
|
||||
With argument, allows you to edit the command line (default is value
|
||||
of `ruby-program-name'). Runs the hooks `inferior-ruby-mode-hook'
|
||||
\(after the `comint-mode-hook' is run).
|
||||
\(Type \\[describe-mode] in the process buffer for a list of commands.)"
|
||||
|
||||
(interactive (list (if current-prefix-arg
|
||||
(read-string "Run Ruby: " ruby-program-name)
|
||||
ruby-program-name)))
|
||||
(if (not (comint-check-proc "*ruby*"))
|
||||
(let ((cmdlist (ruby-args-to-list cmd)))
|
||||
(set-buffer (apply 'make-comint "ruby" (car cmdlist)
|
||||
nil (cdr cmdlist)))
|
||||
(inferior-ruby-mode)))
|
||||
(setq ruby-program-name cmd)
|
||||
(setq ruby-buffer "*ruby*")
|
||||
(pop-to-buffer "*ruby*"))
|
||||
|
||||
(defun ruby-send-region (start end)
|
||||
"Send the current region to the inferior Ruby process."
|
||||
(interactive "r")
|
||||
(comint-send-region (ruby-proc) start end)
|
||||
(comint-send-string (ruby-proc) "\n"))
|
||||
|
||||
(defun ruby-send-definition ()
|
||||
"Send the current definition to the inferior Ruby process."
|
||||
(interactive)
|
||||
(save-excursion
|
||||
(ruby-end-of-defun)
|
||||
(let ((end (point)))
|
||||
(ruby-beginning-of-defun)
|
||||
(ruby-send-region (point) end))))
|
||||
|
||||
;(defun ruby-send-last-sexp ()
|
||||
; "Send the previous sexp to the inferior Ruby process."
|
||||
; (interactive)
|
||||
; (ruby-send-region (save-excursion (backward-sexp) (point)) (point)))
|
||||
|
||||
(defun switch-to-ruby (eob-p)
|
||||
"Switch to the ruby process buffer.
|
||||
With argument, positions cursor at end of buffer."
|
||||
(interactive "P")
|
||||
(if (get-buffer ruby-buffer)
|
||||
(pop-to-buffer ruby-buffer)
|
||||
(error "No current process buffer. See variable ruby-buffer."))
|
||||
(cond (eob-p
|
||||
(push-mark)
|
||||
(goto-char (point-max)))))
|
||||
|
||||
(defun ruby-send-region-and-go (start end)
|
||||
"Send the current region to the inferior Ruby process.
|
||||
Then switch to the process buffer."
|
||||
(interactive "r")
|
||||
(ruby-send-region start end)
|
||||
(switch-to-ruby t))
|
||||
|
||||
(defun ruby-send-definition-and-go ()
|
||||
"Send the current definition to the inferior Ruby.
|
||||
Then switch to the process buffer."
|
||||
(interactive)
|
||||
(ruby-send-definition)
|
||||
(switch-to-ruby t))
|
||||
|
||||
(defvar ruby-source-modes '(ruby-mode)
|
||||
"*Used to determine if a buffer contains Ruby source code.
|
||||
If it's loaded into a buffer that is in one of these major modes, it's
|
||||
considered a ruby source file by ruby-load-file.
|
||||
Used by these commands to determine defaults.")
|
||||
|
||||
(defvar ruby-prev-l/c-dir/file nil
|
||||
"Caches the last (directory . file) pair.
|
||||
Caches the last pair used in the last ruby-load-file command.
|
||||
Used for determining the default in the
|
||||
next one.")
|
||||
|
||||
(defun ruby-load-file (file-name)
|
||||
"Load a Ruby file into the inferior Ruby process."
|
||||
(interactive (comint-get-source "Load Ruby file: " ruby-prev-l/c-dir/file
|
||||
ruby-source-modes t)) ; T because LOAD
|
||||
; needs an exact name
|
||||
(comint-check-source file-name) ; Check to see if buffer needs saved.
|
||||
(setq ruby-prev-l/c-dir/file (cons (file-name-directory file-name)
|
||||
(file-name-nondirectory file-name)))
|
||||
(comint-send-string (ruby-proc) (concat "(load \""
|
||||
file-name
|
||||
"\"\)\n")))
|
||||
|
||||
(defun ruby-proc ()
|
||||
"Returns the current ruby process. See variable ruby-buffer."
|
||||
(let ((proc (get-buffer-process (if (eq major-mode 'inferior-ruby-mode)
|
||||
(current-buffer)
|
||||
ruby-buffer))))
|
||||
(or proc
|
||||
(error "No current process. See variable ruby-buffer"))))
|
||||
|
||||
;;; Do the user's customisation...
|
||||
|
||||
(defvar inf-ruby-load-hook nil
|
||||
"This hook is run when inf-ruby is loaded in.
|
||||
This is a good place to put keybindings.")
|
||||
|
||||
(run-hooks 'inf-ruby-load-hook)
|
||||
|
||||
(provide 'inf-ruby)
|
||||
|
||||
;;; inf-ruby.el ends here
|
||||
724
misc/ruby-mode.el
Normal file
724
misc/ruby-mode.el
Normal file
|
|
@ -0,0 +1,724 @@
|
|||
;;;
|
||||
;;; ruby-mode.el -
|
||||
;;;
|
||||
;;; $Author$
|
||||
;;; $Date$
|
||||
;;; created at: Fri Feb 4 14:49:13 JST 1994
|
||||
;;;
|
||||
|
||||
(defconst ruby-mode-revision "$Revision$")
|
||||
|
||||
(defconst ruby-mode-version
|
||||
(progn
|
||||
(string-match "[0-9.]+" ruby-mode-revision)
|
||||
(substring ruby-mode-revision (match-beginning 0) (match-end 0))))
|
||||
|
||||
(defconst ruby-block-beg-re
|
||||
"class\\|module\\|def\\|if\\|unless\\|case\\|while\\|until\\|for\\|begin\\|do"
|
||||
)
|
||||
|
||||
(defconst ruby-indent-beg-re
|
||||
"\\(\\s *\\(class\\|module\\|def\\)\\)\\|if\\|unless\\|case\\|while\\|until\\|for\\|begin"
|
||||
)
|
||||
|
||||
(defconst ruby-modifier-re
|
||||
"if\\|unless\\|while\\|until"
|
||||
)
|
||||
|
||||
(defconst ruby-block-mid-re
|
||||
"then\\|else\\|elsif\\|when\\|rescue\\|ensure"
|
||||
)
|
||||
|
||||
(defconst ruby-block-op-re
|
||||
"and\\|or\\|not"
|
||||
)
|
||||
|
||||
(defconst ruby-block-end-re "end")
|
||||
|
||||
(defconst ruby-delimiter
|
||||
(concat "[?$/%(){}#\"'`.:]\\|\\[\\|\\]\\|\\<\\("
|
||||
ruby-block-beg-re
|
||||
"\\|" ruby-block-end-re
|
||||
"\\)\\>\\|^=begin")
|
||||
)
|
||||
|
||||
(defconst ruby-negative
|
||||
(concat "^[ \t]*\\(\\(" ruby-block-mid-re "\\)\\>\\|\\("
|
||||
ruby-block-end-re "\\)\\>\\|\\}\\|\\]\\)")
|
||||
)
|
||||
|
||||
(defconst ruby-operator-chars ",.+*/%-&|^~=<>:")
|
||||
(defconst ruby-operator-re (concat "[" ruby-operator-chars "]"))
|
||||
|
||||
(defconst ruby-symbol-chars "a-zA-Z0-9_")
|
||||
(defconst ruby-symbol-re (concat "[" ruby-symbol-chars "]"))
|
||||
|
||||
(defvar ruby-mode-abbrev-table nil
|
||||
"Abbrev table in use in ruby-mode buffers.")
|
||||
|
||||
(define-abbrev-table 'ruby-mode-abbrev-table ())
|
||||
|
||||
(defvar ruby-mode-map nil "Keymap used in ruby mode.")
|
||||
|
||||
(if ruby-mode-map
|
||||
nil
|
||||
(setq ruby-mode-map (make-sparse-keymap))
|
||||
(define-key ruby-mode-map "{" 'ruby-electric-brace)
|
||||
(define-key ruby-mode-map "}" 'ruby-electric-brace)
|
||||
(define-key ruby-mode-map "\e\C-a" 'ruby-beginning-of-defun)
|
||||
(define-key ruby-mode-map "\e\C-e" 'ruby-end-of-defun)
|
||||
(define-key ruby-mode-map "\e\C-b" 'ruby-beginning-of-block)
|
||||
(define-key ruby-mode-map "\e\C-f" 'ruby-end-of-block)
|
||||
(define-key ruby-mode-map "\e\C-p" 'ruby-beginning-of-block)
|
||||
(define-key ruby-mode-map "\e\C-n" 'ruby-end-of-block)
|
||||
(define-key ruby-mode-map "\e\C-h" 'ruby-mark-defun)
|
||||
(define-key ruby-mode-map "\t" 'ruby-indent-command)
|
||||
(define-key ruby-mode-map "\C-c\C-e" 'ruby-insert-end)
|
||||
(define-key ruby-mode-map "\C-j" 'ruby-reindent-then-newline-and-indent)
|
||||
(define-key ruby-mode-map "\C-m" 'newline))
|
||||
|
||||
(defvar ruby-mode-syntax-table nil
|
||||
"Syntax table in use in ruby-mode buffers.")
|
||||
|
||||
(if ruby-mode-syntax-table
|
||||
()
|
||||
(setq ruby-mode-syntax-table (make-syntax-table))
|
||||
(modify-syntax-entry ?\' "\"" ruby-mode-syntax-table)
|
||||
(modify-syntax-entry ?\" "\"" ruby-mode-syntax-table)
|
||||
(modify-syntax-entry ?\` "\"" ruby-mode-syntax-table)
|
||||
(modify-syntax-entry ?# "<" ruby-mode-syntax-table)
|
||||
(modify-syntax-entry ?\n ">" ruby-mode-syntax-table)
|
||||
(modify-syntax-entry ?\\ "\\" ruby-mode-syntax-table)
|
||||
(modify-syntax-entry ?$ "." ruby-mode-syntax-table)
|
||||
(modify-syntax-entry ?? "_" ruby-mode-syntax-table)
|
||||
(modify-syntax-entry ?_ "_" ruby-mode-syntax-table)
|
||||
(modify-syntax-entry ?< "." ruby-mode-syntax-table)
|
||||
(modify-syntax-entry ?> "." ruby-mode-syntax-table)
|
||||
(modify-syntax-entry ?& "." ruby-mode-syntax-table)
|
||||
(modify-syntax-entry ?| "." ruby-mode-syntax-table)
|
||||
(modify-syntax-entry ?% "." ruby-mode-syntax-table)
|
||||
(modify-syntax-entry ?= "." ruby-mode-syntax-table)
|
||||
(modify-syntax-entry ?/ "." ruby-mode-syntax-table)
|
||||
(modify-syntax-entry ?+ "." ruby-mode-syntax-table)
|
||||
(modify-syntax-entry ?* "." ruby-mode-syntax-table)
|
||||
(modify-syntax-entry ?- "." ruby-mode-syntax-table)
|
||||
(modify-syntax-entry ?\; "." ruby-mode-syntax-table)
|
||||
(modify-syntax-entry ?\( "()" ruby-mode-syntax-table)
|
||||
(modify-syntax-entry ?\) ")(" ruby-mode-syntax-table)
|
||||
(modify-syntax-entry ?\{ "(}" ruby-mode-syntax-table)
|
||||
(modify-syntax-entry ?\} "){" ruby-mode-syntax-table)
|
||||
(modify-syntax-entry ?\[ "(]" ruby-mode-syntax-table)
|
||||
(modify-syntax-entry ?\] ")[" ruby-mode-syntax-table)
|
||||
)
|
||||
|
||||
(defvar ruby-indent-level 2
|
||||
"*Indentation of ruby statements.")
|
||||
|
||||
(defun ruby-mode-variables ()
|
||||
(set-syntax-table ruby-mode-syntax-table)
|
||||
(setq local-abbrev-table ruby-mode-abbrev-table)
|
||||
(make-local-variable 'indent-line-function)
|
||||
(setq indent-line-function 'ruby-indent-line)
|
||||
(make-local-variable 'require-final-newline)
|
||||
(setq require-final-newline t)
|
||||
(make-variable-buffer-local 'comment-start)
|
||||
(setq comment-start "# ")
|
||||
(make-variable-buffer-local 'comment-end)
|
||||
(setq comment-end "")
|
||||
(make-variable-buffer-local 'comment-column)
|
||||
(setq comment-column 32)
|
||||
(make-variable-buffer-local 'comment-start-skip)
|
||||
(setq comment-start-skip "\\(^\\|\\s-\\);?#+ *")
|
||||
(make-local-variable 'parse-sexp-ignore-comments)
|
||||
(setq parse-sexp-ignore-comments t)
|
||||
(make-local-variable 'paragraph-start)
|
||||
(setq paragraph-start (concat "$\\|" page-delimiter))
|
||||
(make-local-variable 'paragraph-separate)
|
||||
(setq paragraph-separate paragraph-start)
|
||||
(make-local-variable 'paragraph-ignore-fill-prefix)
|
||||
(setq paragraph-ignore-fill-prefix t))
|
||||
|
||||
(defun ruby-mode ()
|
||||
"Major mode for editing ruby scripts.
|
||||
\\[ruby-indent-command] properly indents subexpressions of multi-line
|
||||
class, module, def, if, while, for, do, and case statements, taking
|
||||
nesting into account.
|
||||
|
||||
The variable ruby-indent-level controls the amount of indentation.
|
||||
\\{ruby-mode-map}"
|
||||
(interactive)
|
||||
(kill-all-local-variables)
|
||||
(use-local-map ruby-mode-map)
|
||||
(setq mode-name "Ruby")
|
||||
(setq major-mode 'ruby-mode)
|
||||
(ruby-mode-variables)
|
||||
|
||||
(run-hooks 'ruby-mode-hook))
|
||||
|
||||
(defun ruby-current-indentation ()
|
||||
(save-excursion
|
||||
(beginning-of-line)
|
||||
(back-to-indentation)
|
||||
(current-column)))
|
||||
|
||||
(defun ruby-indent-line (&optional flag)
|
||||
"Correct indentation of the current ruby line."
|
||||
(ruby-indent-to (ruby-calculate-indent)))
|
||||
|
||||
(defun ruby-indent-command ()
|
||||
(interactive)
|
||||
(ruby-indent-line t))
|
||||
|
||||
(defun ruby-indent-to (x)
|
||||
(if x
|
||||
(let (shift top beg)
|
||||
(and (< x 0)
|
||||
(error "invalid nest"))
|
||||
(setq shift (current-column))
|
||||
(beginning-of-line)
|
||||
(setq beg (point))
|
||||
(back-to-indentation)
|
||||
(setq top (current-column))
|
||||
(skip-chars-backward " \t")
|
||||
(cond
|
||||
((>= x shift)
|
||||
(setq shift 0))
|
||||
((>= shift top)
|
||||
(setq shift (- shift top)))
|
||||
(t (setq shift 0)))
|
||||
(if (and (bolp)
|
||||
(= x top))
|
||||
(move-to-column (+ x shift))
|
||||
(move-to-column top)
|
||||
(delete-region beg (point))
|
||||
(beginning-of-line)
|
||||
(indent-to x)
|
||||
(move-to-column (+ x shift))))))
|
||||
|
||||
(defun ruby-expr-beg (&optional modifier)
|
||||
(save-excursion
|
||||
(if (looking-at "\\?")
|
||||
(progn
|
||||
(or (bolp) (forward-char -1))
|
||||
(not (looking-at "\\sw")))
|
||||
(store-match-data nil)
|
||||
(skip-chars-backward " \t")
|
||||
(or (bolp) (forward-char -1))
|
||||
(or (bolp)
|
||||
(looking-at ruby-operator-re)
|
||||
(looking-at "[\\[({]")
|
||||
(and (not modifier) (looking-at "[!?]"))
|
||||
(and (looking-at ruby-symbol-re)
|
||||
(forward-word -1)
|
||||
(if (and (not modifier) (bolp))
|
||||
t
|
||||
(if (or (looking-at ruby-block-beg-re)
|
||||
(looking-at ruby-block-op-re)
|
||||
(looking-at ruby-block-mid-re))
|
||||
(progn
|
||||
(goto-char (match-end 0))
|
||||
(looking-at "\\>"))
|
||||
(looking-at "[a-zA-Z][a-zA-z0-9_]* +/[^ \t]"))))))))
|
||||
|
||||
(defun ruby-parse-region (start end)
|
||||
(let ((indent-point end)
|
||||
(indent 0)
|
||||
(in-string nil)
|
||||
(in-paren nil)
|
||||
(depth 0)
|
||||
(nest nil)
|
||||
(pcol nil))
|
||||
(save-excursion
|
||||
(if start
|
||||
(goto-char start)
|
||||
(ruby-beginning-of-indent))
|
||||
(save-restriction
|
||||
(narrow-to-region (point) end)
|
||||
(while (and (> indent-point (point))
|
||||
(re-search-forward ruby-delimiter indent-point t))
|
||||
(or depth (setq depth 0))
|
||||
(let ((pnt (point)) w)
|
||||
(goto-char (match-beginning 0))
|
||||
(cond
|
||||
((or (looking-at "\"") ;skip string
|
||||
(looking-at "'")
|
||||
(looking-at "`"))
|
||||
(setq w (char-after (point)))
|
||||
(cond
|
||||
((and (not (eobp))
|
||||
(re-search-forward (format "[^\\]\\(\\\\\\\\\\)*%c" w) indent-point t))
|
||||
nil)
|
||||
(t
|
||||
(setq in-string (point))
|
||||
(goto-char indent-point))))
|
||||
((looking-at "/")
|
||||
(cond
|
||||
((and (not (eobp)) (ruby-expr-beg))
|
||||
(if (re-search-forward "[^\\]/" indent-point t)
|
||||
nil
|
||||
(setq in-string (point))
|
||||
(goto-char indent-point)))
|
||||
(t
|
||||
(goto-char pnt))))
|
||||
((looking-at "%")
|
||||
(cond
|
||||
((and (not (eobp)) (ruby-expr-beg)
|
||||
(not (looking-at "%="))
|
||||
(looking-at "%[Qqrxw]?\\(.\\)"))
|
||||
(setq w (buffer-substring (match-beginning 1)
|
||||
(match-end 1)))
|
||||
(cond
|
||||
((string= w "[") (setq w "]"))
|
||||
((string= w "{") (setq w "}"))
|
||||
((string= w "(") (setq w ")"))
|
||||
((string= w "<") (setq w ">")))
|
||||
(goto-char (match-end 0))
|
||||
(if (search-forward w indent-point t)
|
||||
nil
|
||||
(setq in-string (point))
|
||||
(goto-char indent-point)))
|
||||
(t
|
||||
(goto-char pnt))))
|
||||
((looking-at "\\?") ;skip ?char
|
||||
(cond
|
||||
((ruby-expr-beg)
|
||||
(looking-at "?\\(\\\\C-\\|\\\\M-\\)*.")
|
||||
(goto-char (match-end 0)))
|
||||
(t
|
||||
(goto-char pnt))))
|
||||
((looking-at "\\$") ;skip $char
|
||||
(goto-char pnt)
|
||||
(forward-char 1))
|
||||
((looking-at "#") ;skip comment
|
||||
(forward-line 1)
|
||||
(goto-char (point))
|
||||
)
|
||||
((looking-at "(")
|
||||
(setq nest (cons (cons (char-after (point)) pnt) nest))
|
||||
(setq pcol (cons (cons pnt depth) pcol))
|
||||
(setq depth 0)
|
||||
(goto-char pnt)
|
||||
)
|
||||
((looking-at "[\\[{]")
|
||||
(setq nest (cons (cons (char-after (point)) pnt) nest))
|
||||
(setq depth (1+ depth))
|
||||
(goto-char pnt)
|
||||
)
|
||||
((looking-at ")")
|
||||
(setq nest (cdr nest))
|
||||
(setq depth (cdr (car pcol)))
|
||||
(setq pcol (cdr pcol))
|
||||
(goto-char pnt))
|
||||
((looking-at "[])}]")
|
||||
(setq nest (cdr nest))
|
||||
(setq depth (1- depth))
|
||||
(goto-char pnt))
|
||||
((looking-at ruby-block-end-re)
|
||||
(if (or (and (not (bolp))
|
||||
(progn
|
||||
(forward-char -1)
|
||||
(eq ?_ (char-after (point)))))
|
||||
(progn
|
||||
(goto-char pnt)
|
||||
(setq w (char-after (point)))
|
||||
(or (eq ?_ w)
|
||||
(eq ?! w)
|
||||
(eq ?? w))))
|
||||
nil
|
||||
(setq nest (cdr nest))
|
||||
(setq depth (1- depth)))
|
||||
(goto-char pnt))
|
||||
((looking-at "def\\s +[^(\n;]*")
|
||||
(if (or (bolp)
|
||||
(progn
|
||||
(forward-char -1)
|
||||
(not (eq ?_ (char-after (point))))))
|
||||
(progn
|
||||
(setq nest (cons (cons nil pnt) nest))
|
||||
(setq depth (1+ depth))))
|
||||
(goto-char (match-end 0)))
|
||||
((looking-at ruby-block-beg-re)
|
||||
(and
|
||||
(or (bolp)
|
||||
(progn
|
||||
(forward-char -1)
|
||||
(not (eq ?_ (char-after (point))))))
|
||||
(goto-char pnt)
|
||||
(setq w (char-after (point)))
|
||||
(not (eq ?_ w))
|
||||
(not (eq ?! w))
|
||||
(not (eq ?? w))
|
||||
(skip-chars-forward " \t")
|
||||
(if (not (eolp))
|
||||
(progn
|
||||
(goto-char (match-beginning 0))
|
||||
(if (looking-at ruby-modifier-re)
|
||||
(ruby-expr-beg t)
|
||||
t))
|
||||
t)
|
||||
(goto-char pnt)
|
||||
(setq nest (cons (cons nil pnt) nest))
|
||||
(setq depth (1+ depth)))
|
||||
(goto-char pnt))
|
||||
((looking-at ":\\([a-zA-Z_][a-zA-Z_0-9]*\\)?")
|
||||
(goto-char (match-end 0)))
|
||||
((or (looking-at "\\.")
|
||||
(looking-at "\\.\\.\\.?")
|
||||
(looking-at "\\.[0-9]+")
|
||||
(looking-at "\\.[a-zA-Z_0-9]+"))
|
||||
(goto-char (match-end 0)))
|
||||
((looking-at "^=begin")
|
||||
(if (re-search-forward "^=end" indent-point t)
|
||||
(forward-line 1)
|
||||
(setq in-string (match-end 0))
|
||||
(goto-char indent-point)))
|
||||
(t
|
||||
(error (format "bad string %s"
|
||||
(buffer-substring (point) pnt)
|
||||
)))))))
|
||||
(list in-string (car nest) depth (car (car pcol))))))
|
||||
|
||||
(defun ruby-indent-size (pos nest)
|
||||
(+ pos (* (if nest nest 1) ruby-indent-level)))
|
||||
|
||||
(defun ruby-calculate-indent (&optional parse-start)
|
||||
(save-excursion
|
||||
(beginning-of-line)
|
||||
(let ((indent-point (point))
|
||||
(case-fold-search nil)
|
||||
state bol eol
|
||||
(indent 0))
|
||||
(if parse-start
|
||||
(goto-char parse-start)
|
||||
(ruby-beginning-of-indent)
|
||||
(setq parse-start (point)))
|
||||
(back-to-indentation)
|
||||
(setq indent (current-column))
|
||||
(setq state (ruby-parse-region parse-start indent-point))
|
||||
(cond
|
||||
((nth 0 state) ; within string
|
||||
(setq indent nil)) ; do nothing
|
||||
|
||||
((car (nth 1 state)) ; in paren
|
||||
(goto-char (cdr (nth 1 state)))
|
||||
(if (eq (car (nth 1 state)) ?\( )
|
||||
(let ((column (current-column))
|
||||
(s (ruby-parse-region (point) indent-point)))
|
||||
(cond
|
||||
((and (nth 2 s) (> (nth 2 s) 0))
|
||||
(goto-char (cdr (nth 1 s)))
|
||||
(forward-word -1)
|
||||
(setq indent (ruby-indent-size (current-column) (nth 2 state))))
|
||||
(t
|
||||
(setq indent (current-column)))))
|
||||
(cond
|
||||
((nth 3 state)
|
||||
(goto-char (nth 3 state))
|
||||
(setq indent (ruby-indent-size (current-column) (nth 2 state))))
|
||||
(t
|
||||
(goto-char parse-start)
|
||||
(back-to-indentation)
|
||||
(setq indent (ruby-indent-size (current-column) (nth 2 state)))))
|
||||
))
|
||||
|
||||
((and (nth 2 state)(> (nth 2 state) 0)) ; in nest
|
||||
(if (null (cdr (nth 1 state)))
|
||||
(error "invalid nest"))
|
||||
(goto-char (cdr (nth 1 state)))
|
||||
(forward-word -1) ; skip back a keyword
|
||||
(cond
|
||||
((looking-at "do") ; iter block is a special case
|
||||
(cond
|
||||
((nth 3 state)
|
||||
(goto-char (nth 3 state))
|
||||
(setq indent (ruby-indent-size (current-column) (nth 2 state))))
|
||||
(t
|
||||
(goto-char parse-start)
|
||||
(back-to-indentation)
|
||||
(setq indent (ruby-indent-size (current-column) (nth 2 state))))))
|
||||
(t
|
||||
(setq indent (+ (current-column) ruby-indent-level)))))
|
||||
|
||||
((and (nth 2 state) (< (nth 2 state) 0)) ; in negative nest
|
||||
(setq indent (ruby-indent-size (current-column) (nth 2 state)))))
|
||||
|
||||
(cond
|
||||
(indent
|
||||
(goto-char indent-point)
|
||||
(end-of-line)
|
||||
(setq eol (point))
|
||||
(beginning-of-line)
|
||||
(cond
|
||||
((re-search-forward ruby-negative eol t)
|
||||
(and (not (eq ?_ (char-after (match-end 0))))
|
||||
(setq indent (- indent ruby-indent-level))))
|
||||
;;operator terminated lines
|
||||
((and
|
||||
(save-excursion
|
||||
(beginning-of-line)
|
||||
(not (bobp)))
|
||||
(or (null (car (nth 1 state))) ;not in parens
|
||||
(and (eq (car (nth 1 state)) ?\{)
|
||||
(save-excursion ;except non-block braces
|
||||
(goto-char (cdr (nth 1 state)))
|
||||
(or (bobp) (forward-char -1))
|
||||
(not (ruby-expr-beg))))))
|
||||
;; goto beginning of non-empty no-comment line
|
||||
(let (end done)
|
||||
(while (not done)
|
||||
(skip-chars-backward " \t\n")
|
||||
(setq end (point))
|
||||
(beginning-of-line)
|
||||
(if (re-search-forward "^\\s *#" end t)
|
||||
(beginning-of-line)
|
||||
(setq done t))))
|
||||
(setq bol (point))
|
||||
(end-of-line)
|
||||
(skip-chars-backward " \t")
|
||||
(and (re-search-backward "#" (save-excursion
|
||||
(beginning-of-line)
|
||||
(point)) t)
|
||||
(setq state (ruby-parse-region parse-start (point)))
|
||||
(nth 0 state)
|
||||
(goto-char (nth 0 state)))
|
||||
(or (bobp) (forward-char -1))
|
||||
(and
|
||||
(or (and (looking-at ruby-symbol-re)
|
||||
(skip-chars-backward ruby-symbol-chars)
|
||||
(looking-at ruby-block-op-re)
|
||||
(save-excursion
|
||||
(goto-char (match-end 0))
|
||||
(not (looking-at "[a-z_]"))))
|
||||
(and (looking-at ruby-operator-re)
|
||||
(or (not (eq ?/ (char-after (point))))
|
||||
(null (nth 0 (ruby-parse-region parse-start (point)))))
|
||||
(not (eq (char-after (1- (point))) ?$))
|
||||
(or (not (eq ?| (char-after (point))))
|
||||
(save-excursion
|
||||
(or (eolp) (forward-char -1))
|
||||
(and (search-backward "|")
|
||||
(skip-chars-backward " \t\n")
|
||||
(and (not (eolp))
|
||||
(progn
|
||||
(forward-char -1)
|
||||
(not (looking-at "\\{")))
|
||||
(progn
|
||||
(forward-word -1)
|
||||
(not (looking-at "do\\>[^_]")))))))))
|
||||
(setq indent (+ indent ruby-indent-level)))))))
|
||||
indent)))
|
||||
|
||||
(defun ruby-electric-brace (arg)
|
||||
(interactive "P")
|
||||
(self-insert-command (prefix-numeric-value arg))
|
||||
(ruby-indent-line t))
|
||||
|
||||
(defun ruby-beginning-of-defun (&optional arg)
|
||||
"Move backward to next beginning-of-defun.
|
||||
With argument, do this that many times.
|
||||
Returns t unless search stops due to end of buffer."
|
||||
(interactive "p")
|
||||
(and (re-search-backward (concat "^\\(" ruby-block-beg-re "\\)\\b")
|
||||
nil 'move (or arg 1))
|
||||
(progn (beginning-of-line) t)))
|
||||
|
||||
(defun ruby-beginning-of-indent ()
|
||||
(and (re-search-backward (concat "^\\(" ruby-indent-beg-re "\\)\\b")
|
||||
nil 'move)
|
||||
(progn
|
||||
(beginning-of-line)
|
||||
t)))
|
||||
|
||||
(defun ruby-end-of-defun (&optional arg)
|
||||
"Move forward to next end of defun.
|
||||
An end of a defun is found by moving forward from the beginning of one."
|
||||
(interactive "p")
|
||||
(and (re-search-forward (concat "^\\(" ruby-block-end-re "\\)\\($\\|\\b[^_]\\)")
|
||||
nil 'move (or arg 1))
|
||||
(progn (beginning-of-line) t))
|
||||
(forward-line 1))
|
||||
|
||||
(defun ruby-move-to-block (n)
|
||||
(let (start pos done down)
|
||||
(setq start (ruby-calculate-indent))
|
||||
(if (eobp)
|
||||
nil
|
||||
(while (and (not (bobp)) (not done))
|
||||
(forward-line n)
|
||||
(cond
|
||||
((looking-at "^$"))
|
||||
((looking-at "^\\s *#"))
|
||||
(t
|
||||
(setq pos (current-indentation))
|
||||
(cond
|
||||
((< start pos)
|
||||
(setq down t))
|
||||
((and down (= pos start))
|
||||
(setq done t))
|
||||
((> start pos)
|
||||
(setq done t)))))
|
||||
(if done
|
||||
(progn
|
||||
(back-to-indentation)
|
||||
(if (looking-at ruby-block-mid-re)
|
||||
(setq done nil)))))))
|
||||
(back-to-indentation))
|
||||
|
||||
(defun ruby-beginning-of-block ()
|
||||
"Move backward to next beginning-of-block"
|
||||
(interactive)
|
||||
(ruby-move-to-block -1))
|
||||
|
||||
(defun ruby-end-of-block ()
|
||||
"Move forward to next beginning-of-block"
|
||||
(interactive)
|
||||
(ruby-move-to-block 1))
|
||||
|
||||
(defun ruby-reindent-then-newline-and-indent ()
|
||||
(interactive "*")
|
||||
(save-excursion
|
||||
(delete-region (point) (progn (skip-chars-backward " \t") (point))))
|
||||
(newline)
|
||||
(save-excursion
|
||||
(forward-line -1)
|
||||
(indent-according-to-mode))
|
||||
(indent-according-to-mode))
|
||||
|
||||
(fset 'ruby-encomment-region (symbol-function 'comment-region))
|
||||
|
||||
(defun ruby-decomment-region (beg end)
|
||||
(interactive "r")
|
||||
(save-excursion
|
||||
(goto-char beg)
|
||||
(while (re-search-forward "^\\([ \t]*\\)#" end t)
|
||||
(replace-match "\\1" nil nil)
|
||||
(save-excursion
|
||||
(ruby-indent-line)))))
|
||||
|
||||
(defun ruby-insert-end ()
|
||||
(interactive)
|
||||
(insert "end")
|
||||
(ruby-indent-line t)
|
||||
(end-of-line))
|
||||
|
||||
(defun ruby-mark-defun ()
|
||||
"Put mark at end of this Ruby function, point at beginning."
|
||||
(interactive)
|
||||
(push-mark (point))
|
||||
(ruby-end-of-defun)
|
||||
(push-mark (point) nil t)
|
||||
(ruby-beginning-of-defun)
|
||||
(re-search-backward "^\n" (- (point) 1) t))
|
||||
|
||||
(cond
|
||||
((featurep 'font-lock)
|
||||
(or (boundp 'font-lock-variable-name-face)
|
||||
(setq font-lock-variable-name-face font-lock-type-face))
|
||||
|
||||
(add-hook 'ruby-mode-hook
|
||||
'(lambda ()
|
||||
(make-local-variable 'font-lock-syntactic-keywords)
|
||||
(setq font-lock-syntactic-keywords
|
||||
'(("\\$\\([#\"'`$\\]\\)" 1 (1 . nil))
|
||||
("\\(#\\)[{$@]" 1 (1 . nil))))
|
||||
(make-local-variable 'font-lock-defaults)
|
||||
(setq font-lock-defaults '((ruby-font-lock-keywords) nil nil))
|
||||
(setq font-lock-keywords ruby-font-lock-keywords)))
|
||||
|
||||
(defun ruby-font-lock-docs (limit)
|
||||
(if (re-search-forward "^=begin\\s *$" limit t)
|
||||
(let (beg)
|
||||
(beginning-of-line)
|
||||
(setq beg (point))
|
||||
(forward-line 1)
|
||||
(if (re-search-forward "^=end\\s *$" limit t)
|
||||
(progn
|
||||
(set-match-data (list beg (point)))
|
||||
t)))))
|
||||
|
||||
(defvar ruby-font-lock-keywords
|
||||
(list
|
||||
(cons (concat
|
||||
"\\(^\\|[^_:.@$]\\|\\.\\.\\)\\b\\("
|
||||
(mapconcat
|
||||
'identity
|
||||
'("alias"
|
||||
"and"
|
||||
"begin"
|
||||
"break"
|
||||
"case"
|
||||
"catch"
|
||||
"class"
|
||||
"def"
|
||||
"do"
|
||||
"elsif"
|
||||
"else"
|
||||
"fail"
|
||||
"ensure"
|
||||
"for"
|
||||
"end"
|
||||
"if"
|
||||
"in"
|
||||
"module"
|
||||
"next"
|
||||
"not"
|
||||
"or"
|
||||
"raise"
|
||||
"redo"
|
||||
"rescue"
|
||||
"retry"
|
||||
"return"
|
||||
"then"
|
||||
"throw"
|
||||
"self"
|
||||
"super"
|
||||
"unless"
|
||||
"undef"
|
||||
"until"
|
||||
"when"
|
||||
"while"
|
||||
)
|
||||
"\\|")
|
||||
"\\)\\>[^_]")
|
||||
2)
|
||||
;; variables
|
||||
'("\\b\\(nil\\|self\\|true\\|false\\)\\b"
|
||||
1 font-lock-variable-name-face)
|
||||
;; variables
|
||||
'("[$@].\\(\\w\\|_\\)*"
|
||||
0 font-lock-variable-name-face)
|
||||
;; embedded document
|
||||
'(ruby-font-lock-docs
|
||||
0 font-lock-comment-face t)
|
||||
;; constants
|
||||
'("\\(^\\|[^_]\\)\\b\\([A-Z]+\\(\\w\\|_\\)*\\)"
|
||||
2 font-lock-type-face)
|
||||
;; functions
|
||||
'("^\\s *def\\s *\\<\\(\\(\\w\\|_\\)+\\(\\.\\|::\\)\\)?\\(\\(\\w\\|_\\)+\\??\\)\\>"
|
||||
4 font-lock-function-name-face t)
|
||||
;; symbols
|
||||
'("\\(^\\|[^:]\\)\\(:\\(\\w\\|_\\)+\\??\\)\\b"
|
||||
2 font-lock-reference-face))
|
||||
"*Additional expressions to highlight in ruby mode."))
|
||||
|
||||
((featurep 'hilit19)
|
||||
(hilit-set-mode-patterns
|
||||
'ruby-mode
|
||||
'(("[^$\\?]\\(\"[^\\\"]*\\(\\\\\\(.\\|\n\\)[^\\\"]*\\)*\"\\)" 1 string)
|
||||
("[^$\\?]\\('[^\\']*\\(\\\\\\(.\\|\n\\)[^\\']*\\)*'\\)" 1 string)
|
||||
("[^$\\?]\\(`[^\\`]*\\(\\\\\\(.\\|\n\\)[^\\`]*\\)*`\\)" 1 string)
|
||||
("^\\s *#.*$" nil comment)
|
||||
("[^$@?\\]\\(#[^$@{\n].*$\\)" 1 comment)
|
||||
("[^a-zA-Z_]\\(\\?\\(\\\\[CM]-\\)*.\\)" 1 string)
|
||||
("^\\s *\\(require\\|load\\).*$" nil include)
|
||||
("^\\s *\\(include\\|alias\\|undef\\).*$" nil decl)
|
||||
("^\\s *\\<\\(class\\|def\\|module\\)\\>" "[)\n;]" defun)
|
||||
("[^_]\\<\\(begin\\|case\\|else\\|elsif\\|end\\|ensure\\|for\\|if\\|unless\\|rescue\\|then\\|when\\|while\\|until\\|do\\)\\>[^_]" 1 defun)
|
||||
("[^_]\\<\\(and\\|break\\|next\\|raise\\|fail\\|in\\|not\\|or\\|redo\\|retry\\|return\\|super\\|yield\\|catch\\|throw\\|self\\|nil\\)\\>[^_]" 1 keyword)
|
||||
("\\$\\(.\\|\\sw+\\)" nil type)
|
||||
("[$@].[a-zA-Z_0-9]*" nil struct)
|
||||
("^__END__" nil label))))
|
||||
)
|
||||
|
||||
|
||||
(provide 'ruby-mode)
|
||||
104
misc/rubydb2x.el
Normal file
104
misc/rubydb2x.el
Normal file
|
|
@ -0,0 +1,104 @@
|
|||
(require 'gud)
|
||||
(provide 'rubydb)
|
||||
|
||||
;; ======================================================================
|
||||
;; rubydb functions
|
||||
|
||||
;;; History of argument lists passed to rubydb.
|
||||
(defvar gud-rubydb-history nil)
|
||||
|
||||
(defun gud-rubydb-massage-args (file args)
|
||||
(cons "-I" (cons "." (cons "-r" (cons "debug" (cons file args))))))
|
||||
|
||||
;; There's no guarantee that Emacs will hand the filter the entire
|
||||
;; marker at once; it could be broken up across several strings. We
|
||||
;; might even receive a big chunk with several markers in it. If we
|
||||
;; receive a chunk of text which looks like it might contain the
|
||||
;; beginning of a marker, we save it here between calls to the
|
||||
;; filter.
|
||||
(defvar gud-rubydb-marker-acc "")
|
||||
|
||||
(defun gud-rubydb-marker-filter (string)
|
||||
(save-match-data
|
||||
(setq gud-marker-acc (concat gud-marker-acc string))
|
||||
(let ((output ""))
|
||||
|
||||
;; Process all the complete markers in this chunk.
|
||||
(while (string-match "\032\032\\([^:\n]*\\):\\([0-9]*\\):.*\n"
|
||||
gud-marker-acc)
|
||||
(setq
|
||||
|
||||
;; Extract the frame position from the marker.
|
||||
gud-last-frame
|
||||
(cons (substring gud-marker-acc (match-beginning 1) (match-end 1))
|
||||
(string-to-int (substring gud-marker-acc
|
||||
(match-beginning 2)
|
||||
(match-end 2))))
|
||||
|
||||
;; Append any text before the marker to the output we're going
|
||||
;; to return - we don't include the marker in this text.
|
||||
output (concat output
|
||||
(substring gud-marker-acc 0 (match-beginning 0)))
|
||||
|
||||
;; Set the accumulator to the remaining text.
|
||||
gud-marker-acc (substring gud-marker-acc (match-end 0))))
|
||||
|
||||
;; Does the remaining text look like it might end with the
|
||||
;; beginning of another marker? If it does, then keep it in
|
||||
;; gud-marker-acc until we receive the rest of it. Since we
|
||||
;; know the full marker regexp above failed, it's pretty simple to
|
||||
;; test for marker starts.
|
||||
(if (string-match "\032.*\\'" gud-marker-acc)
|
||||
(progn
|
||||
;; Everything before the potential marker start can be output.
|
||||
(setq output (concat output (substring gud-marker-acc
|
||||
0 (match-beginning 0))))
|
||||
|
||||
;; Everything after, we save, to combine with later input.
|
||||
(setq gud-marker-acc
|
||||
(substring gud-marker-acc (match-beginning 0))))
|
||||
|
||||
(setq output (concat output gud-marker-acc)
|
||||
gud-marker-acc ""))
|
||||
|
||||
output)))
|
||||
|
||||
(defun gud-rubydb-find-file (f)
|
||||
(find-file-noselect f))
|
||||
|
||||
(defvar rubydb-command-name "ruby"
|
||||
"File name for executing ruby.")
|
||||
|
||||
;;;###autoload
|
||||
(defun rubydb (command-line)
|
||||
"Run rubydb on program FILE in buffer *gud-FILE*.
|
||||
The directory containing FILE becomes the initial working directory
|
||||
and source-file directory for your debugger."
|
||||
(interactive
|
||||
(list (read-from-minibuffer "Run rubydb (like this): "
|
||||
(if (consp gud-rubydb-history)
|
||||
(car gud-rubydb-history)
|
||||
(concat rubydb-command-name " "))
|
||||
nil nil
|
||||
'(gud-rubydb-history . 1))))
|
||||
|
||||
(gud-overload-functions '((gud-massage-args . gud-rubydb-massage-args)
|
||||
(gud-marker-filter . gud-rubydb-marker-filter)
|
||||
(gud-find-file . gud-rubydb-find-file)
|
||||
))
|
||||
(gud-common-init command-line)
|
||||
|
||||
(gud-def gud-break "b %l" "\C-b" "Set breakpoint at current line.")
|
||||
; (gud-def gud-remove "clear %l" "\C-d" "Remove breakpoint at current line")
|
||||
(gud-def gud-step "s" "\C-s" "Step one source line with display.")
|
||||
(gud-def gud-next "n" "\C-n" "Step one line (skip functions).")
|
||||
(gud-def gud-cont "c" "\C-r" "Continue with display.")
|
||||
(gud-def gud-finish "finish" "\C-f" "Finish executing current function.")
|
||||
(gud-def gud-up "up %p" "<" "Up N stack frames (numeric arg).")
|
||||
(gud-def gud-down "down %p" ">" "Down N stack frames (numeric arg).")
|
||||
(gud-def gud-print "p %e" "\C-p" "Evaluate ruby expression at point.")
|
||||
|
||||
(setq comint-prompt-regexp "^(rdb:-) ")
|
||||
(setq paragraph-start comint-prompt-regexp)
|
||||
(run-hooks 'rubydb-mode-hook)
|
||||
)
|
||||
113
misc/rubydb3x.el
Normal file
113
misc/rubydb3x.el
Normal file
|
|
@ -0,0 +1,113 @@
|
|||
(require 'gud)
|
||||
(provide 'rubydb)
|
||||
|
||||
;; ======================================================================
|
||||
;; rubydb functions
|
||||
|
||||
;;; History of argument lists passed to rubydb.
|
||||
(defvar gud-rubydb-history nil)
|
||||
|
||||
(if (fboundp 'gud-overload-functions)
|
||||
(defun gud-rubydb-massage-args (file args)
|
||||
(cons "-r" (cons "debug" (cons file args))))
|
||||
(defun gud-rubydb-massage-args (file args)
|
||||
(cons "-r" (cons "debug" args))))
|
||||
|
||||
;; There's no guarantee that Emacs will hand the filter the entire
|
||||
;; marker at once; it could be broken up across several strings. We
|
||||
;; might even receive a big chunk with several markers in it. If we
|
||||
;; receive a chunk of text which looks like it might contain the
|
||||
;; beginning of a marker, we save it here between calls to the
|
||||
;; filter.
|
||||
(defvar gud-rubydb-marker-acc "")
|
||||
(make-variable-buffer-local 'gud-rubydb-marker-acc)
|
||||
|
||||
(defun gud-rubydb-marker-filter (string)
|
||||
(setq gud-rubydb-marker-acc (concat gud-rubydb-marker-acc string))
|
||||
(let ((output ""))
|
||||
|
||||
;; Process all the complete markers in this chunk.
|
||||
(while (string-match "\032\032\\([^:\n]*\\):\\([0-9]*\\):.*\n"
|
||||
gud-rubydb-marker-acc)
|
||||
(setq
|
||||
|
||||
;; Extract the frame position from the marker.
|
||||
gud-last-frame
|
||||
(cons (substring gud-rubydb-marker-acc (match-beginning 1) (match-end 1))
|
||||
(string-to-int (substring gud-rubydb-marker-acc
|
||||
(match-beginning 2)
|
||||
(match-end 2))))
|
||||
|
||||
;; Append any text before the marker to the output we're going
|
||||
;; to return - we don't include the marker in this text.
|
||||
output (concat output
|
||||
(substring gud-rubydb-marker-acc 0 (match-beginning 0)))
|
||||
|
||||
;; Set the accumulator to the remaining text.
|
||||
gud-rubydb-marker-acc (substring gud-rubydb-marker-acc (match-end 0))))
|
||||
|
||||
;; Does the remaining text look like it might end with the
|
||||
;; beginning of another marker? If it does, then keep it in
|
||||
;; gud-rubydb-marker-acc until we receive the rest of it. Since we
|
||||
;; know the full marker regexp above failed, it's pretty simple to
|
||||
;; test for marker starts.
|
||||
(if (string-match "\032.*\\'" gud-rubydb-marker-acc)
|
||||
(progn
|
||||
;; Everything before the potential marker start can be output.
|
||||
(setq output (concat output (substring gud-rubydb-marker-acc
|
||||
0 (match-beginning 0))))
|
||||
|
||||
;; Everything after, we save, to combine with later input.
|
||||
(setq gud-rubydb-marker-acc
|
||||
(substring gud-rubydb-marker-acc (match-beginning 0))))
|
||||
|
||||
(setq output (concat output gud-rubydb-marker-acc)
|
||||
gud-rubydb-marker-acc ""))
|
||||
|
||||
output))
|
||||
|
||||
(defun gud-rubydb-find-file (f)
|
||||
(save-excursion
|
||||
(let ((buf (find-file-noselect f)))
|
||||
(set-buffer buf)
|
||||
;; (gud-make-debug-menu)
|
||||
buf)))
|
||||
|
||||
(defvar rubydb-command-name "ruby"
|
||||
"File name for executing ruby.")
|
||||
|
||||
;;;###autoload
|
||||
(defun rubydb (command-line)
|
||||
"Run rubydb on program FILE in buffer *gud-FILE*.
|
||||
The directory containing FILE becomes the initial working directory
|
||||
and source-file directory for your debugger."
|
||||
(interactive
|
||||
(list (read-from-minibuffer "Run rubydb (like this): "
|
||||
(if (consp gud-rubydb-history)
|
||||
(car gud-rubydb-history)
|
||||
(concat rubydb-command-name " "))
|
||||
nil nil
|
||||
'(gud-rubydb-history . 1))))
|
||||
|
||||
(if (not (fboundp 'gud-overload-functions))
|
||||
(gud-common-init command-line 'gud-rubydb-massage-args
|
||||
'gud-rubydb-marker-filter 'gud-rubydb-find-file)
|
||||
(gud-overload-functions '((gud-massage-args . gud-rubydb-massage-args)
|
||||
(gud-marker-filter . gud-rubydb-marker-filter)
|
||||
(gud-find-file . gud-rubydb-find-file)))
|
||||
(gud-common-init command-line rubydb-command-name))
|
||||
|
||||
(gud-def gud-break "b %l" "\C-b" "Set breakpoint at current line.")
|
||||
; (gud-def gud-remove "clear %l" "\C-d" "Remove breakpoint at current line")
|
||||
(gud-def gud-step "s" "\C-s" "Step one source line with display.")
|
||||
(gud-def gud-next "n" "\C-n" "Step one line (skip functions).")
|
||||
(gud-def gud-cont "c" "\C-r" "Continue with display.")
|
||||
(gud-def gud-finish "finish" "\C-f" "Finish executing current function.")
|
||||
(gud-def gud-up "up %p" "<" "Up N stack frames (numeric arg).")
|
||||
(gud-def gud-down "down %p" ">" "Down N stack frames (numeric arg).")
|
||||
(gud-def gud-print "p %e" "\C-p" "Evaluate ruby expression at point.")
|
||||
|
||||
(setq comint-prompt-regexp "^(rdb:-) ")
|
||||
(set (make-local-variable 'paragraph-start) comint-prompt-regexp)
|
||||
(run-hooks 'rubydb-mode-hook)
|
||||
)
|
||||
Loading…
Add table
Add a link
Reference in a new issue