मैं ऑर्ग-मोड ट्री कैसे चला सकता हूं?

Question

पृष्ठभूमि

मैं Emacs के लिए एक प्रस्तुति मोड लिख रहा हूं। मैं चाहता हूँ कि इनपुट ओआरजी फाइलें हों, क्योंकि ऑर्गन फाइलें डेटा के लिए बहुत अच्छी हैं।

मुसीबत

मुझे ऑर्ग मोड फ़ाइल को "स्लाइड" डेटा संरचनाओं की एक सूची में बदलना है, जिसके माध्यम से मैं पुनरावृत्ति कर सकता हूं। ऐसा करने के लिए, मैं निम्नलिखित org- मोड फ़ाइल जैसा कुछ लेना चाहूंगा:

* this is the first headline, with a title property and no contents
* this is the second headline, with contents
- dash list nested under the second headline
  - further nested
** nested headline

और इसे चलने में सक्षम हो। मैंने कोशिश की है (org-element-parse-buffer), और यह मुझे तत्वों की एक सूची देता है, लेकिन यह पता लगाना मुश्किल है कि उनमें आगे कैसे चलना है। उदाहरण के लिए, कॉलिंग तीन तत्वों (org-element-map (org-element-parse-buffer) 'headline #'identity)की एक सूची देता है ; पिछले एक "नेस्टेड हेडलाइन" का प्रतिनिधित्व करता है। मैं "नेस्टेड हेडलाइन" चाहता हूं कि "यह दूसरी हेडलाइन है, कंटेंट के साथ"।

XY समस्या से बचना

मैं निश्चित रूप से एक मूल-मोड फ़ाइल को एक एलिसा डेटा संरचना में परिवर्तित करने के अन्य तरीकों के लिए खुला हूं। मुझे नहीं लगता कि org- निर्यात मेरे लिए सही उपकरण है, क्योंकि मैं परिणामों वाली एक नई फ़ाइल के साथ समाप्त नहीं करना चाहता, लेकिन एक डेटा संरचना जिसके माध्यम से मैं पुनरावृत्ति कर सकता हूं। मेरा भोला तरीका कुछ ऐसा है "मुझे सभी शीर्ष स्तर की सुर्खियां दें, और फिर मैं उनके गुणों और निहित तत्वों (जैसे, सादे पाठ या नेस्टेड सूची - चाहे आगे की सुर्खियों या डैश की सूची) प्राप्त कर सकता हूं"।

Comments

मेरा मानना ​​है कि तीसरे वैकल्पिक तर्क no-recursionको वह org-element-mapकरना चाहिए जो आप चाहते हैं।

— wvxvw

फ़ाइल के निचले भाग में जाने के बारे में और फिर एक हेडिंग के लिए पीछे की ओर खोजें, सब कुछ पकड़ो, और फिर चलते रहो - प्रक्रिया को दोहराते हुए - जब तक आप फ़ाइल के शीर्ष तक नहीं पहुंचते हैं, तब तक फेंक दिया जाता है? हम पीछे की ओर जाते हैं क्योंकि बिंदु पहले से ही प्रत्येक खोज के बाद शीर्षक की शुरुआत में है, इसलिए यह आगे की ओर जाने की तुलना में अधिक कुशल है और फिर शीर्षक की शुरुआत में थोड़ा पीछे जा सकता है। यह है कि ऑर्ग-एजेंडा कैसे काम करता है - यानी, ऑर्ग-एजेंडा-लिस्ट, ऑर्ग-सर्च-व्यू, ऑर्ग-टैग-व्यू।

— कायर्काल

Answer 1

मेरे पास एक समान समस्या थी, इसलिए शायद यह मदद करेगा - मैं ऑर्ग एक्सपोर्ट या ऑर्गन इंटर्नल से बहुत परिचित नहीं हूं, लेकिन मुझे ऐसा कुछ भी नहीं मिला, जो ऑर्ग फाइल को ट्री स्ट्रक्चर के लिए पार्स कर सके। लेकिन जैसे बफर दिया

* england
** london
** bristol
* france

