क्या कोड टिप्पणियों के रूप में org-babel परिणाम आउटपुट हो सकते हैं?

Question

ब्लॉग, पाठ्य पुस्तकों आदि में, कुछ कोड के परिणामों को टिप्पणी के रूप में प्रदर्शित करना वास्तव में सामान्य है, उदाहरण के लिए:

(+ 1 1) ;=> 2

क्या ऑर्ग-मोड की बैबल सुविधा का उपयोग करके स्वचालित रूप से परिणाम प्रदर्शित करने का कोई तरीका है?

विशेष रूप से, मैं जो चाहूंगा वह हैडर को निर्दिष्ट करने में सक्षम होना चाहिए जैसे कि:

#+begin_src scheme <some headers>
(+ 1 1)
(/ 4 (* 2 2))
#+end_src

निम्नलिखित में बदल जाएगा जब मैं C-c C-c:

#+begin_src scheme <some headers>
(+ 1 1) ;=> 2
(/ 4 (* 2 2)) ;=> 1
#+end_src

और फिर अगर मैंने कुछ बदलाव किए, तो जैसे ...

#+begin_src scheme <some headers>
(+ 1 5) ;=> 2
(/ 8 (* 2 2)) ;=> 1
#+end_src

... और C-c C-c, यह टिप्पणियों को अद्यतन के साथ बदल देगा:

#+begin_src scheme <some headers>
(+ 1 5) ;=> 6
(/ 8 (* 2 2)) ;=> 2
#+end_src

या, जो मैंने ऊपर सपना देखा है, क्या गितुब के ओआरजी फ़ाइल रेंडरर द्वारा परिणाम प्रदर्शित करने का एक आसान तरीका है, इसलिए निम्नलिखित दिखाई देगा (आदर्श रूप से प्रारूपण के साथ कि मैं दस्तावेज़ स्तर पर निर्दिष्ट करता हूं):

#+RESULTS:
: 2

Comments

दिलचस्प विचार है, लेकिन मुझे नहीं लगता कि कुछ भी तैयार है। मैं पूर्व निर्धारित स्थान पर परिणाम देने के लिए विशिष्ट बैबल बैकेंड को संशोधित करने का प्रयास करूंगा। हालांकि यह जटिल लगता है, जब परिणाम उदाहरण के लिए कई लाइनें हैं।

— wvxvw

Answer 1

इसे इस्तेमाल करे

nowebअपने कोड को साक्षर कार्यक्रम में बदलने के लिए नामित कोड ब्लॉक और हेडर का उपयोग करें ।

#+NAME: my-code
#+BEGIN_SRC elisp :exports none 
(+ 1 1)
#+END_SRC

#+NAME: my-other-code 
#+BEGIN_SRC elisp :exports none 
(/ 4 (* 2 2))
#+END_SRC

orgअपने परिणाम के साथ अपने कोड को प्रारूपित करने के लिए एक कोड ब्लॉक बनाएं

#+BEGIN_SRC org :results drawer replace :noweb yes :exports results 

  ,#+NAME: my-code-with-answer
  ,#+BEGIN_SRC elisp  :exports code 
  <<my-code>> ;=> <<my-code()>>
  <<my-other-code>> ;=> <<my-other-code()>>
  ,#+END_SRC


#+END_SRC

एक है C-c C-cपर orgकोड ब्लॉक और आप नीचे दिए गए कोड के समान परिणाम दिखाई देंगे:

#+RESULTS:
:RESULTS:

#+NAME: my-code-with-answer
#+BEGIN_SRC elisp  :exports code 
(+ 1 1) ;=> 2
(/ 4 (* 2 2)) ;=> 1
#+END_SRC

:END:

यदि आप गिथब को कोड पोस्ट करते हैं, तो आपको देखना चाहिए

(+ 1 1) ;=> 2
(/ 4 (* 2 2)) ;=> 1

---

इस कोड को
GNU Emacs 24.5.1 (x86_64-Unknown-cygwin, GTK + Version 3.14.13)
Org-Mode संस्करण: 8.3.2
और github के साथ परीक्षण किया गया था ।

Comments

धन्यवाद। यह एक सहायक दृष्टिकोण है और जो भी मैं चाहता हूं, परिणामों को प्रारूपित करने की अनुमति देने के लिए पर्याप्त लचीला लगता है। लेकिन, मुझे लगता है कि यह (मेरे खुद के समाधान की तरह) त्वरित नोट्स या ब्लॉग पोस्ट के लिए सुविधाजनक होने के लिए बहुत ही क्रियात्मक है, जो कि मैं खोजने की उम्मीद कर रहा था। शायद इस कार्यक्षमता पर बाबेल निर्माण के कुछ संशोधन मुझे वहां मिल सकते हैं, हालांकि।

— पार्करिस्टिपिंग

