;ELC   
;;; Compiled by buildd@lcy01-24.buildd on Tue Sep 19 22:19:58 2017
;;; from file /build/emacs24-8smh0b/emacs24-24.3+1/debian/build-x/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") (#$ . 780))
#@42 Regexp to match the beginning of blocks.
(defconst ruby-block-beg-re (regexp-opt ruby-block-beg-keywords) (#$ . 951))
#@52 Regexp to match keywords that nest without blocks.
(defconst ruby-non-block-do-re (concat "\\(for\\|rescue\\|until\\|while\\)" ruby-keyword-end-re) (#$ . 1075))
#@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\\)\\)\\_>" (#$ . 1242))
#@57 Modifiers that are the same as the beginning of blocks.
(defconst ruby-modifier-beg-keywords '("if" "unless" "while" "until") (#$ . 1453))
#@60 Regexp to match modifiers same as the beginning of blocks.
(defconst ruby-modifier-beg-re (regexp-opt ruby-modifier-beg-keywords) (#$ . 1598))
#@28 Regexp to match modifiers.
(defconst ruby-modifier-re (byte-code "\301\302B!\207" [ruby-modifier-beg-keywords regexp-opt "rescue"] 3) (#$ . 1747))
#@78 Keywords where the indentation gets shallower in middle of block statements.
(defconst ruby-block-mid-keywords '("then" "else" "elsif" "when" "rescue" "ensure") (#$ . 1901))
#@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) (#$ . 2081))
#@35 Regexp to match boolean keywords.
(defconst ruby-block-op-keywords '("and" "or" "not") (#$ . 2249))
#@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) (#$ . 2355))
(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\\)" (#$ . 2594))
#@45 Regexp to match the beginning of a heredoc.
(defconst ruby-here-doc-beg-re "\\(<\\)<\\(-\\)?\\(\\([a-zA-Z0-9_]+\\)\\|[\"]\\([^\"]+\\)[\"]\\|[']\\([^']+\\)[']\\)" (#$ . 2734))
#@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 (#$ . 2916)])
(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 "\\|}\\|\\]\\)") (#$ . 3391))
#@28 Regexp to match operators.
(defconst ruby-operator-re "[-,.+*/%&|^~=<>:]" (#$ . 3576))
#@51 List of characters that symbol names may contain.
(defconst ruby-symbol-chars "a-zA-Z0-9_" (#$ . 3669))
#@26 Regexp to match symbols.
(defconst ruby-symbol-re (concat "[" ruby-symbol-chars "]") (#$ . 3779))
(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) (#$ . 3977))
#@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) (#$ . 4395))
(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 (#$ . 6594)])
#@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 (#$ . 7544)])
#@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 (#$ . 7723)])
#@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 (#$ . 7938)])
#@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\237 eb\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 (#$ . 8724)])
#@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 (#$ . 9746)])
#@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 (#$ . 9927) 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 (#$ . 10109)])
#@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 (#$ . 10505)])
(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\253 n\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 (#$ . 11084)])
#@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 (#$ . 12012)])
#@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 (#$ . 12535)])
#@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!\203V m\204M \316``T{\317\211$\204\215`Bb\210\202\215\313\320!\203q m\204h \307\321\317#\204\215`Bb\210\202\215\313\322!\203~ Ab\210\202\215\313\323!\203\247 m\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 \201g Q\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 (#$ . 12797)])
#@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 (#$ . 16771)])
#@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 (#$ . 17041)])
#@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\351 i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 (#$ . 17228)])
#@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 (#$ . 19747) "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 (#$ . 20104) "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 (#$ . 20410)])
#@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 (#$ . 20738)])
#@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 (#$ . 21563) "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 (#$ . 21782) 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 (#$ . 21992) "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 (#$ . 23156) "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 (#$ . 24302) "*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 (#$ . 24829)])
(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 (#$ . 27195) 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) (#$ . 32168))
#@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) (#$ . 32434))
(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 (#$ . 35508) 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)