| Current File : //proc/self/root/kunden/usr/share/emacs/27.2/lisp/progmodes/ruby-mode.elc |
;ELC
;;; Compiled
;;; in Emacs version 27.2
;;; 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 (#$ . 2930)])
(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 "\\|}\\|\\]\\)") (#$ . 3403))
#@28 Regexp to match operators.
(defconst ruby-operator-re "[-,.+*/%&|^~=<>:]\\|\\\\$" (#$ . 3588))
#@51 List of characters that symbol names may contain.
(defconst ruby-symbol-chars "a-zA-Z0-9_" (#$ . 3689))
#@26 Regexp to match symbols.
(defconst ruby-symbol-re (concat "[" ruby-symbol-chars "]") (#$ . 3799))
(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\302\323\324#\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 "" ruby-find-library-file] 5) (#$ . 3928))
#@16 Ruby Mode Menu
(defvar ruby-mode-menu nil (#$ . 4512))
(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) (#$ . 5193))
(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] "Indentation can insert tabs in Ruby mode if this is non-nil." :type boolean :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."] 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) (#$ . 6518))
(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] "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 "\300D\207" [const] 3 "\n\n(fn KW)"] :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." :group ruby 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 (#$ . 12187)])
(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\205B hz\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 (#$ . 12774)])
(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\303\311!\2038 \312 \2038 l\2030 \307u\210\2024 \313\307!\210\310\202\313d!\210\211`W\203Q \212\314`b\210!)\203Q \315\202\303\305!\203[ \316\202\317 \320 \203h \321P\262\211\322\235\203\201 \212\323\324!\210\325 )\203} \211\202\326\202\327\302\330\331#)\266\203\203\260 \307GZu\210\332\262\333 \203\243 \334\202\335 \203\254 \336\202\211\202\331\337\"\203\302 \324u\210\340\341\324#\202\211\316\232\203\327 \303\342!\203\327 \341\225b\210\343 \202\211\344\267\202\345\346!\204\347 \211\202\212\313d!\210`)\347 V\203\371 \343 \202\310\202\321\202\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-|" "\\`[^|]+|\\'" substring 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" 221 "&." 253)) 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\360 n\203, o\204, \307`\310\"b\210\306\202\360 \211`V\203@ n\204@ \311!\203@ \312\202\360 \313 \314 \211\203M \315P\262\316\267\202v \317 \203\\ \202\356 \320\202\356 \321 \203i \322\202\356 \323 \203r \324\202\356 \202\356 \325\305\326\327#)\266\203\203\212 \324\202\356 \330\305\326\327#)\266\203\203\244 \331u\210\332\331\"\202\356 \333\232\203\300 `Sf\334=\203\300 \335\336!\203\300 \310u\210\337 \202\356 \340\267\202\355 \341 \204\317 \202\356 \212\342\331!\210\301d!\210`)\302 V\203\345 \337 \202\356 \306\202\356 \315\202\356 \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 "." #s(hash-table size 5 test equal rehash-size 1.5 rehash-threshold 0.8125 purecopy t data ("unless" 83 "if" 83 "while" 83 "until" 83 "|" 96)) ruby-smie--bosp "iuwu-mod" ruby-smie--opening-pipe-p "opening-|" ruby-smie--closing-pipe-p "closing-|" "\\`[^|]+|\\'" t string-match "\\`|[*&]\\'" 1 substring "" 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" 198 "&." 233)) 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 (#$ . 16281)])
#@19
(fn KIND TOKEN)
(defalias 'ruby-smie-rules #[514 "B\303\304\305\306\267\2027 \202\350\307\310!\205\350\311\202\350\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333&\205\350\334!\202\350:\203\305@\211\335\267\202\235A\211\336\235\203\255 \333\232\203r \337\340\333\341\342\343\344\345\346&\204r \212\347\350!\210h)\351=\204r \352 \202*\353 \205*\354 @\355=\203\203 \356\202*\312\357!\203\250 \360 \204\243 \361\362\357!8\357\232\203\243 \360 \204\243 \350u\210\202\211 \363 \202*\334 \202*\364\267\202\335 \212\365\356w\210\366i)B\202*\352 \202*\367 \203\321 \205*\311\202*\362\357!\210\366i\\B\202*\211\370\235\203\350 \334 \202*\371\232\203\374 \367 \203\367 \311\202*\334 \202*\372!\n>\203 \373 ?\205*\374!\203\352 \202*\366iB\202*\375\232\203)\334!\202*\356\262\202\300A\211\376\235\203Q\212\377u\210\365\356w\210l\206F\347\377!?\205M\366iB)\202\230\201@ \267\202m \202\230\352 \202\230 \202\230 \202\230\211\201A \267\202\213\312\346\356\"\205\230\201B \205\230\202\230\202\230\375\232\203\227\334!\202\230\356\262\202\300\201C \267\202\277 \202\300\352 \202\300 \202\300 \202\300\334!\202\300\356\262\202\350\201D \267\202\347\211 \202\350\352 \202\350 \202\350 \202\350\334!\202\350\356\207" [ruby-indent-level ruby-align-chained-calls ruby-alignable-keywords #[0 "\300 \203 \301\207\302 \207" [smie-rule-sibling-p 0 smie-rule-parent] 1] #[0 "\302 \203 \205 \303\207\304\305!\210\306i \\B\207" [ruby-align-chained-calls ruby-indent-level smie-rule-sibling-p 0 smie-backward-sexp "." column] 3] #[0 "\212\300\301w\210\302i)B\207" [#1=" " nil column] 2] #s(hash-table size 3 test equal rehash-size 1.5 rehash-threshold 0.8125 purecopy t data ((:elem . basic) 12 (:elem . args) 16 (:before . ";") 26)) 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 68 :after 303)) ("{" "[" "(") 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 (#2=(:before . " @ ") 179 #3=(:before . "do") 191 #4=(:before . ".") 196)) #1# column smie-rule-sibling-p ("ensure" "rescue" "elsif" "then" "else") #5=(:before . "when") intern-soft ruby--at-indentation-p ruby-smie--indent-to-stmt-p #6=(:before . "iuwu-mod") ("{" "[" "(") 1 #s(hash-table size 4 test equal rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (#2# 345 #3# 350 #4# 355 #5# 360)) #s(hash-table size 39 test equal rehash-size 1.5 rehash-threshold 0.8125 purecopy t data ("or" 373 "and" 373 "||=" 373 "&&=" 373 ">>=" 373 "<<=" 373 "|" 373 "^=" 373 "|=" 373 "&=" 373 "**=" 373 "%=" 373 "/=" 373 "*=" 373 "-=" 373 "+=" 373 ">>" 373 "<<" 373 "!=" 373 "===" 373 "==" 373 "<=" 373 ">=" 373 "<" 373 ">" 373 "<=>" 373 "&" 373 "^" 373 "**" 373 "%" 373 "||" 373 "&&" 373 "/" 373 "*" 373 "-" 373 "+" 373 "=" 373 ":" 391 "?" 391)) smie-indent--hanging-p #s(hash-table size 5 test equal rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (#2# 421 #3# 426 #4# 431 #5# 436 #6# 441)) #s(hash-table size 5 test equal rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (#2# 461 #3# 466 #4# 471 #5# 476 #6# 481))] 24 (#$ . 16430)])
#@24
(fn &optional POINT)
(defalias 'ruby--at-indentation-p #[256 "\212\211\204 `\262\300y\210\301\302w\210`)=\207" [0 " " nil] 3 (#$ . 20012)])
#@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\331 \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\206 \203v \315\316\"\203p \317\n\310\320#\317\311\"P\202t P\262BB\262\321!\210\202
\322\230\203\234 \203\265 \317\n\310\320#\262\202\265 \203\255 \317\n\310\320#\323Q\262BB\262\321!\210`\262 \324\203\307 \325\202\310 \326P #\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\\." substring -1 ruby-accurate-end-of-block "self" "::" ruby-imenu-create-index-in-block "." "#"] 14 (#$ . 20164)])
#@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 (#$ . 21135)])
#@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\206 d\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 (#$ . 21313)])
#@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\330 P\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 (#$ . 21669)])
#@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 (#$ . 22505)])
(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 \205R eb\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 (#$ . 23638)])
(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 (#$ . 24328)])
#@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 (#$ . 24735)])
#@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 (#$ . 24915) 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\2032 Z\262\2025 \301\262n\203G U\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 (#$ . 25106)])
#@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 (#$ . 25519)])
#@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 (#$ . 25961)])
#@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\241 \312u\210\313\314!\2030 `\206 `Sfz\315=\204, \316 \2030 \307\202\241 \313!\206\241 \317=\203H \320W\205\241 \321!\202\241 \313\322!\206\241 \313\323!\203j \324=?\206\241 n\206\241 \212\312u\210\313\325!)\206\241 \313 !\205\241 \n\307x\205\241 \313\326\327 \f
#\330\"!\203\216 \320\225b\210\313\331!?\202\241 \332\267\202\240 \313\333!\202\241 \313\334!\202\241 \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 148 expr-re 154)) "[a-zA-Z][a-zA-Z0-9_]* +%[^ ]" "[a-zA-Z][a-zA-Z0-9_]* +/[^ ]"] 9 (#$ . 26253)])
#@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=\203G S\202I T\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 (#$ . 27404)])
#@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 (#$ . 28461)])
#@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!\2033 b\210\202\313\315!\203T m\204J \316``T{ \317\211$\204`\262 b\210\202\313\320!\203q m\204g \307\321 \317#\204`\262 b\210\202\313\322!\203} b\210\202\313\323!\203\247 m\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\203 n\204\315\363u\210`f\262\364=\204 \365=\204 b\203 `f\366=\204 \201E \311w\203 \306\224b\203 \313\f!\203\365\324\201F !\203 b\203 \311BB\211\262 \203 T\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\201V P\262\306\225b\201W \n\n\n\n\n\257`V\203\361\201X \201Y #\211\262\204\334\211@\262\f\211A@\262 \201U 8\262\n\201B 8\262 \201T 8\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 (#$ . 28730)])
#@33 TODO: document.
(fn START END)
(defalias 'ruby-parse-region #[514 "\300\212\203\f b\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 (#$ . 32621)])
#@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 (#$ . 32886)])
#@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\353 i\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!!\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 (#$ . 33071)])
#@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 (#$ . 35739) "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 (#$ . 36112) "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 (#$ . 36458)])
#@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\203v o\202w m\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 (#$ . 36784)])
#@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 (#$ . 37961) "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 (#$ . 38185) "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 (#$ . 38399) "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\353 \211\303V\205\347 \307\310x\210\311u\210\312\313!\203^ \314`T\311\"b\210`Sf\211\315\267\202Z \311u\210\202Z `S\206P `Sf\316=\203Z \317u\210\210\202\340 \312\320!\203\203 \321\303\225\206k `Sf!\322!\203 \323\324\310x\305\"\305=\204n \210\202\340 \312\325!\203\224 \326 \203\340 \311u\210\202\340 \312\327!\204\340 \305u\210\330\311!\210`Sf\211\331\267\202\321 \332\202\322 \311u\210\332\202\322 \311u\210`Sf\310f=\205\322 \311u\202\322 \311u\210`Sf\333=\202\322 \310\262\204\235 \312 !\203\340 \334 \210\211S\262\202! 0\202\357 \210\202\360 \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 #s(hash-table size 7 test eql rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (37 68 120 74 114 74 87 74 119 74 81 74 113 74)) 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 eql rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (95 170 46 174 64 181 36 181 58 198)) t : ruby-beginning-of-block] 6 (#$ . 39639) "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\202G U\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 (#$ . 41033) "*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\373 P\202 \202 \266\207)\207" [ruby-defun-beg-re ruby-singleton-class-re 0 nil #[257 "\301\302\303\260\207" [ruby-symbol-re "^[ ]*" "[ ]+\\(\\([A-Za-z_]" "*[?!]?\\|\\.\\|::\\)+\\)"] 6 "\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 (#$ . 41603)])
#@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 (#$ . 42890)])
#@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 \262m\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\"\210b\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 (#$ . 43151)])
#@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 (#$ . 43705)])
#@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\"?\205J b\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 (#$ . 44315) 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 (#$ . 44978)])
#@40 Check if cursor is at a string or not.
(defalias 'ruby-string-at-point-p #[0 "\300 \207" [ruby--string-region] 1 (#$ . 45172)])
#@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 (#$ . 45306)])
#@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 (#$ . 45489) nil])
#@341 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'
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\313!P!\301\314#\315\316\317\320#)\266\203\203: \321\322\"\202= \323!\207" [inhibit-changing-match-data 0 looking-at "require [\"']\\(.*\\)[\"']" match-string 1 read-string "Feature name: " substring shell-command-to-string "gem which " shell-quote-argument -1 "\\`ERROR" nil t string-match user-error "%s" find-file] 9 (#$ . 46036) nil])
#@51 Regexp to match the beginning of percent literal.
(defconst ruby-percent-literal-beg-re "\\(%\\)[qQrswWxIi]?\\([[:punct:]]\\)" (#$ . 46849))
#@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") (#$ . 46997))
#@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) (#$ . 47286))
#@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\303 h\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 nil) 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 (#$ . 47650)])
(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 (#$ . 50605)])
#@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 (#$ . 51120)])
#@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 (#$ . 51388)])
(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 (#$ . 52479)])
#@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 (#$ . 52884)])
#@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 (#$ . 53112)])
(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) (#$ . 53723))
#@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 (#$ . 57459)])
(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 (#$ . 57859)])
#@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=\205; \305\301!\205; \306\307\310\311\312!\313\"\314$\216r\301q\210\n)=\2034 r\315!q\210\300\301\")\202: \316\317\320\321$)\207" vconcat vector [ruby--flymake-proc process-status exit buffer-live-p 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 (#$ . 58642)])
(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] "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" [#1=".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\205Y \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\331\332\333\f!\334\"\335\336%#)\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-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\330 \315\"%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 substring] 16 "\n\n(fn PROC SOURCE)"] 14 (#$ . 60148)])
#@12
(fn DIR)
(defalias 'ruby-flymake-rubocop--use-bundler-p #[257 "\300\301\"\302!\205) \303\304!r\211q\210\305\306\307\310\311!\312\"\313$\216\314!\210\315\316\317\320#*\262\207" [expand-file-name "Gemfile" file-exists-p generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205 \302\300!\207" vconcat vector [buffer-name kill-buffer] 2 insert-file-contents re-search-forward "^ *gem ['\"]rubocop['\"]" nil t] 9 (#$ . 61549)])
#@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 (#$ . 61991)])
(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
1=\204R \326
\3251C#\210\327 !\210\330\f!\210
1\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!\210\356-)\357\360!\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"))) syntax-propertize-function ruby-syntax-propertize run-mode-hooks ruby-mode-hook local-abbrev-table] 5 (#$ . 63349) 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)