mirror of
https://github.com/ruby/ruby.git
synced 2022-11-09 12:17:21 -05:00
Removed old elisp files. New upstream repository was moved https://github.com/ruby/elisp.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@64741 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
hsbt
parent
5c16b21f44
commit
7eedd308b8
8 changed files with 0 additions and 1657 deletions
|
|
@ -1,12 +1,3 @@
|
|||
README this file
|
||||
inf-ruby.el program to run ruby under emacs
|
||||
rb_optparse.bash bash completion script
|
||||
rb_optparse.zsh zsh completion script
|
||||
rdoc-mode.el RDoc mode for emacs
|
||||
ruby-mode.el ruby mode for emacs
|
||||
ruby-style.el Ruby's C/C++ mode style for emacs
|
||||
rubydb2x.el ruby debugger support for emacs 19.2x or before
|
||||
rubydb3x.el ruby debugger support for emacs 19.3x or later
|
||||
ruby-electric.el emacs minor mode providing electric commands
|
||||
|
||||
Check out https://github.com/ruby-debug/ also.
|
||||
|
|
|
|||
418
misc/inf-ruby.el
418
misc/inf-ruby.el
|
|
@ -1,418 +0,0 @@
|
|||
;;; -*-Emacs-Lisp-*-
|
||||
;;;
|
||||
;;; $Id$
|
||||
;;; $Author$
|
||||
;;;
|
||||
;;; 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" t)
|
||||
;;; (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 load 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.7 2004/07/27 08:11:36 matz
|
||||
;;; * eval.c (rb_eval): copy on write for argument local variable
|
||||
;;; assignment.
|
||||
;;;
|
||||
;;; * eval.c (assign): ditto.
|
||||
;;;
|
||||
;;; * eval.c (rb_call0): update ruby_frame->argv with the default
|
||||
;;; value used for the optional arguments.
|
||||
;;;
|
||||
;;; * object.c (Init_Object): "===" calls rb_obj_equal() directly.
|
||||
;;; [ruby-list:39937]
|
||||
;;;
|
||||
;;; Revision 1.6 2002/09/07 14:35:46 nobu
|
||||
;;; * misc/inf-ruby.el (inferior-ruby-error-regexp-alist): regexp
|
||||
;;; alist for error message from ruby.
|
||||
;;;
|
||||
;;; * misc/inf-ruby.el (inferior-ruby-mode): fixed for Emacs.
|
||||
;;;
|
||||
;;; * misc/inf-ruby.el (ruby-send-region): compilation-parse-errors
|
||||
;;; doesn't parse first line, so insert separators before each
|
||||
;;; evaluations.
|
||||
;;;
|
||||
;;; Revision 1.5 2002/08/19 10:05:47 nobu
|
||||
;;; * misc/inf-ruby.el (inf-ruby-keys): ruby-send-definition
|
||||
;;; conflicted with ruby-insert-end.
|
||||
;;;
|
||||
;;; * misc/inf-ruby.el (inferior-ruby-mode): compilation-minor-mode.
|
||||
;;;
|
||||
;;; * misc/inf-ruby.el (ruby-send-region): send as here document to
|
||||
;;; adjust source file/line. [ruby-talk:47113], [ruby-dev:17965]
|
||||
;;;
|
||||
;;; * misc/inf-ruby.el (ruby-send-terminator): added to make unique
|
||||
;;; terminator.
|
||||
;;;
|
||||
;;; Revision 1.4 2002/01/29 07:16:09 matz
|
||||
;;; * file.c (rb_stat_rdev_major): added. [new]
|
||||
;;;
|
||||
;;; * file.c (rb_stat_rdev_minor): added. [new]
|
||||
;;;
|
||||
;;; * file.c (rb_stat_inspect): print mode in octal.
|
||||
;;;
|
||||
;;; Revision 1.3 1999/12/01 09:24:18 matz
|
||||
;;; 19991201
|
||||
;;;
|
||||
;;; 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 'compile)
|
||||
(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")
|
||||
|
||||
(defconst inferior-ruby-error-regexp-alist
|
||||
'(("SyntaxError: compile error\n^\\([^\(].*\\):\\([1-9][0-9]*\\):" 1 2)
|
||||
("^\tfrom \\([^\(].*\\):\\([1-9][0-9]*\\)\\(:in `.*'\\)?$" 1 2)))
|
||||
|
||||
(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)
|
||||
))
|
||||
|
||||
;;;###autoload
|
||||
(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-b" 'ruby-send-block)
|
||||
(define-key ruby-mode-map "\C-c\M-b" 'ruby-send-block-and-go)
|
||||
(define-key ruby-mode-map "\C-c\C-x" 'ruby-send-definition)
|
||||
(define-key ruby-mode-map "\C-c\M-x" '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))
|
||||
(make-local-variable 'compilation-error-regexp-alist)
|
||||
(setq compilation-error-regexp-alist inferior-ruby-error-regexp-alist)
|
||||
(compilation-shell-minor-mode t)
|
||||
(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)))))))))
|
||||
|
||||
;;;###autoload
|
||||
(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*"))
|
||||
|
||||
(defconst ruby-send-terminator "--inf-ruby-%x-%d-%d-%d--"
|
||||
"Template for irb here document terminator.
|
||||
Must not contain ruby meta characters.")
|
||||
|
||||
(defconst ruby-eval-separator "")
|
||||
|
||||
(defun ruby-send-region (start end)
|
||||
"Send the current region to the inferior Ruby process."
|
||||
(interactive "r")
|
||||
(let (term (file (buffer-file-name)) line)
|
||||
(save-excursion
|
||||
(save-restriction
|
||||
(widen)
|
||||
(goto-char start)
|
||||
(setq line (+ start (forward-line (- start)) 1))
|
||||
(goto-char start)
|
||||
(while (progn
|
||||
(setq term (apply 'format ruby-send-terminator (random) (current-time)))
|
||||
(re-search-forward (concat "^" (regexp-quote term) "$") end t)))))
|
||||
;; compilation-parse-errors parses from second line.
|
||||
(save-excursion
|
||||
(let ((m (process-mark (ruby-proc))))
|
||||
(set-buffer (marker-buffer m))
|
||||
(goto-char m)
|
||||
(insert ruby-eval-separator "\n")
|
||||
(set-marker m (point))))
|
||||
(comint-send-string (ruby-proc) (format "eval <<'%s', nil, %S, %d\n" term file line))
|
||||
(comint-send-region (ruby-proc) start end)
|
||||
(comint-send-string (ruby-proc) (concat "\n" term "\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 ruby-send-block ()
|
||||
"Send the current block to the inferior Ruby process."
|
||||
(interactive)
|
||||
(save-excursion
|
||||
(ruby-end-of-block)
|
||||
(end-of-line)
|
||||
(let ((end (point)))
|
||||
(ruby-beginning-of-block)
|
||||
(ruby-send-region (point) end))))
|
||||
|
||||
(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))
|
||||
|
||||
(defun ruby-send-block-and-go ()
|
||||
"Send the current block to the inferior Ruby.
|
||||
Then switch to the process buffer."
|
||||
(interactive)
|
||||
(ruby-send-block)
|
||||
(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
|
||||
|
|
@ -1,166 +0,0 @@
|
|||
;;
|
||||
;; rdoc-mode.el
|
||||
;; Major mode for RDoc editing
|
||||
;;
|
||||
|
||||
;; Created: Fri Sep 18 09:04:49 JST 2009
|
||||
|
||||
;; License: Ruby's
|
||||
|
||||
(require 'derived)
|
||||
|
||||
;;;###autoload
|
||||
(define-derived-mode rdoc-mode text-mode "RDoc"
|
||||
"Major mode for RD editing.
|
||||
\\{rdoc-mode-map}"
|
||||
(make-local-variable 'paragraph-separate)
|
||||
(setq paragraph-separate "^\\(=+\\|\\*+\\)[ \t\v\f]*\\|^\\s *$")
|
||||
(make-local-variable 'paragraph-start)
|
||||
(setq paragraph-start paragraph-separate)
|
||||
(make-local-variable 'require-final-newline)
|
||||
(setq require-final-newline t)
|
||||
(make-local-variable 'font-lock-defaults)
|
||||
(setq font-lock-defaults '((rdoc-font-lock-keywords) t nil))
|
||||
(make-local-variable 'font-lock-keywords)
|
||||
(setq font-lock-keywords rdoc-font-lock-keywords)
|
||||
(make-local-variable 'outline-regexp)
|
||||
(setq outline-regexp "^\\(=+\\)[ \t\v\f]*")
|
||||
(outline-minor-mode t)
|
||||
(setq show-trailing-whitespace t)
|
||||
(rdoc-setup-keys)
|
||||
(setq indent-tabs-mode nil)
|
||||
(run-hooks 'rdoc-mode-hook)
|
||||
)
|
||||
|
||||
(defun rdoc-fill-paragraph (&optional justify region)
|
||||
"Fills paragraph, except for cited region"
|
||||
(interactive (progn
|
||||
(barf-if-buffer-read-only)
|
||||
(list (if current-prefix-arg 'full))))
|
||||
(save-excursion
|
||||
(beginning-of-line)
|
||||
(save-restriction
|
||||
(let ((pos (point)) beg end indent hanging)
|
||||
(cond
|
||||
((looking-at "^ +\\(\\*\\s *\\)")
|
||||
(setq indent (- (match-end 0) (match-beginning 0))
|
||||
hanging (- (match-end 1) (match-beginning 1))))
|
||||
((looking-at "^ +")
|
||||
(setq indent (- (match-end 0) (match-beginning 0)))
|
||||
(when (and (re-search-backward "^[^ ]\\|^\\( *\\(\\* *\\)\\)" nil t)
|
||||
(match-beginning 1)
|
||||
(= indent (- (match-end 1) (match-beginning 1))))
|
||||
(setq hanging (- (match-end 2) (match-beginning 2)))
|
||||
(setq beg (match-beginning 1))))
|
||||
((setq beg t)))
|
||||
(when beg
|
||||
(when indent
|
||||
(goto-char pos)
|
||||
(while (progn (beginning-of-line 2)
|
||||
(and (looking-at "^\\( +\\)\\S ")
|
||||
(= indent (- (match-end 1) (match-beginning 1))))))
|
||||
(setq end (point))
|
||||
(when (and beg (not region))
|
||||
(setq region (list beg end))
|
||||
(narrow-to-region beg end)
|
||||
))
|
||||
(goto-char pos)
|
||||
(fill-paragraph justify region)
|
||||
(when (and indent
|
||||
(or (goto-char beg) t)
|
||||
(or (beginning-of-line 2) t)
|
||||
(looking-at "^\\( +\\)")
|
||||
(= (- indent hanging) (- (match-end 0) (match-beginning 0))))
|
||||
(insert-char ?\s hanging)
|
||||
(beginning-of-line)
|
||||
(narrow-to-region (point) end)
|
||||
(fill-paragraph justify (list (point) end))))))))
|
||||
|
||||
(defun rdoc-setup-keys ()
|
||||
(interactive)
|
||||
(define-key rdoc-mode-map "\M-q" 'rdoc-fill-paragraph)
|
||||
)
|
||||
|
||||
(defvar rdoc-heading1-face 'font-lock-keywordoc-face)
|
||||
(defvar rdoc-heading2-face 'font-lock-type-face)
|
||||
(defvar rdoc-heading3-face 'font-lock-variable-name-face)
|
||||
(defvar rdoc-heading4-face 'font-lock-comment-face)
|
||||
(defvar rdoc-bold-face 'font-lock-function-name-face)
|
||||
(defvar rdoc-emphasis-face 'font-lock-function-name-face)
|
||||
(defvar rdoc-code-face 'font-lock-keyword-face)
|
||||
(defvar rdoc-description-face 'font-lock-constant-face)
|
||||
|
||||
(defvar rdoc-font-lock-keywords
|
||||
(list
|
||||
(list "^=([^=\r\n].*)?$"
|
||||
0 rdoc-heading1-face)
|
||||
(list "^==([^=\r\n].*)?$"
|
||||
0 rdoc-heading2-face)
|
||||
(list "^===([^=\r\n].*)?$"
|
||||
0 rdoc-heading3-face)
|
||||
(list "^====+.*$"
|
||||
0 rdoc-heading4-face)
|
||||
(list "\\(^\\|[ \t\v\f]\\)\\(\\*\\(\\sw\\|[-_:]\\)+\\*\\)\\($\\|[ \t\v\f]\\)"
|
||||
2 rdoc-bold-face) ; *bold*
|
||||
(list "\\(^\\|[ \t\v\f]\\)\\(_\\(\\sw\\|[-_:]\\)+_\\)\\($\\|[ \t\v\f]\\)"
|
||||
2 rdoc-emphasis-face) ; _emphasis_
|
||||
(list "\\(^\\|[ \t\v\f]\\)\\(\\+\\(\\sw\\|[-_:]\\)+\\+\\)\\($\\|[ \t\v\f]\\)"
|
||||
2 rdoc-code-face) ; +code+
|
||||
(list "<em>[^<>]*</em>" 0 rdoc-emphasis-face)
|
||||
(list "<i>[^<>]*</i>" 0 rdoc-emphasis-face)
|
||||
(list "<b>[^<>]*</b>" 0 rdoc-bold-face)
|
||||
(list "<tt>[^<>]*</tt>" 0 rdoc-code-face)
|
||||
(list "<code>[^<>]*</code>" 0 rdoc-code-face)
|
||||
(list "^\\([-*]\\|[0-9]+\\.\\|[A-Za-z]\\.\\)\\s "
|
||||
1 rdoc-description-face) ; bullet | numbered | alphabetically numbered
|
||||
(list "^\\[[^\]]*\\]\\|\\S .*::\\)\\([ \t\v\f]\\|$\\)"
|
||||
1 rdoc-description-face) ; labeled | node
|
||||
;(list "^[ \t\v\f]+\\(.*\\)" 1 rdoc-verbatim-face)
|
||||
))
|
||||
|
||||
(defun rdoc-imenu-create-index ()
|
||||
(let ((root '(nil . nil))
|
||||
cur-alist
|
||||
(cur-level 0)
|
||||
(pattern (concat outline-regexp "\\(.*?\\)[ \t\v\f]*$"))
|
||||
(empty-heading "-")
|
||||
(self-heading ".")
|
||||
pos level heading alist)
|
||||
(save-excursion
|
||||
(goto-char (point-min))
|
||||
(while (re-search-forward pattern (point-max) t)
|
||||
(setq heading (match-string-no-properties 2)
|
||||
level (min 6 (length (match-string-no-properties 1)))
|
||||
pos (match-beginning 1))
|
||||
(if (= (length heading) 0)
|
||||
(setq heading empty-heading))
|
||||
(setq alist (list (cons heading pos)))
|
||||
(cond
|
||||
((= cur-level level) ; new sibling
|
||||
(setcdr cur-alist alist)
|
||||
(setq cur-alist alist))
|
||||
((< cur-level level) ; first child
|
||||
(dotimes (i (- level cur-level 1))
|
||||
(setq alist (list (cons empty-heading alist))))
|
||||
(if cur-alist
|
||||
(let* ((parent (car cur-alist))
|
||||
(self-pos (cdr parent)))
|
||||
(setcdr parent (cons (cons self-heading self-pos) alist)))
|
||||
(setcdr root alist)) ; primogenitor
|
||||
(setq cur-alist alist
|
||||
cur-level level))
|
||||
(t ; new sibling of an ancestor
|
||||
(let ((sibling-alist (last (cdr root))))
|
||||
(dotimes (i (1- level))
|
||||
(setq sibling-alist (last (cdar sibling-alist))))
|
||||
(setcdr sibling-alist alist)
|
||||
(setq cur-alist alist
|
||||
cur-level level))))))
|
||||
(cdr root)))
|
||||
|
||||
(defun rdoc-set-imenu-create-index-function ()
|
||||
(setq imenu-create-index-function 'rdoc-imenu-create-index))
|
||||
|
||||
(add-hook 'rdoc-mode-hook 'rdoc-set-imenu-create-index-function)
|
||||
|
||||
(provide 'rdoc-mode)
|
||||
|
|
@ -1,181 +0,0 @@
|
|||
;;; ruby-additional.el --- ruby-mode extensions yet to be merged into Emacs
|
||||
|
||||
;; Authors: Yukihiro Matsumoto, Nobuyoshi Nakada, Akinori MUSHA
|
||||
;; URL: https://svn.ruby-lang.org/cgi-bin/viewvc.cgi/trunk/misc/
|
||||
;; Created: 3 Sep 2012
|
||||
;; Package-Requires: ((emacs "24.3") (ruby-mode "1.2"))
|
||||
;; Keywords: ruby, languages
|
||||
|
||||
;;; Commentary:
|
||||
;;
|
||||
;; This package contains ruby-mode extensions yet to be merged into
|
||||
;; the latest released version of Emacs distribution. For older
|
||||
;; versions of Emacs, use ruby-mode.el bundled with CRuby.
|
||||
|
||||
;;; Code:
|
||||
|
||||
(eval-when-compile
|
||||
(require 'ruby-mode))
|
||||
|
||||
(eval-after-load 'ruby-mode
|
||||
'(progn
|
||||
(define-key ruby-mode-map "\C-c\C-e" 'ruby-insert-end)
|
||||
|
||||
(defun ruby-insert-end ()
|
||||
(interactive)
|
||||
(if (eq (char-syntax (preceding-char)) ?w)
|
||||
(insert " "))
|
||||
(insert "end")
|
||||
(save-excursion
|
||||
(if (eq (char-syntax (following-char)) ?w)
|
||||
(insert " "))
|
||||
(ruby-indent-line t)
|
||||
(end-of-line)))
|
||||
|
||||
(defconst ruby-default-encoding-map
|
||||
'((us-ascii . nil) ;; Do not put coding: us-ascii
|
||||
(utf-8 . nil) ;; Do not put coding: utf-8
|
||||
(shift-jis . cp932) ;; Emacs charset name of Shift_JIS
|
||||
(shift_jis . cp932) ;; MIME charset name of Shift_JIS
|
||||
(japanese-cp932 . cp932)) ;; Emacs charset name of CP932
|
||||
)
|
||||
|
||||
(custom-set-default 'ruby-encoding-map ruby-default-encoding-map)
|
||||
|
||||
(defcustom ruby-encoding-map ruby-default-encoding-map
|
||||
"Alist to map encoding name from Emacs to Ruby.
|
||||
Associating an encoding name with nil means it needs not be
|
||||
explicitly declared in magic comment."
|
||||
:type '(repeat (cons (symbol :tag "From") (symbol :tag "To")))
|
||||
:group 'ruby)
|
||||
|
||||
(defun ruby-mode-set-encoding ()
|
||||
"Insert or update a magic comment header with the proper encoding.
|
||||
`ruby-encoding-map' is looked up to convert an encoding name from
|
||||
Emacs to Ruby."
|
||||
(let* ((nonascii
|
||||
(save-excursion
|
||||
(widen)
|
||||
(goto-char (point-min))
|
||||
(re-search-forward "[^\0-\177]" nil t)))
|
||||
(coding-system
|
||||
(or coding-system-for-write
|
||||
buffer-file-coding-system))
|
||||
(coding-system
|
||||
(and coding-system
|
||||
(coding-system-change-eol-conversion coding-system nil)))
|
||||
(coding-system
|
||||
(and coding-system
|
||||
(or
|
||||
(coding-system-get coding-system :mime-charset)
|
||||
(let ((coding-type (coding-system-get coding-system :coding-type)))
|
||||
(cond ((eq coding-type 'undecided)
|
||||
(if nonascii
|
||||
(or (and (coding-system-get coding-system :prefer-utf-8)
|
||||
'utf-8)
|
||||
(coding-system-get default-buffer-file-coding-system :coding-type)
|
||||
'ascii-8bit)))
|
||||
((memq coding-type '(utf-8 shift-jis))
|
||||
coding-type)
|
||||
(t coding-system))))))
|
||||
(coding-system
|
||||
(or coding-system
|
||||
'us-ascii))
|
||||
(coding-system
|
||||
(let ((cons (assq coding-system ruby-encoding-map)))
|
||||
(if cons (cdr cons) coding-system)))
|
||||
(coding-system
|
||||
(and coding-system
|
||||
(symbol-name coding-system))))
|
||||
(if coding-system
|
||||
(save-excursion
|
||||
(widen)
|
||||
(goto-char (point-min))
|
||||
(if (looking-at "^#!") (beginning-of-line 2))
|
||||
(cond ((looking-at "\\s *#.*-\*-\\s *\\(en\\)?coding\\s *:\\s *\\([-a-z0-9_]*\\)\\s *\\(;\\|-\*-\\)")
|
||||
(unless (string= (match-string 2) coding-system)
|
||||
(goto-char (match-beginning 2))
|
||||
(delete-region (point) (match-end 2))
|
||||
(and (looking-at "-\*-")
|
||||
(let ((n (skip-chars-backward " ")))
|
||||
(cond ((= n 0) (insert " ") (backward-char))
|
||||
((= n -1) (insert " "))
|
||||
((forward-char)))))
|
||||
(insert coding-system)))
|
||||
((looking-at "\\s *#.*coding\\s *[:=]"))
|
||||
(t (when ruby-insert-encoding-magic-comment
|
||||
(insert "# -*- coding: " coding-system " -*-\n"))))))))
|
||||
|
||||
(define-key ruby-mode-map "\C-cU" 'ruby-encode-decode-unicode)
|
||||
|
||||
(defun ruby-encode-unicode (beg end)
|
||||
"Convert non-ascii string in the given region to \\u{} form."
|
||||
(interactive "r")
|
||||
(setq end (set-marker (make-marker) end))
|
||||
(goto-char beg)
|
||||
(while (and (< (point) end)
|
||||
(re-search-forward "\\([\C-@-\C-I\C-K\C-_\C-?]+\\)\\|[^\C-@-\C-?]+" end t))
|
||||
(let ((str (match-string-no-properties 0)) sep b e f)
|
||||
(if (match-beginning 1)
|
||||
(setq b "" e "" sep ""
|
||||
f (lambda (c)
|
||||
(cond ((= c ?\t) "\\t")
|
||||
((= c ?\r) "\\r")
|
||||
((= c ?\e) "\\e")
|
||||
((= c ?\f) "\\f")
|
||||
((= c ?\b) "\\b")
|
||||
((= c ?\v) "\\v")
|
||||
((= c ?\C-?) "\\c?")
|
||||
((concat "\\c" (char-to-string (logior c #x40)))))))
|
||||
(setq b "\\u{" e "}" sep " " f (lambda (c) (format "%x" c))))
|
||||
(setq str (mapconcat f str sep))
|
||||
(delete-region (match-beginning 0) (match-end 0))
|
||||
(insert b str e))))
|
||||
|
||||
(defun ruby-decode-unicode (beg end)
|
||||
"Convert escaped Unicode in the given region to raw string."
|
||||
(interactive "r")
|
||||
(setq end (set-marker (make-marker) end))
|
||||
(goto-char beg)
|
||||
(while (and (< (point) end)
|
||||
(re-search-forward "\\\\u\\([0-9a-fA-F]\\{4\\}\\)\\|\\\\u{\\([0-9a-fA-F \t]+\\)}" end t))
|
||||
(let ((b (match-beginning 0)) (e (match-end 0))
|
||||
(s (match-string-no-properties 1)))
|
||||
(if s
|
||||
(setq s (cons s nil))
|
||||
(goto-char (match-beginning 2))
|
||||
(while (looking-at "[ \t]*\\([0-9a-fA-F]+\\)")
|
||||
(setq s (cons (match-string-no-properties 1) s))
|
||||
(goto-char (match-end 0))))
|
||||
(setq s (mapconcat (lambda (c) (format "%c" (string-to-int c 16)))
|
||||
(nreverse s) ""))
|
||||
(delete-region b e)
|
||||
(insert s))
|
||||
))
|
||||
|
||||
(defun ruby-encode-decode-unicode (dec beg end)
|
||||
"Convert Unicode <-> \\u{} in the given region."
|
||||
(interactive "P\nr")
|
||||
(if dec (ruby-decode-unicode beg end) (ruby-encode-unicode beg end)))
|
||||
|
||||
(defun ruby-insert-heredoc-code-block (arg)
|
||||
"Insert indented here document code block"
|
||||
(interactive "P")
|
||||
(let ((c (if arg "~" "-")))
|
||||
(insert "\"#{<<" c "\"{#\"}\\n#{<<" c "'};'}\""))
|
||||
(end-of-line)
|
||||
(if (eobp) (insert "\n") (forward-char))
|
||||
(indent-region (point)
|
||||
(progn (insert "{#\n" "};\n") (point)))
|
||||
(beginning-of-line 0))
|
||||
(define-key ruby-mode-map "\C-cH" 'ruby-insert-heredoc-code-block)
|
||||
))
|
||||
|
||||
;; monkey-patching ruby-mode.el in Emacs 24, as r49872.
|
||||
(when (and (boundp 'ruby-syntax-before-regexp-re)
|
||||
(not (string-match ruby-syntax-before-regexp-re "foo {|" 1)))
|
||||
(replace-regexp-in-string "\\[\\[" "\\&{|" ruby-syntax-before-regexp-re))
|
||||
|
||||
(provide 'ruby-additional)
|
||||
|
||||
;;; ruby-additional.el ends here
|
||||
|
|
@ -1,583 +0,0 @@
|
|||
;;; ruby-electric.el --- Minor mode for electrically editing ruby code
|
||||
;;
|
||||
;; Authors: Dee Zsombor <dee dot zsombor at gmail dot com>
|
||||
;; Yukihiro Matsumoto
|
||||
;; Nobuyoshi Nakada
|
||||
;; Akinori MUSHA <knu@iDaemons.org>
|
||||
;; Jakub Kuźma <qoobaa@gmail.com>
|
||||
;; Maintainer: Akinori MUSHA <knu@iDaemons.org>
|
||||
;; Created: 6 Mar 2005
|
||||
;; URL: https://github.com/knu/ruby-electric.el
|
||||
;; Keywords: languages ruby
|
||||
;; License: The same license terms as Ruby
|
||||
;; Version: 2.3.1
|
||||
|
||||
;;; Commentary:
|
||||
;;
|
||||
;; `ruby-electric-mode' accelerates code writing in ruby by making
|
||||
;; some keys "electric" and automatically supplying with closing
|
||||
;; parentheses and "end" as appropriate.
|
||||
;;
|
||||
;; This work was originally inspired by a code snippet posted by
|
||||
;; [Frederick Ros](https://github.com/sleeper).
|
||||
;;
|
||||
;; Add the following line to enable ruby-electric-mode under
|
||||
;; ruby-mode.
|
||||
;;
|
||||
;; (eval-after-load "ruby-mode"
|
||||
;; '(add-hook 'ruby-mode-hook 'ruby-electric-mode))
|
||||
;;
|
||||
;; Type M-x customize-group ruby-electric for configuration.
|
||||
|
||||
;;; Code:
|
||||
|
||||
(require 'ruby-mode)
|
||||
|
||||
(eval-when-compile
|
||||
(require 'cl))
|
||||
|
||||
(defgroup ruby-electric nil
|
||||
"Minor mode providing electric editing commands for ruby files"
|
||||
:group 'ruby)
|
||||
|
||||
(defconst ruby-electric-expandable-bar-re
|
||||
"\\s-\\(do\\|{\\)\\s-*|")
|
||||
|
||||
(defconst ruby-electric-delimiters-alist
|
||||
'((?\{ :name "Curly brace" :handler ruby-electric-curlies :closing ?\})
|
||||
(?\[ :name "Square brace" :handler ruby-electric-matching-char :closing ?\])
|
||||
(?\( :name "Round brace" :handler ruby-electric-matching-char :closing ?\))
|
||||
(?\' :name "Quote" :handler ruby-electric-matching-char)
|
||||
(?\" :name "Double quote" :handler ruby-electric-matching-char)
|
||||
(?\` :name "Back quote" :handler ruby-electric-matching-char)
|
||||
(?\| :name "Vertical bar" :handler ruby-electric-bar)
|
||||
(?\# :name "Hash" :handler ruby-electric-hash)))
|
||||
|
||||
(defvar ruby-electric-matching-delimeter-alist
|
||||
(apply 'nconc
|
||||
(mapcar #'(lambda (x)
|
||||
(let ((delim (car x))
|
||||
(plist (cdr x)))
|
||||
(if (eq (plist-get plist :handler) 'ruby-electric-matching-char)
|
||||
(list (cons delim (or (plist-get plist :closing)
|
||||
delim))))))
|
||||
ruby-electric-delimiters-alist)))
|
||||
|
||||
(defvar ruby-electric-expandable-keyword-re)
|
||||
|
||||
(defmacro ruby-electric--try-insert-and-do (string &rest body)
|
||||
(declare (indent 1))
|
||||
`(let ((before (point))
|
||||
(after (progn
|
||||
(insert ,string)
|
||||
(point))))
|
||||
(unwind-protect
|
||||
(progn ,@body)
|
||||
(delete-region before after)
|
||||
(goto-char before))))
|
||||
|
||||
(defconst ruby-modifier-beg-symbol-re
|
||||
(regexp-opt ruby-modifier-beg-keywords 'symbols))
|
||||
|
||||
(defun ruby-electric--modifier-keyword-at-point-p ()
|
||||
"Test if there is a modifier keyword at point."
|
||||
(and (looking-at ruby-modifier-beg-symbol-re)
|
||||
(let ((end (match-end 1)))
|
||||
(not (looking-back "\\."))
|
||||
(save-excursion
|
||||
(let ((indent1 (ruby-electric--try-insert-and-do "\n"
|
||||
(ruby-calculate-indent)))
|
||||
(indent2 (save-excursion
|
||||
(goto-char end)
|
||||
(ruby-electric--try-insert-and-do " x\n"
|
||||
(ruby-calculate-indent)))))
|
||||
(= indent1 indent2))))))
|
||||
|
||||
(defconst ruby-block-mid-symbol-re
|
||||
(regexp-opt ruby-block-mid-keywords 'symbols))
|
||||
|
||||
(defun ruby-electric--block-mid-keyword-at-point-p ()
|
||||
"Test if there is a block mid keyword at point."
|
||||
(and (looking-at ruby-block-mid-symbol-re)
|
||||
(looking-back "^\\s-*")))
|
||||
|
||||
(defconst ruby-block-beg-symbol-re
|
||||
(regexp-opt ruby-block-beg-keywords 'symbols))
|
||||
|
||||
(defun ruby-electric--block-beg-keyword-at-point-p ()
|
||||
"Test if there is a block beginning keyword at point."
|
||||
(and (looking-at ruby-block-beg-symbol-re)
|
||||
(if (string= (match-string 1) "do")
|
||||
(looking-back "\\s-")
|
||||
(not (looking-back "\\.")))
|
||||
;; (not (ruby-electric--modifier-keyword-at-point-p)) ;; implicit assumption
|
||||
))
|
||||
|
||||
(defcustom ruby-electric-keywords-alist
|
||||
'(("begin" . end)
|
||||
("case" . end)
|
||||
("class" . end)
|
||||
("def" . end)
|
||||
("do" . end)
|
||||
("else" . reindent)
|
||||
("elsif" . reindent)
|
||||
("end" . reindent)
|
||||
("ensure" . reindent)
|
||||
("for" . end)
|
||||
("if" . end)
|
||||
("module" . end)
|
||||
("rescue" . reindent)
|
||||
("unless" . end)
|
||||
("until" . end)
|
||||
("when" . reindent)
|
||||
("while" . end))
|
||||
"Alist of keywords and actions to define how to react to space
|
||||
or return right after each keyword. In each (KEYWORD . ACTION)
|
||||
cons, ACTION can be set to one of the following values:
|
||||
|
||||
`reindent' Reindent the line.
|
||||
|
||||
`end' Reindent the line and auto-close the keyword with
|
||||
end if applicable.
|
||||
|
||||
`nil' Do nothing.
|
||||
"
|
||||
:type '(repeat (cons (string :tag "Keyword")
|
||||
(choice :tag "Action"
|
||||
:menu-tag "Action"
|
||||
(const :tag "Auto-close with end"
|
||||
:value end)
|
||||
(const :tag "Auto-reindent"
|
||||
:value reindent)
|
||||
(const :tag "None"
|
||||
:value nil))))
|
||||
:set (lambda (sym val)
|
||||
(set sym val)
|
||||
(let (keywords)
|
||||
(dolist (x val)
|
||||
(let ((keyword (car x))
|
||||
(action (cdr x)))
|
||||
(if action
|
||||
(setq keywords (cons keyword keywords)))))
|
||||
(setq ruby-electric-expandable-keyword-re
|
||||
(concat (regexp-opt keywords 'symbols)
|
||||
"$"))))
|
||||
:group 'ruby-electric)
|
||||
|
||||
(defvar ruby-electric-mode-map
|
||||
(let ((map (make-sparse-keymap)))
|
||||
(define-key map " " 'ruby-electric-space/return)
|
||||
(define-key map [remap delete-backward-char] 'ruby-electric-delete-backward-char)
|
||||
(define-key map [remap newline] 'ruby-electric-space/return)
|
||||
(define-key map [remap newline-and-indent] 'ruby-electric-space/return)
|
||||
(define-key map [remap electric-newline-and-maybe-indent] 'ruby-electric-space/return)
|
||||
(define-key map [remap reindent-then-newline-and-indent] 'ruby-electric-space/return)
|
||||
(dolist (x ruby-electric-delimiters-alist)
|
||||
(let* ((delim (car x))
|
||||
(plist (cdr x))
|
||||
(name (plist-get plist :name))
|
||||
(func (plist-get plist :handler))
|
||||
(closing (plist-get plist :closing)))
|
||||
(define-key map (char-to-string delim) func)
|
||||
(if closing
|
||||
(define-key map (char-to-string closing) 'ruby-electric-closing-char))))
|
||||
map)
|
||||
"Keymap used in ruby-electric-mode")
|
||||
|
||||
(defcustom ruby-electric-expand-delimiters-list '(all)
|
||||
"*List of contexts where matching delimiter should be inserted.
|
||||
The word 'all' will do all insertions."
|
||||
:type `(set :extra-offset 8
|
||||
(const :tag "Everything" all)
|
||||
,@(apply 'list
|
||||
(mapcar #'(lambda (x)
|
||||
`(const :tag ,(plist-get (cdr x) :name)
|
||||
,(car x)))
|
||||
ruby-electric-delimiters-alist)))
|
||||
:group 'ruby-electric)
|
||||
|
||||
(defcustom ruby-electric-newline-before-closing-bracket nil
|
||||
"*Non-nil means a newline should be inserted before an
|
||||
automatically inserted closing bracket."
|
||||
:type 'boolean :group 'ruby-electric)
|
||||
|
||||
(defcustom ruby-electric-autoindent-on-closing-char nil
|
||||
"*Non-nil means the current line should be automatically
|
||||
indented when a closing character is manually typed in."
|
||||
:type 'boolean :group 'ruby-electric)
|
||||
|
||||
(defvar ruby-electric-mode-hook nil
|
||||
"Called after `ruby-electric-mode' is turned on.")
|
||||
|
||||
;;;###autoload
|
||||
(define-minor-mode ruby-electric-mode
|
||||
"Toggle Ruby Electric minor mode.
|
||||
With no argument, this command toggles the mode. Non-null prefix
|
||||
argument turns on the mode. Null prefix argument turns off the
|
||||
mode.
|
||||
|
||||
When Ruby Electric mode is enabled, an indented 'end' is
|
||||
heuristicaly inserted whenever typing a word like 'module',
|
||||
'class', 'def', 'if', 'unless', 'case', 'until', 'for', 'begin',
|
||||
'do' followed by a space. Single, double and back quotes as well
|
||||
as braces are paired auto-magically. Expansion does not occur
|
||||
inside comments and strings. Note that you must have Font Lock
|
||||
enabled."
|
||||
;; initial value.
|
||||
nil
|
||||
;;indicator for the mode line.
|
||||
" REl"
|
||||
;;keymap
|
||||
ruby-electric-mode-map
|
||||
(if ruby-electric-mode
|
||||
(run-hooks 'ruby-electric-mode-hook)))
|
||||
|
||||
(defun ruby-electric-space/return-fallback ()
|
||||
(if (or (eq this-original-command 'ruby-electric-space/return)
|
||||
(null (ignore-errors
|
||||
;; ac-complete may fail if there is nothing left to complete
|
||||
(call-interactively this-original-command)
|
||||
(setq this-command this-original-command))))
|
||||
;; fall back to a globally bound command
|
||||
(let ((command (global-key-binding (char-to-string last-command-event) t)))
|
||||
(and command
|
||||
(call-interactively (setq this-command command))))))
|
||||
|
||||
(defun ruby-electric-space/return (arg)
|
||||
(interactive "*P")
|
||||
(and (boundp 'sp-last-operation)
|
||||
(setq sp-delayed-pair nil))
|
||||
(cond ((or arg
|
||||
(region-active-p))
|
||||
(or (= last-command-event ?\s)
|
||||
(setq last-command-event ?\n))
|
||||
(ruby-electric-replace-region-or-insert))
|
||||
((ruby-electric-space/return-can-be-expanded-p)
|
||||
(let (action)
|
||||
(save-excursion
|
||||
(goto-char (match-beginning 0))
|
||||
(let* ((keyword (match-string 1))
|
||||
(allowed-actions
|
||||
(cond ((ruby-electric--modifier-keyword-at-point-p)
|
||||
'(reindent)) ;; no end necessary
|
||||
((ruby-electric--block-mid-keyword-at-point-p)
|
||||
'(reindent)) ;; ditto
|
||||
((ruby-electric--block-beg-keyword-at-point-p)
|
||||
'(end reindent)))))
|
||||
(if allowed-actions
|
||||
(setq action
|
||||
(let ((action (cdr (assoc keyword ruby-electric-keywords-alist))))
|
||||
(and (memq action allowed-actions)
|
||||
action))))))
|
||||
(cond ((eq action 'end)
|
||||
(ruby-indent-line)
|
||||
(save-excursion
|
||||
(newline)
|
||||
(ruby-electric-end)))
|
||||
((eq action 'reindent)
|
||||
(ruby-indent-line)))
|
||||
(ruby-electric-space/return-fallback)))
|
||||
((and (eq this-original-command 'newline-and-indent)
|
||||
(ruby-electric-comment-at-point-p))
|
||||
(call-interactively (setq this-command 'comment-indent-new-line)))
|
||||
(t
|
||||
(ruby-electric-space/return-fallback))))
|
||||
|
||||
(defun ruby-electric--get-faces-at-point ()
|
||||
(let* ((point (point))
|
||||
(value (or
|
||||
(get-text-property point 'read-face-name)
|
||||
(get-text-property point 'face))))
|
||||
(if (listp value) value (list value))))
|
||||
|
||||
(defun ruby-electric--faces-include-p (pfaces &rest faces)
|
||||
(and ruby-electric-mode
|
||||
(loop for face in faces
|
||||
thereis (memq face pfaces))))
|
||||
|
||||
(defun ruby-electric--faces-at-point-include-p (&rest faces)
|
||||
(apply 'ruby-electric--faces-include-p
|
||||
(ruby-electric--get-faces-at-point)
|
||||
faces))
|
||||
|
||||
(defun ruby-electric-code-face-p (faces)
|
||||
(not (ruby-electric--faces-include-p
|
||||
faces
|
||||
'font-lock-string-face
|
||||
'font-lock-comment-face
|
||||
'enh-ruby-string-delimiter-face
|
||||
'enh-ruby-heredoc-delimiter-face
|
||||
'enh-ruby-regexp-delimiter-face
|
||||
'enh-ruby-regexp-face)))
|
||||
|
||||
(defun ruby-electric-code-at-point-p ()
|
||||
(ruby-electric-code-face-p
|
||||
(ruby-electric--get-faces-at-point)))
|
||||
|
||||
(defun ruby-electric-string-face-p (faces)
|
||||
(ruby-electric--faces-include-p
|
||||
faces
|
||||
'font-lock-string-face
|
||||
'enh-ruby-string-delimiter-face
|
||||
'enh-ruby-heredoc-delimiter-face
|
||||
'enh-ruby-regexp-delimiter-face
|
||||
'enh-ruby-regexp-face))
|
||||
|
||||
(defun ruby-electric-string-at-point-p ()
|
||||
(ruby-electric-string-face-p
|
||||
(ruby-electric--get-faces-at-point)))
|
||||
|
||||
(defun ruby-electric-comment-at-point-p ()
|
||||
(ruby-electric--faces-at-point-include-p
|
||||
'font-lock-comment-face))
|
||||
|
||||
(defun ruby-electric-escaped-p()
|
||||
(let ((f nil))
|
||||
(save-excursion
|
||||
(while (char-equal ?\\ (preceding-char))
|
||||
(backward-char 1)
|
||||
(setq f (not f))))
|
||||
f))
|
||||
|
||||
(defun ruby-electric-command-char-expandable-punct-p(char)
|
||||
(or (memq 'all ruby-electric-expand-delimiters-list)
|
||||
(memq char ruby-electric-expand-delimiters-list)))
|
||||
|
||||
(defun ruby-electric-space/return-can-be-expanded-p()
|
||||
(and (ruby-electric-code-at-point-p)
|
||||
(looking-back ruby-electric-expandable-keyword-re)))
|
||||
|
||||
(defun ruby-electric-replace-region-or-insert ()
|
||||
(and (region-active-p)
|
||||
(bound-and-true-p delete-selection-mode)
|
||||
(fboundp 'delete-selection-helper)
|
||||
(delete-selection-helper (get 'self-insert-command 'delete-selection)))
|
||||
(insert (make-string (prefix-numeric-value current-prefix-arg)
|
||||
last-command-event))
|
||||
(setq this-command 'self-insert-command))
|
||||
|
||||
(defmacro ruby-electric-insert (arg &rest body)
|
||||
`(cond ((and
|
||||
(null ,arg)
|
||||
(ruby-electric-command-char-expandable-punct-p last-command-event))
|
||||
(let ((region-beginning
|
||||
(cond ((region-active-p)
|
||||
(prog1
|
||||
(save-excursion
|
||||
(goto-char (region-beginning))
|
||||
(insert last-command-event)
|
||||
(point))
|
||||
(goto-char (region-end))))
|
||||
(t
|
||||
(insert last-command-event)
|
||||
nil)))
|
||||
(faces-at-point
|
||||
(ruby-electric--get-faces-at-point)))
|
||||
,@body
|
||||
(and region-beginning
|
||||
;; If no extra character is inserted, go back to the
|
||||
;; region beginning.
|
||||
(eq this-command 'self-insert-command)
|
||||
(goto-char region-beginning))))
|
||||
((ruby-electric-replace-region-or-insert))))
|
||||
|
||||
(defun ruby-electric-curlies (arg)
|
||||
(interactive "*P")
|
||||
(ruby-electric-insert
|
||||
arg
|
||||
(cond
|
||||
((or (ruby-electric-code-at-point-p)
|
||||
(ruby-electric--faces-include-p
|
||||
faces-at-point
|
||||
'enh-ruby-string-delimiter-face
|
||||
'enh-ruby-regexp-delimiter-face))
|
||||
(save-excursion
|
||||
(insert "}")
|
||||
(font-lock-fontify-region (line-beginning-position) (point)))
|
||||
(cond
|
||||
((or (ruby-electric-string-at-point-p) ;; %w{}, %r{}, etc.
|
||||
(looking-back "%[QqWwRrxIis]{"))
|
||||
(if region-beginning
|
||||
(forward-char 1)))
|
||||
(ruby-electric-newline-before-closing-bracket
|
||||
(cond (region-beginning
|
||||
(save-excursion
|
||||
(goto-char region-beginning)
|
||||
(newline))
|
||||
(newline)
|
||||
(forward-char 1)
|
||||
(indent-region region-beginning (line-end-position)))
|
||||
(t
|
||||
(insert " ")
|
||||
(save-excursion
|
||||
(newline)
|
||||
(ruby-indent-line t)))))
|
||||
(t
|
||||
(if region-beginning
|
||||
(save-excursion
|
||||
(goto-char region-beginning)
|
||||
(insert " "))
|
||||
(insert " "))
|
||||
(insert " ")
|
||||
(backward-char 1)
|
||||
(and region-beginning
|
||||
(forward-char 1)))))
|
||||
((ruby-electric-string-at-point-p)
|
||||
(let ((start-position (1- (or region-beginning (point)))))
|
||||
(cond
|
||||
((char-equal ?\# (char-before start-position))
|
||||
(unless (save-excursion
|
||||
(goto-char (1- start-position))
|
||||
(ruby-electric-escaped-p))
|
||||
(insert "}")
|
||||
(or region-beginning
|
||||
(backward-char 1))))
|
||||
((or
|
||||
(ruby-electric-command-char-expandable-punct-p ?\#)
|
||||
(save-excursion
|
||||
(goto-char start-position)
|
||||
(ruby-electric-escaped-p)))
|
||||
(if region-beginning
|
||||
(goto-char region-beginning))
|
||||
(setq this-command 'self-insert-command))
|
||||
(t
|
||||
(save-excursion
|
||||
(goto-char start-position)
|
||||
(insert "#"))
|
||||
(insert "}")
|
||||
(or region-beginning
|
||||
(backward-char 1))))))
|
||||
(t
|
||||
(delete-char -1)
|
||||
(ruby-electric-replace-region-or-insert)))))
|
||||
|
||||
(defun ruby-electric-hash (arg)
|
||||
(interactive "*P")
|
||||
(ruby-electric-insert
|
||||
arg
|
||||
(if (ruby-electric-string-at-point-p)
|
||||
(let ((start-position (1- (or region-beginning (point)))))
|
||||
(cond
|
||||
((char-equal (following-char) ?')) ;; likely to be in ''
|
||||
((save-excursion
|
||||
(goto-char start-position)
|
||||
(ruby-electric-escaped-p)))
|
||||
(region-beginning
|
||||
(save-excursion
|
||||
(goto-char (1+ start-position))
|
||||
(insert "{"))
|
||||
(insert "}"))
|
||||
(t
|
||||
(insert "{")
|
||||
(save-excursion
|
||||
(insert "}")))))
|
||||
(delete-char -1)
|
||||
(ruby-electric-replace-region-or-insert))))
|
||||
|
||||
(defun ruby-electric-matching-char (arg)
|
||||
(interactive "*P")
|
||||
(ruby-electric-insert
|
||||
arg
|
||||
(let ((closing (cdr (assoc last-command-event
|
||||
ruby-electric-matching-delimeter-alist))))
|
||||
(cond
|
||||
;; quotes
|
||||
((char-equal closing last-command-event)
|
||||
(cond ((not (ruby-electric-string-face-p faces-at-point))
|
||||
(if region-beginning
|
||||
;; escape quotes of the same kind, backslash and hash
|
||||
(let ((re (format "[%c\\%s]"
|
||||
last-command-event
|
||||
(if (char-equal last-command-event ?\")
|
||||
"#" "")))
|
||||
(bound (point)))
|
||||
(save-excursion
|
||||
(goto-char region-beginning)
|
||||
(while (re-search-forward re bound t)
|
||||
(let ((end (point)))
|
||||
(replace-match "\\\\\\&")
|
||||
(setq bound (+ bound (- (point) end))))))))
|
||||
(insert closing)
|
||||
(or region-beginning
|
||||
(backward-char 1)))
|
||||
(t
|
||||
(and (eq last-command 'ruby-electric-matching-char)
|
||||
(char-equal (following-char) closing) ;; repeated quotes
|
||||
(delete-char 1))
|
||||
(setq this-command 'self-insert-command))))
|
||||
((ruby-electric-code-at-point-p)
|
||||
(insert closing)
|
||||
(or region-beginning
|
||||
(backward-char 1)))))))
|
||||
|
||||
(defun ruby-electric-closing-char(arg)
|
||||
(interactive "*P")
|
||||
(cond
|
||||
(arg
|
||||
(ruby-electric-replace-region-or-insert))
|
||||
((and
|
||||
(eq last-command 'ruby-electric-curlies)
|
||||
(= last-command-event ?})
|
||||
(not (char-equal (preceding-char) last-command-event))) ;; {}
|
||||
(if (char-equal (following-char) ?\n) (delete-char 1))
|
||||
(delete-horizontal-space)
|
||||
(forward-char))
|
||||
((and
|
||||
(= last-command-event (following-char))
|
||||
(not (char-equal (preceding-char) last-command-event))
|
||||
(memq last-command '(ruby-electric-matching-char
|
||||
ruby-electric-closing-char))) ;; ()/[] and (())/[[]]
|
||||
(forward-char))
|
||||
(t
|
||||
(ruby-electric-replace-region-or-insert)
|
||||
(if ruby-electric-autoindent-on-closing-char
|
||||
(ruby-indent-line)))))
|
||||
|
||||
(defun ruby-electric-bar(arg)
|
||||
(interactive "*P")
|
||||
(ruby-electric-insert
|
||||
arg
|
||||
(cond ((and (ruby-electric-code-at-point-p)
|
||||
(looking-back ruby-electric-expandable-bar-re))
|
||||
(save-excursion (insert "|")))
|
||||
(t
|
||||
(delete-char -1)
|
||||
(ruby-electric-replace-region-or-insert)))))
|
||||
|
||||
(defun ruby-electric-delete-backward-char(arg)
|
||||
(interactive "*p")
|
||||
(cond ((memq last-command '(ruby-electric-matching-char
|
||||
ruby-electric-bar))
|
||||
(delete-char 1))
|
||||
((eq last-command 'ruby-electric-curlies)
|
||||
(cond ((eolp)
|
||||
(cond ((char-equal (preceding-char) ?\s)
|
||||
(setq this-command last-command))
|
||||
((char-equal (preceding-char) ?{)
|
||||
(and (looking-at "[ \t\n]*}")
|
||||
(delete-char (- (match-end 0) (match-beginning 0)))))))
|
||||
((char-equal (following-char) ?\s)
|
||||
(setq this-command last-command)
|
||||
(delete-char 1))
|
||||
((char-equal (following-char) ?})
|
||||
(delete-char 1))))
|
||||
((eq last-command 'ruby-electric-hash)
|
||||
(and (char-equal (preceding-char) ?{)
|
||||
(delete-char 1))))
|
||||
(delete-char (- arg)))
|
||||
|
||||
(put 'ruby-electric-delete-backward-char 'delete-selection 'supersede)
|
||||
|
||||
(defun ruby-electric-end ()
|
||||
(interactive)
|
||||
(if (eq (char-syntax (preceding-char)) ?w)
|
||||
(insert " "))
|
||||
(insert "end")
|
||||
(save-excursion
|
||||
(if (eq (char-syntax (following-char)) ?w)
|
||||
(insert " "))
|
||||
(ruby-indent-line t)))
|
||||
|
||||
(provide 'ruby-electric)
|
||||
|
||||
;;; ruby-electric.el ends here
|
||||
|
|
@ -1,81 +0,0 @@
|
|||
;;; -*- emacs-lisp -*-
|
||||
;;;
|
||||
;;; ruby-style.el -
|
||||
;;;
|
||||
;;; C/C++ mode style for Ruby.
|
||||
;;;
|
||||
;;; $Author$
|
||||
;;; created at: Thu Apr 26 13:54:01 JST 2007
|
||||
;;;
|
||||
;;; Put this file under a directory contained in ``load-path'', and
|
||||
;;; then load it.
|
||||
;;; To switch to the "ruby" style automatically if it looks like a
|
||||
;;; source file of ruby, add ruby-style-c-mode to c-mode-hook:
|
||||
;;;
|
||||
;;; (require 'ruby-style)
|
||||
;;; (add-hook 'c-mode-hook 'ruby-style-c-mode)
|
||||
;;; (add-hook 'c++-mode-hook 'ruby-style-c-mode)
|
||||
;;;
|
||||
;;; Customize the c-default-style variable to set the default style
|
||||
;;; for each CC major mode.
|
||||
|
||||
(defconst ruby-style-revision "$Revision$"
|
||||
"Ruby style revision string.")
|
||||
|
||||
(defconst ruby-style-version
|
||||
(and
|
||||
(string-match "[0-9.]+" ruby-style-revision)
|
||||
(substring ruby-style-revision (match-beginning 0) (match-end 0)))
|
||||
"Ruby style version number.")
|
||||
|
||||
(defun ruby-style-case-indent (x)
|
||||
(save-excursion
|
||||
(back-to-indentation)
|
||||
(unless (progn (backward-up-list) (back-to-indentation)
|
||||
(> (point) (cdr x)))
|
||||
(goto-char (cdr x))
|
||||
(if (looking-at "\\<case\\|default\\>") '*))))
|
||||
|
||||
(defun ruby-style-label-indent (x)
|
||||
(save-excursion
|
||||
(back-to-indentation)
|
||||
(unless (progn (backward-up-list) (back-to-indentation)
|
||||
(>= (point) (cdr x)))
|
||||
(goto-char (cdr x))
|
||||
(condition-case ()
|
||||
(progn
|
||||
(backward-up-list)
|
||||
(backward-sexp 2)
|
||||
(if (looking-at "\\<switch\\>") '/))
|
||||
(error)))))
|
||||
|
||||
(require 'cc-styles)
|
||||
(c-add-style
|
||||
"ruby"
|
||||
'("bsd"
|
||||
(c-basic-offset . 4)
|
||||
(tab-width . 8)
|
||||
(indent-tabs-mode . nil)
|
||||
(setq show-trailing-whitespace t)
|
||||
(c-offsets-alist
|
||||
(case-label . *)
|
||||
(label . (ruby-style-label-indent *))
|
||||
(statement-case-intro . *)
|
||||
(statement-case-open . *)
|
||||
(statement-block-intro . (ruby-style-case-indent +))
|
||||
(access-label /)
|
||||
)))
|
||||
|
||||
;;;###autoload
|
||||
(defun ruby-style-c-mode ()
|
||||
(interactive)
|
||||
(if (or (let ((name (buffer-file-name))) (and name (string-match "/ruby\\>" name)))
|
||||
(save-excursion
|
||||
(goto-char (point-min))
|
||||
(let ((head (progn (forward-line 100) (point)))
|
||||
(case-fold-search nil))
|
||||
(goto-char (point-min))
|
||||
(re-search-forward "Copyright (C) .* Yukihiro Matsumoto" head t))))
|
||||
(c-set-style "ruby")))
|
||||
|
||||
(provide 'ruby-style)
|
||||
104
misc/rubydb2x.el
104
misc/rubydb2x.el
|
|
@ -1,104 +0,0 @@
|
|||
(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)
|
||||
)
|
||||
115
misc/rubydb3x.el
115
misc/rubydb3x.el
|
|
@ -1,115 +0,0 @@
|
|||
(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:-) ")
|
||||
(if (boundp 'comint-last-output-start)
|
||||
(set-marker comint-last-output-start (point)))
|
||||
(set (make-local-variable 'paragraph-start) comint-prompt-regexp)
|
||||
(run-hooks 'rubydb-mode-hook)
|
||||
)
|
||||
Loading…
Reference in a new issue