HOME

Mini Shell 1.0
DIR:/proc/self/root/usr/share/emacs/26.1/lisp/progmodes/
Current File : //proc/self/root/usr/share/emacs/26.1/lisp/progmodes/ruby-mode.elc
;ELC
;;; Compiled
;;; in Emacs version 26.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)
#@38 Keywords at the beginning of blocks.
(defconst ruby-block-beg-keywords '("class" "module" "def" "if" "unless" "case" "while" "until" "for" "begin" "do") (#$ . 511))
#@42 Regexp to match the beginning of blocks.
(defconst ruby-block-beg-re (regexp-opt ruby-block-beg-keywords) (#$ . 682))
#@52 Regexp to match keywords that nest without blocks.
(defconst ruby-non-block-do-re "\\_<\\(for\\|rescue\\|until\\|while\\)\\_>" (#$ . 806))
#@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\\)\\)\\_>" (#$ . 951))
#@57 Modifiers that are the same as the beginning of blocks.
(defconst ruby-modifier-beg-keywords '("if" "unless" "while" "until") (#$ . 1161))
#@60 Regexp to match modifiers same as the beginning of blocks.
(defconst ruby-modifier-beg-re (regexp-opt ruby-modifier-beg-keywords) (#$ . 1306))
#@28 Regexp to match modifiers.
(defconst ruby-modifier-re (byte-code "\301\302B!\207" [ruby-modifier-beg-keywords regexp-opt "rescue"] 3) (#$ . 1455))
#@78 Keywords where the indentation gets shallower in middle of block statements.
(defconst ruby-block-mid-keywords '("then" "else" "elsif" "when" "rescue" "ensure") (#$ . 1609))
#@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) (#$ . 1789))
#@35 Regexp to match boolean keywords.
(defconst ruby-block-op-keywords '("and" "or" "not") (#$ . 1957))
#@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) (#$ . 2063))
(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\\)" (#$ . 2302))
#@61 Regexp to match the beginning of a singleton class context.
(defconst ruby-singleton-class-re "class\\s *<<" (#$ . 2442))
#@45 Regexp to match the beginning of a heredoc.
(defconst ruby-here-doc-beg-re "\\(<\\)<\\([~-]\\)?\\(\\([a-zA-Z0-9_]+\\)\\|[\"]\\([^\"]+\\)[\"]\\|[']\\([^']+\\)[']\\)" (#$ . 2570))
(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 (#$ . 2934)])
(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 "\\|}\\|\\]\\)") (#$ . 3407))
#@28 Regexp to match operators.
(defconst ruby-operator-re "[-,.+*/%&|^~=<>:]\\|\\\\$" (#$ . 3592))
#@51 List of characters that symbol names may contain.
(defconst ruby-symbol-chars "a-zA-Z0-9_" (#$ . 3693))
#@26 Regexp to match symbols.
(defconst ruby-symbol-re (concat "[" ruby-symbol-chars "]") (#$ . 3803))
(defvar ruby-use-smie t)
#@27 Keymap used in Ruby mode.
(defvar ruby-mode-map (byte-code "\301 \204\302\303\304#\210\302\305\306#\210\302\307\310#\210\203\"\302\311\312#\210\302\313\314#\210\302\315\316#\210\302\317\320#\210\302\321\322#\210\211\207" [ruby-use-smie make-sparse-keymap define-key [134217730] ruby-backward-sexp [134217734] ruby-forward-sexp [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] 5) (#$ . 3932))
#@16 Ruby Mode Menu
(defvar ruby-mode-menu nil (#$ . 4470))
(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" ruby-backward-sexp :visible (not ruby-use-smie)] ["Backward Sexp" backward-sexp :visible ruby-use-smie] ["Forward Sexp" ruby-forward-sexp :visible (not ruby-use-smie)] ["Forward Sexp" forward-sexp :visible ruby-use-smie] ["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\211\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) (#$ . 5151))
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313&	\210\300\314\302\303\315DD\316\306\317\310\311\312\320&	\210\300\321\302\303\322DD\323\306\317\310\311\312\320&	\207" [custom-declare-variable ruby-indent-tabs-mode funcall function #[0 "\300\207" [nil] 1] "Indentation can insert tabs in Ruby mode if this is non-nil." :type boolean :group ruby :safe booleanp ruby-indent-level #[0 "\300\207" [2] 1] "Indentation of Ruby statements." integer integerp ruby-comment-column #[0 "\300\301!\207" [default-value comment-column] 2] "Indentation column of comments."] 10)
#@61 Keywords that can be used in `ruby-align-to-stmt-keywords'.
(defconst ruby-alignable-keywords '(if while unless until begin case for def) (#$ . 6513))
(byte-code "\301\302\303\304\305DD\306\307\310\311\312\313\314\315\310\316\317\"BFF\320\321\322\323\324\325&\210\301\326\303\304\327DD\330\307\331\320\321\322\332\324\325&\210\301\333\303\304\334DD\335\307\331\320\321\322\332&	\210\301\336\303\304\337DD\340\307\341\320\321&\210\301\342\303\304\343DD\344\307\345\320\321&\210\301\346\303\304\347DD\350\307\351\320\321&\210\301\352\303\304\353DD\354\307\331\320\321&\210\301\355\303\304\356DD\357\307\360\320\321\324\325&	\210\301\361\303\304\362DD\363\307\364\320\321\324\325&	\210\301\365\303\304\366DD\367\307\331\320\321&\210\370\371!\207" [ruby-alignable-keywords custom-declare-variable ruby-align-to-stmt-keywords funcall function #[0 "\300\207" [(def)] 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.\n" :type choice (const :tag "None" nil) (const :tag "All" t) repeat :tag "User defined" mapcar #[257 "\300D\207" [const] 3 "\n\n(fn KW)"] :group ruby :safe listp :version "24.4" ruby-align-chained-calls #[0 "\300\207" [nil] 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] "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] "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] "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) (shift-jis . cp932) (shift_jis . cp932) (japanese-cp932 . cp932))] 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] "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." ruby-encoding-magic-comment-style #[0 "\300\207" [ruby] 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" [#1="# 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] "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>)\207" [" 	" nil 92 (59 61)] 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 (#$ . 12251)])
(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 (#$ . 12838)])
(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\202\370\303\311!\2038\312 \2038l\2030\307u\210\2024\313\307!\210\310\202\370\313d!\210\211`W\203Q\212\314`b\210!)\203Q\315\202\370\303\305!\203[\316\202\370\317 \320 \203h\321P\262\211\322\235\203\201\212\323\324!\210\325 )\203}\211\202\366\326\202\366\327\302\330\331#)\266\203\203\260\307GZu\210\332\262\333 \203\243\334\202\366\335 \203\254\336\202\366\211\202\366\211\316\232\203\305\303\337!\203\305\340\225b\210\341 \202\366\211\342\232\203\353\343\344!\204\325\211\202\366\212\313d!\210`)\345 V\203\347\341 \202\366\310\202\366\211\346\232\203\365\321\202\366\211\266\202\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-|" "\\\\\n" 0 ruby-smie--forward-token "do" 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\202\350n\203,o\204,\307`\310\"b\210\306\202\350\211`V\203@n\204@\311!\203@\312\202\350\313 \314 \211\203M\315P\262\316\235\203`\317 \203\\\202\346\320\202\346\321\232\203|\322 \203o\323\202\346\324 \203x\325\202\346\202\346\326\305\327\330#)\266\203\203\226\331u\210\331\305O\202\346\332\232\203\262`Sf\333=\203\262\334\335!\203\262\310u\210\336 \202\346\337\232\203\333\340 \204\301\202\346\212\341\331!\210\301d!\210`)\302 V\203\327\336 \202\346\306\202\346\342\232\203\345\315\202\346\266\202\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 "." ("unless" "if" "while" "until") 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 "do" 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 (#$ . 15989)])
#@19 

(fn KIND TOKEN)
(defalias 'ruby-smie-rules #[514 "B\211:\205\216\211@\211\303\267\202\213A\211\304\267\202&\202'\305\306!\205'\307\202'\310\262\202\214A\211\311\232\203Q\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333&\205>\334!\202>\211\335\235\203\267\333\232\203|\336\337\333\340\341\342\343\344\311&\204|\212\345\346!\210h)\347=\204|\350 \202>\351 \205>\352 @\353=\203\215\310\202>\312\354!\203\262\355 \204\255\356\357\354!8\354\232\203\255\355 \204\255\346u\210\202\223\360 \202>\334 \202>\211\361\232\203\311\212\362\310w\210\363i)B\202>\211\315\232\203\324\350 \202>\211\354\232\203\363\364 \203\347	\205>\307\202>\357\354!\210\363i\\B\202>\211\365\235\203\376\334 \202>\211\330\232\203\364 \203
\307\202>\334 \202>\366!\n>\2031\367 ?\205>\370!\203+\350 \202>\363iB\202>\211\371\232\203=\334!\202>\310\262\202\214A\211\372\235\203e\212\373u\210\362\310w\210l\206Z\345\373!?\205a\363iB)\202\206\211\374\235\203{\312\311\310\"\205\206\375 \205\206\202\206\211\376\235\203\205\202\206\310\262\202\214\310\262\207" [ruby-indent-level ruby-align-chained-calls ruby-alignable-keywords #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (:elem 16 :before 44 :after 323)) #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (basic 24 args 28)) looking-at "\\s\"" 0 nil ";" smie-rule-parent-p "def" "begin" "do" "class" "module" "for" "while" "until" "unless" "if" "then" "elsif" "else" "when" "rescue" "ensure" "{" smie-rule-parent ("{" "[" "(") smie-rule-prev-p "(" "[" "," "=>" "=" "return" forward-comment -1 58 ruby-smie--indent-to-stmt smie-rule-hanging-p smie-indent--parent t "." ruby-smie--bosp 2 smie-backward-sexp smie-indent-virtual " @ " " 	" column smie-rule-sibling-p ("ensure" "rescue" "elsif" "then" "else") intern-soft ruby--at-indentation-p ruby-smie--indent-to-stmt-p "iuwu-mod" ("{" "[" "(") 1 ("or" "and" "||=" "&&=" ">>=" "<<=" "|" "^=" "|=" "&=" "**=" "%=" "/=" "*=" "-=" "+=" ">>" "<<" "!=" "===" "==" "<=" ">=" "<" ">" "<=>" "&" "^" "**" "%" "||" "&&" "/" "*" "-" "+" "=") smie-indent--hanging-p (":" "?")] 23 (#$ . 16138)])
#@24 

(fn &optional POINT)
(defalias 'ruby--at-indentation-p #[256 "\212\211\204`\262\300y\210\301\302w\210`)=\207" [0 " 	" nil] 3 (#$ . 18367)])
#@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\325\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
\314\230\203\204	\203t\315\316\"\203n	\310\317O\311\301OP\202r	P\262BB\262\320!\210\202
\321\230\203\231	\203\261	\310\317O\262\202\261	\203\251	\310\317O\322Q\262BB\262\320!\210`\262	\323\203\303\324\202\304\325P#\244\262b\210\202
)\207" [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 "." "#"] 14 (#$ . 18519)])
#@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 (#$ . 19463)])
#@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 )\2024\304\305#\211\262\2054\3068\307Y\2054`W\2054\202\207" [ruby-use-smie nil back-to-indentation smie-forward-sexp apply ruby-parse-partial 2 0] 7 (#$ . 19641)])
#@54 Set up initial buffer-local variables for Ruby mode.
(defalias 'ruby-mode-variables #[0 "\n\203\306\307\310\311\312\313&\210\202\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-use-smie ruby-smie-grammar 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 (#$ . 19997)])
#@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 (#$ . 20833)])
(defalias 'ruby--detect-encoding #[0 "\305=\203\306\207	\206
\n\211\203\307\310\"\206\311\312\"\262\211\203>\313\2039\f\236\211\2033\211A\2024\262\202:!\202?\314\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 symbol-name "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~\210eb\210\301 \205Reb\210\302 \211\205P\303\304!\203\305\306!\210\303\307!\203;\310\306!\230\204I\306\224b\210`\306\225|\210\211c\210\202I\303\311!\204I\203I\312!\210\313 \205P\314 \262)\207" [ruby-insert-encoding-magic-comment ruby--encoding-comment-required-p ruby--detect-encoding looking-at "^#!" beginning-of-line 2 "\\s *#\\s *.*\\(en\\)?coding\\s *:\\s *\\([-a-z0-9_]*\\)" match-string "\\s *#.*coding\\s *[:=]" ruby--insert-coding-comment buffer-modified-p basic-save-buffer-1] 3 (#$ . 21966)])
(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\225S=)\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 (#$ . 22656)])
#@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 (#$ . 23063)])
#@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 (#$ . 23243) nil])
#@49 Indent the current line to COLUMN.

(fn COLUMN)
(defalias 'ruby-indent-to #[257 "\211\205\\\300\211\211\301W\203\302\303!\210i\262\304 \210`\262\305 \210i\262\306\300x\210Y\2032Z\262\2025\301\262n\203GU\203G\307\\!\202Z\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 (#$ . 23434)])
#@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\205S\206`Sf\300=\206C\301=\206C\302=\203:\211?\206C\211z\303=\206C\304=\205C\211\300=\207" [63 36 58 32 92] 5 (#$ . 23847)])
#@22 

(fn &optional POS)
(defalias 'ruby-verify-heredoc #[256 "\212\211\203\211b\210\301`S!@\302>?\2050`Sf\303>?\2060\304\305\306!\210\2060`Sf\307=\2060\310!?)\207" [ruby-singleton-class-re syntax-after (2 3 6 10) (32 9) nil forward-word-strictly -1 95 looking-at] 4 (#$ . 24289)])
#@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\311\202\247\312u\210\313\314!\2030`\206`Sfz\315=\204,\316 \2030\307\202\247\313!\206\247\317=\203H\320W\205\247\321!\202\247\313\322!\206\247\313\323!\203j\324=?\206\247n\206\247\212\312u\210\313\325!)\206\247\313	!\205\247\n\307x\205\247\313\326\327\f
#\330\"!\203\216\320\225b\210\313\331!?\202\247\332=\203\232\313\333!\202\247\334=\203\246\313\335!\202\247\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_" expr-qstr "[a-zA-Z][a-zA-z0-9_]* +%[^ 	]" expr-re "[a-zA-Z][a-zA-z0-9_]* +/[^ 	]"] 9 (#$ . 24581)])
#@603 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\206h\203e\315\202h\320\321!\207" [1 string-to-char "[^\\]\\(\\\\\\\\\\)*\\(" "^" "\\^" "[" "]" "\\|\\(#{\\)" "\\)" re-search-forward 3 ruby-forward-string "}{" nil 0 -1 error "Unterminated string"] 12 (#$ . 25648)])
#@25 TODO: document.

(fn C)
(defalias 'ruby-deep-indent-paren-p #[257 "<\203\303\"\211\203\211A\206	\202>\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 (#$ . 26705)])
#@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#\203\201`\311\211\211\306\224b\210`Sf\312>\2033\313\314!\2033b\210\202\313\315!\203Tm\204J\316``T{\317\211$\204`\262		b\210\202\313\320!\203qm\204g\307\321\317#\204`\262		b\210\202\313\322!\203}b\210\202\313\323!\203\247m\204\241\324\325!\203\241\316\323\317\211$\204`\262		b\210\202b\210\202\313\326!\203Tm\204N\324\327!\203N\313\330!\204N\313\331!\203N\332\224b\210`Sf\333>?\262\334\332!\262\335\230\203\340\336\262\202\337\230\203\354\340\262\202\341\230\203\370\342\262\202\343\230\203\344\262\202\211\203\345\230\203\345P\262\203!\316\317$\202A\211\203/\316\317\211$\202A\307\345\230\203:\346\202=\347P\317#\204`\262		b\210\202b\210\202\313\350!\203r\324 \203l\313\351!\203l\306\225b\210\202b\210\202\313\352!\203\201b\210\332u\210\202\313\353!\203\220\332y\210`b\210\202\313\354!\203\350\355\311f!\211\203\323\311f\356=\203\252\324 \203\323\211\357=\203\273\313\360!\203\273\306\225S\262`fB	B\262	BB\262\306\262\202\341`fB	B\262	T\262\210b\210\202\313\361!\203\355\362\311f!!\203@A\262A\262\202S\262A\262b\210\202\313	!\203Yn\2040\363u\210`f\262\364=\204S\365=\204Sb\210`f\262\364=\204S\366=\204S\367=\204SA\262S\262b\210\202\313\370!\203\201n\204m\363u\210`f\364=\204z\311BB\262T\262\306\225b\210\202\313\371\n\372Q!\203\373 \374\306\375\376\377!\201A\"\201B$\216\313\201C!?\206\260\212\201D \210\313!)?)\262\203n\204\315\363u\210`f\262\364=\204\365=\204b\203`f\366=\204\201E\311w\203\306\224b\203\313\f!\203\365\324\201F!\203b\203\311BB\211\262	\203T\262b\210\202\313\201G!\203)\332\224b\210\316\334\332!\317#\210\202\313\201H!\2038\306\225b\210\202\313\201I!\203G\306\225b\210\202\313\201J!\204g\313\201K!\204g\313\201L!\204g\313\201M!\203n\306\225b\210\202\313\201N!\203\222\307\201O\317#\203\207\332y\210\202\306\225\262		b\210\202\313\201P!\2038\324\201Q!\2032\313\201R!\2032\201S\334\201T!\206\272\334\201U!!\262\332\224\203\311\201VP\262\306\225b\201W \n\n\n\n\n\257`V\203\361\201X\201Y#\211\262\204\334\211@\262\f\211A@\262\201U8\262\n\201B8\262	\201T8\262\307\201Z\201[Q\310#\203&\332y\210\202-\262\f\fb\210\266\202b\210\202\313\201\\!\203Fb\210\202\313
!\203s\201]\201@!\203s\307\201^ @\317#\203h\332y\210\202\306\225\262	@b\210\202\201_\201``{\"\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-\\)*\\\\?." "\\$" "#" "[\\[{(]" ruby-deep-indent-paren-p 123 space ".\\s +[^# 	\n]" "[])}]" matching-paren -1 95 46 33 63 "def\\s +[^(\n;]*" "\\_<\\(" "\\)\\_>" match-data make-byte-code "\301\300\302\"\207" vconcat vector ruby-indent-point [set-match-data evaporate] 3 "do\\_>" back-to-indentation " 	" 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 "^" "$" "^__END__$" boundp ruby-here-doc-end-match error "Bad string %s"] 17 (#$ . 26974)])
#@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 (#$ . 30863)])
#@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 (#$ . 31128)])
#@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\fA@A\211\262b\210\317A@@!\211\203\313\211\320=\203|A@@=\203|\321\311!\210iS\262\202\353\316`\n\"\3228\205\230\3228\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\301S\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!!\203i\262\210\202~\3228\203e\3228\313V\203eA@A\204'\333\334!\210A@Ab\210\323\324!\210`\262\335\336!\203]\3308\203J\3308b\210\202Qb\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\304A@@\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	\\\262b\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 (#$ . 31313)])
#@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 (#$ . 33981) "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 (#$ . 34354) "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 (#$ . 34700)])
#@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\211\313\262\212\304 \210\316\203V\n\202Z\317\320Q\312 \321#\205f\322\323 8?)\262\204\203vo\202wm\204y\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\3108\\\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 (#$ . 35026)])
#@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 (#$ . 36203) "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 (#$ . 36427) "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\344\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\202\350\210\325\305!\210\211\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 (#$ . 36641) "p"])
#@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\211\303V\205\377\307\310x\210\311u\210\312\313!\203d\314`T\311\"b\210`Sf\211\315=\203J\311u\210\202`\211\316>\203``S\206V`Sf\315=\203`\317u\210\210\202\370\312\320!\203\211\321\303\225\206q`Sf!\322!\203\205\323\324\310x\305\"\305=\204t\210\202\370\312\325!\203\232\326 \203\370\311u\210\202\370\312\327!\204\370\305u\210\330\311!\210`Sf\211\331=\203\264\332\202\352\211\333=\203\301\311u\210\332\202\352\211\334>\203\330\311u\210`Sf\310f=\205\352\311u\202\352\211\335=\203\351\311u\210`Sf\336=\202\352\310\262\204\243\312	!\203\370\337 \210\211S\262\202!0\202\210\202\210\211\207" [ruby-use-smie ruby-block-end-re backward-sexp 0 ruby-forward-sexp 1 (error) " 	\n,.:;|&^~=!?\\+\\-\\*" nil -1 looking-at "\\s)" scan-sexps 37 (120 114 87 119 81 113) -2 "\\s\"\\|\\\\\\S_" char-to-string search-backward logand "\\" "\\s.\\|\\s\\" ruby-special-char-p "\\s(" forward-word-strictly 95 t 46 (64 36) 58 : ruby-beginning-of-block] 6 (#$ . 37887) "p"])
#@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\306\307\310	!\311\"\312$\216\313 \210`\262\314 \262m?\205U\315!\262V\2039\302\211\262\202GU\205U\211\205U\301\262\302\205U\316!\210\313\317!\210\202\")\207" [point-marker nil t set-marker-insertion-type make-byte-code 0 "\300b\210\300\301\211\223\207" vconcat vector [nil] 3 beginning-of-line current-indentation ruby-calculate-indent ruby-indent-to 2] 12 (#$ . 39124) "*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\303\307#\203:\310\224b\210\311\310!\312\230\204)\311\313!C\262\2024\314!\2034\311\313!\262i\262\315 \210\302V\203d\306\303\307#\203d\310\224b\210iW\203:\311\313!B\262i\262\315 \210\202:\203\337\316\317\"\211A\203\277\211@\320\230\204\264\237\211\203\236\211@@\230\203\217\211A\237\262\303\262\211A\211\262\204{\237\210\202{\210\203\257\321!\322!\241\210\202\264\322!\262\323\321!@P\262\202\336\324	\307#\205\317\302\224b\210\314!\211\203\327\323\202\330\325P\262\210\210:\203\354\326\327\330#\262\203\377\203\373P\202\202\266\207)\207" [ruby-defun-beg-re ruby-singleton-class-re 0 nil #[257 "\301\302\303\304\305\306\307\260	\207" [ruby-symbol-re "^[ 	]*" "[ 	]+" "\\(" "\\([A-Za-z_]" "*\\|\\.\\|::" "\\)" "+\\)"] 10 "\n\n(fn RE)"] "\\(class\\|module\\)" re-search-backward t 1 match-string "def" 2 ruby-block-contains-point beginning-of-line split-string "\\.\\|::" "self" last butlast "." re-search-forward "#" mapconcat identity "::"] 12 (#$ . 39694)])
#@11 

(fn PT)
(defalias 'ruby-block-contains-point #[257 "\212\300 \301\302\303\304\305!\306\"\307$\216\310 \210`V)\262)\207" [match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 ruby-forward-sexp] 8 (#$ . 41005)])
#@17 

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

(fn ORIG END)
(defalias 'ruby-do-end-to-brace #[514 "\302\211\211\211\303Zb\210\304!\205\200\305\303!\210\306 \262\307c\210b\210\305\310!\210\311c\210\306 \262\304\312!\203B\305\313\314\225\314\224\315#!\210\302u\210\316\317\320 \321#\210\212\322\302w\210`\262b\210\322\302x\210`\262)\211W\204q\323!\323!U\203|\324iZ\310#	W\203|\325\326!\210b\210\325\326!\210b\210\321\207" [ruby-block-end-re fill-column 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] 11 (#$ . 41792)])
#@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!\205D\303\224\206\304\224b\210`\262\305 \306\307\310\311\312!\313\"\314$\216\315 \210)\210`\262\211V\205D\303\224\203@\316\"\202D\317\"?\205Jb\207" [nil re-search-backward "\\(?:[^#]\\)\\({\\)\\|\\(\\_<do\\_>\\)" 1 2 match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 ruby-forward-sexp ruby-brace-to-do-end ruby-do-end-to-brace] 10 (#$ . 42402) nil])
#@36 Return region for string at point.
(defalias 'ruby--string-region #[0 "\300 \3018\302>\205\212\3038b\210\304 \210\3038`)D\207" [syntax-ppss 3 (39 34) 8 forward-sexp] 3 (#$ . 43065)])
#@40 Check if cursor is at a string or not.
(defalias 'ruby-string-at-point-p #[0 "\300 \207" [ruby--string-region] 1 (#$ . 43259)])
#@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 (#$ . 43393)])
#@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\305\310\311##\2026\305\312\304\305\313\314##\262`|\210\315\316$c\210\211b\262\266\205\207" [ruby-string-at-point-p ruby--string-region ruby--inverse-string-quote buffer-substring-no-properties "'" replace-regexp-in-string "\\\\\"" "\"" "\\(\\`\\|[^\\\\]\\)'" "\\1\\\\'" "\\\\'" "\\(\\`\\|[^\\\\]\\)\"" "\\1\\\\\"" format "%s%s%s"] 12 (#$ . 43576) nil])
#@51 Regexp to match the beginning of percent literal.
(defconst ruby-percent-literal-beg-re "\\(%\\)[qQrswWxIi]?\\([[:punct:]]\\)" (#$ . 44126))
#@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") (#$ . 44274))
#@68 Regexp to match text that can be followed by a regular expression.
(defvar ruby-syntax-before-regexp-re (byte-code "\301\302\303\304\305\306!\307\260\207" [ruby-syntax-methods-before-regexp "\\(^\\|[[{|=(,~;<>!]" "\\|[?:] " "\\|\\(?:^\\|\\s \\)" "\\(?:&&\\|and\\|elsif\\|if\\|not\\|or\\|un\\(?:less\\|til\\)\\|wh\\(?:en\\|ile\\)\\|||\\)" "\\|\\_<" regexp-opt "\\)\\s *"] 7) (#$ . 44563))
#@86 Syntactic keywords for Ruby mode.  See `syntax-propertize-function'.

(fn START END)
(defalias 'ruby-syntax-propertize #[514 "\303b\210\304\305#\210\306!\210\307!\210`b\210`W\205\310\311\312#\205\313\224\203\\\313\224\313\225\212\314\315\316\224!8)\203B\303\313\225b\210\202L\317\313\225\316\225\320\321$\210\322\211\203W\317\320$\210\266\202\323\224\203\223\324\325!\211A\323\233\241\210\326!\266\314\224\314\225\327\315\314\224!8?\205\203\316\225b\210\321\211\203\216\317\320$\210\266\202\330\224\203\331\324\325!\211A\331\233\241\210\326!\266\316\224\316\225\212\327\315\316\224!8\206\303\303\332\333!\316U)\206\303h\334>)?\205\311\321\211\203\324\317\320$\210\266\202\335\224\203\352\317\335\224\335\225\320\321$\210\202\327\224\203\324\325!\211A\336\233\241\210\326!\266\313\224\313\225\337\211\203\317\320$\210\266\202\340\224\203_\324\325!\211A\341\233\241\210\326!\266\313\224\313\225\212\315\313\224!)\3278\204D\212\342u\210\343\n\344 \")\204L\3148\345=\205M\346\262\211\203Z\317\320$\210\266\202\347\224\203y\324\325!\211A\350\233\241\210\326!\266\351 \210\202\352\224\203\212\317\352\224\352\225\320\353$\210\202\341\224\203\233\317\341\224\341\225\320\353$\210\202\354\224\203\342\324\325!\211A\355\233\241\210\326!\266\335\224\335\225\327\212\315\316\224!)8?\205\322\356\316\224!\205\322\317\335\224\335\225\320\357$\210\306!\211\203\335\317\320$\210\266\202\360\224\203\324\325!\211A\361\233\241\210\326!\266\313\224\313\225\327\212\315\313\224!)8?\205\362!\210\363\211\203\317\320$\210\266\202\266\202)\207" [case-fold-search parse-sexp-lookup-properties ruby-syntax-before-regexp-re nil remove-text-properties (ruby-expansion-match-data) ruby-syntax-propertize-heredoc ruby-syntax-enclosing-percent-literal re-search-forward "\\([?$]\\)[#\"'`:?]\\|\\(^\\|[^:]\\)\\(:\\([-+~]@?\\|[/%&|^`]\\|\\*\\*?\\|<\\(<\\|=>?\\)?\\|>[>=]?\\|===?\\|=~\\|![~=]?\\|\\[\\]=?\\)\\)\\|\\([!?]\\)\\|^[ 	]*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) 4 match-data ints set-match-data 8 6 14 skip-syntax-backward "w_" (64 36) 7 16 (1) 9 18 -1 looking-back point-at-bol 47 (7 . 47) 10 22 ruby-syntax-propertize-expansion 17 (14) 25 38 ruby-verify-heredoc (7) 26 52 ruby-syntax-propertize-percent-literal (15)] 12 (#$ . 44959)])
(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 \315PB\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 (#$ . 47914)])
#@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 (#$ . 48429)])
#@14 

(fn LIMIT)
(defalias 'ruby-syntax-propertize-percent-literal #[257 "\301\224b\210\302f\303!\304 HA\206\305\306\"A\302\212\3071u\211\203`\304 p\310\311\312\313\314\"\315\"\301$\216\316\317\304\302\"!\210\320\321\303!P\"\210\320\322P\"\210\320\323\324\"\210\214`}\210\325 \210*\266\202j\326\327\330!P\302#\210\331`S`\304\332$0\202w\210\302*\207" [parse-sexp-lookup-properties 2 nil char-to-string syntax-table assoc ((60 . 62)) (scan-error search-failed) make-byte-code 0 "r\301q\210\302\300!)\207" vconcat vector [set-syntax-table] set-syntax-table make-char-table modify-syntax-entry "(" ")" 92 "\\" forward-list re-search-forward "[^\\]\\(?:\\\\\\\\\\)*" regexp-quote put-text-property (15)] 13 (#$ . 48697)])
(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\311\224\311\225\312\313$\210\202\207" [2 syntax-ppss ruby-syntax-expansion-allowed-p put-text-property ruby-expansion-match-data match-data re-search-forward "[\"`]" move 0 syntax-table (1)] 8])
#@70 Return non-nil if expression expansion is allowed.

(fn PARSE-STATE)
(defalias 'ruby-syntax-expansion-allowed-p #[257 "\3008\211\301>\206)\211\302=\205)\303 \304\305\306\307\310!\311\"\300$\216\212\3128b\210\313\314!*\262\207" [3 (34 96 10 47) t match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 8 looking-at "%\\(?:[QWrxI]\\|\\W\\)"] 9 (#$ . 49788)])
#@18 

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

(fn CONTEXT &optional PPSS)
(defalias 'ruby-in-ppss-context-p #[513 "\211\206\300`!\301\267\202:\3028\204A\3038\202>\3028\202>\3028\304=\202>\305\306!\205B\305\307!?\202>\3038\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 (#$ . 50421)])
#@89 The syntax table to use for fontifying Ruby mode buffers.
See `font-lock-syntax-table'.
(defvar ruby-font-lock-syntax-table (byte-code "\301!\302\303\304#\210\211\207" [ruby-mode-syntax-table make-syntax-table modify-syntax-entry 95 "w"] 5) (#$ . 50960))
(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\\)\\|t[cs]\\)\\)?\\|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\\(?:ivate\\|otected\\)\\|ublic\\)\\|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) (3 (unless (and (eq (char-before (match-end 3)) 61) (eq (char-after (match-end 3)) 62)) font-lock-constant-face) nil t)) "\\$\\(?:[:\"!@;,/\\._><\\$?~=*&`'+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 2 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) (#$ . 51295))
#@14 

(fn LIMIT)
(defalias 'ruby-match-expression-expansion #[257 "\300\301`\302$\302\205*`V\205*b\210\303\"\211\262\203'\304!\210\305\202*\306!\207" [ruby-expansion-match-data next-single-char-property-change nil get-text-property set-match-data t ruby-match-expression-expansion] 7 (#$ . 55033)])
(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\311\312\313	!\314\"\315\316%#\207" [executable-find "ruby" error "Cannot find the ruby executable" ruby-flymake--helper "ruby-flymake" ("ruby" "-w" "-c") make-byte-code 514 "eb\210\301\211\211\211\211\302\303\301\304#\203J\305\306!\262\307\310\305\311!!\"\262\211A\262\242\262\312\313\"\2034\314\2025\315\262\211\316\n%C\244\262\202\300!\210\301\207" vconcat vector [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] 14 "\n\n(fn PROC SOURCE)"] 11 (#$ . 55433)])
#@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\321\322\323\"\324\"\325\326%&\f\327ed#\210\330!)\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-byte-code 514 "\303!\304=\2055\305\306\307\310\311!\312\"\313$\216r\301q\210\n)=\203.r\314!q\210\300\301\")\2024\315\316\317\320$)\207" vconcat vector [ruby--flymake-proc process-status exit make-byte-code 0 "\301\302\300!!\207" vconcat vector [kill-buffer process-buffer] 3 process-buffer flymake--log-1 :debug ruby-mode "Canceling obsolete check %s"] 8 "\n\n(fn PROC EVENT)" process-send-region process-send-eof] 23 (#$ . 56216)])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313\314\315&\210\300\316\302\303\317DD\320\306\307\310\321\312\313\314\322&\207" [custom-declare-variable ruby-flymake-use-rubocop-if-available funcall function #[0 "\300\207" [t] 1] "Non-nil to use the Rubocop Flymake backend.\nOnly takes effect if Rubocop is installed." :version "26.1" :type boolean :group ruby :safe booleanp ruby-rubocop-config #[0 "\300\207" [#1=".rubocop.yml"] 1 #1#] "Configuration file for `ruby-flymake-rubocop'." string stringp] 12)
#@57 Rubocop backend for Flymake.

(fn REPORT-FN &rest ARGS)
(defalias 'ruby-flymake-rubocop #[385 "\302\303!\204\n\304\305!\210\303\306\307\310\311\312\313\257\314\205?\315	\"\262\211\203.\316\317\320	\"D\"\262\321\322\323\324\325\326\327!\330\"\331\332%#\207" [buffer-file-name 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 "--config" expand-file-name ruby-flymake--helper "rubocop-flymake" make-byte-code 514 "\301!\302=\203\303\304\305\306\307 $\210eb\210\310\211\211\211\211\311\312\310\313#\203n\314\315!\262\316\317\314\320!!\317\314\321!!#\262\211A\262\242\262\322\323\"\203I\324\202V\322\325\"\203U\304\202V\326\262\211\327\n\315\310O%C\244\262\202\300!\210\310\207" vconcat vector [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] 16 "\n\n(fn PROC SOURCE)"] 13 (#$ . 57591)])
#@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 (#$ . 58837)])
(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
3=\204R\326
\3253C#\210\327!\210\330\f!\210
3\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!\2104-\306\356!\2105.\306\357!\210\360/)\361\362!\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) font-lock-keywords font-lock-syntax-table syntax-propertize-function ruby-syntax-propertize run-mode-hooks ruby-mode-hook local-abbrev-table ruby-font-lock-keywords ruby-font-lock-syntax-table] 5 (#$ . 60195) nil])
(byte-code "\300\301\302\303!\304B\"\210\305\306\307\310\311\257\211\203&\211@\300\312\302!\304B\"\210A\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\\|Vagrant\\|Guard\\|Pod\\)file\\)\\'" ruby-mode "ruby" "rbx" "jruby" "ruby1.9" "ruby1.8" interpreter-mode-alist provide] 6)