यह आपको देगा

(org-get-header-tree) => ("england" ("london" "bristol") "france")

और पेड़ से अन्य जानकारी भी शामिल कर सकते हैं।

---

इसलिए स्तरों की एक फ्लैट सूची दी गई है, जिसमें हमें एक पेड़ का उत्पादन करने की आवश्यकता है, उदाहरण के लिए (1 1 2 3 1) => (1 1 (2 (3)) 1)। मुझे ऐसा कोई फ़ंक्शन नहीं मिला जो या तो ऐसा कर सकता है ताकि विपक्ष कोशिकाओं के बहुत ड्राइंग के बाद लिखा जाए - मुझे यकीन है कि ऐसा करने का एक बेहतर तरीका है, लेकिन यह काम करता है। फ़ंक्शन unflattenसूची और आइटम स्तरों से इच्छित जानकारी निकालने के लिए एक फ्लैट सूची और कुछ फ़ंक्शन लेता है और एक ट्री संरचना तैयार करता है।

में org-get-header-listआप अधिक जानकारी जोड़ सकते हैं आप के लिए कॉल के साथ प्रत्येक आइटम से निकालना चाहते हैं org-element-property, और उसके बाद में org-get-header-treeआप कार्यों की सूची से जानकारी निकालने के लिए शामिल हो सकते हैं।

जैसा कि यह खड़ा है कि डैश सूचियों के लिए हैंडलिंग शामिल नहीं है, लेकिन शायद यह बहुत अधिक परेशानी के बिना भी उन लोगों को संभालने के लिए अनुकूलित किया जा सकता है ...

(defun unflatten (xs &optional fn-value fn-level)
  "Unflatten a list XS into a tree, e.g. (1 2 3 1) => (1 (2 (3)) 1).
FN-VALUE specifies how to extract the values from each element, which
are included in the output tree, FN-LEVEL tells how to extract the
level of each element. By default these are the `identity' function so
it will work on a list of numbers."
  (let* ((level 1)
         (tree (cons nil nil))
         (start tree)
         (stack nil)
         (fn-value (or fn-value #'identity))
         (fn-level (or fn-level #'identity)))
    (dolist (x xs)
      (let ((x-value (funcall fn-value x))
            (x-level (funcall fn-level x)))
        (cond ((> x-level level)
               (setcdr tree (cons (cons x-value nil) nil))
               (setq tree (cdr tree))
               (push tree stack)
               (setq tree (car tree))
               (setq level x-level))
              ((= x-level level)
               (setcdr tree (cons x-value nil))
               (setq tree (cdr tree)))
              ((< x-level level)
               (while (< x-level level)
                 (setq tree (pop stack))
                 (setq level (- level 1)))
               (setcdr tree (cons x-value nil))
               (setq tree (cdr tree))
               (setq level x-level)))))
      (cdr start)))

; eg (unflatten '(1 2 3 2 3 4)) => '(1 (2 (3) 2 (3 (4))))


(defun org-get-header-list (&optional buffer) 
  "Get the headers of an org buffer as a flat list of headers and levels.
Buffer will default to the current buffer."
  (interactive)
  (with-current-buffer (or buffer (current-buffer))
    (let ((tree (org-element-parse-buffer 'headline)))
      (org-element-map 
          tree 
          'headline
        (lambda (el) (list 
                 (org-element-property :raw-value el) ; get header title without tags etc
                 (org-element-property :level el) ; get depth
                 ;; >> could add other properties here
                 ))))))

; eg (org-get-header-list) => (("pok" 1) ("lkm" 1) (("cedar" 2) ("yr" 2)) ("kjn" 1))


(defun org-get-header-tree (&optional buffer)
  "Get the headers of the given org buffer as a tree."
  (interactive)
  (let* ((headers (org-get-header-list buffer))
         (header-tree (unflatten headers  
                 (lambda (hl) (car hl))  ; extract information to include in tree
                 (lambda (hl) (cadr hl)))))  ; extract item level
    header-tree))

; eg (org-get-header-tree) => ("pok" "lkm" ("cedar" "yr") "kjn")