मैं nxml- मोड के साथ मनमाने टैग कैसे मोड़ सकता हूं?

Question

मैं तह करना चाहूंगा

<type>
  <xsl:attribute name="multiplicity">
    <xsl:choose>
      <xsl:when test="collection = true">*</xsl:when>
      <xsl:otherwise>1</xsl:otherwise>
    </xsl:choose>
  </xsl:attribute>
  <xsl:value-of select="field_type"/>
</type>

में

<type>
  <xsl:attribute name="multiplicity">
    <xsl:choose>...</xsl:choose>
  </xsl:attribute>
  <xsl:value-of select="field_type"/>
</type>

या

<type>
  <xsl:attribute name="multiplicity">...</xsl:attribute>
  <xsl:value-of select="field_type"/>
</type>

nxml-modeकुछ तत्वों को पहले ही रेखांकित कर सकते हैं । मैं किसी भी तत्व की nxml-modeरूपरेखा तैयार करने के लिए कैसे तैयार हो सकता हूं ?

Comments

रूपरेखा सुविधा के लिए एक निश्चित शुरुआत rexxp और एक निश्चित समाप्ति regexp की आवश्यकता होती है। यदि कोई निकट भविष्य में कोई समाधान नहीं देता है, तो मैं इस पर एक कदम उठाऊंगा। इस बीच, कृपया उस क्षेत्र के सभी शुरुआत और रेंगने वाले rexxp की सूची को इकट्ठा करें, जिसे आप तह करना चाहते हैं - जो कि आपके nxml-modeप्रोजेक्ट के लिए एक कस्टम फोल्ड फंक्शन (यदि ऐसा फ़ंक्शन पहले से मौजूद नहीं है) बनाने के लिए आवश्यक होगा । आप छिपा-दिखा पुस्तकालय पर भी एक नज़र डालना चाह सकते हैं : emacswiki.org/emacs/HideShow और gnu.org/software/emacs/manual/html_node/emacs/Hideshn.html

— Lawlist

@lawlist उस समस्या के साथ-जैसा कि मैं शास्त्रीय नियमित अभिव्यक्तियों के साथ समझ सकता हूं — यह है कि नियमित भाव वास्तव में नेस्टेड चीजों को संभाल नहीं सकते हैं। उस ने कहा, xsl:.*मुझे हर चीज को कवर करना चाहिए जिसे मैं नेस्टेड करूंगा, हालांकि ऐसे टैग की सूची को तह करने की क्षमता आदर्श होगी।

— सीन एलेड

ऐसा लगता है कि शुरुआत regexp का उपयोग अंतिम regexp को प्राप्त करने के लिए किया जा सकता है, एक पूर्व उदाहरण के समान, जिसे मैंने LaTeX के लिए ड्राफ्ट किया था: tex.stackexchange.com/a/161196/26911 मैं अगले दिन वापस चेक करूँगा या नहीं यह देखने के लिए किसी के पास एक अंतर्निहित समाधान है या छिपाने के लिए या दूसरी विधि है। यदि नहीं, तो मैंने आपके द्वारा बताए गए लिंक में मसौदे के आधार पर कुछ डाल दिया है। इससे पहले कि मेरा उदाहरण आपको लगता है कि आप क्या चाहते हैं, उसके बहुत करीब लग रहा है - आप इस बीच खुद पर एक छुरा लेना चाहते हैं।

— नियम

Answer 1

प्रारंभिक मसौदा (23 जुलाई, 2014): पहला मोटा मसौदा।

EDIT (23 जुलाई, 2014): दूसरा मोटा मसौदा। एक ही regexp युक्त नेस्टेड स्थितियों से निपटने के प्रयास में एक काउंटर और जबकि-लूप जोड़ा गया।

(defvar beg-xsl-regexp
  "\\(\<xsl:\\)\\([^ >]*\\)\\([^>]*\\)\\(\>\\)"
"Regexp matching the beginning of the folded region.")

(defun toggle-xsl-block ()
"When FLAG is non-nil, hide the region.  Otherwise make it visible.  For this
function to work, the cursor must be on the same line as the beginning regexp."
(interactive)
  (require 'outline)
  (cond
    ((or
        (looking-at beg-xsl-regexp)
        (let ((line-begin (save-excursion (beginning-of-line 1) (point))))
          (save-excursion
            (re-search-backward "\<" line-begin t)
            (looking-at beg-xsl-regexp)))
        (let ((line-begin (save-excursion (beginning-of-line 1) (point))))
          (save-excursion
            (re-search-backward "\<xsl:" line-begin t)
            (looking-at beg-xsl-regexp)))
        (let ((line-end (save-excursion (end-of-line 1) (point))))
          (save-excursion
            (re-search-forward "\<xsl:" line-end t)
            (backward-char 5)
            (looking-at beg-xsl-regexp))))
      (let* (
          congratulations
          (i 0)
          (beg-1 (match-beginning 0))
          (flag (not (get-char-property (match-end 0) 'invisible)))
          (begin-fold (match-end 0))
          end-fold
          (base-flag-match (regexp-quote
            (buffer-substring-no-properties (match-beginning 2) (match-end 2))))
          (beg-flag-match (concat "\<xsl:" base-flag-match))
          (end-flag-match (concat "\</xsl:" base-flag-match "\>"))
          (go-fish (concat "\</xsl:" base-flag-match "\>"))  )
        (save-excursion
          (when (save-excursion (re-search-forward end-flag-match nil t))
            (catch 'done
              (while t 
                (re-search-forward end-flag-match nil t)
                (when
                  (>
                    (save-excursion (re-search-backward beg-flag-match beg-1 t i) (point))
                    beg-1)
                  (setq i (1+ i)))
                (when
                  (=
                    (save-excursion (re-search-backward beg-flag-match beg-1 t i) (point))
                    beg-1)
                  (setq congratulations t)
                  (throw 'done nil)))))
          (if congratulations
            (progn
              (setq end-fold (point))
              (outline-flag-region begin-fold end-fold flag)
              (cond
                (flag
                  (overlay-put (make-overlay begin-fold end-fold) 'display "\u25be"))
                (t
                  (mapc 'delete-overlay (overlays-in begin-fold end-fold)))))
            (user-error "Error locating an ending match for:  %s." go-fish)))
        (if (> (point) begin-fold)
          (goto-char begin-fold)) ))
    (t
      (message "You are not on a line containing the beginning regexp."))))

Comments

इसके साथ बाहर की कोशिश करो transform.xsl --- विशेष रूप से xsl:for-eachलाइन 11 (लेकिन दिलचस्प बात पर नहींxsl:for-each लाइन 43 पर)।

— सीन एलेड

transform.xslपरीक्षण कोड के लिए धन्यवाद । मुझे यह सोचने की आवश्यकता होगी कि हम उसी रेगेक्स के साथ नेस्टेड स्थितियों को कैसे संभाल सकते हैं। हमें आरंभ करने के लिए कम से कम हमारे पास एक अर्ध-काम करने वाला पहला मसौदा है।

— 17

@ सीन संबद्ध - मैंने एक ही लूप और नेगेड स्थितियों से निपटने के लिए एक ही लूप और काउंटर जोड़ा, जिसमें एक ही regexp शामिल हो - जब भी आपके पास कुछ खाली समय हो, तो आप आगे बढ़ सकते हैं और यदि आप चाहें तो इसे आज़मा सकते हैं।

— कानून