Emacs, माणिक: परिवर्तित घुंघराले ब्रेसिज़ के अंत ब्लॉक करना और इसके विपरीत

Question

मैं अक्सर अपने आप को इस तरह कोड में परिवर्तित करने लगता है:

before do 
    :something 
end 

before { :something } 

को वहाँ में इस कार्य को स्वचालित करने के लिए एक रास्ता है Emacs? मैं रूबी-मोड और राइनरी का उपयोग करता हूं, लेकिन वे यहां बहुत उपयोगी नहीं हैं।

Answer 1

ruby-mode Emacs 24.3 में और नए के पास ruby-toggle-block कमांड है।

डिफ़ॉल्ट बाध्यकारी C-c { है।

Answer 2

आप नियमित अभिव्यक्ति का उपयोग कर सकते हैं जो न्यूलाइन को पार करता है।

/करते हैं (सी-क्यू सी जे \?) * (। *) (सी-क्यू सी जे \?) * अंत/

और की जगह

{\2 } 

कुछ उस तरह के साथ काम कर सकता है। इसके बाद आप इसे तब तक कस्टमाइज़ कर सकते हैं जब तक कि आपको इसकी आवश्यकता नहीं होती है और इसे मैक्रो से बांधें ताकि आप इसे चाबुक कर सकें और कभी भी अपने दोस्तों को प्रभावित कर सकें!

मैंने उपरोक्त regexes vi (पसंद के मेरे संपादक) में परीक्षण किया और उन्होंने काम किया। तो कुछ ऐसा ही आपके लिए काम करना चाहिए।

अधिक जानकारी के लिए, emacs wiki चेकआउट करना सुनिश्चित करें!

Answer 3

Here एक फ़ंक्शन है। मैं एक elisp शुरुआत कर रहा हूँ। यह केवल एक ही रास्ता जाता है; से करने के लिए {। अगर यह आप के लिए काम करता है तो मुझे बतलाएगा।

Answer 4

मुझे यकीन है कि यह छोटे और बेहतर बनाया जा सकता है, लेकिन अब के लिए मैं निम्नलिखित है: ruby-goto-containing-block-start और ruby-flip-containing-block-type:

(defun ruby-get-containing-block() 
    (let ((pos (point)) 
     (block nil)) 
    (save-match-data 
     (save-excursion 
     (catch 'break 
      ;; If in the middle of or at end of do, go back until at start 
      (while (and (not (looking-at "do")) 
         (string-equal (word-at-point) "do")) 
      (backward-char 1)) 
      ;; Keep searching for the containing block (i.e. the block that begins 
      ;; before our point, and ends after it) 
      (while (not block) 
      (if (looking-at "do\\|{") 
       (let ((start (point))) 
        (ruby-forward-sexp) 
        (if (> (point) pos) 
         (setq block (cons start (point))) 
        (goto-char start)))) 
      (if (not (search-backward-regexp "do\\|{" (point-min) t)) 
       (throw 'break nil)))))) 
     block)) 

(defun ruby-goto-containing-block-start() 
    (interactive) 
    (let ((block (ruby-get-containing-block))) 
    (if block 
     (goto-char (car block))))) 

(defun ruby-flip-containing-block-type() 
    (interactive) 
    (save-excursion 
    (let ((block (ruby-get-containing-block))) 
     (goto-char (car block)) 
     (save-match-data 
     (let ((strings (if (looking-at "do") 
          (cons 
          (if (= 3 (count-lines (car block) (cdr block))) 
           "do\\(*|[^|]+|\\)? *\n *\\(.*?\\) *\n *end" 
           "do\\(*|[^|]+|\\)? *\\(\\(.*\n?\\)+\\) *end") 
          "{\\1 \\2 }") 
         (cons 
          "{\\(*|[^|]+|\\)? *\\(\\(.*\n?\\)+\\) *}" 
          (if (= 1 (count-lines (car block) (cdr block))) 
           "do\\1\n\\2\nend" 
          "do\\1\\2end"))))) 
      (when (re-search-forward (car strings) (cdr block) t) 
      (replace-match (cdr strings) t) 
      (delete-trailing-whitespace (match-beginning 0) (match-end 0)) 
      (indent-region (match-beginning 0) (match-end 0)))))))) 

दो कार्य चाबियाँ करने के लिए बाध्य होने के लिए कर रहे हैं।

या तो कमांड किसी ब्लॉक के अंदर कहीं भी काम करता है, और उम्मीद है कि वे छोड़े जाने वाले ब्लॉक को छोड़ सकते हैं - हालांकि यदि आप एक छोटे ब्लॉक प्रारूप में परिवर्तित हो रहे हैं तो यह कोई मुद्दा नहीं होना चाहिए।

ruby-flip-containing-block-type तीन पंक्तियों को ध्वस्त करता है .. एकल रेखा {} और इसके विपरीत अंत ब्लॉक। यदि ब्लॉक बिल्कुल 3 लाइनें और 1 लाइन लंबी नहीं हैं, तो उन्हें अकेले छोड़ देना चाहिए।

मैं अब अपने रूबी सेटअप पर इसका उपयोग कर रहा हूं, इसलिए मैं सुधार की सराहना करता हूं।