Skip to content
Browse files

merged from other

  • Loading branch information...
2 parents eff2c75 + 20b4002 commit 57df6360366826ce4dee3232afa6cae157119e17 @technomancy committed Dec 10, 2008
View
3 .gitignore
@@ -1 +1,2 @@
-loaddefs.el*
+loaddefs.el*
+backups/*
View
60 elpa-to-submit/blackboard.el
@@ -0,0 +1,60 @@
+;; Blackboard Colour Theme for Emacs.
+;;
+;; Defines a colour scheme resembling that of the original TextMate Blackboard colour theme.
+;; To use add the following to your .emacs file (requires the color-theme package):
+;;
+;; (require 'color-theme)
+;; (color-theme-initialize)
+;; (load-file "~/.emacs.d/themes/color-theme-blackboard.el")
+;;
+;; And then (color-theme-blackboard) to activate it.
+;;
+;; MIT License Copyright (c) 2008 JD Huntington <jdhuntington at gmail dot com>
+;; Credits due to the excellent TextMate Blackboard theme
+;;
+;; All patches welcome
+
+(defun color-theme-blackboard ()
+ "Color theme by JD Huntington, based off the TextMate Blackboard theme, created 2008-11-27"
+ (interactive)
+ (color-theme-install
+ '(color-theme-blackboard
+ ((background-color . "#0C1021")
+ (background-mode . dark)
+ (border-color . "black")
+ (cursor-color . "#A7A7A7")
+ (foreground-color . "#F8F8F8")
+ (mouse-color . "sienna1"))
+ (default ((t (:background "#0C1021" :foreground "#F8F8F8"))))
+ (blue ((t (:foreground "blue"))))
+ (bold ((t (:bold t))))
+ (bold-italic ((t (:bold t))))
+ (border-glyph ((t (nil))))
+ (buffers-tab ((t (:background "#0C1021" :foreground "#F8F8F8"))))
+ (font-lock-builtin-face ((t (:foreground "#F8F8F8"))))
+ (font-lock-comment-face ((t (:italic t :foreground "#AEAEAE"))))
+ (font-lock-constant-face ((t (:foreground "#D8FA3C"))))
+ (font-lock-doc-string-face ((t (:foreground "DarkOrange"))))
+ (font-lock-function-name-face ((t (:foreground "#FF6400"))))
+ (font-lock-keyword-face ((t (:foreground "#FBDE2D"))))
+ (font-lock-preprocessor-face ((t (:foreground "Aquamarine"))))
+ (font-lock-reference-face ((t (:foreground "SlateBlue"))))
+
+ (font-lock-regexp-grouping-backslash ((t (:foreground "#E9C062"))))
+ (font-lock-regexp-grouping-construct ((t (:foreground "red"))))
+
+ (font-lock-string-face ((t (:foreground "#61CE3C"))))
+ (font-lock-type-face ((t (:foreground "#8DA6CE"))))
+ (font-lock-variable-name-face ((t (:foreground "#FF6400"))))
+ (font-lock-warning-face ((t (:bold t :foreground "Pink"))))
+ (gui-element ((t (:background "#D4D0C8" :foreground "black"))))
+ (region ((t (:background "#253B76"))))
+ (mode-line ((t (:background "grey75" :foreground "black"))))
+ (highlight ((t (:background "#222222"))))
+ (highline-face ((t (:background "SeaGreen"))))
+ (italic ((t (nil))))
+ (left-margin ((t (nil))))
+ (text-cursor ((t (:background "yellow" :foreground "black"))))
+ (toolbar ((t (nil))))
+ (underline ((nil (:underline nil))))
+ (zmacs-region ((t (:background "snow" :foreground "ble")))))))
View
306 elpa-to-submit/inf-ruby.el
@@ -1,306 +0,0 @@
-;;; inf-ruby.el --- Run a ruby process in a buffer
-
-;; Copyright (C) 1999-2008 Yukihiro Matsumoto, Nobuyoshi Nakada
-
-;; Authors: Yukihiro Matsumoto, Nobuyoshi Nakada
-;; URL: http://www.emacswiki.org/cgi-bin/wiki/RubyMode
-;; Created: 8 April 1998
-;; Keywords: languages ruby
-;; Version: 2.0
-;; Package-Requires: (("ruby-mode"))
-
-;;; Commentary:
-;;
-;; inf-ruby.el provides a REPL buffer connected to an IRB subprocess.
-;;
-;; If you're installing manually, you'll need to:
-;; * drop the file somewhere on your load path (perhaps ~/.emacs.d)
-;; * Add the following lines to your .emacs file:
-;; (autoload 'inf-ruby "inf-ruby" "Run an inferior Ruby process" t)
-;; (autoload 'inf-ruby-keys "inf-ruby" "" t)
-;; (eval-after-load 'ruby-mode
-;; '(add-hook 'ruby-mode-hook 'inf-ruby-keys))
-
-;;; TODO:
-;;
-;; Can you autoload an eval-after-load?
-;; What's the meaning of an asterisk at the start of a docstring?
-;; inferior-ruby-error-regexp-alist doesn't match this example
-;; SyntaxError: /home/eschulte/united/org/work/arf/arf/lib/cluster.rb:35: syntax error, unexpected '~', expecting kEND
-;; similarity = comparison_cache[m][n] ||= clusters[m] ~ clusters[n]
-;;
-
-(require 'comint)
-(require 'compile)
-(require 'ruby-mode)
-
-(defvar inf-ruby-default-implementation "ruby"
- "Which ruby implementation to use if none is specified.")
-
-(defvar inf-ruby-first-prompt-pattern "^irb(.*)[0-9:]+0> *"
- "First prompt regex pattern of ruby interpreter.")
-
-(defvar inf-ruby-prompt-pattern "^\\(irb(.*)[0-9:]+[>*\"'] *\\)+"
- "Prompt regex pattern of ruby interpreter.")
-
-(defvar inf-ruby-mode-hook nil
- "*Hook for customising inf-ruby mode.")
-
-(defvar inf-ruby-mode-map
- (let ((map (copy-keymap comint-mode-map)))
- (define-key map (kbd "C-c C-l") 'inf-ruby-load-file)
- (define-key map (kbd "C-x C-e") 'ruby-send-last-sexp)
- map)
- "*Mode map for inf-ruby-mode")
-
-(defvar inf-ruby-implementations
- '(("ruby" . "irb --inf-ruby-mode")
- ("jruby" . "jruby -S irb")
- ("rubinius" . "rbx")
- ("yarv" . "irb1.9 --inf-ruby-mode")) ;; TODO: ironruby?
- "An alist of ruby implementations to irb executable names.")
-
-;; TODO: do we need these two defvars?
-(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.")
-
-(defconst inf-ruby-error-regexp-alist
- '(("SyntaxError: compile error\n^\\([^\(].*\\):\\([1-9][0-9]*\\):" 1 2)
- ("^\tfrom \\([^\(].*\\):\\([1-9][0-9]*\\)\\(:in `.*'\\)?$" 1 2)))
-
-;;;###autoload
-(defun inf-ruby-keys ()
- "Set local key defs to invoke inf-ruby from 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" 'ruby-switch-to-inf)
- (define-key ruby-mode-map "\C-c\C-l" 'ruby-load-file)
- (define-key ruby-mode-map "\C-c\C-s" 'inf-ruby))
-
-(defvar inf-ruby-buffer nil "Current irb process buffer.")
-
-(defun inf-ruby-mode ()
- "Major mode for interacting with an inferior ruby (irb) process.
-
-The following commands are available:
-\\{inf-ruby-mode-map}
-
-A ruby process can be fired up with M-x inf-ruby.
-
-Customisation: Entry to this mode runs the hooks on comint-mode-hook and
-inf-ruby-mode-hook (in that order).
-
-You can send text to the inferior ruby process from other buffers containing
-Ruby source.
- ruby-switch-to-inf 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.
-
-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 arugment, 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)
- (setq comint-prompt-regexp inf-ruby-prompt-pattern)
- (ruby-mode-variables)
- (setq major-mode 'inf-ruby-mode)
- (setq mode-name "Inf-Ruby")
- (setq mode-line-process '(":%s"))
- (use-local-map inf-ruby-mode-map)
- (setq comint-input-filter (function inf-ruby-input-filter))
- (setq comint-get-old-input (function inf-ruby-get-old-input))
- (make-local-variable 'compilation-error-regexp-alist)
- (setq compilation-error-regexp-alist inf-ruby-error-regexp-alist)
- (compilation-shell-minor-mode t)
- (run-hooks 'inf-ruby-mode-hook))
-
-(defvar inf-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 inf-ruby-input-filter (str)
- "Don't save anything matching inf-ruby-filter-regexp"
- (not (string-match inf-ruby-filter-regexp str)))
-
-;; adapted from replace-in-string in XEmacs (subr.el)
-(defun inf-ruby-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 inf-ruby-get-old-input ()
- "Snarf the sexp ending at point"
- (save-excursion
- (let ((end (point)))
- (re-search-backward inf-ruby-first-prompt-pattern)
- (inf-ruby-remove-in-string (buffer-substring (point) end)
- inf-ruby-prompt-pattern))))
-
-;;;###autoload
-(defun inf-ruby (&optional impl)
- "Run an inferior Ruby process in a buffer.
-With prefix argument, prompts for which Ruby implementation
-\(from the list `inf-ruby-implementations') to use. Runs the
-hooks `inf-ruby-mode-hook' \(after the `comint-mode-hook' is
-run)."
-
- (interactive (list (if current-prefix-arg
- (completing-read "Ruby Implementation: "
- (mapc #'car inf-ruby-implementations))
- inf-ruby-default-implementation)))
-
- (let ((buffer-name (format "*%s*" impl))
- (cmd (cdr (assoc impl inf-ruby-implementations))))
- (if (not (comint-check-proc buffer-name))
- (let ((cmdlist (split-string cmd)))
- (set-buffer (apply 'make-comint impl (car cmdlist)
- nil (cdr cmdlist)))
- (inf-ruby-mode)))
- (setq inf-ruby-buffer buffer-name)
- (pop-to-buffer buffer-name)))
-
-(defalias 'run-ruby 'inf-ruby
- "An alias for backwards-compatibility.")
-
-(defun inf-ruby-proc ()
- "Returns the current IRB process. See variable inf-ruby-buffer."
- (or (get-buffer-process (if (eq major-mode 'inf-ruby-mode)
- (current-buffer)
- inf-ruby-buffer))
- (error "No current process. See variable inf-ruby-buffer")))
-
-;; These commands are added to the ruby-mode keymap:
-
-(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 (inf-ruby-proc))))
- (set-buffer (marker-buffer m))
- (goto-char m)
- (insert ruby-eval-separator "\n")
- (set-marker m (point))))
- (comint-send-string (inf-ruby-proc) (format "eval <<'%s', nil, %S, %d\n" term file line))
- (comint-send-region (inf-ruby-proc) start end)
- (comint-send-string (inf-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 ruby-switch-to-inf (eob-p)
- "Switch to the ruby process buffer.
-With argument, positions cursor at end of buffer."
- (interactive "P")
- (if (get-buffer inf-ruby-buffer)
- (pop-to-buffer inf-ruby-buffer)
- (error "No current process buffer. See variable inf-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)
- (ruby-switch-to-inf 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)
- (ruby-switch-to-inf 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)
- (ruby-switch-to-inf t))
-
-(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 (inf-ruby-proc) (concat "(load \""
- file-name
- "\"\)\n")))
-;;;###autoload
-(eval-after-load 'ruby-mode
- '(add-hook 'ruby-mode-hook 'inf-ruby-keys))
-
-(provide 'inf-ruby)
-;;; inf-ruby.el ends here
View
484 elpa-to-submit/lisppaste.el
@@ -1,484 +0,0 @@
-;;; lisppaste.el --- Interact with the lisppaste pastebot via XML-RPC.
-
-;; Copyright (C) 2004, 2005, 2006, 2007, 2008 Lawrence Mitchell <wence@gmx.li>
-;; File: lisppaste.el
-;; Author: Lawrence Mitchell <wence@gmx.li>
-;; Created: 2004-04-25
-;; Version: 1.4
-;; Keywords: IRC xml rpc network
-;; URL: http://purl.org/NET/wence/lisppaste.el
-;; Package-Requires: ((xml-rpc "1.6.4"))
-
-;;; Commentary:
-;; This file provide an Emacs interface to the lisppaste bot running
-;; on the Freenode IRC network (http://freenode.net).
-;; A number of commands are provided.
-;;
-;; Pasting a region may be carried out using `lisppaste-region'.
-;; A top-level entry point to all of lisppaste's functionality is
-;; provided via the `lisppaste' command. If you want to intercept
-;; lisppaste urls and display them in Emacs, you can do so by
-;; modifying `browse-url-browser-function' as described in
-;; `lisppaste-browse-url'.
-;;
-;; Interacting with lisppaste requires xml-rpc.el which you can find
-;; a link for at <URL: http://www.emacswiki.org/cgi-bin/wiki/XmlRpc>.
-
-;;; Code:
-
-(require 'cl)
-(require 'xml-rpc)
-
-(defconst lisppaste-url "http://common-lisp.net:8185/RPC2")
-
-(defun lisppaste-send-command (command &rest stuff)
- "Send COMMAND to the lisppaste bot with STUFF as arguments."
- (let ((xml-entity-alist nil)) ; defeat xml.el encoding of entities
- (apply #'xml-rpc-method-call lisppaste-url command stuff)))
-
-(defun lisppaste-new-paste (channel nick title content &optional annotate)
- "Create a new paste with the specified arguments.
-CHANNEL is the channel the paste will appear in.
-NICK is the nickname the paste will appear to be from.
-TITLE is the paste's title.
-CONTENT is the paste content.
-If ANNOTATE is non-nil, annotate that paste."
- (lisppaste-check-channel channel)
- (lisppaste-send-command 'newpaste channel nick title content annotate))
-
-(defun lisppaste-get-paste (paste &optional n)
- "Fetch PASTE.
-
-If N is non-nil, fetch the Nth annotation."
- (lisppaste-send-command 'pastedetails paste n))
-
-(defun lisppaste-list-annotations (paste)
- "List the annotations for PASTE."
- (lisppaste-send-command 'pasteannotationheaders paste))
-
-(defun lisppaste-list-pastes (n &optional start channel)
- "Fetch the most recent N pastes.
-
-If START is non-nil return the most recent N pastes from the STARTth
-paste.
-If CHANNEL is non-nil, only return pastes from that channel."
- (and start (zerop start) (setq start nil))
- (if (and channel
- (not (string= channel "")))
- (progn (lisppaste-check-channel channel)
- (lisppaste-send-command 'pasteheadersbychannel channel n start))
- (lisppaste-send-command 'pasteheaders n start)))
-
-(defun lisppaste-channels ()
- "Return which channels the lisppaste bot runs on."
- (lisppaste-send-command 'listchannels))
-
-(defvar lisppaste-channels nil
- "Cached value of the channels lisppaste is running on.
-
-Initialised using the function `lisppaste-channels'.")
-
-(defsubst lisppaste-check-channel (channel)
- "Check that CHANNEL is supported by lisppaste.
-
-Checks the cached value of the variable `lisppaste-channels' before
-requesting a new list."
- (or lisppaste-channels (setq lisppaste-channels (lisppaste-channels)))
- (unless (member channel lisppaste-channels)
- (error "%s not a valid channel. Try M-: (setq lisppaste-channels nil) RET"
- channel)))
-
-(defsubst lisppaste-all-channels ()
- ;; Retardedness due to completing read requiring an alist.
- (mapcar #'list
- (or lisppaste-channels
- (setq lisppaste-channels (lisppaste-channels)))))
-
-(defvar lisppaste-default-nick nil
- "*The default nick for pastes.
-
-See also the function `lisppaste-default-nick'.")
-
-(defsubst lisppaste-default-nick (channel)
- "Return the default nick for CHANNEL.
-
-If ERC is loaded, try and find a nick by looking for
-`erc-current-nick' in CHANNEL's buffer.
-
-If that returns nil, return the value of the variable
-`lisppaste-default-nick'."
- (or (when (featurep 'erc)
- (erc-with-buffer ((get-buffer channel))
- (erc-current-nick)))
- lisppaste-default-nick))
-
-(defsubst lisppaste-paste (p)
- (plist-get p 'lisppaste-paste))
-(defsubst lisppaste-annotation (p)
- (plist-get p 'lisppaste-annotation))
-(defsubst lisppaste-channel (p)
- (plist-get p 'lisppaste-channel))
-(defsubst lisppaste-annotations (p)
- (plist-get p 'lisppaste-annotations))
-
-(defsubst lisppaste-read-number (prompt &optional annotation)
- "Read a number prompting with PROMPT.
-
-Default values are picked up from the text-properties around `point'.
-If ANNOTATION is non-nil, look for annotation text-properties."
- (let* ((p (text-properties-at (point)))
- (num (lisppaste-paste p))
- (ann (lisppaste-annotation p)))
- (string-to-number
- (if annotation
- (read-from-minibuffer prompt
- (and ann
- (number-to-string ann)))
- (read-from-minibuffer prompt
- (and num
- (number-to-string num)))))))
-
-(defsubst lisppaste-read-channel ()
- "Read a channel name."
- (completing-read "Channel: " (lisppaste-all-channels)))
-
-(defsubst lisppaste-read-nick (c)
- "Read a nick.
-
-C is the default channel to look for a nick in with `lisppaste-default-nick'."
- (read-string "Nick: " (lisppaste-default-nick c)))
-
-(defsubst lisppaste-read-title ()
- "Read a paste title."
- (read-string "Title: "))
-
-(defun lisppaste-clean-returned-paste (paste)
- "Clean PASTE of HTML character entities."
- (with-temp-buffer
- (insert (format "%s" paste))
- (goto-char (point-min))
- ;; Remove spurious ^M's
- (save-excursion (while (search-forward "&#xD;" nil t)
- (replace-match "")))
- (while (re-search-forward "&\\(#x[^;]+\\);" nil t)
- (insert (read (match-string 1)))
- (replace-match ""))
- (buffer-substring-no-properties (point-min) (point-max))))
-
-(defun lisppaste-clean-time-string (time)
- "Clean an iso8601 TIME string to return YYYY-MM-DD.
-
-Not very robust."
- (if (string-match "^\\(....\\)\\(..\\)\\(..\\)T..:..:..$" time)
- (format "%s-%s-%s" (match-string 1 time)
- (match-string 2 time)
- (match-string 3 time))
- (error "Invalid time format `%s'" time)))
-
-(defvar lisppaste-creation-help
- (concat ";; Enter your paste below, and press C-c C-c to send.\n"
- ";; Press C-c C-d to cancel this paste.\n\n")
- "Paste creation help text.")
-
-(defsubst lisppaste-buffer-substring (beg end)
- "Return part of the current buffer as a string.
-
-BEG and END delimit the part of the buffer to return.
-
-The string is returned with all tabs replaced by spaces. See also
-`untabify'."
- (let* ((inhibit-read-only t)
- (s (buffer-substring-no-properties beg end))
- (tw tab-width))
- (with-temp-buffer
- (let ((tab-width tw))
- (insert s)
- (untabify (point-min) (point-max))
- (buffer-substring-no-properties (point-min) (point-max))))))
-
-;;;###autoload
-(defun lisppaste-paste-region (beg end)
- "Send the region between BEG and END as a paste."
- (interactive "r")
- (let* ((annotate (if (y-or-n-p "Send this region as an annotation? ")
- (lisppaste-read-number "Paste to annotate: ")))
- (channel (lisppaste-read-channel))
- (nick (lisppaste-read-nick channel))
- (title (lisppaste-read-title))
- (content (lisppaste-buffer-substring beg end)))
- (lisppaste-check-channel channel)
- (lisppaste-new-paste channel nick title content annotate)))
-
-
-(defun lisppaste-browse-url (url &rest ignore)
- "Display a paste URL as a paste in Emacs.
-
-To use this, modify `browse-url-browser-function' in the following way:
-
- (setq browse-url-browser-function
- '((\"^http://paste\\\\.lisp\\\\.org/display\" . lisppaste-browse-url)
- (\".\" . whatever-you-want-the-default-browse-url-function-to-be)))"
- (when (string-match
- "http://paste\\.lisp\\.org/display/\\([0-9]+\\)\\(?:#\\([0-9]+\\)\\)?"
- url)
- (let ((paste (string-to-number (match-string 1 url)))
- (ann (match-string 2 url)))
- (lisppaste-display-paste paste (if ann (string-to-number ann))))))
-
-(defun lisppaste-display-paste (paste &optional n)
- "Display PASTE.
-
-If N is non-nil, display PASTE's Nth annotation."
- (interactive
- (list (lisppaste-read-number "Paste number: ")))
- (when current-prefix-arg
- (setq n (lisppaste-read-number "Annotation number: " t)))
- (multiple-value-bind (num time user channel title annotations
- content) (lisppaste-get-paste paste n)
- (switch-to-buffer (get-buffer-create
- (format "*Paste %s%s*" paste
- (if n
- (format " annotation %s"
- n)
- ""))))
- (setq buffer-read-only nil)
- (erase-buffer)
- (insert (format "Paste number: %s%s\nUser: %s\nChannel: %s\nTitle: %s\nDate: %s\nAnnotations: %s\n\n"
- paste (if n
- (format "\nAnnotation: %s" n)
- "")
- user channel title
- (lisppaste-clean-time-string time)
- annotations))
- (insert (lisppaste-clean-returned-paste content))
- (set-text-properties (point-min)
- (point-max)
- `(lisppaste-user ,user
- lisppaste-title ,title
- lisppaste-time ,time
- lisppaste-paste ,paste
- lisppaste-annotation ,n
- lisppaste-annotations ,annotations
- lisppaste-channel ,channel)))
- (lisppaste-mode))
-
-(defun lisppaste-list-paste-annotations (paste)
- "List PASTE's annotations."
- (interactive
- (list (lisppaste-read-number
- "List annotations for paste number: ")))
- (let ((result (lisppaste-list-annotations paste))
- (buffer-read-only nil))
- (unless result
- (error "Paste %s has no annotations" paste))
- (switch-to-buffer (get-buffer-create
- (format "*Paste %s Annotations*" paste)))
- (erase-buffer)
- (loop for (num time user channel title annotations) in result
- do (insert
- (propertize (format
- "Annotation number: %s\nUser: %s\nchannel: %s\nTitle: %s\nDate: %s\n"
- num user channel title
- (lisppaste-clean-time-string time))
- 'lisppaste-user user
- 'lisppaste-time time
- 'lisppaste-paste paste
- 'lisppaste-annotation num
- 'lisppaste-channel channel
- 'lisppaste-annotations annotations)
- (make-string 75 ?=)
- "\n"))
- (lisppaste-mode)))
-
-(defun lisppaste-list-recent-pastes (n &optional start channel)
- "List the most recent N pastes.
-
-If START is non-nil, list the most recent N pastes prior to and
-including START.
-If CHANNEL is non-nil, only list pastes for that channel."
- (interactive "nNumber of pastes to get: ")
- (if current-prefix-arg
- (setq start (lisppaste-read-number "Start paste: ")
- channel (lisppaste-read-channel)))
- (let ((result (lisppaste-list-pastes n start channel)))
- (unless result
- (error "No pastes returned"))
- (switch-to-buffer (get-buffer-create
- (format "*Paste list%s*"
- (if (and channel (not (string= channel "")))
- (format " for %s" channel)
- ""))))
- (setq buffer-read-only nil)
- (erase-buffer)
- (loop for (num time user channel title annotations) in result
- do (insert
- (propertize (format
- "Paste number: %s\nUser: %s\nChannel: %s\nTitle: %s\nDate: %s\nAnnotations: %s\n"
- num user channel title (lisppaste-clean-time-string time)
- annotations)
- 'lisppaste-user user
- 'lisppaste-title title
- 'lisppaste-time time
- 'lisppaste-paste num
- 'lisppaste-channel channel
- 'lisppaste-annotations annotations)
- (make-string 75 ?=)
- "\n"))
- (lisppaste-mode)))
-
-(defun lisppaste-create-paste (callback-fn)
- "Create a new paste.
-
-CALLBACK-FN should be a function accepting one argument to send the
-paste. See also `lisppaste-send-paste'."
- (switch-to-buffer (get-buffer-create "*paste*"))
- (erase-buffer)
- (insert lisppaste-creation-help)
- (local-set-key (kbd "C-c C-d") #'lisppaste-quit)
- (local-set-key (kbd "C-c C-c") `(lambda ()
- (interactive)
- (lisppaste-send-paste ,callback-fn))))
-
-(defun lisppaste-send-paste (callback-fn)
- "Send a paste via CALLBACK-FN.
-
-CALLBACK-FN is called with one argument, the contents of the
-`current-buffer' from the end of `lisppaste-creation-help' to
-`point-max'."
- (goto-char (point-min))
- (search-forward lisppaste-creation-help)
- (funcall callback-fn (buffer-substring-no-properties
- (match-end 0) (point-max)))
- (kill-this-buffer))
-
-(defun lisppaste-create-new-paste (&optional channel nick title)
- "Interactively create a new paste.
-
-CHANNEL, NICK and TITLE are defaults for the paste's channel, nick
-and title arguments respectively."
- (interactive)
- (let* ((channel (or channel (lisppaste-read-channel)))
- (nick (or nick (lisppaste-read-nick channel)))
- (title (or title (lisppaste-read-title))))
- (lisppaste-check-channel channel)
- (lisppaste-create-paste `(lambda (x)
- (lisppaste-new-paste ,channel ,nick
- ,title x)))))
-
-(defun lisppaste-create-new-annotation (&optional channel nick title n)
- "Interactively annotate a paste.
-
-CHANNEL, NICK, TITLE and N are defaults for the annotations's
-channel, nick, title, and paste to annotate respectively."
- (interactive)
- (let* ((channel (or channel (lisppaste-read-channel)))
- (nick (or nick (lisppaste-read-nick channel)))
- (title (or title (lisppaste-read-title)))
- (n (or n (lisppaste-read-number "Paste to annotate: "))))
- (lisppaste-check-channel channel)
- (lisppaste-create-paste `(lambda (x)
- (lisppaste-new-paste ,channel ,nick
- ,title x ,n)))))
-
-(defun lisppaste-dwim ()
- "Display either the paste or annotation at `point'."
- (interactive)
- (let ((props (text-properties-at (point))))
- (unless (lisppaste-paste props)
- (error "No paste at point"))
- (if (lisppaste-annotation props)
- (lisppaste-display-paste (lisppaste-paste props)
- (lisppaste-annotation props))
- (lisppaste-display-paste (lisppaste-paste props)))))
-
-(defun lisppaste-quit ()
- "Quit the current paste buffer."
- (interactive)
- (set-buffer-modified-p nil)
- (kill-this-buffer))
-
-(defun lisppaste-annotate ()
- "Annotate the paste at `point'."
- (interactive)
- (let ((props (text-properties-at (point))))
- (lisppaste-create-new-annotation (lisppaste-channel props)
- nil
- nil
- (lisppaste-paste props))))
-
-(defun lisppaste-display-supported-channels ()
- "Display the channels that lisppaste is running in.
-
-As a side-effect, this updates the channel list stored in the
-variable `lisppaste-channels'."
- (interactive)
- (switch-to-buffer (get-buffer-create "*Lisppaste channels*"))
- (erase-buffer)
- (insert "Lisppaste is running on the following channels.\n\n")
- (mapc #'(lambda (c) (insert c "\n"))
- (setq lisppaste-channels (lisppaste-channels))))
-
-(defvar lisppaste-help
- (concat
- "Commands:\n"
- "`a' -- lisppaste-annotate\n"
- " Annotate the paste at point. With prefix arg, prompt\n"
- " for a paste number to annotate.\n"
- "`c' -- lisppaste-display-supported-channels\n"
- " Display channels lisppaste is running on.\n"
- "`d' -- lisppaste-display-paste\n"
- " Fetch a paste. With prefix arg, fetch an annotation.\n"
- "`h' -- lisppaste-help\n"
- " Show this help.\n"
- "`l a' -- lisppaste-list-paste-annotations\n"
- " List a paste's annotations.\n"
- "`l p' -- lisppaste-list-recent-pastes\n"
- " List recent pastes. With prefix arg, prompt for\n"
- " channel and start paste.\n"
- "`n' -- lisppaste-create-new-paste\n"
- " Create a new paste.\n"
- "RET -- lisppaste-dwim\n"
- " Fetch either the paste or the annotation at point.\n"
- "SPC -- scroll-up\n"
- "`q' -- lisppaste-quit\n"
- " Quit the paste display.\n"))
-
-(defun lisppaste-help ()
- "Show some help for `lisppaste-mode'."
- (interactive)
- (with-output-to-temp-buffer "*Lisppaste Help*"
- (princ lisppaste-help)))
-
-(defun lisppaste ()
- "Top-level interface to lisppaste."
- (interactive)
- (switch-to-buffer (get-buffer-create "*Lisppaste*"))
- (setq buffer-read-only nil)
- (erase-buffer)
- (insert "Top-level interface to lisppaste\n\n"
- lisppaste-help)
- (lisppaste-mode))
-
-(defvar lisppaste-mode-map
- (let ((map (make-sparse-keymap)))
- (define-key map "a" #'lisppaste-annotate)
- (define-key map "c" #'lisppaste-display-supported-channels)
- (define-key map "d" #'lisppaste-display-paste)
- (define-key map "h" #'lisppaste-help)
- (define-key map (kbd "l a") #'lisppaste-list-paste-annotations)
- (define-key map (kbd "l p") #'lisppaste-list-recent-pastes)
- (define-key map "n" #'lisppaste-create-new-paste)
- (define-key map (kbd "RET") #'lisppaste-dwim)
- (define-key map (kbd "SPC") #'scroll-up)
- (define-key map "q" #'lisppaste-quit)
- map)
- "Keymap for `lisppaste-mode'.")
-
-(define-derived-mode lisppaste-mode fundamental-mode "Lisppaste"
- "Major mode for viewing and creating IRC pastes via the lisppaste pastebot."
- (setq buffer-read-only t)
- (goto-char (point-min)))
-
-(provide 'lisppaste)
-
-;;; lisppaste.el ends here
View
1,391 elpa-to-submit/ruby-mode.el
@@ -1,1391 +0,0 @@
-;;; ruby-mode.el --- Major mode for editing Ruby files
-
-;; Copyright (C) 1994-2008 Yukihiro Matsumoto, Nobuyoshi Nakada
-
-;; Authors: Yukihiro Matsumoto, Nobuyoshi Nakada
-;; URL: http://www.emacswiki.org/cgi-bin/wiki/RubyMode
-;; Created: Fri Feb 4 14:49:13 JST 1994
-;; Keywords: languages ruby
-;; Version: 1.0
-
-;; This file is not yet part of GNU Emacs.
-
-;;; Commentary:
-
-;; Provides font-locking, indentation support, and navigation for Ruby code.
-
-;;; Todo:
-
-;; various docstrings labelled below with TODOs
-
-;;; Code:
-
-(defconst ruby-mode-revision "$Revision$"
- "Ruby mode revision string.")
-
-(defconst ruby-mode-version
- (and (string-match "[0-9.]+" ruby-mode-revision)
- (substring ruby-mode-revision (match-beginning 0) (match-end 0)))
- "Ruby mode version number.")
-
-(defconst ruby-block-beg-keywords
- '("class" "module" "def" "if" "unless" "case" "while" "until" "for" "begin" "do")
- "Keywords at the beginning of blocks.")
-
-(defconst ruby-block-beg-re
- (regexp-opt ruby-block-beg-keywords)
- "Regexp to match the beginning of blocks.")
-
-(defconst ruby-non-block-do-re
- (concat (regexp-opt '("while" "until" "for" "rescue") t) "\\_>")
- "Regexp to match keywords that nest without blocks.")
-
-(defconst ruby-indent-beg-re
- (concat "\\(\\s *" (regexp-opt '("class" "module" "def") t) "\\)\\|"
- (regexp-opt '("if" "unless" "case" "while" "until" "for" "begin")))
- "Regexp to match where the indentation gets deeper.")
-
-(defconst ruby-modifier-beg-keywords
- '("if" "unless" "while" "until")
- "Modifiers that are the same as the beginning of blocks.")
-
-(defconst ruby-modifier-beg-re
- (regexp-opt ruby-modifier-beg-keywords)
- "Regexp to match modifiers same as the beginning of blocks.")
-
-(defconst ruby-modifier-re
- (regexp-opt (cons "rescue" ruby-modifier-beg-keywords))
- "Regexp to match modifiers.")
-
-(defconst ruby-block-mid-keywords
- '("then" "else" "elsif" "when" "rescue" "ensure")
- "Keywords where the indentation gets shallower in middle of block statements.")
-
-(defconst ruby-block-mid-re
- (regexp-opt ruby-block-mid-keywords)
- "Regexp to match where the indentation gets shallower in middle of block statements.")
-
-(defconst ruby-block-op-keywords
- '("and" "or" "not")
- "Regexp to match boolean keywords.")
-
-(defconst ruby-block-hanging-re
- (regexp-opt (append ruby-modifier-beg-keywords ruby-block-op-keywords))
- "Regexp to match hanging block modifiers.")
-
-(defconst ruby-block-end-re "\\<end\\>")
-
-(defconst ruby-here-doc-beg-re
- "\\(<\\)<\\(-\\)?\\(\\([a-zA-Z0-9_]+\\)\\|[\"]\\([^\"]+\\)[\"]\\|[']\\([^']+\\)[']\\)"
- "Regexp to match the beginning of a heredoc.")
-
-(defconst ruby-here-doc-end-re
- "^\\([ \t]+\\)?\\(.*\\)\\(.\\)$"
- "Regexp to match the end of heredocs.
-
-This will actually match any line with one or more characters.
-It's useful in that it divides up the match string so that
-`ruby-here-doc-beg-match' can search for the beginning of the heredoc.")
-
-(defun ruby-here-doc-end-match ()
- "Return a regexp to find the end of a heredoc.
-
-This should only be called after matching against `ruby-here-doc-beg-re'."
- (concat "^"
- (if (match-string 2) "[ \t]*" nil)
- (regexp-quote
- (or (match-string 4)
- (match-string 5)
- (match-string 6)))))
-
-(defun ruby-here-doc-beg-match ()
- "Return a regexp to find the beginning of a heredoc.
-
-This should only be called after matching against `ruby-here-doc-end-re'."
- (let ((contents (regexp-quote (concat (match-string 2) (match-string 3)))))
- (concat "<<"
- (let ((match (match-string 1)))
- (if (and match (> (length match) 0))
- (concat "\\(?:-\\([\"']?\\)\\|\\([\"']\\)" (match-string 1) "\\)"
- contents "\\b\\(\\1\\|\\2\\)")
- (concat "-?\\([\"']\\|\\)" contents "\\b\\1"))))))
-
-(defconst ruby-delimiter
- (concat "[?$/%(){}#\"'`.:]\\|<<\\|\\[\\|\\]\\|\\<\\("
- ruby-block-beg-re
- "\\)\\>\\|" ruby-block-end-re
- "\\|^=begin\\|" ruby-here-doc-beg-re))
-
-(defconst ruby-negative
- (concat "^[ \t]*\\(\\(" ruby-block-mid-re "\\)\\>\\|"
- ruby-block-end-re "\\|}\\|\\]\\)")
- "Regexp to match where the indentation gets shallower.")
-
-(defconst ruby-operator-re "[-,.+*/%&|^~=<>:]"
- "Regexp to match operators.")
-
-(defconst ruby-symbol-chars "a-zA-Z0-9_"
- "List of characters that symbol names may contain.")
-(defconst ruby-symbol-re (concat "[" ruby-symbol-chars "]")
- "Regexp to match symbols.")
-
-(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
- (let ((map (make-sparse-keymap)))
- (define-key map "{" 'ruby-electric-brace)
- (define-key map "}" 'ruby-electric-brace)
- (define-key map (kbd "M-C-a") 'ruby-beginning-of-defun)
- (define-key map (kbd "M-C-e") 'ruby-end-of-defun)
- (define-key map (kbd "M-C-b") 'ruby-backward-sexp)
- (define-key map (kbd "M-C-f") 'ruby-forward-sexp)
- (define-key map (kbd "M-C-p") 'ruby-beginning-of-block)
- (define-key map (kbd "M-C-n") 'ruby-end-of-block)
- (define-key map (kbd "M-C-h") 'ruby-mark-defun)
- (define-key map (kbd "M-C-q") 'ruby-indent-exp)
- (define-key map (kbd "TAB") 'ruby-indent-line)
- (define-key map (kbd "C-M-h") 'backward-kill-word)
- (define-key map (kbd "C-j") 'reindent-then-newline-and-indent)
- (define-key map (kbd "C-m") 'newline)
- map)
- "Keymap used in ruby-mode.")
-
-(defvar ruby-mode-syntax-table
- (let ((table (make-syntax-table)))
- (modify-syntax-entry ?\' "\"" table)
- (modify-syntax-entry ?\" "\"" table)
- (modify-syntax-entry ?\` "\"" table)
- (modify-syntax-entry ?# "<" table)
- (modify-syntax-entry ?\n ">" table)
- (modify-syntax-entry ?\\ "\\" table)
- (modify-syntax-entry ?$ "." table)
- (modify-syntax-entry ?? "_" table)
- (modify-syntax-entry ?_ "_" table)
- (modify-syntax-entry ?< "." table)
- (modify-syntax-entry ?> "." table)
- (modify-syntax-entry ?& "." table)
- (modify-syntax-entry ?| "." table)
- (modify-syntax-entry ?% "." table)
- (modify-syntax-entry ?= "." table)
- (modify-syntax-entry ?/ "." table)
- (modify-syntax-entry ?+ "." table)
- (modify-syntax-entry ?* "." table)
- (modify-syntax-entry ?- "." table)
- (modify-syntax-entry ?\; "." table)
- (modify-syntax-entry ?\( "()" table)
- (modify-syntax-entry ?\) ")(" table)
- (modify-syntax-entry ?\{ "(}" table)
- (modify-syntax-entry ?\} "){" table)
- (modify-syntax-entry ?\[ "(]" table)
- (modify-syntax-entry ?\] ")[" table)
- table)
- "Syntax table to use in ruby-mode.")
-
-(defcustom ruby-indent-tabs-mode nil
- "Indentation can insert tabs in ruby mode if this is non-nil."
- :type 'boolean :group 'ruby)
-
-(defcustom ruby-indent-level 2
- "Indentation of ruby statements."
- :type 'integer :group 'ruby)
-
-(defcustom ruby-comment-column 32
- "Indentation column of comments."
- :type 'integer :group 'ruby)
-
-(defcustom ruby-deep-arglist t
- "Deep indent lists in parenthesis when non-nil.
-Also ignores spaces after parenthesis when 'space."
- :group 'ruby)
-
-(defcustom ruby-deep-indent-paren '(?\( ?\[ ?\] t)
- "Deep indent lists in parenthesis when non-nil. t means continuous line.
-Also ignores spaces after parenthesis when 'space."
- :group 'ruby)
-
-(defcustom ruby-deep-indent-paren-style 'space
- "Default deep indent style."
- :options '(t nil space) :group 'ruby)
-
-(defcustom ruby-encoding-map '((shift_jis . cp932) (shift-jis . cp932))
- "Alist to map encoding name from Emacs to Ruby."
- :group 'ruby)
-
-(defcustom ruby-use-encoding-map t
- "Use `ruby-encoding-map' to set encoding magic comment if this is non-nil."
- :type 'boolean :group 'ruby)
-
-(eval-when-compile (require 'cl))
-(defun ruby-imenu-create-index-in-block (prefix beg end)
- "Create an imenu index of methods inside a block."
- (let ((index-alist '()) (case-fold-search nil)
- name next pos decl sing)
- (goto-char beg)
- (while (re-search-forward "^\\s *\\(\\(class\\s +\\|\\(class\\s *<<\\s *\\)\\|module\\s +\\)\\([^\(<\n ]+\\)\\|\\(def\\|alias\\)\\s +\\([^\(\n ]+\\)\\)" end t)
- (setq sing (match-beginning 3))
- (setq decl (match-string 5))
- (setq next (match-end 0))
- (setq name (or (match-string 4) (match-string 6)))
- (setq pos (match-beginning 0))
- (cond
- ((string= "alias" decl)
- (if prefix (setq name (concat prefix name)))
- (push (cons name pos) index-alist))
- ((string= "def" decl)
- (if prefix
- (setq name
- (cond
- ((string-match "^self\." name)
- (concat (substring prefix 0 -1) (substring name 4)))
- (t (concat prefix name)))))
- (push (cons name pos) index-alist)
- (ruby-accurate-end-of-block end))
- (t
- (if (string= "self" name)
- (if prefix (setq name (substring prefix 0 -1)))
- (if prefix (setq name (concat (substring prefix 0 -1) "::" name)))
- (push (cons name pos) index-alist))
- (ruby-accurate-end-of-block end)
- (setq beg (point))
- (setq index-alist
- (nconc (ruby-imenu-create-index-in-block
- (concat name (if sing "." "#"))
- next beg) index-alist))
- (goto-char beg))))
- index-alist))
-
-(defun ruby-imenu-create-index ()
- "Create an imenu index of all methods in the buffer."
- (nreverse (ruby-imenu-create-index-in-block nil (point-min) nil)))
-
-(defun ruby-accurate-end-of-block (&optional end)
- "TODO: document."
- (let (state
- (end (or end (point-max))))
- (while (and (setq state (apply 'ruby-parse-partial end state))
- (>= (nth 2 state) 0) (< (point) end)))))
-
-(defun ruby-mode-variables ()
- "Set up initial buffer-local variables for ruby-mode."
- (set-syntax-table ruby-mode-syntax-table)
- (setq local-abbrev-table ruby-mode-abbrev-table)
- (setq indent-tabs-mode ruby-indent-tabs-mode)
- (set (make-local-variable 'indent-line-function) 'ruby-indent-line)
- (set (make-local-variable 'require-final-newline) t)
- (set (make-variable-buffer-local 'comment-start) "# ")
- (set (make-variable-buffer-local 'comment-end) "")
- (set (make-variable-buffer-local 'comment-column) ruby-comment-column)
- (set (make-variable-buffer-local 'comment-start-skip) "#+ *")
- (set (make-local-variable 'parse-sexp-ignore-comments) t)
- (set (make-local-variable 'parse-sexp-lookup-properties) t)
- (set (make-local-variable 'paragraph-start) (concat "$\\|" page-delimiter))
- (set (make-local-variable 'paragraph-separate) paragraph-start)
- (set (make-local-variable 'paragraph-ignore-fill-prefix) t))
-
-(defun ruby-mode-set-encoding ()
- "Insert a magic comment header with the proper encoding if necessary."
- (save-excursion
- (widen)
- (goto-char (point-min))
- (when (re-search-forward "[^\0-\177]" nil t)
- (goto-char (point-min))
- (let ((coding-system
- (or coding-system-for-write
- buffer-file-coding-system)))
- (if coding-system
- (setq coding-system
- (or (coding-system-get coding-system 'mime-charset)
- (coding-system-change-eol-conversion coding-system nil))))
- (setq coding-system
- (if coding-system
- (symbol-name
- (or (and ruby-use-encoding-map
- (cdr (assq coding-system ruby-encoding-map)))
- coding-system))
- "ascii-8bit"))
- (if (looking-at "^#![^\n]*ruby") (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 (insert "# -*- coding: " coding-system " -*-\n"))
- )))))
-
-;;;###autoload
-(defun ruby-mode ()
- "Major mode for editing Ruby scripts.
-\\[ruby-indent-line] 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)
-
- (set (make-local-variable 'imenu-create-index-function)
- 'ruby-imenu-create-index)
- (set (make-local-variable 'add-log-current-defun-function)
- 'ruby-add-log-current-method)
-
- (add-hook
- (cond ((boundp 'before-save-hook)
- (make-local-variable 'before-save-hook)
- 'before-save-hook)
- ((boundp 'write-contents-functions) 'write-contents-functions)
- ((boundp 'write-contents-hooks) 'write-contents-hooks))
- 'ruby-mode-set-encoding)
-
- (set (make-local-variable 'font-lock-defaults) '((ruby-font-lock-keywords) nil nil))
- (set (make-local-variable 'font-lock-keywords) ruby-font-lock-keywords)
- (set (make-local-variable 'font-lock-syntax-table) ruby-font-lock-syntax-table)
- (set (make-local-variable 'font-lock-syntactic-keywords) ruby-font-lock-syntactic-keywords)
-
- (if (fboundp 'run-mode-hooks)
- (run-mode-hooks 'ruby-mode-hook)
- (run-hooks 'ruby-mode-hook)))
-
-(defun ruby-current-indentation ()
- "Return the indentation level of current line."
- (save-excursion
- (beginning-of-line)
- (back-to-indentation)
- (current-column)))
-
-(defun ruby-indent-line (&optional flag)
- "Correct the indentation of the current ruby line."
- (interactive)
- (ruby-indent-to (ruby-calculate-indent)))
-
-(defun ruby-indent-to (column)
- "Indent the current line to COLUMN."
- (when column
- (let (shift top beg)
- (and (< column 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")
- (if (>= shift top) (setq shift (- shift top))
- (setq shift 0))
- (if (and (bolp)
- (= column top))
- (move-to-column (+ column shift))
- (move-to-column top)
- (delete-region beg (point))
- (beginning-of-line)
- (indent-to column)
- (move-to-column (+ column shift))))))
-
-(defun ruby-special-char-p (&optional pnt)
- "Return t if the character before PNT (default `point') is a special character.
-
-Special characters are `?', `$', `:' when preceded by whitespace,
-and `\\' when preceded by `?'."
- (setq pnt (or pnt (point)))
- (let ((c (char-before pnt)) (b (and (< (point-min) pnt) (char-before (1- pnt)))))
- (cond ((or (eq c ??) (eq c ?$)))
- ((and (eq c ?:) (or (not b) (eq (char-syntax b) ? ))))
- ((eq c ?\\) (eq b ??)))))
-
-(defun ruby-expr-beg (&optional option)
- "TODO: document."
- (save-excursion
- (store-match-data nil)
- (let ((space (skip-chars-backward " \t"))
- (start (point)))
- (cond
- ((bolp) t)
- ((progn
- (forward-char -1)
- (and (looking-at "\\?")
- (or (eq (char-syntax (char-before (point))) ?w)
- (ruby-special-char-p))))
- nil)
- ((and (eq option 'heredoc) (< space 0)) t)
- ((or (looking-at ruby-operator-re)
- (looking-at "[\\[({,;]")
- (and (looking-at "[!?]")
- (or (not (eq option 'modifier))
- (bolp)
- (save-excursion (forward-char -1) (looking-at "\\Sw$"))))
- (and (looking-at ruby-symbol-re)
- (skip-chars-backward ruby-symbol-chars)
- (cond
- ((looking-at (regexp-opt
- (append ruby-block-beg-keywords
- ruby-block-op-keywords
- ruby-block-mid-keywords)
- 'words))
- (goto-char (match-end 0))
- (not (looking-at "\\s_")))
- ((eq option 'expr-qstr)
- (looking-at "[a-zA-Z][a-zA-z0-9_]* +%[^ \t]"))
- ((eq option 'expr-re)
- (looking-at "[a-zA-Z][a-zA-z0-9_]* +/[^ \t]"))
- (t nil)))))))))
-
-(defun ruby-forward-string (term &optional end no-error expand)
- "TODO: document."
- (let ((n 1) (c (string-to-char term))
- (re (if expand
- (concat "[^\\]\\(\\\\\\\\\\)*\\([" term "]\\|\\(#{\\)\\)")
- (concat "[^\\]\\(\\\\\\\\\\)*[" term "]"))))
- (while (and (re-search-forward re end no-error)
- (if (match-beginning 3)
- (ruby-forward-string "}{" end no-error nil)
- (> (setq n (if (eq (char-before (point)) c)
- (1- n) (1+ n))) 0)))
- (forward-char -1))
- (cond ((zerop n))
- (no-error nil)
- ((error "unterminated string")))))
-
-(defun ruby-deep-indent-paren-p (c)
- "TODO: document."
- (cond ((listp ruby-deep-indent-paren)
- (let ((deep (assoc c ruby-deep-indent-paren)))
- (cond (deep
- (or (cdr deep) ruby-deep-indent-paren-style))
- ((memq c ruby-deep-indent-paren)
- ruby-deep-indent-paren-style))))
- ((eq c ruby-deep-indent-paren) ruby-deep-indent-paren-style)
- ((eq c ?\( ) ruby-deep-arglist)))
-
-(defun ruby-parse-partial (&optional end in-string nest depth pcol indent)
- "TODO: document throughout function body."
- (or depth (setq depth 0))
- (or indent (setq indent 0))
- (when (re-search-forward ruby-delimiter end 'move)
- (let ((pnt (point)) w re expand)
- (goto-char (match-beginning 0))
- (cond
- ((and (memq (char-before) '(?@ ?$)) (looking-at "\\sw"))
- (goto-char pnt))
- ((looking-at "[\"`]") ;skip string
- (cond
- ((and (not (eobp))
- (ruby-forward-string (buffer-substring (point) (1+ (point))) end t t))
- nil)
- (t
- (setq in-string (point))
- (goto-char end))))
- ((looking-at "'")
- (cond
- ((and (not (eobp))
- (re-search-forward "[^\\]\\(\\\\\\\\\\)*'" end t))
- nil)
- (t
- (setq in-string (point))
- (goto-char end))))
- ((looking-at "/=")
- (goto-char pnt))
- ((looking-at "/")
- (cond
- ((and (not (eobp)) (ruby-expr-beg 'expr-re))
- (if (ruby-forward-string "/" end t t)
- nil
- (setq in-string (point))
- (goto-char end)))
- (t
- (goto-char pnt))))
- ((looking-at "%")
- (cond
- ((and (not (eobp))
- (ruby-expr-beg 'expr-qstr)
- (not (looking-at "%="))
- (looking-at "%[QqrxWw]?\\([^a-zA-Z0-9 \t\n]\\)"))
- (goto-char (match-beginning 1))
- (setq expand (not (memq (char-before) '(?q ?w))))
- (setq w (match-string 1))
- (cond
- ((string= w "[") (setq re "]["))
- ((string= w "{") (setq re "}{"))
- ((string= w "(") (setq re ")("))
- ((string= w "<") (setq re "><"))
- ((and expand (string= w "\\"))
- (setq w (concat "\\" w))))
- (unless (cond (re (ruby-forward-string re end t expand))
- (expand (ruby-forward-string w end t t))
- (t (re-search-forward
- (if (string= w "\\")
- "\\\\[^\\]*\\\\"
- (concat "[^\\]\\(\\\\\\\\\\)*" w))
- end t)))
- (setq in-string (point))
- (goto-char end)))
- (t
- (goto-char pnt))))
- ((looking-at "\\?") ;skip ?char
- (cond
- ((and (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 "[\\[{(]")
- (let ((deep (ruby-deep-indent-paren-p (char-after))))
- (if (and deep (or (not (eq (char-after) ?\{)) (ruby-expr-beg)))
- (progn
- (and (eq deep 'space) (looking-at ".\\s +[^# \t\n]")
- (setq pnt (1- (match-end 0))))
- (setq nest (cons (cons (char-after (point)) pnt) nest))
- (setq pcol (cons (cons pnt depth) pcol))
- (setq depth 0))
- (setq nest (cons (cons (char-after (point)) pnt) nest))
- (setq depth (1+ depth))))
- (goto-char pnt)
- )
- ((looking-at "[])}]")
- (if (ruby-deep-indent-paren-p (matching-paren (char-after)))
- (setq depth (cdr (car pcol)) pcol (cdr pcol))
- (setq depth (1- depth)))
- (setq nest (cdr nest))
- (goto-char pnt))
- ((looking-at ruby-block-end-re)
- (if (or (and (not (bolp))
- (progn
- (forward-char -1)
- (setq w (char-after (point)))
- (or (eq ?_ w)
- (eq ?. w))))
- (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 (concat "\\<\\(" ruby-block-beg-re "\\)\\>"))
- (and
- (save-match-data
- (or (not (looking-at "do\\_>"))
- (save-excursion
- (back-to-indentation)
- (not (looking-at ruby-non-block-do-re)))))
- (or (bolp)
- (progn
- (forward-char -1)
- (setq w (char-after (point)))
- (not (or (eq ?_ w)
- (eq ?. w)))))
- (goto-char pnt)
- (setq w (char-after (point)))
- (not (eq ?_ w))
- (not (eq ?! w))
- (not (eq ?? w))
- (skip-chars-forward " \t")
- (goto-char (match-beginning 0))
- (or (not (looking-at ruby-modifier-re))
- (ruby-expr-beg 'modifier))
- (goto-char pnt)
- (setq nest (cons (cons nil pnt) nest))
- (setq depth (1+ depth)))
- (goto-char pnt))
- ((looking-at ":\\(['\"]\\)")
- (goto-char (match-beginning 1))
- (ruby-forward-string (buffer-substring (match-beginning 1) (match-end 1)) end))
- ((looking-at ":\\([-,.+*/%&|^~<>]=?\\|===?\\|<=>\\)")
- (goto-char (match-end 0)))
- ((looking-at ":\\([a-zA-Z_][a-zA-Z_0-9]*[!?=]?\\)?")
- (goto-char (match-end 0)))
- ((or (looking-at "\\.\\.\\.?")
- (looking-at "\\.[0-9]+")
- (looking-at "\\.[a-zA-Z_0-9]+")
- (looking-at "\\."))
- (goto-char (match-end 0)))
- ((looking-at "^=begin")
- (if (re-search-forward "^=end" end t)
- (forward-line 1)
- (setq in-string (match-end 0))
- (goto-char end)))
- ((looking-at "<<")
- (cond
- ((and (ruby-expr-beg 'heredoc)
- (looking-at "<<\\(-\\)?\\(\\([\"'`]\\)\\([^\n]+?\\)\\3\\|\\(?:\\sw\\|\\s_\\)+\\)"))
- (setq re (regexp-quote (or (match-string 4) (match-string 2))))
- (if (match-beginning 1) (setq re (concat "\\s *" re)))
- (let* ((id-end (goto-char (match-end 0)))
- (line-end-position (save-excursion (end-of-line) (point)))
- (state (list in-string nest depth pcol indent)))
- ;; parse the rest of the line
- (while (and (> line-end-position (point))
- (setq state (apply 'ruby-parse-partial
- line-end-position state))))
- (setq in-string (car state)
- nest (nth 1 state)
- depth (nth 2 state)
- pcol (nth 3 state)
- indent (nth 4 state))
- ;; skip heredoc section
- (if (re-search-forward (concat "^" re "$") end 'move)
- (forward-line 1)
- (setq in-string id-end)
- (goto-char end))))
- (t
- (goto-char pnt))))
- ((looking-at "^__END__$")
- (goto-char pnt))
- ((looking-at ruby-here-doc-beg-re)
- (if (re-search-forward (ruby-here-doc-end-match)
- 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 nest depth pcol))
-
-(defun ruby-parse-region (start end)
- "TODO: document."
- (let (state)
- (save-excursion
- (if start
- (goto-char start)
- (ruby-beginning-of-indent))
- (save-restriction
- (narrow-to-region (point) end)
- (while (and (> end (point))
- (setq state (apply 'ruby-parse-partial end state))))))
- (list (nth 0 state) ; in-string
- (car (nth 1 state)) ; nest
- (nth 2 state) ; depth
- (car (car (nth 3 state))) ; pcol
- ;(car (nth 5 state)) ; indent
- )))
-
-(defun ruby-indent-size (pos nest)
- "Returns the indentation level in spaces NEST levels deeper than POS."
- (+ pos (* (or nest 1) ruby-indent-level)))
-
-(defun ruby-calculate-indent (&optional parse-start)
- "Returns the proper indentation level of the current line."
- ;; TODO: Document body
- (save-excursion
- (beginning-of-line)
- (let ((indent-point (point))
- (case-fold-search nil)
- state bol eol begin op-end
- (paren (progn (skip-syntax-forward " ")
- (and (char-after) (matching-paren (char-after)))))
- (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 (setq begin (cdr (nth 1 state))))
- (let ((deep (ruby-deep-indent-paren-p (car (nth 1 state)))))
- (if deep
- (cond ((and (eq deep t) (eq (car (nth 1 state)) paren))
- (skip-syntax-backward " ")
- (setq indent (1- (current-column))))
- ((let ((s (ruby-parse-region (point) indent-point)))
- (and (nth 2 s) (> (nth 2 s) 0)
- (or (goto-char (cdr (nth 1 s))) t)))
- (forward-word -1)
- (setq indent (ruby-indent-size (current-column) (nth 2 state))))
- (t
- (setq indent (current-column))
- (cond ((eq deep 'space))
- (paren (setq indent (1- indent)))
- (t (setq indent (ruby-indent-size (1- indent) 1))))))
- (if (nth 3 state) (goto-char (nth 3 state))
- (goto-char parse-start) (back-to-indentation))
- (setq indent (ruby-indent-size (current-column) (nth 2 state))))
- (and (eq (car (nth 1 state)) paren)
- (ruby-deep-indent-paren-p (matching-paren paren))
- (search-backward (char-to-string paren))
- (setq indent (current-column)))))
- ((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
- (setq begin (point))
- (cond
- ((looking-at "do\\>[^_]") ; iter block is a special case
- (if (nth 3 state) (goto-char (nth 3 state))
- (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)))))
- (when indent
- (goto-char indent-point)
- (end-of-line)
- (setq eol (point))
- (beginning-of-line)
- (cond
- ((and (not (ruby-deep-indent-paren-p paren))
- (re-search-forward ruby-negative eol t))
- (and (not (eq ?_ (char-after (match-end 0))))
- (setq indent (- indent ruby-indent-level))))
- ((and
- (save-excursion
- (beginning-of-line)
- (not (bobp)))
- (or (ruby-deep-indent-paren-p t)
- (null (car (nth 1 state)))))
- ;; 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 the comment at the end
- (skip-chars-backward " \t")
- (let (end (pos (point)))
- (beginning-of-line)
- (while (and (re-search-forward "#" pos t)
- (setq end (1- (point)))
- (or (ruby-special-char-p end)
- (and (setq state (ruby-parse-region parse-start end))
- (nth 0 state))))
- (setq end nil))
- (goto-char (or end pos))
- (skip-chars-backward " \t")
- (setq begin (if (and end (nth 0 state)) pos (cdr (nth 1 state))))
- (setq state (ruby-parse-region parse-start (point))))
- (or (bobp) (forward-char -1))
- (and
- (or (and (looking-at ruby-symbol-re)
- (skip-chars-backward ruby-symbol-chars)
- (looking-at (concat "\\<\\(" ruby-block-hanging-re "\\)\\>"))
- (not (eq (point) (nth 3 state)))
- (save-excursion
- (goto-char (match-end 0))
- (not (looking-at "[a-z_]"))))
- (and (looking-at ruby-operator-re)
- (not (ruby-special-char-p))
- ;; operator at the end of line
- (let ((c (char-after (point))))
- (and
-;; (or (null begin)
-;; (save-excursion
-;; (goto-char begin)
-;; (skip-chars-forward " \t")
-;; (not (or (eolp) (looking-at "#")
-;; (and (eq (car (nth 1 state)) ?{)
-;; (looking-at "|"))))))
- (or (not (eq ?/ c))
- (null (nth 0 (ruby-parse-region (or begin parse-start) (point)))))
- (or (not (eq ?| (char-after (point))))
- (save-excursion
- (or (eolp) (forward-char -1))
- (cond
- ((search-backward "|" nil t)
- (skip-chars-backward " \t\n")
- (and (not (eolp))
- (progn
- (forward-char -1)
- (not (looking-at "{")))
- (progn
- (forward-word -1)
- (not (looking-at "do\\>[^_]")))))
- (t t))))
- (not (eq ?, c))
- (setq op-end t)))))
- (setq indent
- (cond
- ((and
- (null op-end)
- (not (looking-at (concat "\\<\\(" ruby-block-hanging-re "\\)\\>")))
- (eq (ruby-deep-indent-paren-p t) 'space)
- (not (bobp)))
- (widen)
- (goto-char (or begin parse-start))
- (skip-syntax-forward " ")
- (current-column))
- ((car (nth 1 state)) indent)
- (t
- (+ indent ruby-indent-level))))))))
- (goto-char indent-point)
- (beginning-of-line)
- (skip-syntax-forward " ")
- (if (looking-at "\\.[^.]")
- (+ indent ruby-indent-level)
- indent))))
-
-(defun ruby-electric-brace (arg)
- "Inserts a brace and re-indents the current line."
- (interactive "P")
- (self-insert-command (prefix-numeric-value arg))
- (ruby-indent-line t))
-
-(eval-when-compile
- (defmacro defun-region-command (func args &rest body)
- "TODO: document."
- ;; If we drop xemacs support, we can replace this macro with a simple defun
- (let ((intr (car body)))
- (when (featurep 'xemacs)
- (if (stringp intr) (setq intr (cadr body)))
- (and (eq (car intr) 'interactive)
- (setq intr (cdr intr))
- (setcar intr (concat "_" (car intr)))))
- (cons 'defun (cons func (cons args body))))))
-
-
-;; TODO: Why isn't one ruby-*-of-defun written in terms of the other?
-(defun-region-command ruby-beginning-of-defun (&optional arg)
- "Move backward to the beginning of the current top-level defun.
-With ARG, move backward multiple defuns. Negative ARG means
-move forward."
- (interactive "p")
- (and (re-search-backward (concat "^\\(" ruby-block-beg-re "\\)\\b")
- nil 'move (or arg 1))
- (beginning-of-line)))
-
-(defun-region-command ruby-end-of-defun (&optional arg)
- "Move forward to the end of the current top-level defun.
-With ARG, move forward multiple defuns. Negative ARG means
-move backward."
- (interactive "p")
- (and (re-search-forward (concat "^\\(" ruby-block-end-re "\\)\\($\\|\\b[^_]\\)")
- nil 'move (or arg 1))
- (beginning-of-line))
- (forward-line 1))
-
-(defun ruby-beginning-of-indent ()
- "TODO: document"
- ;; I don't understand this function.
- ;; It seems like it should move to the line where indentation should deepen,
- ;; but ruby-indent-beg-re only accounts for whitespace before class, module and def,
- ;; so this will only match other block beginners at the beginning of the line.
- (and (re-search-backward (concat "^\\(" ruby-indent-beg-re "\\)\\b") nil 'move)
- (beginning-of-line)))
-
-(defun ruby-move-to-block (n)
- "Moves to the beginning (N < 0) or the end (N > 0) of the current block
-or blocks containing the current block."
- ;; TODO: Make this work for n > 1,
- ;; make it not loop for n = 0,
- ;; document body
- (let (start pos done down)
- (setq start (ruby-calculate-indent))
- (setq down (looking-at (if (< n 0) ruby-block-end-re
- (concat "\\<\\(" ruby-block-beg-re "\\)\\>"))))
- (while (and (not done) (not (if (< n 0) (bobp) (eobp))))
- (forward-line n)
- (cond
- ((looking-at "^\\s *$"))
- ((looking-at "^\\s *#"))
- ((and (> n 0) (looking-at "^=begin\\>"))
- (re-search-forward "^=end\\>"))
- ((and (< n 0) (looking-at "^=end\\>"))
- (re-search-backward "^=begin\\>"))
- (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
- (save-excursion
- (back-to-indentation)
- (if (looking-at (concat "\\<\\(" ruby-block-mid-re "\\)\\>"))
- (setq done nil))))))
- (back-to-indentation))
-
-(defun-region-command ruby-beginning-of-block (&optional arg)
- "Move backward to the beginning of the current block.
-With ARG, move up multiple blocks."
- (interactive "p")
- (ruby-move-to-block (- (or arg 1))))
-
-(defun-region-command ruby-end-of-block (&optional arg)
- "Move forward to the end of the current block.
-With ARG, move out of multiple blocks."
- ;; Passing a value > 1 to ruby-move-to-block currently doesn't work.
- (interactive)
- (ruby-move-to-block (or arg 1)))
-
-(defun-region-command ruby-forward-sexp (&optional arg)
- "Move forward across one balanced expression (sexp).
-With ARG, do it many times. Negative ARG means move backward."
- ;; TODO: Document body
- (interactive "p")
- (if (and (numberp arg) (< arg 0))
- (ruby-backward-sexp (- arg))
- (let ((i (or arg 1)))
- (condition-case nil
- (while (> i 0)
- (skip-syntax-forward " ")
- (cond ((looking-at "\\?\\(\\\\[CM]-\\)*\\\\?\\S ")
- (goto-char (match-end 0)))
- ((progn
- (skip-chars-forward ",.:;|&^~=!?\\+\\-\\*")
- (looking-at "\\s("))
- (goto-char (scan-sexps (point) 1)))
- ((and (looking-at (concat "\\<\\(" ruby-block-beg-re "\\)\\>"))
- (not (eq (char-before (point)) ?.))
- (not (eq (char-before (point)) ?:)))
- (ruby-end-of-block)
- (forward-word 1))
- ((looking-at "\\(\\$\\|@@?\\)?\\sw")
- (while (progn
- (while (progn (forward-word 1) (looking-at "_")))
- (cond ((looking-at "::") (forward-char 2) t)
- ((> (skip-chars-forward ".") 0))
- ((looking-at "\\?\\|!\\(=[~=>]\\|[^~=]\\)")
- (forward-char 1) nil)))))
- ((let (state expr)
- (while
- (progn
- (setq expr (or expr (ruby-expr-beg)
- (looking-at "%\\sw?\\Sw\\|[\"'`/]")))
- (nth 1 (setq state (apply 'ruby-parse-partial nil state))))
- (setq expr t)
- (skip-chars-forward "<"))
- (not expr))))
- (setq i (1- i)))
- ((error) (forward-word 1)))
- i)))
-
-(defun-region-command ruby-backward-sexp (&optional arg)
- "Move backward across one balanced expression (sexp).
-With ARG, do it many times. Negative ARG means move forward."
- ;; TODO: Document body
- (interactive "p")
- (if (and (numberp arg) (< arg 0))
- (ruby-forward-sexp (- arg))
- (let ((i (or arg 1)))
- (condition-case nil
- (while (> i 0)
- (skip-chars-backward " \t\n,.:;|&^~=!?\\+\\-\\*")
- (forward-char -1)
- (cond ((looking-at "\\s)")
- (goto-char (scan-sexps (1+ (point)) -1))
- (case (char-before)
- (?% (forward-char -1))
- ('(?q ?Q ?w ?W ?r ?x)
- (if (eq (char-before (1- (point))) ?%) (forward-char -2))))
- nil)
- ((looking-at "\\s\"\\|\\\\\\S_")
- (let ((c (char-to-string (char-before (match-end 0)))))
- (while (and (search-backward c)
- (oddp (skip-chars-backward "\\")))))
- nil)
- ((looking-at "\\s.\\|\\s\\")
- (if (ruby-special-char-p) (forward-char -1)))
- ((looking-at "\\s(") nil)
- (t
- (forward-char 1)
- (while (progn (forward-word -1)
- (case (char-before)
- (?_ t)
- (?. (forward-char -1) t)
- ((?$ ?@)
- (forward-char -1)
- (and (eq (char-before) (char-after)) (forward-char -1)))
- (?:
- (forward-char -1)
- (eq (char-before) :)))))
- (if (looking-at ruby-block-end-re)
- (ruby-beginning-of-block))
- nil))
- (setq i (1- i)))
- ((error)))
- i)))
-
-(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))
-
-(defun ruby-indent-exp (&optional shutup-p)
- "Indent each line in the balanced expression following the point.
-If a prefix arg is given or SHUTUP-P is non-nil, no errors
-are signalled if a balanced expression isn't found."
- (interactive "*P")
- (let ((here (point-marker)) start top column (nest t))
- (set-marker-insertion-type here t)
- (unwind-protect
- (progn
- (beginning-of-line)
- (setq start (point) top (current-indentation))
- (while (and (not (eobp))
- (progn
- (setq column (ruby-calculate-indent start))
- (cond ((> column top)
- (setq nest t))
- ((and (= column top) nest)
- (setq nest nil) t))))
- (ruby-indent-to column)
- (beginning-of-line 2)))
- (goto-char here)
- (set-marker here nil))))
-
-(defun ruby-add-log-current-method ()
- "Returns the current method name as a string.
-This string includes all namespaces.
-
-For example:
-
- #exit
- String#gsub
- Net::HTTP#active?
- File::open.
-
-See `add-log-current-defun-function'."
- ;; TODO: Document body
- ;; Why does this append a period to class methods?
- (condition-case nil
- (save-excursion
- (let (mname mlist (indent 0))
- ;; get current method (or class/module)
- (if (re-search-backward
- (concat "^[ \t]*\\(def\\|class\\|module\\)[ \t]+"
- "\\("
- ;; \\. and :: for class method
- "\\([A-Za-z_]" ruby-symbol-re "*\\|\\.\\|::" "\\)"
- "+\\)")
- nil t)
- (progn
- (setq mname (match-string 2))
- (unless (string-equal "def" (match-string 1))
- (setq mlist (list mname) mname nil))
- (goto-char (match-beginning 1))
- (setq indent (current-column))
- (beginning-of-line)))
- ;; nest class/module
- (while (and (> indent 0)
- (re-search-backward
- (concat
- "^[ \t]*\\(class\\|module\\)[ \t]+"
- "\\([A-Z]" ruby-symbol-re "*\\)")
- nil t))
- (goto-char (match-beginning 1))
- (if (< (current-column) indent)
- (progn
- (setq mlist (cons (match-string 2) mlist))
- (setq indent (current-column))
- (beginning-of-line))))
- (when mname
- (let ((mn (split-string mname "\\.\\|::")))
- (if (cdr mn)
- (progn
- (cond
- ((string-equal "" (car mn))
- (setq mn (cdr mn) mlist nil))
- ((string-equal "self" (car mn))
- (setq mn (cdr mn)))
- ((let ((ml (nreverse mlist)))
- (while ml
- (if (string-equal (car ml) (car mn))
- (setq mlist (nreverse (cdr ml)) ml nil))
- (or (setq ml (cdr ml)) (nreverse mlist))))))
- (if mlist
- (setcdr (last mlist) mn)
- (setq mlist mn))
- (setq mn (last mn 2))
- (setq mname (concat "." (cadr mn)))
- (setcdr mn nil))
- (setq mname (concat "#" mname)))))
- ;; generate string
- (if (consp mlist)
- (setq mlist (mapconcat (function identity) mlist "::")))
- (if mname
- (if mlist (concat mlist mname) mname)
- mlist)))))
-
-(defconst ruby-font-lock-syntactic-keywords
- `(;; #{ }, #$hoge, #@foo are not comments
- ("\\(#\\)[{$@]" 1 (1 . nil))
- ;; the last $', $", $` in the respective string is not variable
- ;; the last ?', ?", ?` in the respective string is not ascii code
- ("\\(^\\|[\[ \t\n<+\(,=]\\)\\(['\"`]\\)\\(\\\\.\\|\\2\\|[^'\"`\n\\\\]\\)*?\\\\?[?$]\\(\\2\\)"
- (2 (7 . nil))
- (4 (7 . nil)))
- ;; $' $" $` .... are variables
- ;; ?' ?" ?` are ascii codes
- ("\\(^\\|[^\\\\]\\)\\(\\\\\\\\\\)*[?$]\\([#\"'`]\\)" 3 (1 . nil))
- ;; regexps
- ("\\(^\\|[=(,~?:;<>]\\|\\(^\\|\\s \\)\\(if\\|elsif\\|unless\\|while\\|until\\|when\\|and\\|or\\|&&\\|||\\)\\|g?sub!?\\|scan\\|split!?\\)\\s *\\(/\\)[^/\n\\\\]*\\(\\\\.[^/\n\\\\]*\\)*\\(/\\)"
- (4 (7 . ?/))
- (6 (7 . ?/)))
- ("^=en\\(d\\)\\_>" 1 "!")
- ("^\\(=\\)begin\\_>" 1 (ruby-comment-beg-syntax))
- ;; Currently, the following case is highlighted incorrectly:
- ;;
- ;; <<FOO
- ;; FOO
- ;; <<BAR
- ;; <<BAZ
- ;; BAZ
- ;; BAR
- ;;
- ;; This is because all here-doc beginnings are highlighted before any endings,
- ;; so although <<BAR is properly marked as a beginning, when we get to <<BAZ
- ;; it thinks <<BAR is part of a string so it's marked as well.
- ;;
- ;; This may be fixable by modifying ruby-in-here-doc-p to use
- ;; ruby-in-non-here-doc-string-p rather than syntax-ppss-context,
- ;; but I don't want to try that until we've got unit tests set up
- ;; to make sure I don't break anything else.
- (,(concat ruby-here-doc-beg-re ".*\\(\n\\)")
- ,(+ 1 (regexp-opt-depth ruby-here-doc-beg-re))
- (ruby-here-doc-beg-syntax))
- (,ruby-here-doc-end-re 3 (ruby-here-doc-end-syntax)))
- "Syntactic keywords for ruby-mode. See `font-lock-syntactic-keywords'.")
-
-(defun ruby-comment-beg-syntax ()
- "Returns the syntax cell for a the first character of a =begin.
-See the definition of `ruby-font-lock-syntactic-keywords'.
-
-This returns a comment-delimiter cell as long as the =begin
-isn't in a string or another comment."
- (when (not (nth 3 (syntax-ppss)))
- (string-to-syntax "!")))
-
-(defun ruby-in-non-here-doc-string-p ()
- "Returns whether or not the point is in a comment or
-a string that's not a heredoc.
-
-This function assumes that all strings with generic delimiters
-are heredocs. In ruby-mode, regexps also use generic delimiters,
-so text in them will count as text in heredocs for the purpose
-of this function. See `parse-partial-sexp'."
- ;; TODO: We may be able to make this more accurate
- ;; by looking at the character at (nth 3 syntax)
- (let ((syntax (syntax-ppss)))
- (or (nth 4 syntax)
- (numberp (nth 3 syntax)))))
-
-(defun ruby-in-here-doc-p ()
- "Returns whether or not the point is in a heredoc."
- (save-excursion
- (let ((old-point (point)) (case-fold-search nil))
- (beginning-of-line)
- (catch 'found-beg
- (while (re-search-backward ruby-here-doc-beg-re nil t)
- (if (not (or (syntax-ppss-context (syntax-ppss))
- (ruby-here-doc-find-end old-point)))
- (throw 'found-beg t)))))))
-
-(defun ruby-here-doc-find-end (&optional limit)
- "Expects the point to be on a line with one or more heredoc
-openers. Returns the buffer position at which all heredocs on the
-line are terminated, or nil if they aren't terminated before the
-buffer position `limit' or the end of the buffer."
- (save-excursion
- (beginning-of-line)
- (catch 'done
- (let ((eol (save-excursion (end-of-line) (point)))
- (case-fold-search nil)
- ;; Fake match data such that (match-end 0) is at eol
- (end-match-data (progn (looking-at ".*$") (match-data)))
- beg-match-data end-re)
- (while (re-search-forward ruby-here-doc-beg-re eol t)
- (setq beg-match-data (match-data))
- (setq end-re (ruby-here-doc-end-match))
-
- (set-match-data end-match-data)
- (goto-char (match-end 0))
- (unless (re-search-forward end-re limit t) (throw 'done nil))
- (setq end-match-data (match-data))
-
- (set-match-data beg-match-data)
- (goto-char (match-end 0)))
- (set-match-data end-match-data)
- (goto-char (match-end 0))
- (point)))))
-
-(defun ruby-here-doc-beg-syntax ()
- "Returns the syntax cell for a line that may begin a heredoc.
-See the definition of `ruby-font-lock-syntactic-keywords'.
-
-This sets the syntax cell for the newline ending the line
-containing the heredoc beginning so that cases where multiple
-heredocs are started on one line are handled correctly."
- (save-excursion
- (goto-char (match-beginning 0))
- (unless (or (ruby-in-non-here-doc-string-p)
- (ruby-in-here-doc-p))
- (string-to-syntax "|"))))
-
-(defun ruby-here-doc-end-syntax ()
- "Returns the syntax cell for a line that may end a heredoc.
-See the definition of `ruby-font-lock-syntactic-keywords'."
- (let ((pss (syntax-ppss)) (case-fold-search nil))
- ;; If we aren't in a string, we definitely aren't ending a heredoc,
- ;; so we can just give up.
- ;; This means we aren't doing a full-document search
- ;; every time we enter a character.
- (when (eq (syntax-ppss-context pss) 'string)
- (save-excursion
- (goto-char (nth 8 pss))
- (let ((eol (point)))
- (beginning-of-line)
- (if (and (re-search-forward (ruby-here-doc-beg-match) eol t) ; If there is a heredoc that matches this line...
- (null (syntax-ppss-context (syntax-ppss))) ; And that's not inside a heredoc/string/comment...
- (progn (goto-char (match-end 0)) ; And it's the last heredoc on its line...
- (not (re-search-forward ruby-here-doc-beg-re eol t))))
- (string-to-syntax "|")))))))
-
-(if (featurep 'xemacs)
- (put 'ruby-mode 'font-lock-defaults
- '((ruby-font-lock-keywords)
- nil nil nil
- beginning-of-line
- (font-lock-syntactic-keywords
- . ruby-font-lock-syntactic-keywords))))
-
-(defvar ruby-font-lock-syntax-table
- (let ((tbl (copy-syntax-table ruby-mode-syntax-table)))
- (modify-syntax-entry ?_ "w" tbl)
- tbl)
- "The syntax table to use for fontifying ruby-mode buffers.
-See `font-lock-syntax-table'.")
-
-(defconst ruby-font-lock-keywords
- (list
- ;; functions
- '("^\\s *def\\s +\\([^( \t\n]+\\)"
- 1 font-lock-function-name-face)
- ;; keywords
- (cons (concat
- "\\(^\\|[^_:.@$]\\|\\.\\.\\)\\b\\(defined\\?\\|"
- (regexp-opt
- '("alias_method"
- "alias"
- "and"
- "begin"
- "break"
- "case"
- "catch"
- "class"
- "def"
- "do"
- "elsif"
- "else"
- "fail"
- "ensure"
- "for"
- "end"
- "if"
- "in"
- "module_function"
- "module"
- "next"
- "not"
- "or"
- "public"
- "private"
- "protected"
- "raise"
- "redo"
- "rescue"
- "retry"
- "return"
- "then"
- "throw"
- "super"
- "unless"
- "undef"
- "until"
- "when"
- "while"
- "yield")
- t)
- "\\_>\\)")
- 2)
- ;; here-doc beginnings
- (list ruby-here-doc-beg-re 0 'font-lock-string-face)
- ;; variables
- '("\\(^\\|[^_:.@$]\\|\\.\\.\\)\\b\\(nil\\|self\\|true\\|false\\)\\>"
- 2 font-lock-variable-name-face)
- ;; variables
- '("\\(\\$\\([^a-zA-Z0-9 \n]\\|[0-9]\\)\\)\\W"
- 1 font-lock-variable-name-face)
- '("\\(\\$\\|@\\|@@\\)\\(\\w\\|_\\)+"
- 0 font-lock-variable-name-face)
- ;; general delimited string
- '("\\(^\\|[[ \t\n<+(,=]\\)\\(%[xrqQwW]?\\([^<[{(a-zA-Z0-9 \n]\\)[^\n\\\\]*\\(\\\\.[^\n\\\\]*\\)*\\(\\3\\)\\)"
- (2 font-lock-string-face))
- ;; constants
- '("\\(^\\|[^_]\\)\\b\\([A-Z]+\\(\\w\\|_\\)*\\)"
- 2 font-lock-type-face)
- ;; symbols
- '("\\(^\\|[^:]\\)\\(:\\([-+~]@?\\|[/%&|^`]\\|\\*\\*?\\|<\\(<\\|=>?\\)?\\|>[>=]?\\|===?\\|=~\\|\\[\\]=?\\|\\(\\w\\|_\\)+\\([!?=]\\|\\b_*\\)\\|#{[^}\n\\\\]*\\(\\\\.[^}\n\\\\]*\\)*}\\)\\)"
- 2 font-lock-reference-face)
- ;; expression expansion
- '("#\\({[^}\n\\\\]*\\(\\\\.[^}\n\\\\]*\\)*}\\|\\(\\$\\|@\\|@@\\)\\(\\w\\|_\\)+\\)"
- 0 font-lock-variable-name-face t)
- ;; warn lower camel case
- ;'("\\<[a-z]+[a-z0-9]*[A-Z][A-Za-z0-9]*\\([!?]?\\|\\>\\)"
- ; 0 font-lock-warning-face)
- )
- "Additional expressions to highlight in ruby mode.")
-
-;; Invoke ruby-mode when appropriate
-
-;;;###autoload
-(add-to-list 'auto-mode-alist '("\\.rb$" . ruby-mode))
-
-;;;###autoload
-(add-to-list 'interpreter-mode-alist '("ruby" . ruby-mode))
-(add-to-list 'interpreter-mode-alist '("rbx" . ruby-mode))
-(add-to-list 'interpreter-mode-alist '("jruby" . ruby-mode))
-(add-to-list 'interpreter-mode-alist '("ruby1.9" . ruby-mode))
-(add-to-list 'interpreter-mode-alist '("ruby1.8" . ruby-mode))
-
-(provide 'ruby-mode)
-;;; ruby-mode.el ends here
View
630 elpa-to-submit/xml-rpc.el
@@ -1,630 +0,0 @@
-;;; xml-rpc.el -- An elisp implementation of clientside XML-RPC
-
-;; Copyright (C) 2001 CodeFactory AB.
-;; Copyright (C) 2001 Daniel Lundin.
-;; Parts Copyright (C) 2002-2005 Mark A. Hershberger
-
-;; Author: Daniel Lundin <daniel@codefactory.se>
-;; Maintainer: Mark A. Hershberger <mah@everybody.org>
-;; Version: 1.6.4
-;; Created: May 13 2001
-;; Keywords: xml rpc network
-;; URL: http://elisp.info/package/xml-rpc/
-
-;; This file is NOT (yet) part of GNU Emacs.
-
-;; This is free software; you can redistribute it and/or modify it
-;; under the terms of the GNU General Public License as published by
-;; the Free Software Foundation; either version 2, or (at your option)
-;; any later version.
-
-;; This software is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-;; General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs; see the file COPYING. If not, write to the
-;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-;; Boston, MA 02111-1307, USA.
-
-
-;;; Commentary:
-
-;; This is an XML-RPC client implementation in elisp, capable of both
-;; synchronous and asynchronous method calls (using the url package's async
-;; retrieval functionality).
-;; XML-RPC is remote procedure calls over HTTP using XML to describe the
-;; function call and return values.
-
-;; xml-rpc.el represents XML-RPC datatypes as lisp values, automatically
-;; converting to and from the XML datastructures as needed, both for method
-;; parameters and return values, making using XML-RPC methods fairly
-;; transparent to the lisp code.
-
-;; Requirements
-;; ------------
-
-;; xml-rpc.el uses the url package for http handling and xml.el for XML
-;; parsing. url is a part of the W3 browser package (but now as a separate
-;; module in the CVS repository).
-;; xml.el is a part of GNU Emacs 21, but can also be downloaded from
-;; here: <URL:ftp://ftp.codefactory.se/pub/people/daniel/elisp/xml.el>
-
-
-;; XML-RPC datatypes are represented as follows
-;; --------------------------------------------
-
-;; int: 42
-;; float/double: 42.0
-;; string: "foo"
-;; array: '(1 2 3 4) '(1 2 3 (4.1 4.2))
-;; struct: '(("name" . "daniel") ("height" . 6.1))
-
-
-;; Examples
-;; ========
-;; Here follows some examples demonstrating the use of xml-rpc.el
-
-;; Normal synchronous operation
-;; ----------------------------
-
-;; (xml-rpc-method-call "http://localhost:80/RPC" 'foo-method foo bar zoo)
-
-;; Asynchronous example (cb-foo will be called when the methods returns)
-;; ---------------------------------------------------------------------
-
-;; (defun cb-foo (foo)
-;; (print (format "%s" foo)))
-
-;; (xml-rpc-method-call-async 'cb-foo "http://localhost:80/RPC"
-;; 'foo-method foo bar zoo)
-
-
-;; Some real world working examples for fun and play
-;; -------------------------------------------------
-
-;; Check the temperature (celsius) outside jonas@codefactory.se's apartment
-
-;; (xml-rpc-method-call
-;; "http://flint.bengburken.net:80/xmlrpc/onewire_temp.php"
-;; 'onewire.getTemp)
-
-
-;; Fetch the latest NetBSD news the past 5 days from O'reillynet
-
-;; (xml-rpc-method-call "http://www.oreillynet.com/meerkat/xml-rpc/server.php"
-;; 'meerkat.getItems
-;; '(("channel" . 1024)
-;; ("search" . "/NetBSD/")
-;; ("time_period" . "5DAY")
-;; ("ids" . 0)
-;; ("descriptions" . 200)
-;; ("categories" . 0)
-;; ("channels" . 0)
-;; ("dates" . 0)
-;; ("num_items" . 5)))
-
-
-;;; History:
-
-;; 1.6.2 - Fix whitespace issues to work better with new xml.el
-;; Fix bug in string handling.
-;; Add support for gzip-encoding when needed.
-
-;; 1.6.1 - base64 support added.
-;; url-insert-entities-in-string done on string types now.
-
-;; 1.6 - Fixed dependencies (remove w3, add cl).
-;; Move string-to-boolean and boolean-to-string into xml-rpc namespace.
-;; Fix bug in xml-rpc-xml-to-response where non-existent var was.
-;; More tweaking of "Connection: close" header.
-;; Fix bug in xml-rpc-request-process-buffer so that this works with
-;; different mixes of the url.el code.
-
-;; 1.5.1 - Added Andrew J Cosgriff's patch to make the
-;; xml-rpc-clean-string function work in XEmacs.
-
-;; 1.5 - Added headers to the outgoing url-retreive-synchronously
-;; so that it would close connections immediately on completion.
-
-;; 1.4 - Added conditional debugging code. Added version tag.
-
-;; 1.2 - Better error handling. The documentation didn't match
-;; the code. That was changed so that an error was
-;; signaled. Also, better handling of various and
-;; different combinations of xml.el and url.el.
-
-;; 1.1 - Added support for boolean types. If the type of a
-;; returned value is not specified, string is assumed
-
-;; 1.0 - First version
-
-
-;;; Code:
-
-(defun xml-rpc-clean-string (s)
- (if (string-match "\\`[ \t\n\r]*\\'" s)
- ;"^[ \t\n]*$" s)
- nil
- s))