;ELC
;;; Compiled
;;; in Emacs version 28.2
;;; with all optimizations.



(byte-code "\300\301!\210\302\303\304\305\306\307\310\311&\207" [require cl-lib custom-declare-group ruby nil "Major mode for editing Ruby code." :prefix "ruby-" :group languages] 8)
#@38 Keywords at the beginning of blocks.
(defconst ruby-block-beg-keywords '("class" "module" "def" "if" "unless" "case" "while" "until" "for" "begin" "do") (#$ . 268))
#@42 Regexp to match the beginning of blocks.
(defconst ruby-block-beg-re (regexp-opt ruby-block-beg-keywords) (#$ . 439))
#@52 Regexp to match keywords that nest without blocks.
(defconst ruby-non-block-do-re "\\_<\\(for\\|rescue\\|until\\|while\\)\\_>" (#$ . 563))
#@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\\)\\)\\_>" (#$ . 708))
#@57 Modifiers that are the same as the beginning of blocks.
(defconst ruby-modifier-beg-keywords '("if" "unless" "while" "until") (#$ . 918))
#@60 Regexp to match modifiers same as the beginning of blocks.
(defconst ruby-modifier-beg-re (regexp-opt ruby-modifier-beg-keywords) (#$ . 1062))
#@28 Regexp to match modifiers.
(defconst ruby-modifier-re (byte-code "\301\302B!\207" [ruby-modifier-beg-keywords regexp-opt "rescue"] 3) (#$ . 1211))
#@78 Keywords where the indentation gets shallower in middle of block statements.
(defconst ruby-block-mid-keywords '("then" "else" "elsif" "when" "rescue" "ensure") (#$ . 1365))
#@80 Regexp for where the indentation gets shallower in middle of block statements.
(defconst ruby-block-mid-re (regexp-opt ruby-block-mid-keywords) (#$ . 1545))
#@35 Regexp to match boolean keywords.
(defconst ruby-block-op-keywords '("and" "or" "not") (#$ . 1708))
#@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) (#$ . 1814))
(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\\)" (#$ . 2053))
#@61 Regexp to match the beginning of a singleton class context.
(defconst ruby-singleton-class-re "class\\s *<<" (#$ . 2193))
#@45 Regexp to match the beginning of a heredoc.
(defconst ruby-here-doc-beg-re "\\(<\\)<\\([~-]\\)?\\(\\([a-zA-Z0-9_]+\\)\\|[\"]\\([^\"]+\\)[\"]\\|[']\\([^']+\\)[']\\)" (#$ . 2321))
(defconst ruby-expression-expansion-re "#\\({[^}\n\\]*\\(\\\\.[^}\n\\]*\\)*}\\|\\(?:\\$\\|@\\|@@\\)\\(\\w\\|_\\)+\\|\\$[^a-zA-Z \n]\\)")
#@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 #[0 "\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 (#$ . 2643)])
(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 "\\|}\\|\\]\\)") (#$ . 3116))
#@28 Regexp to match operators.
(defconst ruby-operator-re "[-,.+*/%&|^~=<>:]\\|\\\\$" (#$ . 3301))
#@51 List of characters that symbol names may contain.
(defconst ruby-symbol-chars "a-zA-Z0-9_" (#$ . 3402))
#@26 Regexp to match symbols.
(defconst ruby-symbol-re (concat "[" ruby-symbol-chars "]") (#$ . 3512))
(defvar ruby-use-smie t)
(make-obsolete-variable 'ruby-use-smie nil "28.1")
#@27 Keymap used in Ruby mode.
(defvar ruby-mode-map (byte-code "\301 \204\f\302
\303\304#\210\203\302
\305\306#\210\302
\307\310#\210\302
\311\312#\210\302
\313\314#\210\302
\315\316#\210\302
\317\320#\210\207" [ruby-use-smie make-sparse-keymap define-key [134217745] ruby-indent-exp [134217732] smie-down-list [134217744] ruby-beginning-of-block [134217742] ruby-end-of-block "{" ruby-toggle-block "'" ruby-toggle-string-quotes "" ruby-find-library-file] 5) (#$ . 3692))
#@17 Ruby Mode Menu.
(defvar ruby-mode-menu nil (#$ . 4175))
(easy-menu-do-define 'ruby-mode-menu ruby-mode-map "Ruby Mode Menu." '("Ruby" ["Beginning of Block" ruby-beginning-of-block t] ["End of Block" ruby-end-of-block t] ["Toggle Block" ruby-toggle-block t] "--" ["Toggle String Quotes" ruby-toggle-string-quotes t] "--" ["Backward Sexp" backward-sexp t] ["Forward Sexp" forward-sexp t] ["Indent Sexp" ruby-indent-exp :visible (not ruby-use-smie)] ["Indent Sexp" prog-indent-sexp :visible ruby-use-smie]))
#@35 Syntax table to use in Ruby mode.
(defvar ruby-mode-syntax-table (byte-code "\300 \301\302\303#\210\301\304\303#\210\301\305\303#\210\301\306\307#\210\301\310\311#\210\301\312\313#\210\301\314\315#\210\301\316\317#\210\301\320\315#\210\301\321\315#\210\301\322\323#\210\301\324\323#\210\301\325\323#\210\301\326\323#\210\301\327\323#\210\301\330\323#\210\301\331\323#\210\301\332\323#\210\301\333\323#\210\301\334\323#\210\301\335\323#\210\301\336\337#\210\301\340\341#\210\301\342\343#\210\301\344\345#\210\301\346\347#\210\301\350\351#\210\207" [make-syntax-table modify-syntax-entry 39 "\"" 34 96 35 "<" 10 ">" 92 "\\" 36 "'" 95 "_" 58 64 60 "." 62 38 124 37 61 47 43 42 45 59 40 "()" 41 ")(" 123 "(}" 125 "){" 91 "(]" 93 ")["] 5) (#$ . 4686))
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\210\300\312\302\303\313DD\314\306\315\310\316&\210\300\317\302\303\320DD\321\306\315\310\316&\207" [custom-declare-variable ruby-indent-tabs-mode funcall function #[0 "\300\207" [nil] 1 #1=""] "Indentation can insert tabs in Ruby mode if this is non-nil." :type boolean :safe booleanp ruby-indent-level #[0 "\300\207" [2] 1 #1#] "Indentation of Ruby statements." integer integerp ruby-comment-column #[0 "\300\301!\207" [default-value comment-column] 2 #1#] "Indentation column of comments."] 8)
#@61 Keywords that can be used in `ruby-align-to-stmt-keywords'.
(defconst ruby-alignable-keywords '(if while unless until begin case for def) (#$ . 6021))
(byte-code "\301\302\303\304\305DD\306\307\310\311\312\313\314\315\310\316\317\"BFF\320\321\322\323&	\210\301\324\303\304\325DD\326\307\327\320\330\322\323&	\210\301\331\303\304\332DD\333\307\327\320\330&\210\301\334\303\304\335DD\336\307\337%\210\301\340\303\304\341DD\342\307\343%\210\301\344\303\304\345DD\346\307\347%\210\301\350\303\304\351DD\352\307\327\353\354&\210\301\355\303\304\356DD\357\307\360\322\323&\210\301\361\303\304\362DD\363\307\364\322\323&\210\301\365\303\304\366DD\367\307\327\353\354&\210\370\371!\207" [ruby-alignable-keywords custom-declare-variable ruby-align-to-stmt-keywords funcall function #[0 "\300\207" [(def)] 1 #1=""] "Keywords after which we align the expression body to statement.\n\nWhen nil, an expression that begins with one these keywords is\nindented to the column of the keyword.  Example:\n\n  tee = if foo\n          bar\n        else\n          qux\n        end\n\nIf this value is t or contains a symbol with the name of given\nkeyword, the expression is indented to align to the beginning of\nthe statement:\n\n  tee = if foo\n    bar\n  else\n    qux\n  end\n\nOnly has effect when `ruby-use-smie' is t." :type choice (const :tag "None" nil) (const :tag "All" t) repeat :tag "User defined" mapcar #[257 "\300
D\207" [const] 3 "\n\n(fn KW)"] :safe listp :version "24.4" ruby-align-chained-calls #[0 "\300\207" [nil] 1 #1#] "If non-nil, align chained method calls.\n\nEach method call on a separate line will be aligned to the column\nof its parent.\n\nOnly has effect when `ruby-use-smie' is t." boolean booleanp ruby-deep-arglist #[0 "\300\207" [t] 1 #1#] "Deep indent lists in parenthesis when non-nil.\nAlso ignores spaces after parenthesis when `space'.\nOnly has effect when `ruby-use-smie' is nil." ruby-deep-indent-paren #[0 "\300\207" [(40 91 93 t)] 1 #1#] "Deep indent lists in parenthesis when non-nil.\nThe value t means continuous line.\nAlso ignores spaces after parenthesis when `space'.\nOnly has effect when `ruby-use-smie' is nil." (choice (const nil) character (repeat (choice character (cons character (choice (const nil) (const t))) (const t)))) ruby-deep-indent-paren-style #[0 "\300\207" [space] 1 #1#] "Default deep indent style.\nOnly has effect when `ruby-use-smie' is nil." (choice (const t) (const nil) (const space)) ruby-encoding-map #[0 "\300\207" [((us-ascii) (utf-8) (shift-jis . cp932) (shift_jis . cp932) (japanese-cp932 . cp932))] 1 #1#] "Alist to map encoding name from Emacs to Ruby.\nAssociating an encoding name with nil means it needs not be\nexplicitly declared in magic comment." (repeat (cons (symbol :tag "From") (symbol :tag "To"))) ruby-insert-encoding-magic-comment #[0 "\300\207" [t] 1 #1#] "Insert a magic Ruby encoding comment upon save if this is non-nil.\nThe encoding will be auto-detected.  The format of the encoding comment\nis customizable via `ruby-encoding-magic-comment-style'.\n\nWhen set to `always-utf8' an utf-8 comment will always be added,\neven if it's not required." :group ruby ruby-encoding-magic-comment-style #[0 "\300\207" [ruby] 1 #1#] "The style of the magic encoding comment to use." (choice (const :tag "Emacs Style" emacs) (const :tag "Ruby Style" ruby) (const :tag "Custom Style" custom)) ruby-custom-encoding-magic-comment-template #[0 "\300\207" ["# encoding: %s"] 1 #1#] "A custom encoding comment template.\nIt is used when `ruby-encoding-magic-comment-style' is set to `custom'." string ruby-use-encoding-map #[0 "\300\207" [t] 1 #1#] "Use `ruby-encoding-map' to set encoding magic comment if this is non-nil." require smie] 15)
(defconst ruby-smie-grammar '((:smie-closer-alist (#14="def" . "end") (#13="begin" . "end") (#12="do" . "end") (#11="class" . "end") (#10="module" . "end") (#9="for" . "end") (#8="[" . #16="]") ("{" . "}") (#7="while" . "end") (#6="until" . "end") (#5="unless" . "end") (#4="if" . "end") (#3="case" . #15="end") (#2="opening-|" . #1="closing-|")) ("**" 372 383) ("%" 346 359) ("/" 347 360) ("*" 348 361) ("-" 322 334) ("+" 323 335) (">>" 298 310) ("<<" 299 311) ("|" 272 285) ("&" 273 286) ("^" 274 287) ("<=" 242 258) ("<" 243 259) (">=" 244 260) (">" 245 261) ("!~" 246 227) ("=~" 247 228) ("!=" 213 229) ("===" 214 230) ("==" 215 231) ("<=>" 216 200) ("||" 188 201) ("&&" 189 202) ("..." 150 176) (".." 151 177) ("||=" 152 126) ("&&=" 153 127) (">>=" 154 128) ("<<=" 155 129) ("^=" 156 130) ("|=" 157 131) ("&=" 158 132) ("**=" 159 133) ("%=" 160 134) ("/=" 161 135) ("*=" 162 136) ("-=" 163 137) ("+=" 164 138) (#1# 0 (405)) (#2# (406) 0) ("when" 17 17) ("elsif" 15 15) ("else" 28 29) ("then" 30 41) ("=>" 104 103) ("in" 407 63) ("rescue" 16 16) ("ensure" 16 16) (#3# (408) 1) (#4# (409) 1) (#5# (410) 1) (#6# (411) 1) (#7# (412) 1) ("{" (413) 2) (#8# (414) 3) (#9# (415) 1) (#10# (416) 1) (#11# (417) 1) (#12# (418) 1) (#13# (419) 1) (#14# (420) 1) ("?" 165 4) ("," 91 91) ("=" 115 102) (" @ " 421 77) ("." 394 394) (#15# 1 (422)) ("}" 2 (423)) (#16# 3 (424)) (":" 4 139) ("or" 64 78) ("and" 65 79) (";" 52 52) ("iuwu-mod" 66 80)))
(defalias 'ruby-smie--bosp #[0 "\212\300\301x\210n\203`S\206`Sf\302=?\206-`Sf\303=\206-`Sf\304=\205-\305`S!\306\232)\207" [" 	" nil 92 59 61 syntax-after (1)] 2])
(defalias 'ruby-smie--implicit-semi-p #[0 "\212\300\301x\210n\206Q`Sf\302>\206Q`Sf\303>\203$\304`S!@\305>?\206Q`Sf\306=\2035\212\307 )\310\235\206Q\304`S!@\311=\203H\212\307 )\312\235\206Q\212\313d!\210\314\315!))?\207" [" 	" nil (91 40) (59 45 43 42 47 58 46 44 92 38 62 60 37 126 94 61 63) syntax-after (3 7 15) 124 ruby-smie--backward-token ("|" "||") 2 ("iuwu-mod" "and" "or") forward-comment looking-at "&?\\."] 2])
#@23 

(fn &optional SKIP)
(defalias 'ruby-smie--redundant-do-p #[256 "\212\211\203	\300\301!\210\302\303\304!8\305\235)\207" [backward-word-strictly 1 2 smie-backward-sexp ";" ("while" "until" "for")] 4 (#$ . 11783)])
(defalias 'ruby-smie--opening-pipe-p #[0 "\212`Sf\300=\203\f\301u\210\302\303x\210`Sf\304=\206\305\306`\307Z\")\207" [124 -1 " 	\n" nil 123 looking-back "\\_<do" 2] 4])
(defalias 'ruby-smie--closing-pipe-p #[0 "\212`Sf\300=\203\f\301u\210\302\303\304 \305#\205\306 )\207" [124 -1 re-search-backward "|" line-beginning-position t ruby-smie--opening-pipe-p] 4])
#@12 

(fn POS)
(defalias 'ruby-smie--args-separator-p #[257 "\211\300 W\205Bhz\301=\204\"h\302>\205B`S\206`Sfz\301=\205B\212\211b\210\303fz\301=\2035\304\305!?\206A\306
!@\307>\206A\304\310!)\207" [line-end-position 119 (33 63) nil looking-at "\\_<\\(and\\|do\\|e\\(?:ls\\(?:e\\|if\\)\\|nd\\)\\|if\\|or\\|un\\(?:less\\|til\\)\\|while\\)\\_>" syntax-after (7 15) "[([]\\|[-+!~:]\\(?:\\sw\\|\\s_\\)"] 3 (#$ . 12370)])
(defalias 'ruby-smie--before-method-name #[0 "gz\300=\205\"`Sf\301=\203`S\206`Sf\301=?\206\"\302\303\304 \"\207" [119 46 looking-back "^\\s *def\\s +\\=" line-beginning-position] 3])
(defalias 'ruby-smie--forward-token #[0 "`\301\302w\210\303\304!\203\303\305!\203\306`\307\"b\210\310\207\303\311!\2034\312 \2034l\203.\307u\210\2022\313\307!\210\310\207\313d!\210\211`W\203K\212\314`b\210!)\203K\315\207\303\305!\203S\316\207\317 \320 
\203`\321
P\262
\211\322\235\203v\212\323\324!\210\325 )\203r\207\266\326\207\327
\302\330\331#)\266\203\203\242\307
GZu\210\332\262
\333 \203\230\266\334\207\335 \203\241\266\336\207\207\331\337\"\203\261\324u\210\211\340\324O\207\211\316\232\203\304\303\341!\203\304\340\225b\210\342 \207\211\343\267\207\344\345!\204\317\207\212\313d!\210`)\346 V\203\337\342 \207\266\310\207\266\321\207\207" [inhibit-changing-match-data " 	" nil looking-at "\n" "\\s\"" scan-sexps 1 ";" "[\n#]" ruby-smie--implicit-semi-p forward-comment ruby-smie--args-separator-p " @ " "" ruby-smie--before-method-name smie-default-forward-token "." ("unless" "if" "while" "until") forward-word-strictly -1 ruby-smie--bosp "iuwu-mod" "\\`|[*&]?\\'" t string-match "|" ruby-smie--opening-pipe-p "opening-|" ruby-smie--closing-pipe-p "closing-|" "\\`[^|]+|\\'" 0 "\\\\\n" ruby-smie--forward-token #s(hash-table size 2 test equal rehash-size 1.5 rehash-threshold 0.8125 purecopy t data ("do" 200 "&." 227)) ruby-smie--redundant-do-p skip line-end-position] 10])
(defalias 'ruby-smie--backward-token #[0 "`\301`[!\210\211\302 V\203\303 \203\304\305w\210\306\207n\203(o\204(\307`\310\"b\210\306\207\211`V\203:n\204:\311
!\203:\312\207\313 \314 \211\203G\315P\262
\316\267\202l\317 \203T
\207\266\320\207\321 \203a\266\322\207\323 \203j\266\324\207
\207\325\305\326\327#)\266\203\203\200\266\324\207\330\305\326\327#)\266\203\203\230\331u\210
\331\305O\207
\332\232\203\262`Sf\333=\203\262\334\335!\203\262\310u\210\336 \207
\337\267\202\333\340 \204\277
\207\212\341\331!\210\301d!\210`)\302 V\203\323\336 \207\266\306\207\266\315\207
\207" [inhibit-changing-match-data forward-comment line-end-position ruby-smie--implicit-semi-p " 	" nil ";" scan-sexps -1 ruby-smie--args-separator-p " @ " smie-default-backward-token ruby-smie--before-method-name "." #s(hash-table size 5 test equal rehash-size 1.5 rehash-threshold 0.8125 purecopy t data ("unless" 77 "if" 77 "while" 77 "until" 77 "|" 88)) ruby-smie--bosp "iuwu-mod" ruby-smie--opening-pipe-p "opening-|" ruby-smie--closing-pipe-p "closing-|" "\\`[^|]+|\\'" t string-match "\\`|[*&]\\'" 1 "" 92 looking-at "\n" ruby-smie--backward-token #s(hash-table size 2 test equal rehash-size 1.5 rehash-threshold 0.8125 purecopy t data ("do" 184 "&." 215)) ruby-smie--redundant-do-p forward-word-strictly] 10])
(defalias 'ruby-smie--indent-to-stmt #[0 "\212\300\301!\210\302\303 )B\207" [smie-backward-sexp ";" column smie-indent-virtual] 2])
#@16 

(fn KEYWORD)
(defalias 'ruby-smie--indent-to-stmt-p #[257 "\301=\206\302
!>\207" [ruby-align-to-stmt-keywords t intern] 3 (#$ . 15767)])
#@19 

(fn KIND TOKEN)
(defalias 'ruby-smie-rules #[514 "\302\303\304B\211\305\267\2021\207\306\307!\205\322\310\207\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332&\205\322\333!\207\211:\203V
\211\242\211\334\267\202<

\243\211\335\235\203\240\332\232\203k\336\337\332\340\341\342\343\344\345\314&	\204k\212\346\347!\210h)\350=\204k\351 \207\352 \205\347\353 @\354=\203z\355\207\311\356!\203\235\357 \204\232\360\361\356!8\356\232\203\232\357 \204\232\347u\210\202\200\362 \207\333 \207\363\267\202\257 \207\351 \207 \207\211\364\235\203\270\333 \207\365\232\203\301 \207\366!	>\203\336\367 ?\205\347\370!\203\332\351 \207\371iB\207\372\232\205\347\333!\207
\243\211\373\235\203
\212\374u\210\375\355w\210l\206\377\346\374!?\205
\371iB)\207\376\267\202
 \207\351 \207 \207 \207\211\377\267\2022
\311\345\355\"\205;
\201@ \205;
\207\207\372\232\205;
\333!\207
\201A\267\202T
 \207\351 \207 \207 \207\333!\207\355\207\211\201B\267\202n
 \207\351 \207 \207
 \207\333!\207\211:\205\322\211\242\211\201C\267\202\255
\243\211\335\235\203\347
\332\232\203\254
\336\337\332\340\341\342\343\344\345\314&	\204\254
\212\346\347!\210h)\350=\204\254
\351 \202>\352 \205>\353 @\354=\203\275
\355\202>\311\356!\203\342
\357 \204\335
\360\361\356!8\356\232\203\335
\357 \204\335
\347u\210\202\303
\362 \202>\333 \202>\201D\267\202\376
 \202>\351 \202> \202>\211\364\235\203	\333 \202>\365\232\203 \202>\366!	>\2035\367 ?\205>\370!\203/\351 \202>\371iB\202>\372\232\205>\333!\262
\202\320
\243\211\373\235\203e\212\374u\210\375\355w\210l\206Z\346\374!?\205a\371iB)\202\250\201E\267\202\201 \202\250\351 \202\250 \202\250 \202\250\211\201F\267\202\237\311\345\355\"\205\250\201@ \205\250\202\250\202\250\372\232\205\250\333!\262
\202\320
\201G\267\202\317 \202\320\351 \202\320 \202\320 \202\320\333!\202\320\355\262
\207" [ruby-indent-level ruby-alignable-keywords #[0 "\212\300\301w\210\302i)B\207" [" 	" nil column] 2] #[0 "\302 \203-\2056`\303\304!\305
8\304\232\204
b\266\202)\211A@b\210\306 ?\266\202\204	\307iB\207\303\304!\210\307i	\\B\207" [ruby-align-chained-calls ruby-indent-level smie-rule-sibling-p smie-backward-sexp "." 2 smie-rule-bolp column] 4] #[0 "\300 \203\301\207\302 \207" [smie-rule-sibling-p 0 smie-rule-parent] 1] #s(hash-table size 3 test equal rehash-size 1.5 rehash-threshold 0.8125 purecopy t data ((:elem . basic) 12 (:elem . args) 14 (:before . ";") 22)) looking-at "\\s\"" 0 smie-rule-parent-p "def" "begin" "do" "class" "module" "for" "while" "until" "unless" "if" "then" "elsif" "else" "when" "rescue" "ensure" "{" smie-rule-parent #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (:before 62 :after 232)) ("{" "[" "(") smie-rule-prev-p "(" "[" "," "=>" "=" "return" ";" forward-comment -1 58 ruby-smie--indent-to-stmt smie-rule-hanging-p smie-indent--parent t nil "." ruby-smie--bosp 2 smie-backward-sexp smie-indent-virtual #s(hash-table size 3 test equal rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (#1=(:before . " @ ") 166 #2=(:before . "do") 169 #3=(:before . ".") 172)) ("ensure" "rescue" "elsif" "then" "else") #4=(:before . "when") intern-soft ruby--at-indentation-p ruby-smie--indent-to-stmt-p column #5=(:before . "iuwu-mod") ("{" "[" "(") 1 " 	" #s(hash-table size 4 test equal rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (#1# 270 #2# 273 #3# 276 #4# 279)) #s(hash-table size 39 test equal rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (#6="or" 288 #7="and" 288 #8="||=" 288 #9="&&=" 288 #10=">>=" 288 #11="<<=" 288 #12="|" 288 #13="^=" 288 #14="|=" 288 #15="&=" 288 #16="**=" 288 #17="%=" 288 #18="/=" 288 #19="*=" 288 #20="-=" 288 #21="+=" 288 #22=">>" 288 #23="<<" 288 #24="!=" 288 #25="===" 288 #26="==" 288 #27="<=" 288 #28=">=" 288 #29="<" 288 #30=">" 288 #31="<=>" 288 #32="&" 288 #33="^" 288 #34="**" 288 #35="%" 288 #36="||" 288 #37="&&" 288 #38="/" 288 #39="*" 288 #40="-" 288 #41="+" 288 #42="=" 288 #43=":" 304 #44="?" 304)) smie-indent--hanging-p #s(hash-table size 5 test equal rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (#1# 324 #2# 327 #3# 330 #4# 333 #5# 336)) #s(hash-table size 5 test equal rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (#1# 350 #2# 353 #3# 356 #4# 359 #5# 362)) #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (:before 381 :after 579)) #s(hash-table size 3 test equal rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (#1# 495 #2# 500 #3# 505)) #s(hash-table size 4 test equal rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (#1# 621 #2# 626 #3# 631 #4# 636)) #s(hash-table size 39 test equal rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (#6# 649 #7# 649 #8# 649 #9# 649 #10# 649 #11# 649 #12# 649 #13# 649 #14# 649 #15# 649 #16# 649 #17# 649 #18# 649 #19# 649 #20# 649 #21# 649 #22# 649 #23# 649 #24# 649 #25# 649 #26# 649 #27# 649 #28# 649 #29# 649 #30# 649 #31# 649 #32# 649 #33# 649 #34# 649 #35# 649 #36# 649 #37# 649 #38# 649 #39# 649 #40# 649 #41# 649 #42# 649 #43# 667 #44# 667)) #s(hash-table size 5 test equal rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (#1# 693 #2# 698 #3# 703 #4# 708 #5# 713))] 24 (#$ . 15916)])
#@24 

(fn &optional POINT)
(defalias 'ruby--at-indentation-p #[256 "\212\211\204`\262
\300y\210\301\302w\210`
)=\207" [0 " 	" nil] 3 (#$ . 21248)])
#@71 Create an imenu index of methods inside a block.

(fn PREFIX BEG END)
(defalias 'ruby-imenu-create-index-in-block #[771 "\301\211\211\211\211\211\211b\210\302\303	\304#\203\323\305\224\262
\306\307!\262\310\225\262\306\311!\206,\306\312!\262\310\224\262
\313\230\203N	\203C	P\262BB\262\202

\203\202	\203r\314\315\"\203l	\310\316O\311\301OP\202p	P\262BB\262\317!\210\202
\320\230\203\227	\203\257	\310\316O\262\202\257	\203\247	\310\316O\321Q\262BB\262\317!\210`\262	\322\203\301\323\202\302\324P#\244\262b\210\202
)\207" [case-fold-search nil re-search-forward "^\\s *\\(\\(class\\s +\\|\\(class\\s *<<\\s *\\)\\|module\\s +\\)\\([^(<\n ]+\\)\\|\\(\\(?:\\(?:private\\|protected\\|public\\) +\\)?def\\|alias\\)\\s +\\([^(\n ]+\\)\\)" t 3 match-string 5 0 4 6 "alias" string-match "^self\\." -1 ruby-accurate-end-of-block "self" "::" ruby-imenu-create-index-in-block "." "#"] 14 (#$ . 21400)])
#@53 Create an imenu index of all methods in the buffer.
(defalias 'ruby-imenu-create-index #[0 "\300\301e\301#\237\207" [ruby-imenu-create-index-in-block nil] 4 (#$ . 22377)])
#@87 Jump to the end of the current block or END, whichever is closer.

(fn &optional END)
(defalias 'ruby-accurate-end-of-block #[256 "\301
\206d\203\214\302 \210`
}\210\303 )\207\304\305#\211\262\2052\3068\307Y\2052`
W\2052\202\207" [ruby-use-smie nil back-to-indentation smie-forward-sexp apply ruby-parse-partial 2 0] 7 (#$ . 22555)])
#@54 Set up initial buffer-local variables for Ruby mode.
(defalias 'ruby-mode-variables #[0 "\306\n\307\310\311\312\313&\210\204\314\304!\210\315\314\305!\210\316\314\317!\210\320\314\321!\210\314\322!\210\323\314\324!\210\325\314\326!\210\325\314\327!\210\330P\314\331!\210\314\332!\210\325\211\207" [ruby-indent-tabs-mode indent-tabs-mode ruby-smie-grammar ruby-use-smie indent-line-function comment-start smie-setup ruby-smie-rules :forward-token ruby-smie--forward-token :backward-token ruby-smie--backward-token make-local-variable ruby-indent-line "# " comment-end "" comment-column comment-start-skip "#+ *" parse-sexp-ignore-comments t parse-sexp-lookup-properties paragraph-start "$\\|" paragraph-separate paragraph-ignore-fill-prefix ruby-comment-column page-delimiter] 7 (#$ . 22909)])
#@139 Insert a magic coding comment for ENCODING.
The style of the comment is controlled by `ruby-encoding-magic-comment-style'.

(fn ENCODING)
(defalias 'ruby--insert-coding-comment #[257 "\302\267\202\303\202\304\202	\202\305\306
\"\307\261\207" [ruby-encoding-magic-comment-style ruby-custom-encoding-magic-comment-template #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (ruby 6 emacs 10 custom 14)) "# coding: %s" "# -*- coding: %s -*-" nil format "\n"] 5 (#$ . 23739)])
(defalias 'ruby--detect-encoding #[0 "\305=\203\306\207	\206
\n\211\203\307
\310\"\206\311
\312\"\262
\211\2033\2032\211\f\236\211\2030\211A\207
\207\207\313\207" [ruby-insert-encoding-magic-comment save-buffer-coding-system buffer-file-coding-system ruby-use-encoding-map ruby-encoding-map always-utf8 utf-8 coding-system-get mime-charset coding-system-change-eol-conversion nil ascii-8bit] 4])
(defalias 'ruby--encoding-comment-required-p #[0 "\301=\206\302\303\304\305#\207" [ruby-insert-encoding-magic-comment always-utf8 re-search-forward "[^-]" nil t] 4])
#@70 Insert a magic comment header with the proper encoding if necessary.
(defalias 'ruby-mode-set-encoding #[0 "\212\214~\210eb\210\301 \205Ueb\210\302 \211\205S\303\304!\203\305\306!\210\303\307!\203>\310\306!
\230\204L\306\224b\210`\306\225|\210\311
!c\210\202L\303\312!\204L\203L\313
!\210\314 \205S\315 \262
*\207" [ruby-insert-encoding-magic-comment ruby--encoding-comment-required-p ruby--detect-encoding looking-at "^#!" beginning-of-line 2 "\\s *#.*\\(en\\)?coding\\s *:\\s *\\([-a-z0-9_]*\\)" match-string symbol-name "\\s *#.*coding\\s *[:=]" ruby--insert-coding-comment buffer-modified-p basic-save-buffer-1] 3 (#$ . 24842)])
(defvar ruby--electric-indent-chars '(46 41 125 93))
#@13 

(fn CHAR)
(defalias 'ruby--electric-indent-p #[257 "\211>\203\302`S!\207\303f>\203\302`S!\207\211\304Y\203#\211\305X\204)\211\306>\205M`\212\307\303x\210\302 \205J\310\311\312	B!!\205J\313\225
=\206J\313\225
S=)\262
\207" [ruby--electric-indent-chars ruby-block-mid-keywords ruby--at-indentation-p nil 97 122 (95 63 33 58) "[:alpha:]:_?!" looking-at regexp-opt "end" 0] 6 (#$ . 25545)])
#@47 Return the indentation level of current line.
(defalias 'ruby-current-indentation #[0 "\212\300 \210\301 \210i)\207" [beginning-of-line back-to-indentation] 1 (#$ . 25952)])
(make-obsolete 'ruby-current-indentation 'current-indentation "28.1")
#@75 Correct the indentation of the current Ruby line.

(fn &optional IGNORED)
(defalias 'ruby-indent-line #[256 "\300\301 !\207" [ruby-indent-to ruby-calculate-indent] 3 (#$ . 26202) nil])
#@49 Indent the current line to COLUMN.

(fn COLUMN)
(defalias 'ruby-indent-to #[257 "\211\205Z\300\211\211\301W\203\302\303!\210i\262\304 \210`\262
\305 \210i\262\306\300x\210Y\2032Z\262\2025\301\262n\203EU\203E\307\\!\207\307!\210\211`|\210\304 \210j\210\307\\!\266\203\207" [nil 0 error "Invalid nesting" beginning-of-line back-to-indentation " 	" move-to-column] 7 (#$ . 26393)])
#@225 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 `?'.

(fn &optional POS)
(defalias 'ruby-special-char-p #[256 "\211\206`\262
\211\206\f`SfeW\205
S\206`Sf
\300=\206C
\301=\206C
\302=\203:\211?\206C\211z\303=\206C
\304=\205C\211\300=\207" [63 36 58 32 92] 5 (#$ . 26803)])
#@22 

(fn &optional POS)
(defalias 'ruby-verify-heredoc #[256 "\212\211\203\211b\210\301`S!@\302>?\205,`Sf\303>?\206,\304\305!\210`Sf\306=\206,\307!?)\207" [ruby-singleton-class-re syntax-after (2 3 6 10) (32 9) forward-word-strictly -1 95 looking-at] 3 (#$ . 27245)])
#@192 Check if point is possibly at the beginning of an expression.
OPTION specifies the type of the expression.
Can be one of `heredoc', `modifier', `expr-qstr', `expr-re'.

(fn &optional OPTION)
(defalias 'ruby-expr-beg #[256 "\212\306\307!\210\310\307x`n\203\266\311\202\257\312u\210\313\314!\2034`\206!`Sfz\315=\204.\316 \2034\266\307\202\257\313!\206\255\317=\203N
\320W\205\255\321
!\266\202\202\257\313\322!\206\255\313\323!\203p\324=?\206\255n\206\255\212\312u\210\313\325!)\206\255\313	!\205\255\n\307x\205\255\313\326\327\f
#\330\"!\203\226\320\225b\210\313\331!?\266\202\202\257\332\267\202\254\313\333!\266\202\202\257\313\334!\266\202\202\257\307\266\202)\207" [ruby-operator-re ruby-symbol-re ruby-symbol-chars ruby-block-beg-keywords ruby-block-op-keywords ruby-block-mid-keywords store-match-data nil " 	" t -1 looking-at "\\?" 119 ruby-special-char-p heredoc 0 ruby-verify-heredoc "[\\[({,;]" "[!?]" modifier "\\Sw$" regexp-opt append words "\\s_" #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (expr-qstr 156 expr-re 164)) "[a-zA-Z][a-zA-Z0-9_]* +%[^ 	]" "[a-zA-Z][a-zA-Z0-9_]* +/[^ 	]"] 9 (#$ . 27523)])
#@604 Move forward across one balanced pair of string delimiters.
Skips escaped delimiters.  If EXPAND is non-nil, also ignores
delimiters in interpolated strings.

TERM should be a string containing either a single, self-matching
delimiter (e.g. "/"), or a pair of matching delimiters with the
close delimiter first (e.g. "][").

When non-nil, search is bounded by position END.

Throws an error if a balanced match is not found, unless NO-ERROR
is non-nil, in which case nil will be returned.

This command assumes the character after point is an opening
delimiter.

(fn TERM &optional END NO-ERROR EXPAND)
(defalias 'ruby-forward-string #[1025 "\300\301!\302\303\230\203\304\202\305\306Q\205\307\310R\311
#\203W\312\224\2036\313\314\315$\202N`\206;`Sf=\203GS\202IT\211\262\316V\203W\317u\210\202\316U\206f\203c\315\207\320\321!\207" [1 string-to-char "[^\\]\\(\\\\\\\\\\)*\\(" "^" "\\^" "[" "]" "\\|\\(#{\\)" "\\)" re-search-forward 3 ruby-forward-string "}{" nil 0 -1 error "Unterminated string"] 12 (#$ . 28716)])
#@25 TODO: document.

(fn C)
(defalias 'ruby-deep-indent-paren-p #[257 "<\203\303
\"\211\203\211A\206	\207
>\205	\207\211=\203$	\207\211\304=\205+\n\207" [ruby-deep-indent-paren ruby-deep-indent-paren-style ruby-deep-arglist assoc 40] 4 (#$ . 29772)])
#@95 TODO: document throughout function body.

(fn &optional END IN-STRING NEST DEPTH PCOL INDENT)
(defalias 'ruby-parse-partial #[1536 "\204\306\262\211\204\306\262
\307\310#\2032`\311\211\211\306\224b\210`Sf\312>\2034\313\314!\2034b\266\2022\313\315!\203Vm\204K\316``T{\317\211$\2040`\262		b\266\2022\313\320!\203tm\204i\307\321\317#\2040`\262		b\266\2022\313\322!\203\201b\266\2022\313\323!\203\256m\204\246\324\325!\203\246\316\323\317\211$\204\251`\262		b\266\2022b\210\266\2022\313\326!\203^
m\204V
\324\327!\203V
\313\330!\204V
\313\331!\203V
\332\224b\210`Sf\333>?\262
\334\332!\262\335\230\203\347\336\262\202
\337\230\203\363\340\262\202
\341\230\203\377\342\262\202
\343\230\203
\344\262\202
\211\203
\345\230\203
\345P\262
\203(
\316\317$\202H
\211\2036
\316\317\211$\202H
\307\345\230\203A
\346\202D
\347P\317#\204Y
`\262		b\266\2022b\210\266\2022\313\350!\203~
\324 \203w
\313\351!\203w
\306\225b\266\2022b\266\2022\313\352!\203\216
b\210\332u\266\2022\313\353!\203\236
\332y\210`b\266\2022\313\354!\203\271
`fBB\262T\262b\266\2022\313\355!\203\320
S\262A\262b\266\2022\313	!\203n\204\355
\356u\210`f\262\357=\204\360=\204b\210`f\262\357=\204\361=\204\362=\204A\262S\262b\266\2022\313\363!\203@n\204+\356u\210`f\357=\2048\311BB\262T\262\306\225b\266\2022\313\364\n\365Q!\203\276\366 \367\370\"\216\313\371!?\206`\212\372 \210\313!)?)\262
\203\267n\204}\356u\210`f\262\357=\204\267\360=\204\267b\203\267`f\361=\204\267\373\311w\203\267\306\224b\203\267\313\f!\203\241\324\374!\203\267b\203\267\311BB\211\262	\203\267T\262b\266\2022\313\375!\203\325\332\224b\210\316\334\332!\317#\266\2022\313\376!\203\343\306\225b\266\2022\313\377!\203\361\306\225b\266\2022\313\201A!\204\313\201B!\204\313\201C!\204\313\201D!\203\306\225b\266\2022\313\201E!\203?\307\201F\317#\2033\332y\266\2022\306\225\262		b\266\2022\313\201G!\203\346\324\201H!\203\337\313\201I!\203\337\201J\334\201K!\206g\334\201L!!\262\332\224\203v\201MP\262\306\225b\201N \n\n\n\n\n\257
`V\203\236\201O\201P#\211\262\204\211\211@\262\f\211A@\262\201L
8\262\n\201Q
8\262	\201K
8\262\307\201R\201SQ\310#\203\324\332y\266\2022\262\f\fb\266\2022b\266\2022\313\201T!\203\365b\266\2022\313
!\203$\201U\201@!\203$\307\201V @\317#\203\332y\266\2022\306\225\262	@b\266\2022\201W\201X`{\"\210\266F\207" [ruby-delimiter ruby-block-end-re ruby-block-beg-re ruby-non-block-do-re ruby-modifier-re ruby-here-doc-beg-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-\\)*\\\\?." "\\$" "#" "[\\[{(]" "[])}]" -1 95 46 33 63 "def\\s +[^(\n;]*" "\\_<\\(" "\\)\\_>" match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] "do\\_>" back-to-indentation " 	" modifier ":\\(['\"]\\)" ":\\([-,.+*/%&|^~<>]=?\\|===?\\|<=>\\|![~=]?\\)" ":\\([a-zA-Z_][a-zA-Z_0-9]*[!?=]?\\)?" ruby-indent-point "\\.\\.\\.?" "\\.[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 "Bad string %s"] 17 (#$ . 30039)])
#@33 TODO: document.

(fn START END)
(defalias 'ruby-parse-region #[514 "\300\212\203\fb\210\202\301 \210\214`}\210
`V\203%\302\303#\211\262\204*\211@
A@@\3048\3058@@F\207" [nil ruby-beginning-of-indent apply ruby-parse-partial 2 3] 8 (#$ . 33698)])
#@84 Return the indentation level in spaces NEST levels deeper than POS.

(fn POS NEST)
(defalias 'ruby-indent-size #[514 "

\206\301_\\\207" [ruby-indent-level 1] 5 (#$ . 33963)])
#@86 Return the proper indentation level of the current line.

(fn &optional PARSE-START)
(defalias 'ruby-calculate-indent #[256 "\212\306 \210`\307\211\211\211\211\310\311!\210\307f\205\312\307f!\313\203'b\210\202-\314 \210`\262	\315 \210i\262
\316		\"\262@\203F\307\262
\202~
A@@\203\f
A@A\211\262b\210\317A@@!\211\203\313\211\320=\203|A@@=\203|\321\311!\210iS\262\202\353\316`\n\"\322
8\205\230\322
8\313V\205\230\211A@Ab\206\230\320\262
\203\255\323\324!\210\325i\322	8\"\262\202\353i\262\211\326=\204\353\203\301
S\262\202\353\325S\327\"\262\202\353\3308\203\333\3308b\210\202\342	b\210\315 \210\325i\322	8\"\262A@@=\203
\317\312!!\203
\331\332!!\203
i\262\210\202~
\3228\203e
\3228\313V\203e
A@A\204'
\333\334!\210A@Ab\210\323\324!\210`\262\335\336!\203]
\3308\203J
\3308b\210\202Q
b\210\315 \210\325i\3228\"\262
\202~
i	\\\262
\202~
\3228\203~
\3228\313W\203~
\325i\3228\"\262
\211\2032b\210\307\210`\262\306 \210\317!\204\256
\337\n\320#\203\256
\313\225f\340=\2042\211	Z\262
\2022\212\306 \210o)\2042\317\320!\204\304
A@@\2042\307\211\211\204\350
\341\307x\210`\262\306 \210\337\342\320#\203\342
\306 \210\202\306
\320\262
\202\306
\266\307\210\343\307x\210\307`\306 \210\337\344\320#\203#`S\211\262\203#\345!\204\316\"\211\262	\203#@\203#\307\262\202\366

\206(\211b\210\343\307x\210
\203<@\203<\211\202AA@A\262\316`\"\262\266o\204S\324u\210\335!\203}\f\307x\203}\335\346
\347Q!\203}`\3308=\204}\212\313\225b\210\335\350!)\203\371\335/!\2032\345 \2042\212\324u\210\335/!?\206\233`Sf\351=?)\2032`f\316\206\250\n`\"@?\205\364`f\352=\203\351\212l\204\276\324u\210\331\353\307\320#\203\344\341\307x\210l?\205\345\324u\210\335\354!?\205\345\323\324!\210\335\336!?\202\345\320)\205\364\211\355=?\205\364\320\211\262\262
\2032\204\"\335\346
\347Q!\204\"\317\320!\326=\203\"o\204\"\206b\210\310\311!\210i\2020A@@\203-\211\2020\211	\\\262
b\210\306 \210\310\311!\210\335\356!\203I\211	\\\202J\211)\266\210)\207" [case-fold-search ruby-indent-level ruby-negative ruby-symbol-re ruby-symbol-chars ruby-block-hanging-re 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 forward-word-strictly -1 ruby-indent-size space 1 3 search-backward char-to-string error "Invalid nesting" looking-at "do\\>[^_]" re-search-forward 95 " 	\n" "^\\s *#" " 	" "#" ruby-special-char-p "\\<\\(" "\\)\\>" "[a-z_]" 58 124 "|" "{" 44 "\\.[^.]\\|&\\." ruby-operator-re] 15 (#$ . 34148)])
#@149 Move backward to the beginning of the current defun.
With ARG, move backward multiple defuns.  Negative ARG means
move forward.

(fn &optional ARG)
(defalias 'ruby-beginning-of-defun #[256 "\302\303\304	\305Q\302\306\206\307$\205\310 )\207" [case-fold-search ruby-defun-beg-re nil re-search-backward "^\\s *" "\\_>" t 1 beginning-of-line] 6 (#$ . 36816) "p"])
#@129 Move point to the end of the current defun.
The defun begins at or after the point.  This function is called
by `end-of-defun'.
(defalias 'ruby-end-of-defun #[0 "\302 \210\303\304\305	P\306 \"\205\307y)\207" [case-fold-search ruby-block-end-re ruby-forward-sexp nil looking-back "^\\s *" line-beginning-position 1] 3 (#$ . 37189) "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 #[0 "\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 (#$ . 37535)])
#@140 Move to the beginning (N < 0) or the end (N > 0) of the
current block, a sibling block, or an outer block.  Do that (abs N) times.

(fn N)
(defalias 'ruby-move-to-block #[257 "\304 \210\211\305V\203
\306\202\307
\305W\310\311`\312 \"8\206\305\313\211\211\314	!\203-\\\262_\305W\2039\305\262\315!\305\211W\203
\313\211\262\212\304 \210\316\203V\n\202Z\317\320Q\312 \321#\205f\322\323 8?)\262\204
\203vo\202wm\204
y\210\314\324!\204i\314\325!\204i\204\234\314\326!\203\234\316\327!\210\202i\203\256\314\327!\203\256\330\326!\210\202i\331\332!\203\314\322\323 8b\210\204i\333 \210n\203i\307u\210\202i\311`\312 \"\211@\204\336\310
8\\\262\210_\305V\203\357\321\262\202i\203
\305U\203
\321\262\202i_\305W\203i\321\262\202i\210\211T\262
\202>\266\304 )\207" [case-fold-search ruby-block-mid-re ruby-block-end-re ruby-block-beg-re back-to-indentation 0 1 -1 2 ruby-parse-region line-end-position nil looking-at abs re-search-forward "\\_<\\(" "\\)\\_>" t 8 syntax-ppss "^\\s *$" "^\\s *#" "^=begin\\>" "^=end\\>" re-search-backward ruby-in-ppss-context-p string forward-sexp] 14 (#$ . 37861)])
#@109 Move backward to the beginning of the current block.
With ARG, move up multiple blocks.

(fn &optional ARG)
(defalias 'ruby-beginning-of-block #[256 "\300
\206\301[!\207" [ruby-move-to-block 1] 3 (#$ . 39038) "p"])
#@106 Move forward to the end of the current block.
With ARG, move out of multiple blocks.

(fn &optional ARG)
(defalias 'ruby-end-of-block #[256 "\300
\206\301!\207" [ruby-move-to-block 1] 3 (#$ . 39262) "p"])
#@136 Move forward across one balanced expression (sexp).
With ARG, do it many times.  Negative ARG means move backward.

(fn &optional ARG)
(defalias 'ruby-forward-sexp #[256 "\203\302
!\207\211\247\203\211\303W\203\304
[!\207\211\206\305\3061\343\211\303V\205\340\307\310!\210\311\312!\2035\303\225b\210\311\313!\203B\303\225b\210\202\331\314\315w\210\311\316!\203U\317`\305\"b\210\202\331\311\320	\321Q!\203\200`\206c`Sf\322=\204\200`\206o`Sf\323=\204\200\324 \210\325\305!\210\202\331\311\326!\203\260\325\305!\210\311\327!\204\206\311\330!\203\234\331u\210\202\206\332\315w\303V\204\206\311\333!\203\331\305u\210\202\331\315\211\211\206\276\334 \206\276\311\335!\262
\336\337\315#\211\262A@\203\327\340\262
\341\315w\210\202\262\266\211S\262
\202!0\210\207\210\325\305!\210\207" [ruby-use-smie ruby-block-beg-re forward-sexp 0 ruby-backward-sexp 1 (error) skip-syntax-forward " " looking-at ",\\s *" "\\?\\(\\\\[CM]-\\)*\\\\?\\S " "-,.:;|&^~=!?+*" nil "\\s(" scan-sexps "\\<\\(" "\\)\\>" 46 58 ruby-end-of-block forward-word-strictly "\\(\\$\\|@@?\\)?\\sw" "_" "::" 2 "." "\\?\\|!\\(=[~=>]\\|[^~=]\\)" ruby-expr-beg "%\\sw?\\Sw\\|[\"'`/]" apply ruby-parse-partial t "<"] 8 (#$ . 39476) "p"])
(make-obsolete 'ruby-forward-sexp 'forward-sexp "28.1")
#@136 Move backward across one balanced expression (sexp).
With ARG, do it many times.  Negative ARG means move forward.

(fn &optional ARG)
(defalias 'ruby-backward-sexp #[256 "\203\302
!\207\211\247\203\211\303W\203\304
[!\207\211\206\305\3061\360\211\303V\205\355\307\310x\210\311u\210\312\313!\203d\314`T\311\"b\210`Sf\211\315\267\210\202\346\311u\266\202\346`S\206R`Sf\316=\203`\317u\266\202\346\210\202\346\312\320!\203\211\321\303\225\206q`Sf!\322
!\203\205\323\324\310x\305\"\305=\204t\210\202\346\312\325!\203\232\326 \203\346\311u\210\202\346\312\327!\204\346\305u\210\330\311!\210`Sf\211\331\267\202\327\332\202\330\311u\210\332\202\330\311u\210`Sf\310f=\205\330\311u\202\330\311u\210`Sf\333=\202\330\310\262
\204\243\312	!\203\346\334 \210\211S\262
\202!0\210\207\210\207\210\207" [ruby-use-smie ruby-block-end-re backward-sexp 0 ruby-forward-sexp 1 (error) "- 	\n,.:;|&^~=!?+*" nil -1 looking-at "\\s)" scan-sexps #s(hash-table size 7 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (37 69 120 76 114 76 87 76 119 76 81 76 113 76)) 37 -2 "\\s\"\\|\\\\\\S_" char-to-string search-backward logand "\\\\" "\\s.\\|\\s\\" ruby-special-char-p "\\s(" forward-word-strictly #s(hash-table size 5 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (95 176 46 180 64 187 36 187 58 204)) t : ruby-beginning-of-block] 6 (#$ . 40767) "p"])
(make-obsolete 'ruby-backward-sexp 'backward-sexp "28.1")
#@90 Indent each line in the balanced expression following the point.

(fn &optional IGNORED)
(defalias 'ruby-indent-exp #[256 "\300 \301\211\211\302\303\302\"\210\304\305\"\216\306 \210`\262\307 \262m?\205N\310!\262
V\2032\302\211\262\202@
U\205N\211\205N\301\262
\302\205N\311!\210\306\312!\210\202)\207" [point-marker nil t set-marker-insertion-type make-closure #[0 "\300b\210\300\301\211\223\207" [V0 nil] 3] beginning-of-line current-indentation ruby-calculate-indent ruby-indent-to 2] 9 (#$ . 42231) "*P"])
#@190 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 #[0 "\212\302\303\211`\304\211\305\"
\306!\307\303\305#\203;\310\224b\210\311\310!\312\230\204*\311\313!C\262\2025\314!\2035\311\313!\262i\262\315 \210\302V\203e\307
\303\305#\203e\310\224b\210iW\203;\311\313!B\262i\262\315 \210\202;\203\341\316\317\"\211A\203\301\211@\320\230\204\265\237\211\203\237\211@@\230\203\220\211A\237\262\303\262
\211A\211\262\204|\237\210\202|\210\203\260\321!\322!\241\210\202\265\322
!\262\323\321!@P\262\210\202\341\324	\305#\205\321\302\224b\210\314!\211\203\331\323\202\332\325P\262\266:\203\356\326\327\330#\262\203
\203\377P\266\207\202
\266\207\202
\266\207)\207" [ruby-defun-beg-re ruby-singleton-class-re 0 nil #[513 "\302\303\304\203
	\202\305\306\260\207" [ruby-symbol-re ruby-operator-re "^[ 	]*" "[ 	]+\\(\\([A-Za-z_]" "*[?!]?\\|" "\\." "\\|::\\)+\\)"] 9 "\n\n(fn RE &optional METHOD-NAME\\=\\?)"] t "\\(class\\|module\\)" re-search-backward 1 match-string "def" 2 ruby-block-contains-point beginning-of-line split-string "\\.\\|::" "self" last butlast "." re-search-forward "#" mapconcat identity "::"] 12 (#$ . 42766)])
#@11 

(fn PT)
(defalias 'ruby-block-contains-point #[257 "\212\300 \301\302\"\216\303 \210`V)\262
)\207" [match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] ruby-forward-sexp] 5 (#$ . 44145)])
#@17 

(fn ORIG END)
(defalias 'ruby-brace-to-do-end #[514 "\300\211b\210`Sf\301=\205\202\302\303!\210\212\304\300x\211\305W\203 \302
[!\210\210n)\204)\306c\210\307c\210\310 \262
m\204?\300fz\311=\203?\312c\210b\210\302\313!\210`Sfz\311=\203R\312c\210\314c\210\310 \262\315\316!\203p\313\224\204g\312c\210\305\225Tb\210\317\320!\210\315\321!\204y\306c\210\322\"\210
b\210\323\207" [nil 125 delete-char -1 " 	" 0 "\n" "end" point-marker 119 " " 1 "do" looking-at "\\(\\s \\)*|" search-forward "|" "\\s *$" indent-region t] 7 (#$ . 44373)])
#@17 

(fn ORIG END)
(defalias 'ruby-do-end-to-brace #[514 "\302\211\211\211\303Zb\210\304!\205\305\303!\210\306 \262\307c\210b\210\305\310!\210\311c\210\306 \262\304\312!\203A\305\313\225\313\224ZS!\210\302u\210\314\315\316 \317#\210\212\320\302w\210`\262b\210\320\302x\210`\262
)\211W\204p\321!\321!U\203{i
Z\\\310\\	W\203{\322\323!\210b\210\322\323!\210b\210\317\207" [ruby-block-end-re fill-column nil 3 looking-at delete-char point-marker "}" 2 "{ " "\\s +|" 0 re-search-forward "|" line-end-position t " 	\n
" line-number-at-pos just-one-space -1] 10 (#$ . 44927)])
#@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 #[0 "`\300\211\211\210\301\302!\205=\303\224\206\304\224b\210`\262\305 \306\307\"\216\310 )\266`\262
\211V\205=\303\224\2039\311\"\202=\312\"?\205Cb\207" [nil re-search-backward "\\(?:[^#]\\)\\({\\)\\|\\(\\_<do\\_>\\)" 1 2 match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] ruby-forward-sexp ruby-brace-to-do-end ruby-do-end-to-brace] 7 (#$ . 45520) nil])
#@36 Return region for string at point.
(defalias 'ruby--string-region #[0 "\300 \301
8\302>\205\212\303
8b\210\304 \210\303
8`)D\207" [syntax-ppss 3 (39 34) 8 forward-sexp] 3 (#$ . 46146)])
#@40 Check if cursor is at a string or not.
(defalias 'ruby-string-at-point-p #[0 "\300 \207" [ruby--string-region] 1 (#$ . 46340)])
#@69 Get the inverse string quoting for STRING-QUOTE.

(fn STRING-QUOTE)
(defalias 'ruby--inverse-string-quote #[257 "\211\300\232\203\301\207\300\207" ["\"" "'"] 3 (#$ . 46474)])
#@58 Toggle string literal quoting between single and double.
(defalias 'ruby-toggle-string-quotes #[0 "\300 \205L\301 \211@
A@\302\303\211T\"!\303TS\"
\304\232\203,\305\306\307\310\311\312##\2026\305\313\304\310\314\315##\262
`|\210\316\317$c\210\211b\262
\266\205\207" [ruby-string-at-point-p ruby--string-region ruby--inverse-string-quote buffer-substring-no-properties "'" string-replace "\\\"" "\"" replace-regexp-in-string "\\(\\`\\|[^\\]\\)'" "\\1\\\\'" "\\'" "\\(\\`\\|[^\\]\\)\"" "\\1\\\\\"" format "%s%s%s"] 12 (#$ . 46657) nil])
#@350 Visit a library file denoted by FEATURE-NAME.
FEATURE-NAME is a relative file name, file extension is optional.
This commands delegates to `gem which', which searches both
installed gems and the standard library.  When called
interactively, defaults to the feature name in the `require'
or `gem' statement around point.

(fn &optional FEATURE-NAME)
(defalias 'ruby-find-library-file #[256 "\211\204\212\301y\210\302\303!\205\304\305!)\306\307\"\266\202\310\311\312!P!\301\313O\314
\315\316\317#)\266\203\2037\320\321\"\207\322
!\207" [inhibit-changing-match-data 0 looking-at "\\(?:require\\| *gem\\) [\"']\\(.*?\\)[\"']" match-string 1 read-string "Feature name: " shell-command-to-string "gem which " shell-quote-argument -1 "\\`ERROR" nil t string-match user-error "%s" find-file] 9 (#$ . 47215) nil])
#@51 Regexp to match the beginning of percent literal.
(defconst ruby-percent-literal-beg-re "\\(%\\)[qQrswWxIi]?\\([[:punct:]]\\)" (#$ . 48038))
#@118 Methods that can take regexp as the first argument.
It will be properly highlighted even when the call omits parens.
(defconst ruby-syntax-methods-before-regexp '("gsub" "gsub!" "sub" "sub!" "scan" "split" "split!" "index" "match" "assert_match" "Given" "Then" "When") (#$ . 48186))
#@68 Regexp to match text that can be followed by a regular expression.
(defvar ruby-syntax-before-regexp-re (byte-code "\301\302!\303Q\207" [ruby-syntax-methods-before-regexp "\\(^\\|[[{|=(,~;<>!]\\|[?:] \\|\\(?:^\\|\\s \\)\\(?:&&\\|and\\|elsif\\|if\\|not\\|or\\|un\\(?:less\\|til\\)\\|wh\\(?:en\\|ile\\)\\|||\\)\\|\\_<" regexp-opt "\\)\\s *"] 3) (#$ . 48475))
#@86 Syntactic keywords for Ruby mode.  See `syntax-propertize-function'.

(fn START END)
(defalias 'ruby-syntax-propertize #[514 "\303
b\210\304\305#\210\306
!\210\307
!\210`\211b\210`W\205\217\310\311\312#\205\217\313\224\203[\313\224\313\225\212\314\315\316\224!8)\203A\313\225b\210\303\202K\317\313\225\316\225\320\321$\210\322\211\203V\317\320$\210\266\202\323\224\203\237\324\325!\211A\326\233\241\210\327
!\266\313\224\313\225\330\315\313\224!8\206\206\316\224\206\202`Sf\331=?\205\217\316\225b\210\321\211\203\232\317\320$\210\266\202\326\224\203\345\324\325!\211A\330\233\241\210\327
!\266\313\224\313\225\330\315 8\206\320\316\224\206\304`Sf\331=\206\320\314\225f\332=?\205\325\321\211\203\340\317\320$\210\266\202\333\224\203+
\324\325!\211A\334\233\241\210\327
!\266\316\224\316\225\212\330\315\316\224!8\206
\303\335\336!\316U)\206
h\337>)?\205
\321\211\203&
\317\320$\210\266\202\340\224\203<
\317\340\224\340\225\320\321$\210\202\341\224\203e
\324\325!\211A\342\233\241\210\327
!\266\313\224\313\225\343\211\203`
\317\320$\210\266\202\330\224\203\276
\324\325!\211A\344\233\241\210\327
!\266\313\224\313\225\212\345u\210\346\347\303x!)\205\256
\212\315\313\224!)\330
8\204\243
\212\345u\210\350\n\351 \")\204\253
\314
8\352=\205\254
\353\262
\211\203\271
\317\320$\210\266\202\354\224\203\355
\324\325!\211A\355\233\241\210\327
!\266\212\316\224b\210\346\347\303x!)\203\346
\356 \210\202\313\224b\210\202\357\224\203\376
\317\357\224\357\225\320\360$\210\202\342\224\203\317\342\224\342\225\320\360$\210\202\361\224\203V\324\325!\211A\362\233\241\210\327
!\266\341\224\341\225\330\212\315\316\224!)8?\205F\363\316\224!\205F\317\341\224\341\225\320\364$\210\306!\211\203Q\317\320$\210\266\202\365\224\203\324\325!\211A\366\233\241\210\327
!\266\313\224\313\225\330\212\315\313\224!)8?\205\367!\210\370\211\203\212\317\320$\210\266\202\262
)\207" [case-fold-search parse-sexp-lookup-properties ruby-syntax-before-regexp-re nil remove-text-properties (ruby-expansion-match-data nil) ruby-syntax-propertize-heredoc ruby-syntax-enclosing-percent-literal re-search-forward "\\([?$]\\)[#\"'`:?]\\|:\\([-+~]@?\\|[/%&|^`]\\|\\*\\*?\\|<\\(<\\|=>?\\)?\\|>[>=]?\\|===?\\|=~\\|![~=]?\\|\\[\\]=?\\)\\|:[[:alpha:]][[:alnum:]_]*\\(=\\)\\|\\([!?]\\)\\|^[ 	]*def +\\(`\\)\\|\\(:\\)\\(?:[({]\\|\\[[^]]\\)\\|\\(/\\)\\|\\(#\\({[^}\n\\]*\\(\\\\.[^}\n\\]*\\)*}\\|\\(?:\\$\\|@\\|@@\\)\\(\\w\\|_\\)+\\|\\$[^a-zA-Z \n]\\)\\)\\|^=en\\(d\\)\\_>\\|^\\(=\\)begin\\_>\\|\\(<\\)<\\([~-]\\)?\\(\\([a-zA-Z0-9_]+\\)\\|[\"]\\([^\"]+\\)[\"]\\|[']\\([^']+\\)[']\\).*\\(\n\\)\\|\\(?:^\\|[[ 	\n<+(,=*]\\)\\(%\\)[qQrswWxIi]?\\([[:punct:]]\\)" t 1 3 syntax-ppss 0 put-text-property syntax-table (3) (6) 2 match-data ints 4 set-match-data 8 58 62 5 12 skip-syntax-backward "w_" (64 36) 6 7 14 (1) 16 -1 cl-evenp "\\\\" looking-back point-at-bol 47 (7 . 47) 9 20 ruby-syntax-propertize-expansion 13 (14) 21 30 ruby-verify-heredoc (7) 22 44 ruby-syntax-propertize-percent-literal (15)] 11 (#$ . 48839)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias ruby-syntax-propertize-function ruby-syntax-propertize nil make-obsolete "25.1"] 4)
#@14 

(fn LIMIT)
(defalias 'ruby-syntax-propertize-heredoc #[257 "\301 \302\3038\304=\205`\212\3058b\210\306 \210\307\310 \311#\203/\312\313\224!\203\314 \315P
B\262
\202)\212\211A\203?\3058b\210\211\237\262
\211\205_\307
\211A\262\242\316#\205_\211\204?\317`S`\320\321$\210\202?)\207" [ruby-here-doc-beg-re syntax-ppss nil 3 10 8 beginning-of-line re-search-forward line-end-position t ruby-verify-heredoc 0 ruby-here-doc-end-match "\n" move put-text-property syntax-table (7)] 8 (#$ . 52077)])
#@14 

(fn LIMIT)
(defalias 'ruby-syntax-enclosing-percent-literal #[257 "\301 `\3028\303=\205\"\3048b\210\305!\203\306!\210`
W\205\"\211b\207" [ruby-percent-literal-beg-re syntax-ppss 3 t 8 looking-at ruby-syntax-propertize-percent-literal] 5 (#$ . 52592)])
#@14 

(fn LIMIT)
(defalias 'ruby-syntax-propertize-percent-literal #[257 "\301\224b\210\302f\303
!\304 HA\206\305\306\"A\302\212\3071l\211\203W\304 p\310\311#\216\312\313\304\302\"!\210\314\315\303!P\"\210\314\316P\"\210\314\317\320\"\210\214`}\210\321 \210*\266\202a\322\323\324!P\302#\210\325`S`\304\326$0\202n\210\302*\207" [parse-sexp-lookup-properties 2 nil char-to-string syntax-table assoc ((60 . 62)) (scan-error search-failed) make-closure #[0 "r\301q\210\302\300!)\207" [V0 V1 set-syntax-table] 2] set-syntax-table make-char-table modify-syntax-entry "(" ")" 92 "\\" forward-list re-search-forward "[^\\]\\(?:\\\\\\\\\\)*" regexp-quote put-text-property (15)] 11 (#$ . 52860)])
(defalias 'ruby-syntax-propertize-expansion #[0 "\300\224\300\225
\205
\212\301!)\302
!\2053\303\211T\304\305 $\210b\210\306\307\310#\2053\303\300\224\300\225\311\312$\210\202\207" [0 syntax-ppss ruby-syntax-expansion-allowed-p put-text-property ruby-expansion-match-data match-data re-search-forward "[\"`]" move syntax-table (1)] 8])
#@70 Return non-nil if expression expansion is allowed.

(fn PARSE-STATE)
(defalias 'ruby-syntax-expansion-allowed-p #[257 "\300
8\211\301>\206\"\211\302=\205\"\303 \304\305\"\216\212\3068b\210\307\310!*\262
\207" [3 (34 96 10 47) t match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] 8 looking-at "%\\(?:[QWrxI]\\|\\W\\)"] 6 (#$ . 53917)])
#@18 

(fn START END)
(defalias 'ruby-syntax-propertize-expansions #[514 "\212
b\210\301\302#\205\303 \210\202)\207" [ruby-expression-expansion-re re-search-forward move ruby-syntax-propertize-expansion] 6 (#$ . 54293)])
#@31 

(fn CONTEXT &optional PPSS)
(defalias 'ruby-in-ppss-context-p #[513 "\211\206\300`!\301\267\202:\302
8\204A\303
8\202>\302
8\202>\302
8\304=\202>\305\306!\205B\305\307!?\202>\303
8\202>\310\311\"\205B\312\207" [syntax-ppss #s(hash-table size 5 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (anything 13 string 25 heredoc 31 non-heredoc 39 comment 52)) 3 4 10 ruby-in-ppss-context-p anything heredoc error "Internal error on `ruby-in-ppss-context-p': context name `%s' is unknown" t] 6 (#$ . 54521)])
(defconst ruby-font-lock-keyword-beg-re "\\(?:^\\|[^.@$:]\\|\\.\\.\\)")
#@51 Additional expressions to highlight in Ruby mode.
(defconst ruby-font-lock-keywords (byte-code "\302\303P\304B\305P\306B\307P\310B	\311B\312\313P\314B\315\316\317\320B\321\322\323\324P\325B\326BBBBBBBBBBBBBB\207" [ruby-font-lock-keyword-beg-re ruby-here-doc-beg-re ("^\\s *def\\s +\\(?:[^( 	\n.]*\\.\\)?\\([^( 	\n]+\\)" 1 font-lock-function-name-face) "\\_<\\(a\\(?:lias\\|nd\\)\\|b\\(?:egin\\|reak\\)\\|c\\(?:ase\\|lass\\)\\|d\\(?:ef\\(?:ined\\?\\)?\\|o\\)\\|e\\(?:ls\\(?:e\\|if\\)\\|n\\(?:d\\|sure\\)\\)\\|f\\(?:ail\\|or\\)\\|i[fn]\\|module\\|n\\(?:\\(?:ex\\|o\\)t\\)\\|or\\|re\\(?:do\\|scue\\|t\\(?:ry\\|urn\\)\\)\\|s\\(?:elf\\|uper\\)\\|then\\|un\\(?:def\\|less\\|til\\)\\|wh\\(?:en\\|ile\\)\\|yield\\)\\_>" ((1 font-lock-keyword-face)) "\\_<\\(a\\(?:lias_method\\|t\\(?:_exit\\|tr\\(?:_\\(?:\\(?:accesso\\|\\(?:read\\|writ\\)e\\)r\\)\\)?\\)\\|utoload\\??\\)\\|ca\\(?:llcc\\|tch\\)\\|define_method\\|e\\(?:val\\|x\\(?:ec\\|tend\\)\\)\\|format\\|include\\|l\\(?:ambda\\|o\\(?:ad\\|op\\)\\)\\|module_function\\|open\\|p\\(?:r\\(?:epend\\|i\\(?:ntf\\|vate_c\\(?:lass_method\\|onstant\\)\\)\\|oc\\)\\|u\\(?:blic_c\\(?:lass_method\\|onstant\\)\\|tc\\)\\)?\\|re\\(?:\\(?:fin\\|quir\\(?:e_relativ\\)?\\)e\\)\\|s\\(?:p\\(?:awn\\|rintf\\)\\|ys\\(?:call\\|tem\\)\\)\\|t\\(?:hrow\\|ra\\(?:ce_var\\|p\\)\\)\\|u\\(?:ntrace_var\\|sing\\)\\|warn\\)\\_>" ((1 (unless (looking-at " *\\(?:[]|,.)}=]\\|$\\)") font-lock-builtin-face))) "\\_<\\(__\\(?:\\(?:callee\\|dir\\|method\\)__\\)\\|abort\\|b\\(?:inding\\|lock_given\\?\\)\\|caller\\|exit!?\\|f\\(?:ail\\|ork\\)\\|global_variables\\|local_variables\\|p\\(?:r\\(?:i\\(?:nt\\|vate\\)\\|otected\\)\\|u\\(?:blic\\|ts\\)\\)\\|r\\(?:a\\(?:ise\\|nd\\)\\|eadlines?\\)\\|s\\(?:leep\\|rand\\)\\)\\_>" ((1 font-lock-builtin-face)) ((0 (when (ruby-verify-heredoc (match-beginning 0)) 'font-lock-string-face))) "\\_<\\(?:BEGIN\\|END\\)\\_>\\|^__END__$" "\\_<\\(nil\\|true\\|false\\)\\_>" (1 font-lock-constant-face) ("\\_<__\\(?:LINE\\|ENCODING\\|FILE\\)__\\_>" (0 font-lock-builtin-face)) ("\\(^\\|[^:]\\)\\(:@\\{0,2\\}\\(?:\\sw\\|\\s_\\)+\\)" (2 font-lock-constant-face)) "\\$\\(?:[:\"!@;,/._><\\$?~=*&`'+0-9]\\|-[0adFiIlpvw]\\|\\(?:ARGV\\|C\\(?:HILD_STATUS\\|LASSPATH\\)\\|DE\\(?:BUG\\|FAULT_\\(?:\\(?:IN\\|OUT\\)PUT\\)\\)\\|E\\(?:NV_JAVA\\|RROR_\\(?:INFO\\|POSITION\\)\\)\\|F\\(?:I\\(?:ELD_SEPARATOR\\|LENAME\\)\\|S\\)\\|I\\(?:GNORECASE\\|NPUT_\\(?:\\(?:LINE_NUMBE\\|RECORD_SEPARATO\\)R\\)\\)\\|JRUBY_\\(?:\\(?:REVI\\|VER\\)SION\\)\\|L\\(?:AST_\\(?:MATCH_INFO\\|PAREN_MATCH\\|READ_LINE\\)\\|OAD\\(?:ED_FEATURES\\|_PATH\\)\\)\\|MATCH\\|NR\\|O\\(?:FS\\|RS\\|UTPUT_\\(?:\\(?:FIEL\\|RECOR\\)D_SEPARATOR\\)\\)\\|P\\(?:ID\\|OSTMATCH\\|R\\(?:EMATCH\\|O\\(?:CESS_ID\\|GRAM_NAME\\)\\)\\)\\|RS\\|SAFE\\|VERBOSE\\|std\\(?:err\\|in\\|out\\)\\)\\_>\\)" (0 font-lock-builtin-face) ("\\(\\$\\|@\\|@@\\)\\(\\w\\|_\\)+" 0 font-lock-variable-name-face) ("\\_<\\([A-Z]+\\(\\w\\|_\\)*\\)" 1 (unless (eq 40 (char-after)) font-lock-type-face)) ("\\(?:^\\s *\\|[[{(,]\\s *\\|\\sw\\s +\\)\\(\\(\\sw\\|_\\)+:\\)[^:]" (1 (progn (forward-char -1) font-lock-constant-face))) "\\_<\\(Array\\|Complex\\|Float\\|Hash\\|Integer\\|Rational\\|String\\)\\_>" ((1 font-lock-builtin-face)) ((ruby-match-expression-expansion 0 font-lock-variable-name-face t) ("\\(?:^\\|[^[:alnum:]_]\\)\\(!+\\)[^=~]" 1 font-lock-negation-char-face) ("\\?\\\\?\\_<.\\_>" 0 font-lock-string-face) ("\\(?:\\s|\\|/\\)\\([imxo]+\\)" 1 (when (save-excursion (let ((state (syntax-ppss (match-beginning 0)))) (and (nth 3 state) (or (eq (char-after) 47) (progn (goto-char (nth 8 state)) (looking-at "%r")))))) font-lock-preprocessor-face)))] 15) (#$ . 55132))
#@14 

(fn LIMIT)
(defalias 'ruby-match-expression-expansion #[257 "\300`\301\302$\302
\205'
`V\205'
b\210\303\301\"\211\262\203$\304
!\210\305\207\306!\207" [next-single-char-property-change ruby-expansion-match-data nil get-text-property set-match-data t ruby-match-expression-expansion] 6 (#$ . 58770)])
(defvar ruby--flymake-proc nil nil)
(make-variable-buffer-local 'ruby--flymake-proc)
#@60 `ruby -wc' backend for Flymake.

(fn REPORT-FN &rest ARGS)
(defalias 'ruby-flymake-simple #[385 "\300\301!\204\n\302\303!\210\304\305\306\307\310\"#\207" [executable-find "ruby" error "Cannot find the ruby executable" ruby-flymake--helper "ruby-flymake" ("ruby" "-w" "-c") make-closure #[514 "eb\210\301\211\211\211\211\211\302\303\301\304#\203O\305\306!\262\307\310\305\311!!\"\262\211A\262\242\262\312\313\"\2035\314\2026\315\262
\316%C\244\262\301\262
\202	\300!\210\301\207" [V0 nil search-forward-regexp "^\\(?:.*.rb\\|-\\):\\([0-9]+\\): \\(.*\\)$" t match-string 2 flymake-diag-region string-to-number 1 string-match "^warning" :warning :error flymake-make-diagnostic] 15 "\n\n(fn PROC SOURCE)"]] 8 (#$ . 59170)])
#@39 

(fn PROCESS-NAME COMMAND PARSER-FN)
(defalias 'ruby-flymake--helper #[771 "\301!\203\n\302!\210p\214~\210\303\304\305\306\307\310\311\312\313\314\"!\315\f\316\317\320#&\f\321ed#\210\322!)\207" [ruby--flymake-proc process-live-p kill-process make-process :name :noquery t :connection-type pipe :buffer generate-new-buffer format " *%s*" :command :sentinel make-closure #[514 "\303!\304=\2053\305\301!\2053\306\307\"\216r\301q\210
\n)=\203,r\310!q\210\300\301\")\2022\311\312\313\314$)\207" [V0 V1 ruby--flymake-proc process-status exit buffer-live-p make-closure #[0 "\301\302\300!!\207" [V0 kill-buffer process-buffer] 3] process-buffer flymake--log-1 :debug ruby-mode "Canceling obsolete check %s"] 7 "\n\n(fn PROC EVENT)"] process-send-region process-send-eof] 20 (#$ . 59925)])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313&	\210\300\314\302\303\315DD\316\306\307\310\317\312\320&	\207" [custom-declare-variable ruby-flymake-use-rubocop-if-available funcall function #[0 "\300\207" [t] 1 #1=""] "Non-nil to use the RuboCop Flymake backend.\nOnly takes effect if RuboCop is installed.\n\nIf there is no Rubocop config file, Rubocop will be passed a flag\n'--lint' to only show syntax errors and important problems." :version "26.1" :type boolean :safe booleanp ruby-rubocop-config #[0 "\300\207" [".rubocop.yml"] 1 #1#] "Configuration file for `ruby-flymake-rubocop'." string stringp] 10)
#@57 RuboCop backend for Flymake.

(fn REPORT-FN &rest ARGS)
(defalias 'ruby-flymake-rubocop #[385 "\303\304!\204\n\305\306!\210\304\307\310\311\312\313\314\257	\315
\205Q\316\n\"\262
\211\204/\317\320\"\262\202H\317\321\322\n\"D\"\262\323
!\203H\317\324\"\262\211\325\326\327\330	\"#)\207" [buffer-file-name default-directory ruby-rubocop-config executable-find "rubocop" error "Cannot find the rubocop executable" "--stdin" "--format" "emacs" "--cache" "false" "--display-cop-names" nil locate-dominating-file append ("--lint") "--config" expand-file-name ruby-flymake-rubocop--use-bundler-p ("bundle" "exec") ruby-flymake--helper "rubocop-flymake" make-closure #[514 "\301!\302=\203\303\304\305\306\307 $\210eb\210\310\211\211\211\211\211\311\312\310\313#\203s\314\315!\262\316\317\314\320!!\317\314\321!!#\262\211A\262\242\262\322\323\"\203J\324\202W\322\325\"\203V\304\202W\326\262
\327\315\310O%C\244\262\310\262
\202\300!\210\310\207" [V0 process-exit-status 127 flymake--log-1 :warning ruby-mode "RuboCop returned status 127: %s" buffer-string nil search-forward-regexp "^\\(?:.*.rb\\|-\\):\\([0-9]+\\):\\([0-9]+\\): \\(.*\\)$" t match-string 3 flymake-diag-region string-to-number 1 2 string-match "^[EF]: " :error "^W: " :note flymake-make-diagnostic] 17 "\n\n(fn PROC SOURCE)"]] 11 (#$ . 61364)])
#@12 

(fn DIR)
(defalias 'ruby-flymake-rubocop--use-bundler-p #[257 "\300\301\"\302
!\205#\303\304\305\"r\211q\210\306\307\"\216\310!\210\311\312\313\305#*\262
\207" [expand-file-name "Gemfile" file-exists-p generate-new-buffer " *temp*" t make-closure #[0 "\301\300!\205	\302\300!\207" [V0 buffer-name kill-buffer] 2] insert-file-contents re-search-forward "^ *gem ['\"]rubocop['\"]" nil] 7 (#$ . 62727)])
#@29 

(fn REPORT-FN &rest ARGS)
(defalias 'ruby-flymake-auto #[385 "\301\203\302\303!\203\304\202\305#\207" [ruby-flymake-use-rubocop-if-available apply executable-find "rubocop" ruby-flymake-rubocop ruby-flymake-simple] 6 (#$ . 63141)])
#@52 Value for `prettify-symbols-alist' in `ruby-mode'.
(defconst ruby--prettify-symbols-alist '(("<=" . 8804) (">=" . 8805) ("->" . 8594) ("=>" . 8658) ("::" . 8759) ("lambda" . 955)) (#$ . 63390))
(defvar ruby-mode-hook nil)
(byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [ruby-mode-hook variable-documentation put "Hook run after 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] 4)
(defvar ruby-mode-map (make-sparse-keymap))
(byte-code "\301\302N\204\303\301\302\304\305!#\210\306\307!\204\303\307\310\311#\210\312\313 !\210\307\302N\204-\303\307\302\304\314!#\210\306\300!\204B\303\300\310\311#\210\315\316\300\317\"\210!\210\300\302N\204P\303\300\302\304\320!#\210\303\311\321\322#\207" [ruby-mode-abbrev-table ruby-mode-map variable-documentation put purecopy "Keymap for `ruby-mode'." boundp ruby-mode-syntax-table definition-name ruby-mode (lambda (#1=#:def-tmp-var) (defvar ruby-mode-syntax-table #1#)) make-syntax-table "Syntax table for `ruby-mode'." (lambda (#1#) (defvar ruby-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `ruby-mode'." derived-mode-parent prog-mode] 5)
#@221 Major mode for editing Ruby code.

In addition to any hooks its parent mode `prog-mode' might have run,
this mode runs the hook `ruby-mode-hook', as the final or penultimate
step during initialization.

\{ruby-mode-map}
(defalias 'ruby-mode #[0 "\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\2035\211\321 =\203;\322\f\323 \"\210\210\324
\325\"\204R
2=\204R\326
\3252C#\210\327!\210\330\f!\210
2\331 \210\306\332!\210\333\306\334!\210\335\306\336!\210\337\306\340!\210\341 \342\343\344\345\346$\210\342\347\350\345\346$\210\342\351\352\345\346$\210\306\353!\210\354+\306\355!\2103-\306\356!\210\357.)\360\361!\207" [delay-mode-hooks major-mode mode-name ruby-mode-map ruby-mode-syntax-table ruby-mode-abbrev-table 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 after-save-hook ruby-mode-set-encoding nil local electric-indent-functions ruby--electric-indent-p flymake-diagnostic-functions ruby-flymake-auto font-lock-defaults ((ruby-font-lock-keywords) nil nil ((95 . "w"))) prettify-symbols-alist syntax-propertize-function ruby-syntax-propertize run-mode-hooks ruby-mode-hook local-abbrev-table ruby--prettify-symbols-alist] 5 (#$ . 64699) nil])
(byte-code "\300\301\302\303!\304B\"\210\305\306\307\310\311\257\211\203&\211@\300\312\302!\304B\"\210
A\266\202\202\210\313\304!\207" [add-to-list auto-mode-alist purecopy "\\(?:\\.\\(?:rbw?\\|ru\\|rake\\|thor\\|jbuilder\\|rabl\\|gemspec\\|podspec\\)\\|/\\(?:Gem\\|Rake\\|Cap\\|Thor\\|Puppet\\|Berks\\|Brew\\|Vagrant\\|Guard\\|Pod\\)file\\)\\'" ruby-mode "ruby" "rbx" "jruby" "ruby1.9" "ruby1.8" interpreter-mode-alist provide] 6)