@ सहकर्मी - मैं सहमत हूँ। यह बहुत अधिक क्रिया है। अगर यह कुछ ऐसा है जो मैं अक्सर करने जा रहा हूं, उदाहरण के लिए, ब्लॉग, मैं आमतौर पर चरण 2 में स्वरूपित org कोड उत्पन्न करने के लिए कुछ टेम्पलेट कोड लिखता हूं। फिर मैं सिर्फ टेम्पलेट जनरेटर में पारित एक चर को अपडेट करता हूं, जैसे :var my_code='("my-code" "my-other-code")। यहां तक ​​कि यह अभी भी अधिक बोझिल है जितना मैं चाहूंगा। क्या आप मुझे अपना जवाब अपडेट करना चाहेंगे?

— Melioratus

@pareristyping - मुझे अभी एक और तरीका सूझा है लेकिन इसके लिए जरूरी है कि आप ओरिजिनल ओआरजी फाइल को एक्सपोर्ट करें और एक्सपोर्ट को GHHub पर पोस्ट करें।

— Melioratus

Answer 2

मौजूदा बैबल कार्यक्षमता को पूरा करने में मैं निकटतम है जो निम्नलिखित है:

सबसे पहले, मैं एक emacs- लिस्प फंक्शन को परिभाषित करता हूं ताकि परिणामों को प्रस्तुत किया जा सके ";=> ":

#+name: commentify
#+begin_src emacs-lisp :var result="" :exports none
(concat ";=> " (format "%s" result))
#+end_src

फिर मैं :postशीर्ष लेख का उपयोग करके परिणाम संसाधित करता हूं :

#+begin_src scheme :post commentify(*this*) :results code :exports both
(+ 5 7)
#+end_src

यह निम्नलिखित पर लौटाता है C-c C-c, जो :exports bothहेडर के कारण जीथब पर प्रदर्शित होता है , लेकिन यह एक अलग कोड ब्लॉक में है।

#+RESULTS:
#+BEGIN_SRC scheme
;=> 12
#+END_SRC

मुझे लगता है कि यह रणनीति ओआरजी फाइल को छोड़ देती है, हालांकि यह इसके लायक है। और, जब तक मैं कोड मूल्यांकन की पुष्टि को अक्षम नहीं करता, मुझे दो को स्वीकार करना होगा "क्या आप सुनिश्चित हैं कि आप कोड का मूल्यांकन करना चाहते हैं?" संकेत (एक योजना ब्लॉक के लिए और एक क्विक के लिए commentify)।

Answer 3

आप ऐसा कुछ कर सकते हैं:

1. अपने नामित मल्टी-लाइन स्रोत कोड ब्लॉक को हमेशा की तरह लिखें

2. से रैपिंग बदलें BEGIN/END_SRCकरने के लिए …-EXAMPLE:

    # + नाम: वास्तविक-स्रोत
    # + BEGIN_EXAMPLE इमैक-लिस्प
    (+ 4)
    (* ४ ४ 47)
    # + END_EXAMPLE

3. पहले कोड ब्लॉक के तहत इस ब्लॉक को चिपकाएँ और निष्पादित करें।

    # + नाम: लिस्पब्लॉक
    # हेडर:: var lcmds = वास्तविक स्रोत
    # + BEGIN_SRC emacs-lisp: परिणाम आउटपुट: रैप src emacs-lisp
    (डोलिस्ट (cmd (स्प्लिट-स्ट्रिंग lcmds "\ n"))
      (जब तक (स्ट्रिंग = "" cmd)
        (princ
         (प्रारूप "% s \ t; →% s \ n"
                 cmd (eval (कार-रीड-स्ट्रिंग cmd))))))
    # + END_SRC

4. परिणाम:

    # परिणाम: लिस्पब्लॉक
    # + BEGIN_src इमैक-लिस्प
    (+ ३ ४); → 7
    (* ४ ४ 4); → 188
    # + END_src

5. अपने टेक्स्ट में आवश्यकतानुसार अलग - अलग मल्टी-लाइन स्रोत ब्लॉक जोड़ें

6. उन #+CALL:पंक्तियों को जोड़ें जहां आप ब्लॉक का नाम lcmdsचर के रूप में देते हैं। दस्तावेज़ के अनुसार उपरोक्त रूपांतरित ब्लॉक की केवल एक बार आवश्यकता है।

ध्यान दें कि ट्रांसफ़ॉर्मिंग ब्लॉक को उस भाषा में लिखा जाना चाहिए जिसे आप व्यवहार कर रहे हैं।

मैंने पहले @melioratus से अच्छे समाधान को "स्वचालित" करने की कोशिश की, लेकिन जब मैं उपरोक्त समाधान में भाग गया, तो इसके साथ समस्याओं में भाग गया।

नंबर-सूची-के-कोड-ब्लॉक-समस्या से बचने के लिए आवश्यक फिक्स को इंगित करने के लिए @jpkotta thx।

Comments

बहुत चालाक वर्कअराउंड! पोस्ट करने का शुक्रिया!

— मेलियोराटस