ikan Uploader :
Directory : /usr/share/emacs/25.2/lisp/progmodes/
Upload File : |
| Current File : //usr/share/emacs/25.2/lisp/progmodes/ruby-mode.elc |
;ELC
;;; Compiled
;;; in Emacs version 25.2.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") (#$ . 513))
#@42 Regexp to match the beginning of blocks.
(defconst ruby-block-beg-re (regexp-opt ruby-block-beg-keywords) (#$ . 684))
#@52 Regexp to match keywords that nest without blocks.
(defconst ruby-non-block-do-re "\\_<\\(for\\|rescue\\|until\\|while\\)\\_>" (#$ . 808))
#@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\\)\\)\\_>" (#$ . 953))
#@57 Modifiers that are the same as the beginning of blocks.
(defconst ruby-modifier-beg-keywords '("if" "unless" "while" "until") (#$ . 1163))
#@60 Regexp to match modifiers same as the beginning of blocks.
(defconst ruby-modifier-beg-re (regexp-opt ruby-modifier-beg-keywords) (#$ . 1308))
#@28 Regexp to match modifiers.
(defconst ruby-modifier-re (byte-code "\301\302B!\207" [ruby-modifier-beg-keywords regexp-opt "rescue"] 3) (#$ . 1457))
#@78 Keywords where the indentation gets shallower in middle of block statements.
(defconst ruby-block-mid-keywords '("then" "else" "elsif" "when" "rescue" "ensure") (#$ . 1611))
#@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) (#$ . 1791))
#@35 Regexp to match boolean keywords.
(defconst ruby-block-op-keywords '("and" "or" "not") (#$ . 1959))
#@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) (#$ . 2065))
(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\\)" (#$ . 2304))
#@61 Regexp to match the beginning of a singleton class context.
(defconst ruby-singleton-class-re "class\\s *<<" (#$ . 2444))
#@45 Regexp to match the beginning of a heredoc.
(defconst ruby-here-doc-beg-re "\\(<\\)<\\([~-]\\)?\\(\\([a-zA-Z0-9_]+\\)\\|[\"]\\([^\"]+\\)[\"]\\|[']\\([^']+\\)[']\\)" (#$ . 2572))
(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 #[nil "\300\301\302!\205 \303\304\301\305!\206 \301\306!\206 \301\307!!Q\207" ["^" match-string 2 "[ ]*" regexp-quote 4 5 6] 5 (#$ . 2936)])
(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 "\\|}\\|\\]\\)") (#$ . 3411))
#@28 Regexp to match operators.
(defconst ruby-operator-re "[-,.+*/%&|^~=<>:]\\|\\\\$" (#$ . 3596))
#@51 List of characters that symbol names may contain.
(defconst ruby-symbol-chars "a-zA-Z0-9_" (#$ . 3697))
#@26 Regexp to match symbols.
(defconst ruby-symbol-re (concat "[" ruby-symbol-chars "]") (#$ . 3807))
(defvar ruby-use-smie t)
#@27 Keymap used in Ruby mode.
(defvar ruby-mode-map (byte-code "\302 \204 \303\304\305#\210\303\306\307#\210\303\310\311#\210 \203# \303\312\313#\210\303\314\315#\210\303\316\317#\210\303\320\321#\210\303\322\323#\210)\207" [map 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] 4) (#$ . 3936))
#@16 Ruby Mode Menu
(defvar ruby-mode-menu nil (#$ . 4476))
(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 "\301 \302\303\304#\210\302\305\304#\210\302\306\304#\210\302\307\310#\210\302\311\312#\210\302\313\314#\210\302\315\316#\210\302\317\320#\210\302\321\316#\210\302\322\316#\210\302\323\324#\210\302\325\324#\210\302\326\324#\210\302\327\324#\210\302\330\324#\210\302\331\324#\210\302\332\324#\210\302\333\324#\210\302\334\324#\210\302\335\324#\210\302\336\324#\210\302\337\340#\210\302\341\342#\210\302\343\344#\210\302\345\346#\210\302\347\350#\210\302\351\352#\210)\207" [table 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 ")["] 4) (#$ . 5157))
(byte-code "\300\301\302\303\304\305\306\307\310\311& \210\300\312\313\314\304\315\306\307\310\316& \210\300\317\320\321\304\315\306\307\310\316& \207" [custom-declare-variable ruby-indent-tabs-mode nil "Indentation can insert tabs in Ruby mode if this is non-nil." :type boolean :group ruby :safe booleanp ruby-indent-level 2 "Indentation of Ruby statements." integer integerp ruby-comment-column (default-value 'comment-column) "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) (#$ . 6415))
(byte-code "\301\302\303\304\305\306\307\310\311\312\313\306\314\315\"BFF\316\317\320\321\322\323& \210\301\324\325\326\305\327\316\317\320\330\322\323& \210\301\331\332\333\305\327\316\317\320\330& \210\301\334\335\336\305\337\316\317&\210\301\340\341\342\305\343\316\317&\210\301\344\345\346\305\347\316\317&\210\301\350\332\351\305\327\316\317&\210\301\352\353\354\305\355\316\317\322\323& \210\301\356\357\360\305\361\316\317\322\323& \210\301\362\332\363\305\327\316\317&\210\364\365!\207" [ruby-alignable-keywords custom-declare-variable ruby-align-to-stmt-keywords '(def) "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 #[(kw) "\301D\207" [kw const] 2] :group ruby :safe listp :version "24.4" ruby-align-chained-calls nil "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 t "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 '(40 91 93 t) "Deep indent lists in parenthesis when non-nil.\nThe value t means continuous line.\nAlso ignores spaces after parenthesis when `space'.\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 'space "Default deep indent style.\nOnly has effect when `ruby-use-smie' is nil." (choice (const t) (const nil) (const space)) ruby-encoding-map '((us-ascii) (shift-jis . cp932) (shift_jis . cp932) (japanese-cp932 . cp932)) "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 "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 'ruby "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 "# encoding: %s" "A custom encoding comment template.\nIt is used when `ruby-encoding-magic-comment-style' is set to `custom'." string ruby-use-encoding-map "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 #[nil "\212\300\301x\210n\203 `S\206 `Sf\302=?\206 `Sf\303>)\207" [" " nil 92 (59 61)] 2])
(defalias 'ruby-smie--implicit-semi-p #[nil "\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])
(defalias 'ruby-smie--redundant-do-p #[(&optional skip) "\212\203 \301\302!\210\303\304\305!8\306\235)\207" [skip backward-word-strictly 1 2 smie-backward-sexp ";" ("while" "until" "for")] 3])
(defalias 'ruby-smie--opening-pipe-p #[nil "\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 #[nil "\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])
(defalias 'ruby-smie--args-separator-p #[(pos) "\301 W\205B hz\302=\204\" h\303>\205B `S\206 `Sfz\302=\205B \212b\210\304fz\302=\2035 \305\306!?\206A \307!@\310>\206A \305\311!)\207" [pos 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_\\)"] 2])
(defalias 'ruby-smie--before-method-name #[nil "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 #[nil "`\304\305w\210\306\307!\203 \306\310!\203 \311`\312\"b\210\313\202\370 \306\314!\2039 \315 \2039 l\2031 \312u\210\2025 \316\312!\210\313\202\370 \316d!\210`W\203R \212\317`b\210!)\203R \320\202\370 \306\310!\203\\ \321\202\370 \322 \323 \211\203j \324 P \325\235\203\203 \212\326\327!\210\330 )\203 \202\367 \331\202\367 \332 \305\333\334#)\266\203\203\261 \312 GZu\210\335\336 \203\244 \337\202\367 \340 \203\255 \341\202\367 \202\367 \321\232\203\306 \306\342!\203\306 \343\225b\210\344 \202\367 \345\232\203\354 \346\347!\204\326 \202\367 \212\316d!\210`)\350 V\203\350 \344 \202\367 \313\202\367 \351\232\203\366 \324\202\367 *)\207" [pos tok dot 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 "&."] 8])
(defalias 'ruby-smie--backward-token #[nil "`\304`[!\210\305 V\203 \306 \203 \307\310w\210\311\202\351 n\203- o\204- \312`\313\"b\210\311\202\351 `V\203A n\204A \314!\203A \315\202\351 \316 \317 \203O \320\nP\n\321\235\203b \322 \203^ \n\202\350 \323\202\350 \n\324\232\203~ \325 \203q \326\202\350 \327 \203z \330\202\350 \n\202\350 \331\n\310\332\333#)\266\203\203\230 \334u\210\n\334\310O\202\350 \n\335\232\203\264 `Sf\336=\203\264 \337\340!\203\264 \313u\210\341 \202\350 \n\342\232\203\335 \343 \204\303 \n\202\350 \212\344\334!\210\304d!\210`)\305 V\203\331 \341 \202\350 \311\202\350 \n\345\232\203\347 \320\202\350 \n*)\207" [pos dot tok 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 "&."] 7])
(defalias 'ruby-smie--indent-to-stmt #[nil "\212\300\301!\210\302\303 )B\207" [smie-backward-sexp ";" column smie-indent-virtual] 2])
(defalias 'ruby-smie--indent-to-stmt-p #[(keyword) "\302=\206 \303 !>\207" [ruby-align-to-stmt-keywords keyword t intern] 2])
(defalias 'ruby-smie-rules #[(kind token) " B\211:\205\272\n@\211\306=\2034 \nA\211 \307=\203
\2020 \f\310=\203/ \311\312!\2050 \313\2020 \314)\202\271 \315=\203[\nA\211 @\316\232\203a \317\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337\340&\205W\341
!\202W@\342\235\203\310 \340\232\203\215 \343\344\340\345\346\347\350\351\316&\204\215 \212\352\353!\210h)\354=\204\215 \355 \202W\356 \205W\357 @\360=\203\236 \314\202W\317\361!\203\303 \362 \204\276 \363\364\361!8\361\232\203\276 \362 \204\276 \353u\210\202\244 \365 \202W\341 \202W@\366\232\203\333 \212\367\314w\210\370i)B\202W@\322\232\203\347 \355 \202W@\361\232\203\371 \203\374 A\205W\313\202W\364\361!\210\370i
\\B\202W@\372\235\203\341 \202W@\335\232\203)\371 \203$\313\202W\341 \202W\373 !B>\203I\374 ?\205W\375 !\203C\355 \202W\370iB\202W@\376\232\203V\341
!\202W\314)\202\271 \377=\203\270\nA\211 C\201D \235\203\213\212\201E u\210\367\314w\210l\206\200\352\201E !?\205\207\370iB)\202\264C\201F \235\203\246\317\316\314\"\205\264\201G \205\264
\202\264C\201H \235\203\263
\202\264\314)\202\271\314))\207" [kind token #1=#:val #2=#:x #3=#:x ruby-indent-level :elem basic args looking-at "\\s\"" 0 nil :before ";" 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" :after #4=#:x ruby-align-chained-calls ruby-alignable-keywords #5=#:x ("{" "[" "(") 1 ("or" "and" "||=" "&&=" ">>=" "<<=" "|" "^=" "|=" "&=" "**=" "%=" "/=" "*=" "-=" "+=" ">>" "<<" "!=" "===" "==" "<=" ">=" "<" ">" "<=>" "&" "^" "**" "%" "||" "&&" "/" "*" "-" "+" "=") smie-indent--hanging-p (":" "?")] 19])
(defalias 'ruby--at-indentation-p #[(&optional point) "\212\204 `\301y\210\302\303w\210`)=\207" [point 0 " " nil] 2])
#@50 Create an imenu index of methods inside a block.
(defalias 'ruby-imenu-create-index-in-block #[(prefix beg end) "\306\211\211\211\211\211\211 b\210\307\310 \311#\203\320 \312\224\313\314!\315\225\313\316!\206/ \313\317!\315\224 \320\230\203N \203C \fP\f\nBB\202 \321\230\203\202 \203r \322\323\f\"\203m \315\324O\f\316\306OP\202q \fP\f\nBB\325 !\210\202 \f\326\230\203\226 \203\254 \315\324O\202\254 \203\244 \315\324O\327\fQ\f\nBB\325 !\210` \330\f\203\276 \331\202\277 \332P #\244 b\210\202 .\207" [sing decl pos next name case-fold-search nil re-search-forward "^\\s *\\(\\(class\\s +\\|\\(class\\s *<<\\s *\\)\\|module\\s +\\)\\([^(<\n ]+\\)\\|\\(def\\|alias\\)\\s +\\([^(\n ]+\\)\\)" t 3 match-string 5 0 4 6 "alias" "def" string-match "^self\\." -1 ruby-accurate-end-of-block "self" "::" ruby-imenu-create-index-in-block "." "#" index-alist beg end prefix] 7 (#$ . 17844)])
#@53 Create an imenu index of all methods in the buffer.
(defalias 'ruby-imenu-create-index #[nil "\300\301e\301#\237\207" [ruby-imenu-create-index-in-block nil] 4 (#$ . 18797)])
#@67 Jump to the end of the current block or END, whichever is closer.
(defalias 'ruby-accurate-end-of-block #[(&optional end) "\303\206 d\n\203 \214\304 \210`}\210\305 )\2025 \306\307 #\211\2055 \310 8\311Y\2055 `W\2055 \202 *\207" [end state ruby-use-smie nil back-to-indentation smie-forward-sexp apply ruby-parse-partial 2 0] 4 (#$ . 18977)])
#@54 Set up initial buffer-local variables for Ruby mode.
(defalias 'ruby-mode-variables #[nil "\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 (#$ . 19335)])
#@124 Insert a magic coding comment for ENCODING.
The style of the comment is controlled by `ruby-encoding-magic-comment-style'.
(defalias 'ruby--insert-coding-comment #[(encoding) "\304=\203\n \305\202 \306=\203 \307\202 \310=\203 \202 \311\312\n \"\313\261)\207" [ruby-encoding-magic-comment-style ruby-custom-encoding-magic-comment-template encoding-magic-comment-template encoding ruby "# coding: %s" emacs "# -*- coding: %s -*-" custom nil format "\n"] 3 (#$ . 20173)])
(defalias 'ruby--detect-encoding #[nil "\306=\203 \307\207 \206
\n\211\203 \310 \311\"\206 \312 \313\" \203@ \314\f\203;
\236\211 \2036 A\2027 )\202< !\202A \315)\207" [ruby-insert-encoding-magic-comment save-buffer-coding-system buffer-file-coding-system 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" elt] 4])
(defalias 'ruby--encoding-comment-required-p #[nil "\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 #[nil "\212~\210eb\210\302 \205R eb\210\303 \211\205Q \304\305!\203 \306\307!\210\304\310!\203< \311\307!\230\204J \307\224b\210`\307\225|\210c\210\202J \304\312!\204J \203J \313!\210\314 \205Q \315 ))\207" [coding-system 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 (#$ . 21281)])
(defvar ruby--electric-indent-chars '(46 41 125 93))
(defalias 'ruby--electric-indent-p #[(char) " >\203 \304`S!\207\305f >\203 \304`S!\207\306Y\203# \307X\204) \310>\205L `\212\311\305x\210\304 \205K \312\313\314 B!!\205K \315\225\n=\206K \315\225\nS=*\207" [char ruby--electric-indent-chars pt ruby-block-mid-keywords ruby--at-indentation-p nil 97 122 (95 63 33 58) "[:alpha:]:_?!" looking-at regexp-opt "end" 0] 4])
#@47 Return the indentation level of current line.
(defalias 'ruby-current-indentation #[nil "\212\300 \210\301 \210i)\207" [beginning-of-line back-to-indentation] 1 (#$ . 22354)])
#@51 Correct the indentation of the current Ruby line.
(defalias 'ruby-indent-line #[(&optional ignored) "\300\301 !\207" [ruby-indent-to ruby-calculate-indent] 2 (#$ . 22536) nil])
#@36 Indent the current line to COLUMN.
(defalias 'ruby-indent-to #[(column) "\205Y \304\211\211\305W\203 \306\307!\210i\310 \210`\311 \210i\312\304x\210 \nY\2031 \nZ\2023 \305n\203E \nU\203E \313 \\!\202X \313\n!\210 `|\210\310 \210j\210\313 \\!+\207" [column beg top shift nil 0 error "Invalid nesting" beginning-of-line back-to-indentation " " move-to-column] 3 (#$ . 22719)])
#@205 Return t if the character before POS is a special character.
If omitted, POS defaults to the current point.
Special characters are `?', `$', `:' when preceded by whitespace,
and `\' when preceded by `?'.
(defalias 'ruby-special-char-p #[(&optional pos) "\206 `\211\206 `SfeW\205 S\206 `Sf\211\303=\206D \n\304=\206D \n\305=\203; ?\206D z\306=\206D \n\307=\205D \303=*\207" [pos b c 63 36 58 32 92] 4 (#$ . 23118)])
(defalias 'ruby-verify-heredoc #[(&optional pos) "\212\203 b\210\302`S!@\303>?\2050 `Sf\304>?\2060 \305\306\307!\210\2060 `Sf\310=\2060 \311 !?)\207" [pos ruby-singleton-class-re syntax-after (2 3 6 10) (32 9) nil forward-word-strictly -1 95 looking-at] 3])
#@169 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'.
(defalias 'ruby-expr-beg #[(&optional option) "\212\306\307!\210\310\307x`n\203 \311\202\254 \312u\210\313\314!\2032 `\206! `Sfz\315=\204. \316 \2032 \307\202\254 \313\n!\206\254 \317=\203J \320W\205\254 \321!\202\254 \313\322!\206\254 \313\323!\203l \324=?\206\254 n\206\254 \212\312u\210\313\325!)\206\254 \313\f!\205\254
\307x\205\254 \313\326\327 #\330\"!\203\223 \320\225b\210\313\331!?\202\254 \332=\203\237 \313\333!\202\254 \334=\203\253 \313\335!\202\254 \307+\207" [start space ruby-operator-re option ruby-symbol-re ruby-symbol-chars 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_]* +/[^ ]" ruby-block-beg-keywords ruby-block-op-keywords ruby-block-mid-keywords] 6 (#$ . 23814)])
#@562 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.
(defalias 'ruby-forward-string #[(term &optional end no-error expand) "\306\307!\310\311\230\203 \312\202 \313\314Q \205 \315\316R \317\n
#\203U \320\224\2035 \321\322
\323$\202L `\206: `Sf =\203F \fS\202H \fT\211\324V\203U \325u\210\202 \f\324U\206g \203d \323\202g \326\327!+\207" [term expand re c n end 1 string-to-char "[^\\]\\(\\\\\\\\\\)*\\(" "^" "\\^" "[" "]" "\\|\\(#{\\)" "\\)" re-search-forward 3 ruby-forward-string "}{" nil 0 -1 error "Unterminated string" no-error] 6 (#$ . 24889)])
#@17 TODO: document.
(defalias 'ruby-deep-indent-paren-p #[(c) "<\203 \305 \"\211\203 \nA\206 \202 >\205 )\207 =\203( \207 \306=\205/ \f\207" [ruby-deep-indent-paren c deep ruby-deep-indent-paren-style ruby-deep-arglist assoc 40] 4 (#$ . 25969)])
#@42 TODO: document throughout function body.
(defalias 'ruby-parse-partial #[(&optional end in-string nest depth pcol indent) "\204 \306 \204\f \306\307\n \310#\203`\311\211\211 @ A\306\224b\210`Sf\312>\2037 \313\314!\2037 Ab\210\202~\313\315!\203V m\204M \316``T{ \317\211$\204~`B b\210\202~\313\320!\203q m\204h \307\321 \317#\204~`B b\210\202~\313\322!\203~ Ab\210\202~\313\323!\203\247 m\204\240 \324\325!\203\240 \316\323 \317\211$\204~`B b\210\202~Ab\210\202~\313\326!\203Tm\204M\324\327!\203M\313\330!\204M\313\331!\203M\332\224b\210`Sf\333>?\334\332!\211@\335\230\203\336 \336\202@\337\230\203\352 \340\202@\341\230\203\366 \342\202@\343\230\203\344\202\f\203@\345\230\203\345@P@
\203 \316
\317\f$\202A\f\203.\316@ \317\211$\202A\307@\345\230\203:\346\202>\347@P \317#\204~`B b\210\202~Ab\210\202~\313\350!\203s\324 \203l\313\351!\203l\306\225b\210\202~Ab\210\202~\313\352!\203\203Ab\210\332u\210\202~\313\353!\203\222\332y\210`b\210\202~\313\354!\203\355\355\311f!\211 C\203\330\311f\356=\203\256\324 \203\330C\357=\203\300\313\360!\203\300\306\225SA`fABDBDABEBE\306\202\345`fABDBDT)Ab\210\202~\313\361!\203\355\362\311f!!\203 E@AEAE\202\fSDADAb\210\202~\313F!\203bn\2047\363u\210`f\211@\364=\204[@\365=\204[Ab\210`f\211@\364=\204[@\366=\204[@\367=\204[DADSAb\210\202~\313\370!\203\211n\204v\363u\210`f\364=\204\202\311ABDBDT\306\225b\210\202~\313\371G\372Q!\203 \373 H\374\216\313\375!?\206\252\212\376 \210\313I!)?*\203n\204\306\363u\210`f\211@\364=\204@\365=\204Ab\203`f\366=\204\377\311w\203\306\224b\203\313J!\203\356\324\201P !\203Ab\203\311ABDB\211D\203TAb\210\202~\313\201Q !\203\"\332\224b\210\316\334\332! \317#\210\202~\313\201R !\2031\306\225b\210\202~\313\201S !\203@\306\225b\210\202~\313\201T !\204`\313\201U !\204`\313\201V !\204`\313\201W !\203g\306\225b\210\202~\313\201X !\203\211\307\201Y \317#\203\332y\210\202~\306\225B b\210\202~\313\201Z !\2035\324\201[ !\203.\313\201\\ !\203.\201] \334\201^ !\206\261\334\201_ !!\332\224\203\276\201`
P\306\225b K\201a LBDE \257 ML`V\203\355\201b \201c LM#\211M\204\325M@BMA@D\201_ M8\201d M8E\201^ M8\307\201e
\201f Q \310#\203#\332y\210\202*KB b\210+\202~Ab\210\202~\313\201g !\203DAb\210\202~\313N!\203r\201h \201O !\203r\307\201i O\317#\203g\332y\210\202~\306\225BOb\210\202~\201j \201k `A{\"\210,BDEF\207" [depth indent ruby-delimiter end expand re 0 re-search-forward move nil (64 36) looking-at "\\sw" "[\"`]" ruby-forward-string t "'" "[^\\]\\(\\\\\\\\\\)*'" "/=" "/" ruby-expr-beg expr-re "%" expr-qstr "%=" "%[QqrxWw]?\\([^a-zA-Z0-9 \n]\\)" 1 (113 119) match-string "[" "][" "{" "}{" "(" ")(" "<" "><" "\\" "\\\\[^\\]*\\\\" "[^\\]\\(\\\\\\\\\\)*" "\\?" "?\\(\\\\C-\\|\\\\M-\\)*\\\\?." "\\$" "#" "[\\[{(]" ruby-deep-indent-paren-p 123 space ".\\s +[^# \n]" "[])}]" matching-paren -1 95 46 33 63 "def\\s +[^(\n;]*" "\\_<\\(" "\\)\\_>" match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] "do\\_>" back-to-indentation " " w pnt in-string deep nest pcol ruby-block-end-re ruby-block-beg-re save-match-data-internal ruby-non-block-do-re ruby-modifier-re id-end line-end-position state ruby-here-doc-beg-re ruby-indent-point modifier ":\\(['\"]\\)" ":\\([-,.+*/%&|^~<>]=?\\|===?\\|<=>\\|![~=]?\\)" ":\\([a-zA-Z_][a-zA-Z_0-9]*[!?=]?\\)?" "\\.\\.\\.?" "\\.[0-9]+" "\\.[a-zA-Z_0-9]+" "\\." "^=begin" "^=end" "<<" heredoc "<<\\([-~]\\)?\\(\\([\"'`]\\)\\([^\n]+?\\)\\3\\|\\(?:\\sw\\|\\s_\\)+\\)" regexp-quote 4 2 "\\s *" point-at-eol apply ruby-parse-partial 3 "^" "$" "^__END__$" boundp ruby-here-doc-end-match error "Bad string %s"] 6 (#$ . 26231)])
#@17 TODO: document.
(defalias 'ruby-parse-region #[(start end) "\303\212 \203
b\210\202 \304 \210\214`\n}\210\n`V\203% \305\306\n#\211\204 *@A@@\3078\3108@@F)\207" [state start end nil ruby-beginning-of-indent apply ruby-parse-partial 2 3] 5 (#$ . 30053)])
#@69 Return the indentation level in spaces NEST levels deeper than POS.
(defalias 'ruby-indent-size #[(pos nest) " \206 \303\n_\\\207" [pos nest ruby-indent-level 1] 3 (#$ . 30323)])
#@58 Return the proper indentation level of the current line.
(defalias 'ruby-calculate-indent #[(&optional parse-start) "\212\306 \210`\307\211\211\211\211\310\311!\210\307f\205 \312\307f!\313 / 01\203. 1b\210\2024 \314 \210`1\315 \210i\31610\"\211@\203J \307\202p
A@@\203
A@A\211b\210\317
A@@!\211 2\203\316 2\320=\203
A@@ =\203 \321\311!\210iS\202\352 \316`0\" 3\32238\205\240 \32238\313V\205\240 3A@Ab\206\240 \320)\203\262 \323\324!\210\325i\322
8\"\202\352 i2\326=\204\352 \203\305 S\202\352 \325S\327\"\202\352 \330
8\203\334 \330
8b\210\202\343 1b\210\315 \210\325i\322
8\"
A@@ =\203\317\312 !!\203\331\332 !!\203i)\202p\322
8\203[\322
8\313V\203[
A@A\204\"\333\334!\210
A@Ab\210\323\324!\210`\335\336!\203S\330
8\203B\330
8b\210\202I1b\210\315 \210\325i\322
8\"\202pi4\\\202p\322
8\203p\322
8\313W\203p\325i\322
8\"\20330b\210\307\210`\306 \210\317 !\204\237\3375\f\320#\203\237\313\225f\340=\20434Z\2023\212\306 \210o)\2043\317\320!\204\265
A@@\2043\307\211 6 76\204\340\341\307x\210`7\306 \210\337\3427\320#\203\331\306 \210\202\273\320\2116\203\300*\307\210\343\307x\210\307` 8 7\306 \210\337\3448\320#\203 `S\2117\203 \3457!\204\31617\"\211\203
@\203 \3077\202\3617\206&8b\210\343\307x\2107\203;
@\203;8\202?
A@A\3161`\"*o\204N\324u\210\3359!\203z:\307x\203z\335\346;\347Q!\203z`\330
8=\204z\212\313\225b\210\335\350!)\203\367\335<!\2033\345 \2043\212\324u\210\335<!?\206\230`Sf\351=?)\2033`f =\316 \206\2471`\"@?\205\363`f\352=\203\350\212l\204\275\324u\210\331\353\307\320#\203\343\341\307x\210l?\205\344\324u\210\335\354!?\205\344\323\324!\210\335\336!?\202\344\320)\205\363=\355=?\205\363\320\211)\2033\n\204#\335\346;\347Q!\204#\317\320!\326=\203#o\204#~\210 \2061b\210\310\311!\210i\2022
A@@\203.\20224\\0b\210\306 \210\310\311!\210\335\356!\203K4\\\202L. \207" [indent paren op-end begin eol state beginning-of-line nil skip-syntax-forward " " matching-paren 0 ruby-beginning-of-indent back-to-indentation ruby-parse-region ruby-deep-indent-paren-p t skip-syntax-backward 2 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 "\\.[^.]\\|&\\." case-fold-search ruby-indent-point parse-start deep s ruby-indent-level ruby-negative done end pos ruby-symbol-re ruby-symbol-chars ruby-block-hanging-re ruby-operator-re c] 9 (#$ . 30510)])
#@129 Move backward to the beginning of the current defun.
With ARG, move backward multiple defuns. Negative ARG means
move forward.
(defalias 'ruby-beginning-of-defun #[(&optional arg) "\303\304\305 \306Q\303\307\n\206 \310$\205 \311 )\207" [case-fold-search ruby-defun-beg-re arg nil re-search-backward "^\\s *" "\\_>" t 1 beginning-of-line] 5 (#$ . 33119) "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 #[nil "\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 (#$ . 33489) "p"])
#@105 Backtrack to a line which can be used as a reference for
calculating indentation on the lines after it.
(defalias 'ruby-beginning-of-indent #[nil "\301\302\303#\205 \304\305!\204 \306 \205 \202 \207" [ruby-indent-beg-re re-search-backward nil move ruby-in-ppss-context-p anything beginning-of-line] 4 (#$ . 33837)])
#@132 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.
(defalias 'ruby-move-to-block #[(n) "\306 \210\307V\203
\310\202 \311\307W\312\313`\314 \"8\206 \307\315\211\211 \316 !\2032 \f \\\f _\307W\203= \307\317!\307 ! !W\203\315\212\306 \210\320
\203] \"\202b \321#\322Q\314 \323#\205n \324\325 8?) \204
\203| o\202} m\204 y\210\316\326!\204p \316\327!\204p
\204\241 \316\330!\203\241 \320\331!\210\202p
\203\262 \316\331!\203\262 \332\330!\210\202p \333\334!\203\317 \324\325 8b\210
\204p \335 \210n\203p \311u\210\202p \313`\314 \"\211 $@\204\342 \312$8\f\\) \f_\307V\203\361 \323\202p \n\203\f\307U\203\323\211\202q \f_\307W\203p \323\211\203t T\211 \202G *\306 .\207" [n done down case-fold-search depth backward 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 signum ruby-block-mid-re _ --dotimes-limit-- ruby-block-end-re ruby-block-beg-re state] 7 (#$ . 34165)])
#@89 Move backward to the beginning of the current block.
With ARG, move up multiple blocks.
(defalias 'ruby-beginning-of-block #[(&optional arg) "\301\206 \302[!\207" [arg ruby-move-to-block 1] 2 (#$ . 35361) "p"])
#@86 Move forward to the end of the current block.
With ARG, move out of multiple blocks.
(defalias 'ruby-end-of-block #[(&optional arg) "\301\206 \302!\207" [arg ruby-move-to-block 1] 2 (#$ . 35580) "p"])
#@116 Move forward across one balanced expression (sexp).
With ARG, do it many times. Negative ARG means move backward.
(defalias 'ruby-forward-sexp #[(&optional arg) "\203 \306 !\207 \247\203 \307W\203 \310 [!\207 \206 \311\3121\345 \n\307V\205\341 \313\314!\210\315\316!\2036 \307\225b\210\315\317!\203C \307\225b\210\202\332 \320\321w\210\315\322!\203V \323`\311\"b\210\202\332 \315\324 \325Q!\203\201 `\206d `Sf\326=\204\201 `\206p `Sf\327=\204\201 \330 \210\331\311!\210\202\332 \315\332!\203\261 \331\311!\210\315\333!\204\207 \315\334!\203\235 \335u\210\202\207 \336\321w\307V\204\207 \315\337!\203\332 \311u\210\202\332 \321\211 \f\206\301 \340 \206\301 \315\341!\342\343\321
#\211A@\203\327 \344\345\321w\210\202\265 \f\210*\nS\211\202# 0\202\351 \210\331\311!\210\n)\207" [ruby-use-smie arg i ruby-block-beg-re expr state 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 "<"] 5 (#$ . 35790) "p"])
#@116 Move backward across one balanced expression (sexp).
With ARG, do it many times. Negative ARG means move forward.
(defalias 'ruby-backward-sexp #[(&optional arg) "\203 \306 !\207 \247\203 \307W\203 \310 [!\207 \206 \311\3121\n\307V\205\313\314x\210\315u\210\316\317!\203f \320`T\315\"b\210`Sf\211\321=\203L \315u\210\202b \322>\203b `S\206X `Sf\321=\203b \323u\210)\202\374 \316\324!\203\214 \325\307\225\206s `Sf! \326\f!\203\210 \327\330\314x\311\"\311=\204w )\202\374 \316\331!\203\235 \332 \203\374 \315u\210\202\374 \316\333!\204\374 \311u\210\334\315!\210`Sf\211 \335=\203\270 \336\202\356
\337=\203\305 \315u\210\336\202\356
\340>\203\334 \315u\210`Sf\314f=\205\356 \315u\202\356
\341=\203\355 \315u\210`Sf\342=\202\356 \314)\204\246 \316$!\203\374 \343 \210\nS\211\202# 0\202 \210\202\f\210\n)\207" [ruby-use-smie arg i #1=#:val c #2=#:val 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 ruby-block-end-re] 4 (#$ . 37022) "p"])
#@66 Indent each line in the balanced expression following the point.
(defalias 'ruby-indent-exp #[(&optional ignored) "\305 \306\211\211\307 \310\f\307\"\210\311\216\312 \210`\313 m?\205J \314 !\211\nV\203/ \307\211\202< \nU\205J \205J \306\307\205J \315 !\210\312\316!\210\202 .\207" [nest column top start here point-marker nil t set-marker-insertion-type #[nil "b\210\301\211\223\207" [here nil] 3] beginning-of-line current-indentation ruby-calculate-indent ruby-indent-to 2] 6 (#$ . 38245) "*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 #[nil "\212\306\307\211`\310\211
! \f\311! \312 \307\313#\203A \314\224b\210\315\314!\316\230\2042 \315\317!C\202< \320 !\203< \315\317!i\321 \210\306V\203h \312 \307\313#\203h \314\224b\210iW\203A \315\317!\nBi\321 \210\202A \203\352 \322 \323\"\211 A\203\312 @\324\230\204\277 \n\237 \203\251 @ @\230\203\232 A\237\307 A\211 \204\203 \n\237\210\202\203 )\n\203\272 \325\n!\326 !\241\210\202\277 \326 !\327\325 !@P\202\351 \330! \313#\205\332 \306\224b\210\320 !\211 \"\203\344 \327\202\345 \331 P))\n:\203\365 \332\333\n\334# \203\n\203\n P\202 \202\n.\207" [indent mname mlist start make-definition-re ruby-defun-beg-re 0 nil #[(re) "\302\303\304\305 \306\307\310\260 \207" [re ruby-symbol-re "^[ ]*" "[ ]+" "\\(" "\\([A-Za-z_]" "*\\|\\.\\|::" "\\)" "+\\)"] 9] "\\(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 "::" definition-re module-re mn ml ruby-singleton-class-re in-singleton-class] 5 (#$ . 38765)])
(defalias 'ruby-block-contains-point #[(pt) "\212\302 \303\216\304 \210` V+\207" [save-match-data-internal pt match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] ruby-forward-sexp] 2])
(defalias 'ruby-brace-to-do-end #[(orig end) "\304\211\nb\210`Sf\305=\205w \306\307!\210\212\310\304x\210n)\204 \311c\210\312c\210\313 m\2045 \304fz\314=\2035 \315c\210 b\210\306\316!\210`Sfz\314=\203H \315c\210\317c\210\313 \320\321!\203e \316\224\204\\ \315c\210\322\225Tb\210\323\324!\210\320\325!\204n \311c\210\326 \"\210 b\210\327*\207" [end-marker beg-marker end orig nil 125 delete-char -1 " " "\n" "end" point-marker 119 " " 1 "do" looking-at "\\(\\s \\)*|" 0 search-forward "|" "\\s *$" indent-region t] 3])
(defalias 'ruby-do-end-to-brace #[(orig end) "\306\211\211\211\f\307Zb\210\310
!\205\202 \311\307!\210\312 \313c\210b\210\311\314!\210\315c\210\312 \310\316!\203E \311\317\320\225\320\224\321#!\210\306u\210\322\323\324 \325#\210\212\326\306w\210`\nb\210\326\306x\210`) W\204s \327 !\327!U\203~ \330i Z\314# W\203~ \331\332!\210\nb\210\331\332!\210 b\210\325,\207" [end-pos beg-pos end-marker beg-marker end ruby-block-end-re nil 3 looking-at delete-char point-marker "}" 2 "{ " "\\s +|" - 0 1 re-search-forward "|" line-end-position t " \n
" line-number-at-pos + just-one-space -1 orig fill-column] 5])
#@188 Toggle block type from do-end to braces or back.
The block must begin on the current line or above it and end after the point.
If the result is do-end block, it will always be multiline.
(defalias 'ruby-toggle-block #[nil "`\304\211\304\210\305\306!\205; \307\224\206 \310\224b\210`\311 \312\216\313 \210*`\211\nV\205; \307\224\2037 \314 \"\202; \315 \"?\205A \nb+\207" [end beg start save-match-data-internal nil re-search-backward "\\(?:[^#]\\)\\({\\)\\|\\(\\_<do\\_>\\)" 1 2 match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] ruby-forward-sexp ruby-brace-to-do-end ruby-do-end-to-brace] 4 (#$ . 41480) nil])
#@36 Return region for string at point.
(defalias 'ruby--string-region #[nil "\301 \3028\303>\205 \212\3048b\210\305 \210\3048`)D)\207" [state syntax-ppss 3 (39 34) 8 forward-sexp] 2 (#$ . 42146)])
#@40 Check if cursor is at a string or not.
(defalias 'ruby-string-at-point-p #[nil "\300 \207" [ruby--string-region] 1 (#$ . 42350)])
#@50 Get the inverse string quoting for STRING-QUOTE.
(defalias 'ruby--inverse-string-quote #[(string-quote) "\301\232\203 \302\207\301\207" [string-quote "\"" "'"] 2 (#$ . 42486)])
#@58 Toggle string literal quoting between single and double.
(defalias 'ruby-toggle-string-quotes #[nil "\306 \205L \307 \211@A@\310\311 \211T\"!\311 T\nS\" \312\232\2030 \313\314\312\313\315\316\f##\2029 \313\317\320\313\321\322\f##` \n|\210\323\324 \f $c\210
b.\207" [region min max string-quote content orig-point 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"] 8 (#$ . 42671) nil])
#@51 Regexp to match the beginning of percent literal.
(defconst ruby-percent-literal-beg-re "\\(%\\)[qQrswWxIi]?\\([[:punct:]]\\)" (#$ . 43247))
#@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") (#$ . 43395))
#@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) (#$ . 43684))
#@70 Syntactic keywords for Ruby mode. See `syntax-propertize-function'.
(defalias 'ruby-syntax-propertize #[(start end) "\306 b\210\307 \n\310#\210\311\n!\210\312\n!\210`\n\211b\210`\nW\205L\313\314\n\315#\205L\316\224\203` \316\224\316\225\212\317\320\321\224!8)\203D \306\316\225b\210\202N \322\316\225\321\225\323\324$\210\325 \203\\ \322
\f\323 $\210+\202 \326\224\203\235 \327\330!\211 7A\3267\233\241\210\3317!\210)\317\224\317\225\332\320\317\224!8?\205\213 \321\225b\210\324 \203\231 \322
\f\323 $\210+\202 \333\224\203\352 \327\330!\211 7A\3347\233\241\210\3317!\210)\321\224\321\225\212\332\320\321\224!8\206\322 \306 8\335\336!\321U)\206\322 h\337>)?\205\330 \324 \203\346 \322
\f\323 $\210+\202 \340\224\203\373 \322\340\224\340\225\323\324$\210\202 \332\224\203*\327\330!\211 7A\3417\233\241\210\3317!\210)\316\224\316\225\342 \203&\322
\f\323 $\210+\202 \343\224\203\200\327\330!\211 7A\3447\233\241\210\3317!\210)\316\224\316\225\212\320\316\224!) 9\33298\204c\212\345u\210\346:\347 \")\204l\31798\350=\205m\351) \203|\322
\f\323 $\210+\202 \352\224\203\236\327\330!\211 7A\3537\233\241\210\3317!\210)\354 \210\202 \355\224\203\257\322\355\224\355\225\323\356$\210\202 \344\224\203\300\322\344\224\344\225\323\356$\210\202 \357\224\203
\327\330!\211 7A\3607\233\241\210\3317!\210)\340\224\340\225\332\212\320\321\224!)8?\205\373\361\321\224!\205\373\322\340\224\340\225\323\362$\210\311\n! \203 \322
\f\323 $\210+\202 \363\224\203 \327\330!\211 7A\3647\233\241\210\3317!\210)\316\224\316\225\332\212\320\316\224!)8?\205:\365\n!\210\366 \203H\322
\f\323 $\210+\202 +\207" [case-fold-search start end syntax me mb 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) md parse-sexp-lookup-properties state ruby-syntax-before-regexp-re] 8 (#$ . 44080)])
(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)
(defalias 'ruby-syntax-propertize-heredoc #[(limit) "\304 \305\306 8\307=\205_ \212\310 8b\210\311 \210\312\n\313 \314#\2030 \315\316\224!\203 \317 \320PB\202 )\212A\203? \310 8b\210\237\205^ \312\211A\242 \321#\205^ \204? \322`S`\323\324$\210\202? )*\207" [res ppss ruby-here-doc-beg-re limit 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)] 5])
(defalias 'ruby-syntax-enclosing-percent-literal #[(limit) "\304 `\305 8\306=\205$ \307 8b\210\310\n!\203 \311 !\210`W\205$ b*\207" [start state ruby-percent-literal-beg-re limit syntax-ppss 3 t 8 looking-at ruby-syntax-propertize-percent-literal] 2])
(defalias 'ruby-syntax-propertize-percent-literal #[(limit) "\306\224b\210\307f\310!\311 HA\206 \312\313\"A\307\212\3141j \n\203T \311 p \315\216\316\317\311\307\"!\210\320\321\310\n!P\"\210\320\n\322 P\"\210\320\323\324\"\210\214`}\210\325 \210,\202_ \326\327\330 !P\307#\210\331`S`\311\332$0\202l \210\307-\207" [op ops cl parse-sexp-lookup-properties #1=#:buffer #2=#:table 2 nil char-to-string syntax-table assoc ((60 . 62)) (scan-error search-failed) #[nil "rq\210\302 !)\207" [#1# #2# set-syntax-table] 2] set-syntax-table make-char-table modify-syntax-entry "(" ")" 92 "\\" forward-list re-search-forward "[^\\]\\(?:\\\\\\\\\\)*" regexp-quote put-text-property (15) limit] 5])
(defalias 'ruby-syntax-propertize-expansion #[nil "\303\224\303\225\205 \212\304!)\305\n!\2056 \306\211T\307\310 $\210b\210\311\312 \313#\2056 \306\314\224\314\225\315\316$\210\202\" +\207" [beg end state 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)] 5])
#@52 Return non-nil if expression expansion is allowed.
(defalias 'ruby-syntax-expansion-allowed-p #[(parse-state) "\3038\211\304>\206 \305=\205 \306 \307\216\212\3108b\210\311\312!+)\207" [parse-state term save-match-data-internal 3 (34 96 10 47) t match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] 8 looking-at "%\\(?:[QWrxI]\\|\\W\\)"] 3 (#$ . 48878)])
(defalias 'ruby-syntax-propertize-expansions #[(start end) "\212b\210\303 \n\304#\205 \305 \210\202 )\207" [start ruby-expression-expansion-re end re-search-forward move ruby-syntax-propertize-expansion] 4])
(defalias 'ruby-in-ppss-context-p #[(context &optional ppss) "\206 \302`! \303=\203 \3048\204Z \3058\202W \306=\203& \3048\202W \307=\2034 \3048\310=\202W \311=\203G \312\303!\205[ \312\307!?\202W \313=\203S \3058\202W \314\315 \"\205[ \316)\207" [ppss context syntax-ppss anything 3 4 string heredoc 10 non-heredoc ruby-in-ppss-context-p comment error "Internal error on `ruby-in-ppss-context-p': context name `%s' is unknown" t] 3])
#@89 The syntax table to use for fontifying Ruby mode buffers.
See `font-lock-syntax-table'.
(defvar ruby-font-lock-syntax-table (byte-code "\302!\303\304\305 #\210 )\207" [ruby-mode-syntax-table tbl copy-syntax-table modify-syntax-entry 95 "w"] 4) (#$ . 49941))
(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) (#$ . 50279))
(defalias 'ruby-match-expression-expansion #[(limit) "\304\305`\306 $\306\n\205, \n`V\205, \nb\210\307\n\"\211\203) \310 !\210\311\202, \312 !+\207" [prop limit pos value ruby-expansion-match-data next-single-char-property-change nil get-text-property set-match-data t ruby-match-expression-expansion] 5])
#@161 Hook run after entering Ruby mode.
No problems result if this variable is not bound.
`add-hook' automatically binds it. (This is true for all hook variables.)
(defvar ruby-mode-hook nil (#$ . 54330))
(byte-code "\300\301!\204\f \302\301\303\304#\210\300\207" [boundp ruby-mode-map put definition-name ruby-mode] 4)
(defvar ruby-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204 \302\300\301\303\304!#\210\305\306!\204 \302\306\307\310#\210\300\207" [ruby-mode-map variable-documentation put purecopy "Keymap for `ruby-mode'." boundp ruby-mode-syntax-table definition-name ruby-mode] 5)
(defvar ruby-mode-syntax-table (make-syntax-table))
(byte-code "\300\301N\204 \302\300\301\303\304!#\210\302\305\306\307#\207" [ruby-mode-syntax-table variable-documentation put purecopy "Syntax table for `ruby-mode'." ruby-mode-abbrev-table definition-name ruby-mode] 5)
(defvar ruby-mode-abbrev-table (progn (define-abbrev-table 'ruby-mode-abbrev-table nil) ruby-mode-abbrev-table))
(byte-code "\300\301N\204 \302\300\301\303\304!#\210\302\305\306\307#\207" [ruby-mode-abbrev-table variable-documentation put purecopy "Abbrev table for `ruby-mode'." ruby-mode derived-mode-parent prog-mode] 5)
#@206 Major mode for editing Ruby code.
\{ruby-mode-map}
In addition to any hooks its parent mode `prog-mode' might have run,
this mode runs the hook `ruby-mode-hook', as the final step
during initialization.
(defalias 'ruby-mode #[nil "\306\300!\210\307\310 \210\311\312\310\313N\203 \314\311\313\310\313N#\210\315 !\204' \316 \317 \"\210\320\f!\211 \2036
\321 =\203< \322\f\323 \"\210)\3241\325\"\204V 12=\204V \3261\3252C#\210\327 !\210\330\f!\21012\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\306\351!\210\352)\306\353!\2103+\306\354!\2104,\306\355!\210\356-)\357\360!\207" [delay-mode-hooks major-mode mode-name ruby-mode-map ruby-mode-syntax-table parent make-local-variable t prog-mode ruby-mode "Ruby" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table ruby-mode-variables imenu-create-index-function ruby-imenu-create-index add-log-current-defun-function ruby-add-log-current-method beginning-of-defun-function ruby-beginning-of-defun end-of-defun-function ruby-end-of-defun add-hook after-save-hook ruby-mode-set-encoding nil local electric-indent-functions ruby--electric-indent-p 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 ruby-mode-abbrev-table local-abbrev-table ruby-font-lock-keywords ruby-font-lock-syntax-table] 6 (#$ . 55531) nil])
(byte-code "\302\303\304\305!\306B\"\210\307\310\311\312\313\257\314\211\203* @\302\315\304!\306B\"\210 A\211\204 *\316\306!\207" [name --dolist-tail-- add-to-list auto-mode-alist purecopy "\\(?:\\.\\(?: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" nil interpreter-mode-alist provide] 6)
Kontol Shell Bypass