Darlan Cavalcante Moreira <darc...@gmail.com> writes:
> Thank you Eric and Jambunathan for your answers.
>
> If I process the whole table with babel to manually add the lines from the
> external file than I would have to take care of updating the formula for
> the "Total" value as well as making sure the new content was added before
> the "Total" line, right?. The later is simple, but updating the formula
> could be complicated.
>
Alternately, since the table is simply an array you could pass it to
another code block in your preferred language, and then perform the
total calculation on the array. Then run `continually-run' on this
second code block.
>
> Meanwhile, I'm investigating using org-capture for this.
>
I'm not familiar with Org-capture myself, but the below sounds like a
good plan, I hope it works out.
If you do find a natural way to combine org-capture and Babel code
blocks I'm sure such a system would be of use to others on the list, so
please do share.
Best,
>
> For instance, if I use a template such as
> #+begin_src emacs-lisp
> ("f" "test" table-line
> (file+headline "test.org" "Test table")
> (file "path/food.org")
> :table-line-pos "II-1"
> :immediate-finish t)
> #+end_src
> where the food.org file has a single line then I can capture with
> #+begin_src emacs-lisp
> (org-capture nil "f")'
> #+end_src
> and org-capture will place the content from the "food.org" file in a table
> in the "Test Table" headline of the test.org file.
>
> The advantage of using org-capture instead of pure babel is that it will
> already put the content in the correct place and update the
> formulas. However, the formulas are updated correctly only if I capture a
> single line each time.
>
> I think a combination of babel with org-capture is my best option.
> Once that is working I will use your timer approach for automating this
> (while I investigate inotify suggested by Jambunathan).
>
> --
> Darlan
>
>
> At Wed, 09 Jan 2013 22:10:37 -0700,
> Eric Schulte wrote:
>>
>> #+Title: Periodically Rerun a Code Block
>>
>> Here's the lisp code to define a function to continually re-run a code
>> block. Evaluate the following code block, then =M-x continually-run=,
>> press ENTER and then type in the name of the code block to continually
>> run (in this case "date").
>> #+begin_src emacs-lisp :results silent
>> (defvar continual-runners nil
>> "Holds running block timers (so they may be canceled).")
>>
>> (defun run-block-in-buffer (name buffer)
>> (save-match-data
>> (with-current-buffer buffer
>> (save-excursion
>> (org-babel-goto-named-src-block name)
>> (with-local-quit
>> (undo-boundary)
>> (with-temp-message (format "re-running %s" name)
>> (org-babel-execute-src-block))
>> (undo-boundary))))))
>>
>> (defun continually-run (name)
>> "Continually run the supplied code block name.
>> The code block is assumed to be in the current buffer."
>> (interactive "scode block to continually run: ")
>> (let ((run-buffer (current-buffer)))
>> (add-to-list 'continual-runners
>> (run-at-time nil 5 'run-block-in-buffer name
>> run-buffer))))
>> #+end_src
>>
>> Here's the code block to be continually re-run.
>> #+Name: date
>> #+begin_src sh
>> date
>> #+end_src
>>
>> And here are the results which will be continually updated.
>> #+RESULTS: date
>> : Wed Jan 9 22:04:08 MST 2013
>>
>> Execute the following to stop all continually updating code blocks.
>> #+begin_src emacs-lisp :results silent
>> (mapc #'cancel-timer continual-runners)
>> #+end_src
--
Eric Schulte
http://cs.unm.edu/~eschulte
