;ELC ;;; Compiled ;;; in Emacs version 25.3.1 ;;; with all optimizations. ;;; This file uses dynamic docstrings, first added in Emacs 19.29. ;;; This file does not contain utf-8 non-ASCII characters, ;;; and so can be loaded in Emacs versions earlier than 23. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (require 'smartparens) #@59 Wrapper for `ruby-forward-sexp' based on `enh-ruby-mode'. (defalias 'sp-ruby-forward-sexp #[nil "\300\301!\203 \301 \207\302 \207" [boundp enh-ruby-forward-sexp ruby-forward-sexp] 2 (#$ . 433) nil]) #@60 Wrapper for `ruby-backward-sexp' based on `enh-ruby-mode'. (defalias 'sp-ruby-backward-sexp #[nil "\300\301!\203 \301 \207\302 \207" [boundp enh-ruby-backward-sexp ruby-backward-sexp] 2 (#$ . 639) nil]) #@49 Turn whitespace around point to just one space. (defalias 'sp-ruby-maybe-one-space #[nil "\301\302!\203\f\303u\210\202\302\304\305!)\262\204<\306\304\305!)\262\204<\301\307!\204<\310\304\305!)\262\203A\301\311!\203A\212\312 \210)\301\313!?\205\200\212\314u\210\315\304\305!)\262\206y\316\304\305!)\262\206y\317\304\305!)\262\206y\320\304\305!)\262)\205\200\321\322!\207" [inhibit-changing-match-data looking-back " " -1 t looking-at "}" "{" "\\sw" ":" just-one-space "^.?" -2 ".[^:] [.([,;]" ".. ::" ".[.@$] " ":: " delete-char 1] 3 (#$ . 849)]) #@75 Better way of joining ruby lines. ARG is how many indentation to delete. (defalias 'sp-ruby-delete-indentation #[(&optional arg) "\301!\210\302 \207" [arg delete-indentation sp-ruby-maybe-one-space] 2 (#$ . 1435)]) #@62 Handler for ruby block-like insertions. ID, ACTION, CONTEXT. (defalias 'sp-ruby-block-post-handler #[(id action context) "\303\232\203\212\304 \210\305 \210)\305 \210\306 \n#\207" [action id context insert newline indent-according-to-mode sp-ruby-post-handler] 4 (#$ . 1658)]) #@60 Handler for ruby def-like insertions. ID, ACTION, CONTEXT. (defalias 'sp-ruby-def-post-handler #[(id action context) "\303\232\203\212\304c\210\305 \210\306 \210)\307\310!\210\311 \n#\207" [action id context insert "x" newline indent-according-to-mode delete-char 1 sp-ruby-post-handler] 4 (#$ . 1945)]) #@41 Ruby post handler. ID, ACTION, CONTEXT. (defalias 'sp-ruby-post-handler #[(id action context) "\306 \307\"\306 \310\"\f\311\232\203%\312\313!\210\314 \210\212\315 \210\315\n!\210\316 \210)\f\317\232\205_ \320\306 \321\"\306 \322\"G\\!\320\306 \323\"\306 \324\"GZ!\325\n!\210\316 \210\320 U\204\\\312\326!\210\314 ++\207" [sp-handler-context #1=#:input0 arg enc action #2=#:struct plist-get :arg :enc barf-backward sp-ruby-delete-indentation 1 indent-according-to-mode sp-backward-sexp sp-ruby-maybe-one-space barf-forward line-number-at-pos :beg :op :end :cl sp-forward-sexp -1 end-line beg-line] 6 (#$ . 2259)]) #@55 Handler for ruby slurp and barf. ID, ACTION, CONTEXT. (defalias 'sp-ruby-pre-handler #[(id action context) "\306\307\"\211\310\306\n\311\"\306\n\312\"G\\!\310\306\n\313\"\306\n\314\"GZ! \315\232\203\257\212\316 \210\317\320.\321!)\262\203;\322u\210\323 \210\310 U\204I\324\325!\210)\326\320.\321!)\262\203|\327\330!\203|\331\320!\211/\205x/0\3060\311\"\3060\332\"GZb))\204W\333\334!\203\210\335 \210\202|\327\336!\203\232\325u\210\327\337!\203\232\325u\210\340 \210\212\310 U\203\253\341c\210\202\256\342 \210) \343\232\203\331\333\344!\203\301\316 \210\202\265\345\320.\321!)\262\203\324\342 \210\202\331\212\342 \210) \346\232\203>\212\335 \210\327\347!\203\354\325u\210\323 \210\310 \fU\204\n\333\334!\203\350\325!\210\324\325!\210\202\n\324 \210)\326\320.\321!)\262\203\351 \210\202 \352\320.\321!)\262\203.\322u\210\310 \fU\203;\341c\210\202>\342 \210 \353\232\205\232\327\354!\203M\325u\210\326\320.\321!)\262\203\327\330!\203\331\320!\211/\205{/1\3061\311\"\3061\332\"GZb))\204Z\310 U\203\213\341c\202\232\327\355!\203\230\212\342 )\202\232\342 ,\207" [sp-handler-context enc #1=#:struct end-line beg-line action plist-get :enc line-number-at-pos :beg :op :end :cl slurp-backward sp-forward-sexp ";" t looking-at nil sp-ruby-maybe-one-space sp-ruby-delete-indentation -1 "::" looking-back "\\sw" sp-get-symbol :prefix thing-at-point-looking-at "\\.[[:blank:]\n]*" sp-backward-sexp "[@$:&?!]" "[@&:]" just-one-space " " newline barf-backward "[(.:[][\n[:blank:]]*" " *$" slurp-forward "." forward-symbol sp-forward-symbol "[?!;]" barf-forward "\\." "^[[:blank:]]*" inhibit-changing-match-data it #2=#:struct #3=#:struct] 7 (#$ . 2892)]) #@23 Test if ID is inline. (defalias 'sp-ruby-inline-p #[(id) "\212\302!\203\n\303v\210\302\304!\206\302\305!?\205L\212\306\303!\210\306\307!\210\310P\311\312!)\262)\206L\212\3131I\314 \210\315 \210\316P\311\312!)\2620\202K\210\317))\207" [id inhibit-changing-match-data looking-back -1 "^[[:blank:]]*" "= *" forward-symbol 1 " *" t looking-at (error) sp-ruby-backward-sexp sp-ruby-forward-sexp "[^[:blank:]]* *" nil] 3 (#$ . 4619)]) #@25 Test if ID is a method. (defalias 'sp-ruby-method-p #[(id) "\212\302!\203\n\303v\210\304\305!)\262\205?\306P\304\305!)\262\206?\302\307!\206?\302\310!\206?\302\311!\205?\212\312\313!\210\314 )?)\207" [id inhibit-changing-match-data looking-back -1 t looking-at "[_?!:]" "[_:@$.]" "def \\|class \\|module " "\\.[[:blank:]\n]*" search-backward "." sp-point-in-comment] 3 (#$ . 5070)]) #@44 If non-nil, skip inline match. MS, MB, ME. (defalias 'sp-ruby-skip-inline-match-p #[(ms mb me) "\301!\206 \302!\207" [ms sp-ruby-method-p sp-ruby-inline-p] 2 (#$ . 5474)]) #@38 If non-nil, skip method. MS, MB, ME. (defalias 'sp-ruby-skip-method-p #[(ms mb me) "\301!\207" [ms sp-ruby-method-p] 2 (#$ . 5655)]) #@62 Test if point is inside string or word. ID, ACTION, CONTEXT. (defalias 'sp-ruby-in-string-or-word-p #[(id action context) "\303 \n#\206\304!\203\304\305!!?\206\306!\207" [id action context sp-in-string-p looking-back sp--strict-regexp-quote sp-ruby-method-p] 4 (#$ . 5795)]) #@70 Test if point is inside string, word or inline. ID, ACTION, CONTEXT. (defalias 'sp-ruby-in-string-word-or-inline-p #[(id action context) "\303 \n#\206\304!\205\305!\207" [id action context sp-ruby-in-string-or-word-p looking-back sp-ruby-inline-p] 4 (#$ . 6086)]) #@41 Ruby pipe handler. ID, ACTION, CONTEXT. (defalias 'sp-ruby-pre-pipe-handler #[(id action context) "\302\232\205\212\303 \210)\212\304 !\210\303 )\207" [action id insert just-one-space search-backward] 2 (#$ . 6363)]) #@93 Test whether to insert the closing pipe for a lambda-binding pipe pair. ID, ACTION, CONTEXT (defalias 'sp-ruby-should-insert-pipe-close #[(id action context) "\302=\203\303\304\305\306\307 F!!\207\310\207" [action id insert thing-at-point-looking-at rx-to-string and (or "do" "{") (* space) t] 6 (#$ . 6589)]) #@30 Ruby skip match. MS, ME, MB. (defalias 'sp--ruby-skip-match #[(ms me mb) "\303\230\205\304 \n#\206\305\303!\207" [ms me mb "end" sp-in-string-p sp-ruby-method-p] 4 (#$ . 6908)]) (byte-code "\303\304\305\"\210\306\307\211\203 @\303\310\311B\"\210 A\211\204 *\312\313\n\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333&\210\313\n\334\335\324\336\326\337\332\333& \210\313\n\340\315\316\341\320\342\322\343\324\344\326\345\330\331\332\333&\210\313\n\346\315\316\347\320\350\322\351\324\352\326\353\330\331\332\333&\210\313\n\354\315\316\355\320\356\322\357\324\360\326\361\330\331\332\333&\210\313\n\362\315\316\363\320\364\322\365\324\366\326\367\330\331\332\333&\210\313\n\370\315\316\371\320\372\322\373\324\374\326\375\330\331\332\333&\210\313\n\376\315\316\377\320\201@\322\201A\324\201B\326\201C\330\201D&\210\313\n\201E\315\316\201F\320\201G\322\201H\324\201I\326\201J\330\201D\332\333&\210\313\n\201K\315\316\201L\320\201M\322\201N\324\201O\326\201P\330\201D\332\333&\210\313\n\201Q\315\316\201R\320\201S\322\201T\324\201U\326\201V\330\201D\332\333&\210\313\n\201W\315\316\201X\320\201Y\322\201Z\324\201[\326\201\\\330\201D\332\333&\210\313\n\201]\211\316\201^\324\201_\332\333& \210)\201`\201a!\207" [mode --dolist-tail-- #:modes add-to-list sp-navigate-skip-match ((ruby-mode enh-ruby-mode motion-mode) . sp--ruby-skip-match) (ruby-mode motion-mode) nil sp-sexp-suffix (syntax #1="") (ruby-mode enh-ruby-mode motion-mode) sp-local-pair "do" "end" :when (("SPC" "RET" "")) :unless (sp-ruby-in-string-or-word-p sp-in-comment-p) :actions (insert navigate) :pre-handlers (sp-ruby-pre-handler) :post-handlers (sp-ruby-block-post-handler) :skip-match sp-ruby-skip-method-p :suffix #1# "{" "}" (sp-ruby-pre-handler) (sp-ruby-post-handler) "begin" (("SPC" "RET" "")) (sp-ruby-in-string-or-word-p sp-in-comment-p) (insert navigate) (sp-ruby-pre-handler) (sp-ruby-block-post-handler) "def" (("SPC" "RET" "")) (sp-ruby-in-string-or-word-p sp-in-comment-p) (insert navigate) (sp-ruby-pre-handler) (sp-ruby-def-post-handler) "class" (("SPC" "RET" "")) (sp-ruby-in-string-or-word-p sp-in-comment-p) (insert navigate) (sp-ruby-pre-handler) (sp-ruby-def-post-handler) "module" (("SPC" "RET" "")) (sp-ruby-in-string-or-word-p sp-in-comment-p) (insert navigate) (sp-ruby-pre-handler) (sp-ruby-def-post-handler) "case" (("SPC" "RET" "")) (sp-ruby-in-string-or-word-p sp-in-comment-p) (insert navigate) (sp-ruby-pre-handler) (sp-ruby-def-post-handler) "for" (("SPC" "RET" "")) (sp-ruby-in-string-or-word-p sp-in-comment-p) (insert navigate) (sp-ruby-pre-handler) (sp-ruby-def-post-handler) sp-ruby-skip-inline-match-p "if" (("SPC" "RET" "")) (sp-ruby-in-string-word-or-inline-p sp-in-comment-p) (insert navigate) (sp-ruby-pre-handler) (sp-ruby-def-post-handler) "unless" (("SPC" "RET" "")) (sp-ruby-in-string-word-or-inline-p sp-in-comment-p) (insert navigate) (sp-ruby-pre-handler) (sp-ruby-def-post-handler) "while" (("SPC" "RET" "")) (sp-ruby-in-string-word-or-inline-p sp-in-comment-p) (insert navigate) (sp-ruby-pre-handler) (sp-ruby-def-post-handler) "until" (("SPC" "RET" "")) (sp-ruby-in-string-word-or-inline-p sp-in-comment-p) (insert navigate) (sp-ruby-pre-handler) (sp-ruby-def-post-handler) "|" (sp-ruby-should-insert-pipe-close) (sp-ruby-pre-pipe-handler) provide smartparens-ruby] 19)