WWWWWW

Current Directory: /usr/share/emacs/24.3/lisp/progmodes
Viewing File: /usr/share/emacs/24.3/lisp/progmodes/ruby-mode.elc
;ELC
;;; Compiled by mockbuild@buildfarm01-new.corp.cloudlinux.com on Tue Nov 11 12:53:43 2025
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/progmodes/ruby-mode.el
;;; in Emacs version 24.3.1
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(custom-declare-group 'ruby nil "Major mode for editing Ruby code." :prefix "ruby-" :group 'languages)
(defconst ruby-keyword-end-re (byte-code "\300\301\302\"\203	\301\207\303\207" [string-match "\\_>" "ruby" "\\>"] 3))
#@38 Keywords at the beginning of blocks.
(defconst ruby-block-beg-keywords '("class" "module" "def" "if" "unless" "case" "while" "until" "for" "begin" "do") (#$ . 784))
#@42 Regexp to match the beginning of blocks.
(defconst ruby-block-beg-re (regexp-opt ruby-block-beg-keywords) (#$ . 955))
#@52 Regexp to match keywords that nest without blocks.
(defconst ruby-non-block-do-re (concat "\\(for\\|rescue\\|until\\|while\\)" ruby-keyword-end-re) (#$ . 1079))
#@52 Regexp to match where the indentation gets deeper.
(defconst ruby-indent-beg-re "^\\(\\s *\\(?:class\\|def\\|module\\)\\|\\(?:begin\\|case\\|for\\|if\\|un\\(?:less\\|til\\)\\|while\\)\\)\\_>" (#$ . 1246))
#@57 Modifiers that are the same as the beginning of blocks.
(defconst ruby-modifier-beg-keywords '("if" "unless" "while" "until") (#$ . 1457))
#@60 Regexp to match modifiers same as the beginning of blocks.
(defconst ruby-modifier-beg-re (regexp-opt ruby-modifier-beg-keywords) (#$ . 1602))
#@28 Regexp to match modifiers.
(defconst ruby-modifier-re (byte-code "\301\302B!\207" [ruby-modifier-beg-keywords regexp-opt "rescue"] 3) (#$ . 1751))
#@78 Keywords where the indentation gets shallower in middle of block statements.
(defconst ruby-block-mid-keywords '("then" "else" "elsif" "when" "rescue" "ensure") (#$ . 1905))
#@85 Regexp to match where the indentation gets shallower in middle of block statements.
(defconst ruby-block-mid-re (regexp-opt ruby-block-mid-keywords) (#$ . 2085))
#@35 Regexp to match boolean keywords.
(defconst ruby-block-op-keywords '("and" "or" "not") (#$ . 2253))
#@42 Regexp to match hanging block modifiers.
(defconst ruby-block-hanging-re (byte-code "\302\303	\"!\207" [ruby-modifier-beg-keywords ruby-block-op-keywords regexp-opt append] 4) (#$ . 2359))
(defconst ruby-block-end-re "\\_<end\\_>")
#@65 Regexp to match the beginning of a defun, in the general sense.
(defconst ruby-defun-beg-re "\\(def\\|class\\|module\\)" (#$ . 2598))
#@45 Regexp to match the beginning of a heredoc.
(defconst ruby-here-doc-beg-re "\\(<\\)<\\(-\\)?\\(\\([a-zA-Z0-9_]+\\)\\|[\"]\\([^\"]+\\)[\"]\\|[']\\([^']+\\)[']\\)" (#$ . 2738))
#@122 Return a regexp to find the end of a heredoc.

This should only be called after matching against `ruby-here-doc-beg-re'.
(defalias 'ruby-here-doc-end-match #[nil "\300\301\302!\205\303\304\301\305!\206\301\306!\206\301\307!!Q\207" ["^" match-string 2 "[ 	]*" regexp-quote 4 5 6] 5 (#$ . 2920)])
(defconst ruby-delimiter (concat "[?$/%(){}#\"'`.:]\\|<<\\|\\[\\|\\]\\|\\_<\\(" ruby-block-beg-re "\\)\\_>\\|" ruby-block-end-re "\\|^=begin\\|" ruby-here-doc-beg-re))
#@55 Regexp to match where the indentation gets shallower.
(defconst ruby-negative (concat "^[ 	]*\\(\\(" ruby-block-mid-re "\\)\\>\\|" ruby-block-end-re "\\|}\\|\\]\\)") (#$ . 3395))
#@28 Regexp to match operators.
(defconst ruby-operator-re "[-,.+*/%&|^~=<>:]" (#$ . 3580))
#@51 List of characters that symbol names may contain.
(defconst ruby-symbol-chars "a-zA-Z0-9_" (#$ . 3673))
#@26 Regexp to match symbols.
(defconst ruby-symbol-re (concat "[" ruby-symbol-chars "]") (#$ . 3783))
(define-abbrev-table 'ruby-mode-abbrev-table nil "Abbrev table in use in Ruby mode buffers.")
#@27 Keymap used in Ruby mode.
(defvar ruby-mode-map (byte-code "\301 \302\303\304#\210\302\305\306#\210\302\307\310#\210\302\311\312#\210\302\313\314#\210\302\315\316#\210)\207" [map make-sparse-keymap define-key [134217730] ruby-backward-sexp [134217734] ruby-forward-sexp [134217744] ruby-beginning-of-block [134217742] ruby-end-of-block [134217745] ruby-indent-exp "{" ruby-toggle-block] 4) (#$ . 3981))
#@35 Syntax table to use in Ruby mode.
(defvar ruby-mode-syntax-table (byte-code "\301 \302\303\304#\210\302\305\304#\210\302\306\304#\210\302\307\310#\210\302\311\312#\210\302\313\314#\210\302\315\316#\210\302\317\320#\210\302\321\320#\210\302\322\320#\210\302\323\316#\210\302\324\316#\210\302\325\316#\210\302\326\316#\210\302\327\316#\210\302\330\316#\210\302\331\316#\210\302\332\316#\210\302\333\316#\210\302\334\316#\210\302\335\316#\210\302\336\337#\210\302\340\341#\210\302\342\343#\210\302\344\345#\210\302\346\347#\210\302\350\351#\210)\207" [table make-syntax-table modify-syntax-entry 39 "\"" 34 96 35 "<" 10 ">" 92 "\\" 36 "." 63 "_" 95 58 60 62 38 124 37 61 47 43 42 45 59 40 "()" 41 ")(" 123 "(}" 125 "){" 91 "(]" 93 ")["] 4) (#$ . 4399))
(byte-code "\300\301\302\303\304\305\306\307&\210\300\310\311\312\304\313\306\307&\210\300\314\315\316\304\313\306\307&\210\300\317\320\321\306\307%\210\300\322\323\324\306\307%\210\300\325\326\327\330\331\306\307&\210\300\332\333\334\306\307%\210\300\335\320\336\304\305\306\307&\210\300\337\320\340\304\305\306\307&\210\341\301\342\343#\210\341\310\342\344#\210\341\314\342\344#\210\341\317\342\343#\207" [custom-declare-variable ruby-indent-tabs-mode nil "Indentation can insert tabs in Ruby mode if this is non-nil." :type boolean :group ruby ruby-indent-level 2 "Indentation of Ruby statements." integer ruby-comment-column 32 "Indentation column of comments." ruby-deep-arglist t "Deep indent lists in parenthesis when non-nil.\nAlso ignores spaces after parenthesis when 'space." ruby-deep-indent-paren '(40 91 93 t) "Deep indent lists in parenthesis when non-nil.\nThe value t means continuous line.\nAlso ignores spaces after parenthesis when 'space." ruby-deep-indent-paren-style 'space "Default deep indent style." :options (t nil space) ruby-encoding-map '((shift_jis . cp932) (shift-jis . cp932)) "Alist to map encoding name from Emacs to Ruby." ruby-insert-encoding-magic-comment "Insert a magic Emacs 'coding' comment upon save if this is non-nil." ruby-use-encoding-map "Use `ruby-encoding-map' to set encoding magic comment if this is non-nil." put safe-local-variable booleanp integerp] 8)
#@50 Create an imenu index of methods inside a block.
(defalias 'ruby-imenu-create-index-in-block #[(prefix beg end) "\306\211\211\211\211\211\211b\210\307\310\311#\203\320\312\224\313\314!\315\225\313\316!\206/\313\317!\315\224	\320\230\203N\203C\fP\f\nBB\202	\321\230\203\202\203r\322\323\f\"\203m\315\324O\f\316\306OP\202q\fP\f\nBB\325!\210\202\f\326\230\203\226\203\254\315\324O\202\254\203\244\315\324O\327\fQ\f\nBB\325!\210`\330\f\203\276\331\202\277\332P#\244b\210\202.\207" [sing decl pos next name case-fold-search nil re-search-forward "^\\s *\\(\\(class\\s +\\|\\(class\\s *<<\\s *\\)\\|module\\s +\\)\\([^(<\n ]+\\)\\|\\(def\\|alias\\)\\s +\\([^(\n ]+\\)\\)" t 3 match-string 5 0 4 6 "alias" "def" string-match "^self." -1 ruby-accurate-end-of-block "self" "::" ruby-imenu-create-index-in-block "." "#" index-alist beg end prefix] 7 (#$ . 6598)])
#@53 Create an imenu index of all methods in the buffer.
(defalias 'ruby-imenu-create-index #[nil "\300\301e\301#\237\207" [ruby-imenu-create-index-in-block nil] 4 (#$ . 7548)])
#@17 TODO: document.
(defalias 'ruby-accurate-end-of-block #[(&optional end) "\302\206d\303\304	#\211\205#\305	8\306Y\205#`W\205#\202*\207" [end state nil apply ruby-parse-partial 2 0] 4 (#$ . 7727)])
#@54 Set up initial buffer-local variables for Ruby mode.
(defalias 'ruby-mode-variables #[nil "\306!\210	\307\305!\210\310\307\311!\210\312	\307\313!\210\314\307\315!\210\316
\307\317!\210\307\320!\210\321\307\322!\210\312\307\323!\210\312\307\324!\210\325P\307\326!\210\307\327!\210\312\211\207" [ruby-mode-syntax-table ruby-mode-abbrev-table local-abbrev-table ruby-indent-tabs-mode indent-tabs-mode indent-line-function set-syntax-table make-local-variable ruby-indent-line require-final-newline t comment-start "# " comment-end "" comment-column comment-start-skip "#+ *" parse-sexp-ignore-comments parse-sexp-lookup-properties paragraph-start "$\\|" paragraph-separate paragraph-ignore-fill-prefix ruby-comment-column page-delimiter] 2 (#$ . 7942)])
#@70 Insert a magic comment header with the proper encoding if necessary.
(defalias 'ruby-mode-set-encoding #[nil "\212~\210eb\210\306\307\310\311#\205\237eb\210\206	\211\203'\312\n\313\"\206&\314\n\310\"\n\203<\315\2037\n\f\236A\2068\n!\202=\316\317\320!\203H\321\322!\210\317\323!\203\216\324\322!\n\230?\205\236\322\224b\210`\322\225|\210\317\325!\203\211\326\310x\211\327U\203y\330c\210\331u\210\202\210
\331U\203\205\326c\210\202\210\310u\210)\nc\202\236\317\332!\206\236\205\236\333\n\334\261))\207" [coding-system-for-write buffer-file-coding-system coding-system ruby-use-encoding-map ruby-encoding-map n re-search-forward "[^-]" nil t coding-system-get mime-charset coding-system-change-eol-conversion symbol-name "ascii-8bit" looking-at "^#!" beginning-of-line 2 "\\s *#.*-*-\\s *\\(en\\)?coding\\s *:\\s *\\([-a-z0-9_]*\\)\\s *\\(;\\|-*-\\)" match-string "-*-" " " 0 "  " -1 "\\s *#.*coding\\s *[:=]" "# -*- coding: " " -*-\n" ruby-insert-encoding-magic-comment] 5 (#$ . 8728)])
#@47 Return the indentation level of current line.
(defalias 'ruby-current-indentation #[nil "\212\300 \210\301 \210i)\207" [beginning-of-line back-to-indentation] 1 (#$ . 9750)])
#@51 Correct the indentation of the current Ruby line.
(defalias 'ruby-indent-line #[(&optional ignored) "\300\301 !\207" [ruby-indent-to ruby-calculate-indent] 2 (#$ . 9931) nil])
#@36 Indent the current line to COLUMN.
(defalias 'ruby-indent-to #[(column) "\205Y\304\211\211\305W\203\306\307!\210i\310 \210`\311 \210i\312\304x\210\nY\2031\nZ\2023\305n\203E\nU\203E\313\\!\202X\313\n!\210	`|\210\310 \210j\210\313\\!+\207" [column beg top shift nil 0 error "invalid nest" beginning-of-line back-to-indentation " 	" move-to-column] 3 (#$ . 10113)])
#@205 Return t if the character before POS is a special character.
If omitted, POS defaults to the current point.
Special characters are `?', `$', `:' when preceded by whitespace,
and `\' when preceded by `?'.
(defalias 'ruby-special-char-p #[(&optional pos) "\206`\211SfeW\205SSf\211\303=\206<\n\304=\206<\n\305=\2033	?\206<	z\306=\206<\n\307=\205<	\303=*\207" [pos b c 63 36 58 32 92] 4 (#$ . 10509)])
(defalias 'ruby-singleton-class-p #[(&optional pos) "\212\203b\210\301v\210n\204`Sf\302=?\205\303\304!)\207" [pos -1 95 looking-at "class\\s *<<"] 2])
#@17 TODO: document.
(defalias 'ruby-expr-beg #[(&optional option) "\212\306\307!\210\310\307x`n\203\311\202\253\312u\210\313\314!\203.`Sfz\315=\204*\316 \203.\307\202\253\n\317=\203C	\320W\203Cb\210\321 ?\202\253\313!\206\253\313\322!\206\253\313\323!\203k\n\324=?\206\253n\206\253\212\312u\210\313\325!)\206\253\313\f!\205\253
\307x\205\253\313\326\327 #\330\"!\203\222\320\225b\210\313\331!?\202\253\n\332=\203\236\313\333!\202\253\n\334=\203\252\313\335!\202\253\307+\207" [start space option ruby-operator-re ruby-symbol-re ruby-symbol-chars store-match-data nil " 	" t -1 looking-at "\\?" 119 ruby-special-char-p heredoc 0 ruby-singleton-class-p "[\\[({,;]" "[!?]" modifier "\\Sw$" regexp-opt append words "\\s_\\|!" expr-qstr "[a-zA-Z][a-zA-z0-9_]* +%[^ 	]" expr-re "[a-zA-Z][a-zA-z0-9_]* +/[^ 	]" ruby-block-beg-keywords ruby-block-op-keywords ruby-block-mid-keywords] 6 (#$ . 11088)])
#@17 TODO: document.
(defalias 'ruby-forward-string #[(term &optional end no-error expand) "\306\307!	\203\310\311Q\202\312\313Q\314\n
#\203J\315\224\203.\316\317
\320$\202A`Sf=\203;\fS\202=\fT\211\321V\203J\322u\210\202\323\f!\206\\\203Y\320\202\\\324\325!+\207" [term expand re c n end 1 string-to-char "[^\\]\\(\\\\\\\\\\)*\\([" "]\\|\\(#{\\)\\)" "[^\\]\\(\\\\\\\\\\)*[" "]" re-search-forward 3 ruby-forward-string "}{" nil 0 -1 zerop error "unterminated string" no-error] 5 (#$ . 12016)])
#@17 TODO: document.
(defalias 'ruby-deep-indent-paren-p #[(c) "<\203 \305	\"\211\203\nA\206\202	>\205)\207	=\203(\207	\306=\205/\f\207" [ruby-deep-indent-paren c deep ruby-deep-indent-paren-style ruby-deep-arglist assoc 40] 4 (#$ . 12539)])
#@42 TODO: document throughout function body.
(defalias 'ruby-parse-partial #[(&optional end in-string nest depth pcol indent) "\204\306	\204\f\306\307\n\310#\203\216`\311\211\211@A\306\224b\210`Sf\312>\2037\313\314!\2037Ab\210\202\215\313\315!\203Vm\204M\316``T{\317\211$\204\215`Bb\210\202\215\313\320!\203qm\204h\307\321\317#\204\215`Bb\210\202\215\313\322!\203~Ab\210\202\215\313\323!\203\247m\204\240\324\325!\203\240\316\323\317\211$\204\215`Bb\210\202\215Ab\210\202\215\313\326!\203Tm\204M\324\327!\203M\313\330!\204M\313\331!\203M\332\224b\210`Sf\333>?\334\332!\211@\335\230\203\336\336\202@\337\230\203\352\340\202@\341\230\203\366\342\202@\343\230\203\344\202\f\203@\345\230\203\345@P@
\203 \316
\317\f$\202A\f\203.\316@\317\211$\202A\307@\345\230\203:\346\202>\347@P\317#\204\215`Bb\210\202\215Ab\210\202\215\313\350!\203s\324 \203l\313\351!\203l\306\225b\210\202\215Ab\210\202\215\313\352!\203\203Ab\210\332u\210\202\215\313\353!\203\222\332y\210`b\210\202\215\313\354!\203\355\355\311f!\211C\203\330\311f\356=\203\256\324 \203\330C\357=\203\300\313\360!\203\300\306\225SA`fABDBDABEBE\306\202\345`fABDBDT)Ab\210\202\215\313\361!\203\355\362\311f!!\203	E@AEAE\202\fSDADAb\210\202\215\313F!\203bn\2047\363u\210`f\211@\364=\204[@\365=\204[Ab\210`f\211@\364=\204[@\366=\204[@\367=\204[DADSAb\210\202\215\313\370!\203\211n\204v\363u\210`f\364=\204\202\311ABDBDT\306\225b\210\202\215\313\371G\372Q!\203\373 H\374\216\313\375IP!?\206\255\212\376 \210\313J!)?*\203n\204\311\363u\210`f\211@\364=\204@\365=\204Ab\203`f\211@\203@\366=\204\377\311w\203\306\224b\203\313K!\203\371\324\201Q!\203Ab\203\311ABDB\211D\203TAb\210\202\215\313\201R!\203-\332\224b\210\316\334\332!\317#\210\202\215\313\201S!\203<\306\225b\210\202\215\313\201T!\203K\306\225b\210\202\215\313\201U!\204k\313\201V!\204k\313\201W!\204k\313\201X!\203r\306\225b\210\202\215\313\201Y!\203\224\307\201Z\317#\203\212\332y\210\202\215\306\225Bb\210\202\215\313\201[!\203@\324\201\\!\2039\313\201]!\2039\201^\334\201_!\206\274\334\201`!!\332\224\203\311\201a
P\306\225bL\201b MBDE	\257NM`V\203\370\201c\201dMN#\211N\204\340N@BNA@D\201`N8\201eN8E\201_N8\307\201f
\201gQ\310#\203.\332y\210\2025LBb\210+\202\215Ab\210\202\215\313\201h!\203OAb\210\202\215\313O!\203}\201i\201P!\203}\307\201j P\317#\203r\332y\210\202\215\306\225BPb\210\202\215\201k\201l\201m`A{\"!\210,BDEF\207" [depth indent ruby-delimiter end expand re 0 re-search-forward move nil (64 36) looking-at "\\sw" "[\"`]" ruby-forward-string t "'" "[^\\]\\(\\\\\\\\\\)*'" "/=" "/" ruby-expr-beg expr-re "%" expr-qstr "%=" "%[QqrxWw]?\\([^a-zA-Z0-9 	\n]\\)" 1 (113 119) match-string "[" "][" "{" "}{" "(" ")(" "<" "><" "\\" "\\\\[^\\]*\\\\" "[^\\]\\(\\\\\\\\\\)*" "\\?" "?\\(\\\\C-\\|\\\\M-\\)*\\\\?." "\\$" "#" "[\\[{(]" ruby-deep-indent-paren-p 123 space ".\\s +[^# 	\n]" "[])}]" matching-paren -1 95 46 33 63 "def\\s +[^(\n;]*" "\\_<\\(" "\\)\\_>" match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) "do" back-to-indentation " 	" w pnt in-string deep nest pcol ruby-block-end-re ruby-block-beg-re save-match-data-internal ruby-keyword-end-re ruby-non-block-do-re ruby-modifier-re id-end line-end-position state ruby-here-doc-beg-re ruby-indent-point modifier ":\\(['\"]\\)" ":\\([-,.+*/%&|^~<>]=?\\|===?\\|<=>\\|![~=]?\\)" ":\\([a-zA-Z_][a-zA-Z_0-9]*[!?=]?\\)?" "\\.\\.\\.?" "\\.[0-9]+" "\\.[a-zA-Z_0-9]+" "\\." "^=begin" "^=end" "<<" heredoc "<<\\(-\\)?\\(\\([\"'`]\\)\\([^\n]+?\\)\\3\\|\\(?:\\sw\\|\\s_\\)+\\)" regexp-quote 4 2 "\\s *" point-at-eol apply ruby-parse-partial 3 "^" "$" "^__END__$" boundp ruby-here-doc-end-match error format "bad string %s"] 6 (#$ . 12801)])
#@17 TODO: document.
(defalias 'ruby-parse-region #[(start end) "\303\212	\203
	b\210\202\304 \210\214`\n}\210\n`V\203%\305\306\n#\211\204*@A@@\3078\3108@@F)\207" [state start end nil ruby-beginning-of-indent apply ruby-parse-partial 2 3] 5 (#$ . 16775)])
#@69 Return the indentation level in spaces NEST levels deeper than POS.
(defalias 'ruby-indent-size #[(pos nest) "	\206\303\n_\\\207" [pos nest ruby-indent-level 1] 3 (#$ . 17045)])
#@58 Return the proper indentation level of the current line.
(defalias 'ruby-calculate-indent #[(&optional parse-start) "\212\306 \210`\307\211\211\211\211\310\311!\210\307f\205\312\307f!\313-./\203./b\210\2024\314 \210`/\315 \210i\316/.\"\211@\203J\307\202n
A@@\203
A@A\211b\210\317
A@@!\2110\203\3150\320=\203
A@@	=\203\321\311!\210iS\202\351\316`.\"1\32218\205\240\32218\313V\205\2401A@Ab\206\240\320)\203\261\323v\210\324i\322
8\"\202\351i0\325=\204\351	\203\304S\202\351\324S\326\"\202\351\327
8\203\333\327
8b\210\202\342/b\210\315 \210\324i\322
8\"
A@@	=\203\317\312	!!\203\330\331	!!\203i)\202n\322
8\203Y\322
8\313V\203Y
A@A\204!\332\333!\210
A@Ab\210\323v\210`\334\335!\203Q\327
8\203@\327
8b\210\202G/b\210\315 \210\324i\322
8\"\202ni2\\\202n\322
8\203n\322
8\313W\203n\324i\322
8\"\203.b\210\307\210`\306 \210\317	!\204\235\3363\f\320#\203\235\313\225f\337=\2042Z\202\212\306 \210o)\204\317\320!\204\263
A@@\204\307\211454\204\336\340\307x\210`5\306 \210\336\3415\320#\203\327\306 \210\202\271\320\2114\203\276*\307\210\342\307x\210\307`65\306 \210\336\3436\320#\203`S\2115\203\3445!\204\316/5\"\211\203
@\203\3075\202\3575\206$6b\210\342\307x\2105\2039
@\20396\202=
A@A\316/`\"*o\204L\323u\210\3347!\203x8\307x\203x\334\3459\346Q!\203x`\327
8=\204x\212\313\225b\210\334\347!)\203\336\334:!\203\344 \204`f;\316\206\217/`\"@?\205\332`f\350=\203\317\212l\204\245\323u\210\330\351\307\320#\203\312\340\307x\210l?\205\313\323u\210\334\352!?\205\313\323v\210\334\335!?\202\313\320)\205\332;\353=?\205\332\320\211)\203\n\204\n\334\3459\346Q!\204\n\317\320!\325=\203\no\204\n~\210\206/b\210\310\311!\210i\202
A@@\203\2022\\.b\210\306 \210\310\311!\210\334\354!\20322\\\2023.	\207" [indent paren op-end begin eol state beginning-of-line nil skip-syntax-forward " " matching-paren 0 ruby-beginning-of-indent back-to-indentation ruby-parse-region ruby-deep-indent-paren-p t skip-syntax-backward 2 -1 ruby-indent-size space 1 3 search-backward char-to-string error "invalid nest" looking-at "do\\>[^_]" re-search-forward 95 " 	\n" "^\\s *#" " 	" "#" ruby-special-char-p "\\<\\(" "\\)\\>" "[a-z_]" 124 "|" "{" 44 "\\.[^.]" case-fold-search ruby-indent-point parse-start deep s ruby-indent-level ruby-negative done end pos ruby-symbol-re ruby-symbol-chars ruby-block-hanging-re ruby-operator-re c] 9 (#$ . 17232)])
#@139 Move backward to the beginning of the current top-level defun.
With ARG, move backward multiple defuns.  Negative ARG means
move forward.
(defalias 'ruby-beginning-of-defun #[(&optional arg) "\302\303\304Q\305\306	\206\f\307$\205\310 \207" [ruby-defun-beg-re arg re-search-backward "^\\s *" "\\_>" nil t 1 beginning-of-line] 5 (#$ . 19751) "p"])
#@132 Move forward to the end of the current top-level defun.
With ARG, move forward multiple defuns.  Negative ARG means
move backward.
(defalias 'ruby-end-of-defun #[(&optional arg) "\301 \210\302\303P!\205
\304y\207" [ruby-block-end-re ruby-forward-sexp looking-back "^\\s *" 1] 3 (#$ . 20108) "p"])
#@105 Backtrack to a line which can be used as a reference for
calculating indentation on the lines after it.
(defalias 'ruby-beginning-of-indent #[nil "\301\302\303#\205\304\305!\204\306 \205\202\207" [ruby-indent-beg-re re-search-backward nil move ruby-in-ppss-context-p anything beginning-of-line] 4 (#$ . 20414)])
#@111 Move to the beginning (N < 0) or the end (N > 0) of the current block
or blocks containing the current block.
(defalias 'ruby-move-to-block #[(n) "`\306 \307\310W\203	\202\311\n\312Q!\313\211\204\243\310W\203*o\202+m\204\243y\210\307\314!\204\213\307\315!\204\213\310V\203P\307\316!\203P\317\320!\210\202\213\310W\203c\307\320!\203c\321\316!\210\202\213\322 \fW\203r\323\202\213
\203\202\fU\203\202\323\202\213\fV\203\213\323\203\212\324 \210\307\311\312Q!\203\237\313)\202\324 -\207" [n ruby-block-end-re ruby-block-beg-re done pos down ruby-calculate-indent looking-at 0 "\\<\\(" "\\)\\>" nil "^\\s *$" "^\\s *#" "^=begin\\>" re-search-forward "^=end\\>" re-search-backward current-indentation t back-to-indentation start orig ruby-block-mid-re] 6 (#$ . 20742)])
#@89 Move backward to the beginning of the current block.
With ARG, move up multiple blocks.
(defalias 'ruby-beginning-of-block #[(&optional arg) "\301\206\302[!\207" [arg ruby-move-to-block 1] 2 (#$ . 21567) "p"])
#@86 Move forward to the end of the current block.
With ARG, move out of multiple blocks.
(defalias 'ruby-end-of-block #[(&optional arg) "\301\206\302!\207" [arg ruby-move-to-block 1] 2 (#$ . 21786) nil])
#@116 Move forward across one balanced expression (sexp).
With ARG, do it many times.  Negative ARG means move backward.
(defalias 'ruby-forward-sexp #[(&optional arg) "\247\203\302W\203\303[!\207\206\304\305\306\307\217\210	)\207" [arg i 0 ruby-backward-sexp 1 nil (byte-code "\304V\203\265\305\306!\210\307\310!\203\304\225b\210\307\311!\203!\304\225b\210\202\256\312\313w\210\307\314!\2034\315`\316\"b\210\202\256\307\317	\320Q!\203V`Sf\321=\204V`Sf\322=\204V\323 \210\316v\210\202\256\307\324!\203\205\316v\210\307\325!\204\\\307\326!\203q\327u\210\202\\\330\313w\304V\204\\\307\331!\203\256\316u\210\202\256\313\211\n\206\225\332 \206\225\307\333!\334\335\313#\211A@\203\253\336\337\313w\210\202\211\n\210*S\211\202\313\207" [i ruby-block-beg-re expr state 0 skip-syntax-forward " " looking-at ",\\s *" "\\?\\(\\\\[CM]-\\)*\\\\?\\S " ",.:;|&^~=!?\\+\\-\\*" nil "\\s(" scan-sexps 1 "\\<\\(" "\\)\\>" 46 58 ruby-end-of-block "\\(\\$\\|@@?\\)?\\sw" "_" "::" 2 "." "\\?\\|!\\(=[~=>]\\|[^~=]\\)" ruby-expr-beg "%\\sw?\\Sw\\|[\"'`/]" apply ruby-parse-partial t "<"] 5) (((error) (forward-word 1)))] 3 (#$ . 21996) "p"])
#@116 Move backward across one balanced expression (sexp).
With ARG, do it many times.  Negative ARG means move forward.
(defalias 'ruby-backward-sexp #[(&optional arg) "\247\203\302W\203\303[!\207\206\304\305\306\307\217\210	)\207" [arg i 0 ruby-forward-sexp 1 nil (byte-code "\303V\203\326\304\305x\210\306u\210\307\310!\203A\311`T\306\"b\210\312`Sf\313\"\203)\306u\210\202\317\314`Sf\315\"\203\317`SSf\313=\203\317\316u\210\202\317\307\317!\203c\320\303\225Sf!\321	!\203_\322\323\305x\324\"\324=\204N)\202\317\307\325!\203t\326 \203\317\306u\210\202\317\307\327!\204\317\324u\210\306v\210\312`Sf\330\"\204}\312`Sf\331\"\203\230\306u\210\202}\314`Sf\332\"\203\262\306u\210`Sf\305f=\203\306\306u\202\303\312`Sf\333\"\203\306\306u\210`Sf\334=\204}\307\n!\203\317\335 \210S\211\202\305\207" [i c ruby-block-end-re 0 " 	\n,.:;|&^~=!?\\+\\-\\*" nil -1 looking-at "\\s)" scan-sexps eql 37 memql (113 81 119 87 114 120) -2 "\\s\"\\|\\\\\\S_" char-to-string search-backward logand "\\" 1 "\\s.\\|\\s\\" ruby-special-char-p "\\s(" 95 46 (36 64) 58 : ruby-beginning-of-block] 4) (((error)))] 3 (#$ . 23160) "p"])
#@66 Indent each line in the balanced expression following the point.
(defalias 'ruby-indent-exp #[(&optional ignored) "\305 \306\211\211\307\310\f\307\"\210\311\216\312 \210`\313 m?\205J\314!\211\nV\203/\307\211\202<	\nU\205J\205J\306\307\205J\315	!\210\312\316!\210\202.\207" [nest column top start here point-marker nil t set-marker-insertion-type ((byte-code "b\210\301\211\223\207" [here nil] 3)) beginning-of-line current-indentation ruby-calculate-indent ruby-indent-to 2] 6 (#$ . 24306) "*P"])
#@192 Return 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'.
(defalias 'ruby-add-log-current-method #[nil "\300\301\300\217\207" [nil (byte-code "\212\306\211\307\310\311\312\313\314\f\315\316\317\260	\306\320#\2033\321\322!\321\323!\324\230\204*\nC\306\323\224b\210i\325 \210\307V\203]\310\326\327\f\330R\306\320#\203]\323\224b\210iW\2033\321\322!	Bi\325 \210\2023\n\203\333\331\n\332\"\211A\203\326
@\333\230\203z
A\306\202\261
@\334\230\203\207
A\202\261	\237##\203\260#@
@\230\203\241#A\237\306##A\211#\204\213	\237\210\202\213)	\203\276\335	!
\241\210\202\300
\335
\322\"\336
\211$A@)P
\306\241\210\202\332\337\nP)	:\203\346\340\341	\342#\n\203\370	\203\364	\nP\202\371\n\202\371	,\207" [indent mlist mname ruby-defun-beg-re ruby-symbol-re mn nil 0 re-search-backward "^[ 	]*" "[ 	]+" "\\(" "\\([A-Za-z_]" "*\\|\\.\\|::" "\\)" "+\\)" t match-string 2 1 "def" beginning-of-line "^[ 	]*\\(class\\|module\\)[ 	]+" "\\([A-Z]" "*\\)" split-string "\\.\\|::" "" "self" last "." "#" mapconcat identity "::" ml x] 11)] 3 (#$ . 24833)])
(defalias 'ruby-brace-to-do-end #[(orig end) "\304\211\nb\210`Sf\305=\205w\306\307!\210\212\310\304x\210n)\204 \311c\210\312c\210\313 m\2045\304fz\314=\2035\315c\210b\210\306\316!\210`Sfz\314=\203H\315c\210\317c\210\313 \320\321!\203e\316\224\204\\\315c\210\322\225Tb\210\323\324!\210\320\325!\204n\311c\210\326	\"\210	b\210\327*\207" [end-marker beg-marker end orig nil 125 delete-char -1 " 	" "\n" "end" point-marker 119 " " 1 "do" looking-at "\\(\\s \\)*|" 0 search-forward "|" "\\s *$" indent-region t] 3])
(defalias 'ruby-do-end-to-brace #[(orig end) "\306\211\211\211\f\307Zb\210\310
!\205\202\311\307!\210\312 \313c\210b\210\311\314!\210\315c\210\312 \310\316!\203E\311\317\320\225\320\224\321#!\210\306u\210\322\323\324 \325#\210\212\326\306w\210`\nb\210\326\306x\210`)	W\204s\327	!\327!U\203~\330i	Z\314#W\203~\331\332!\210\nb\210\331\332!\210b\210\325,\207" [end-pos beg-pos end-marker beg-marker end ruby-block-end-re nil 3 looking-at delete-char point-marker "}" 2 "{" "\\s +|" - 0 1 re-search-forward "|" line-end-position t " 	\n
" line-number-at-pos + just-one-space -1 orig fill-column] 5])
#@188 Toggle block type from do-end to braces or back.
The block must begin on the current line or above it and end after the point.
If the result is do-end block, it will always be multiline.
(defalias 'ruby-toggle-block #[nil "`\304\211\304\210\305\306!\2052`\307 \310\216\311 \210*`\211\nV\2052\312\224\203.\313	\"\2022\314	\"?\2058\nb+\207" [end beg start save-match-data-internal nil re-search-backward "\\({\\)\\|\\_<do\\(\\s \\|$\\||\\)" match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) ruby-forward-sexp 1 ruby-brace-to-do-end ruby-do-end-to-brace] 4 (#$ . 27199) nil])
(byte-code "\300\301!\210\302\303!\210\304\305\306\"\210\304\307\310\"\210\304\311\312\"\210\304\313\314\"\207" [(lambda (#1=#:def-tmp-var) (defconst ruby-percent-literal-beg-re #1# "Regexp to match the beginning of percent literal.")) "\\(%\\)[qQrswWx]?\\([[:punct:]]\\)" (lambda (#1#) (defconst ruby-syntax-methods-before-regexp #1# "Methods that can take regexp as the first argument.\nIt will be properly highlighted even when the call omits parens.")) ("gsub" "gsub!" "sub" "sub!" "scan" "split" "split!" "index" "match" "assert_match" "Given" "Then" "When") defalias ruby-syntax-propertize-function #[(start end) "b\210\306	!\210\307	!\210`	\211b\210`	W\205\310\311	\312#\205\313\224\203H\313\224\313\225\212\314\315\316\224!8)?\2056\317\n\203D\320\f\321\n$\210+\202\314\224\204R\322\224\203\227\323\324!\211A\322
\233\241\210\325
!\210)\326\224\203{\326\224\326\225\327\n\203z\320\f\321\n$\210+\314\224\203\314\224\314\225\330\n\203\223\320\f\321\n$\210+\202\331\224\203\250\320\331\224\331\225\321\332$\210\202\333\224\203\271\320\333\224\333\225\321\332$\210\202\334\224\203\370\323\324!\211A\335
\233\241\210\325
!\210)\336\224\336\225\337\316\224!?\205\346\320\336\224\336\225\321\340$\210\306	!\n\203\364\320\f\321\n$\210+\202\335\224\203\323\324!\211A\341
\233\241\210\325
!\210)\320\313\224\313\225\321\342$\210\343	!\210\202*\207" [start end syntax me mb md ruby-syntax-propertize-heredoc ruby-syntax-enclosing-percent-literal re-search-forward "\\([?$]\\)[#\"'`]\\|\\(^\\|[[=(,~?:;<>]\\|\\(?:^\\|\\s \\)\\(?:&&\\|and\\|elsif\\|if\\|not\\|or\\|un\\(?:less\\|til\\)\\|wh\\(?:en\\|ile\\)\\|||\\)\\|\\_<\\(?:Given\\|Then\\|When\\|assert_match\\|gsub!?\\|index\\|match\\|s\\(?:can\\|plit!?\\|ub!?\\)\\)\\)\\s *\\(/\\)[^/\n\\\\]*\\(?:\\\\.[^/\n\\\\]*\\)*\\(/\\)\\|^=en\\(d\\)\\_>\\|^\\(=\\)begin\\_>\\|\\(<\\)<\\(-\\)?\\(\\([a-zA-Z0-9_]+\\)\\|[\"]\\([^\"]+\\)[\"]\\|[']\\([^']+\\)[']\\).*\\(\n\\)\\|\\(?:^\\|[[ 	\n<+(,=]\\)\\(%\\)[qQrswWx]?\\([[:punct:]]\\)" t 1 3 syntax-ppss 0 (9) put-text-property syntax-table 4 match-data ints set-match-data 2 (7 . 47) (7 . 47) 5 (14) 6 13 14 7 ruby-singleton-class-p #2=(7) 28 #5=(15) ruby-syntax-propertize-percent-literal] 8 "Syntactic keywords for Ruby mode.  See `syntax-propertize-function'."] ruby-syntax-propertize-heredoc #[(limit) "\305 \306\307	8\310=\205h\212\311	8b\210\312 \210\313\n\314 \315#\2030\316\317\224!\204\320 \321PB\202)`A\203@\311	8b\210\237\203_\313\211A@\f\322#\203_\204@\323`S`\324\325$\210\202@`W\205gb)*\207" [res ppss ruby-here-doc-beg-re start limit syntax-ppss nil 3 10 8 beginning-of-line re-search-forward line-end-position t ruby-singleton-class-p 0 ruby-here-doc-end-match "\n" move put-text-property syntax-table #2#] 5] ruby-syntax-enclosing-percent-literal #[(limit) "\304 `\305	8\306=\205$\307	8b\210\310\n!\203\311!\210`W\205$b*\207" [start state ruby-percent-literal-beg-re limit syntax-ppss 3 t 8 looking-at ruby-syntax-propertize-percent-literal] 2] ruby-syntax-propertize-percent-literal #[(limit) "\304\224b\210\305\306 8\307=\205)\310f\311!\312 HA\206!\313\314\"A\310\211\315\316\217,\207" [op ops cl parse-sexp-lookup-properties 2 3 syntax-ppss t nil char-to-string syntax-table assoc ((60 . 62)) (byte-code "\2033\306 p\307\216\310\311\306\312\"!\210\313\314\315!P\"\210\313\316\fP\"\210\313\317\320\"\210\214`
}\210\321 \210,\202=\322\323\324\f!P
\312#\210\325`S`\306\326$\207" [cl #3=#:buffer #4=#:table op ops limit syntax-table ((byte-code "rq\210\302	!\210)\302\207" [#3# #4# set-syntax-table] 2)) set-syntax-table make-char-table nil modify-syntax-entry "(" char-to-string ")" 92 "\\" forward-list re-search-forward "[^\\]\\(?:\\\\\\\\\\)*" regexp-quote put-text-property #5#] 5) (((scan-error search-failed) (goto-char limit)))] 4]] 3)
(defalias 'ruby-in-ppss-context-p #[(context &optional ppss) "\206\302`!	\303=\203\3048\204_\3058\202\\	\306=\203&\3048\202\\	\307=\2034\3048\310=\202\\	\311=\203G\312\303!\205`\312\307!?\202\\	\313=\203S\3058\202\\\314\315\316\317	!\320R!\205`\321)\207" [ppss context syntax-ppss anything 3 4 string heredoc 10 non-heredoc ruby-in-ppss-context-p comment error "Internal error on `ruby-in-ppss-context-p': " "context name `" symbol-name "' is unknown" t] 5])
#@89 The syntax table to use for fontifying Ruby mode buffers.
See `font-lock-syntax-table'.
(defvar ruby-font-lock-syntax-table (byte-code "\302!\303\304\305	#\210	)\207" [ruby-mode-syntax-table tbl copy-syntax-table modify-syntax-entry 95 "w"] 4) (#$ . 32172))
#@51 Additional expressions to highlight in Ruby mode.
(defconst ruby-font-lock-keywords (byte-code "\302\303\304\305R\306B	\307\310E\311\312\313\314\315\316\317\257\n\207" [ruby-keyword-end-re ruby-here-doc-beg-re ("^\\s *def\\s +\\([^( 	\n]+\\)" 1 font-lock-function-name-face) "\\(^\\|[^_:.@$]\\|\\.\\.\\)\\b\\(defined\\?\\|" "\\(a\\(?:lias\\(?:_method\\)?\\|nd\\)\\|b\\(?:egin\\|reak\\)\\|c\\(?:a\\(?:se\\|tch\\)\\|lass\\)\\|d\\(?:ef\\|o\\)\\|e\\(?:ls\\(?:e\\|if\\)\\|n\\(?:d\\|sure\\)\\)\\|f\\(?:ail\\|or\\)\\|i[fn]\\|module\\(?:_function\\)?\\|n\\(?:\\(?:ex\\|o\\)t\\)\\|or\\|p\\(?:r\\(?:ivate\\|otected\\)\\|ublic\\)\\|r\\(?:aise\\|e\\(?:do\\|scue\\|t\\(?:ry\\|urn\\)\\)\\)\\|super\\|th\\(?:en\\|row\\)\\|un\\(?:def\\|less\\|til\\)\\|wh\\(?:en\\|ile\\)\\|yield\\)" "\\)" 2 0 font-lock-string-face ("\\(^\\|[^_:.@$]\\|\\.\\.\\)\\b\\(nil\\|self\\|true\\|false\\)\\>" 2 font-lock-variable-name-face) ("\\(^\\|[^:]\\)\\(:\\([-+~]@?\\|[/%&|^`]\\|\\*\\*?\\|<\\(<\\|=>?\\)?\\|>[>=]?\\|===?\\|=~\\|![~=]?\\|\\[\\]=?\\|@?\\(\\w\\|_\\)+\\([!?=]\\|\\b_*\\)\\|#{[^}\n\\\\]*\\(\\\\.[^}\n\\\\]*\\)*}\\)\\)" 2 font-lock-constant-face) ("\\(\\$\\([^a-zA-Z0-9 \n]\\|[0-9]\\)\\)\\W" 1 font-lock-variable-name-face) ("\\(\\$\\|@\\|@@\\)\\(\\w\\|_\\)+" 0 font-lock-variable-name-face) ("\\(^\\|[^_]\\)\\b\\([A-Z]+\\(\\w\\|_\\)*\\)" 2 font-lock-type-face) ("\\(^\\s *\\|[[{(,]\\s *\\|\\sw\\s +\\)\\(\\(\\sw\\|_\\)+\\):[^:]" 2 font-lock-constant-face) (ruby-match-expression-expansion 0 font-lock-variable-name-face t)] 10) (#$ . 32438))
(defalias 'ruby-match-expression-expansion #[(limit) "\301\302\303#\205\304\305!\206\306!\207" [limit re-search-forward "[^\\]\\(\\\\\\\\\\)*\\(#\\({[^}\n\\\\]*\\(\\\\.[^}\n\\\\]*\\)*}\\|\\(\\$\\|@\\|@@\\)\\(\\w\\|_\\)+\\)\\)" move ruby-in-ppss-context-p string ruby-match-expression-expansion] 4])
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [ruby-mode-hook variable-documentation put purecopy "Hook run when entering Ruby mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp ruby-mode-map definition-name ruby-mode] 5)
(defvar ruby-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [ruby-mode-map variable-documentation put purecopy "Keymap for `ruby-mode'." boundp ruby-mode-syntax-table definition-name ruby-mode] 5)
(defvar ruby-mode-syntax-table (make-syntax-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [ruby-mode-syntax-table variable-documentation put purecopy "Syntax table for `ruby-mode'." ruby-mode-abbrev-table definition-name ruby-mode] 5)
(defvar ruby-mode-abbrev-table (progn (define-abbrev-table 'ruby-mode-abbrev-table nil) ruby-mode-abbrev-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [ruby-mode-abbrev-table variable-documentation put purecopy "Abbrev table for `ruby-mode'." ruby-mode derived-mode-parent prog-mode] 5)
#@435 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}

In addition to any hooks its parent mode `prog-mode' might have run,
this mode runs the hook `ruby-mode-hook', as the final step
during initialization.
(defalias 'ruby-mode #[nil "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f!\211\2036
\321 =\203<\322\f\323 \"\210)\3245\325\"\204V56=\204V\3265\3256C#\210\327!\210\330\f!\21056\331 \210\306\332!\210\333\306\334!\210\335\306\336!\210\337\306\340!\210\341 \342\343\344!\203\214\344\202\235\343\345!\203\226\345\202\235\343\346!\205\235\346\347\350\351$\210\306\352!\210\353\354*\"*\306\355!\210\356-\306\357!\2107/\306\360!\21080\306\361!\210\3621)\363\364!\207" [delay-mode-hooks major-mode mode-name ruby-mode-map ruby-mode-syntax-table parent make-local-variable t prog-mode ruby-mode "Ruby" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table ruby-mode-variables imenu-create-index-function ruby-imenu-create-index add-log-current-defun-function ruby-add-log-current-method beginning-of-defun-function ruby-beginning-of-defun end-of-defun-function ruby-end-of-defun add-hook boundp before-save-hook write-contents-functions write-contents-hooks ruby-mode-set-encoding nil local electric-indent-chars append (123 125) font-lock-defaults ((ruby-font-lock-keywords) nil nil) font-lock-keywords font-lock-syntax-table syntax-propertize-function ruby-syntax-propertize-function run-mode-hooks ruby-mode-hook ruby-mode-abbrev-table local-abbrev-table ruby-font-lock-keywords ruby-font-lock-syntax-table] 6 (#$ . 35512) nil])
(byte-code "\302\303\304\305!\306B\"\210\307\310\311\312\313\257\314\211\203*	@\302\315\304!\306B\"\210	A\211\204*\316\306!\207" [name --dolist-tail-- add-to-list auto-mode-alist purecopy "\\.rb\\'" ruby-mode "ruby" "rbx" "jruby" "ruby1.9" "ruby1.8" nil interpreter-mode-alist provide] 6)
F1l3 Manager
