Re: [O] Accessing the communication channel from a link exporter

[John Kitchin]

then the preprocessing hook sounds better. You can just replace the
links with generated html, and then export the buffer.

For example, here is a function that goes through an org file and
replaces links that are file times with image or urls, and copies the
file contents to a media-directory.

(defun bf-process-links (backend)
  "Modify links to change paths and copy files to `media-dir'.
Argument BACKEND the export backend."
  (org-mode)
  (let* ((links (nreverse (org-element-map (org-element-parse-buffer) 'link 
#'identity))))
    (loop for link in links
          do
          (let* ((type (org-element-property :type link))
                 (path (org-element-property :path link))
                 (beg (org-element-property :begin link))
                 (end (org-element-property :end link))
                 (fname (car (last (split-string path "/")))))
            
            (cond
             ((string= type "file")
              (copy-file path (concat bf-media-directory fname) t)
              (setf (buffer-substring beg end)
                    (if (string-match "png\\|svg" (or (file-name-extension
                                                       (org-element-property 
:path link))
                                                      ""))
                        (format
                         "@@html:<img src=\"%s%s\">@@ "
                         bf-media-url-base fname)
                      (format
                       "@@html:<a href=\"%s%s\">%s</a>@@ "
                       bf-media-url-base fname fname)))))))))


This function just wraps an export with a temporary definition of the
before processing hook, which runs the function on a copy of the
org-buffer you are creating.

(defun bf-get-HTML ()
  "Return the body html of the headline at point."
  (let ((org-export-before-processing-hook '(bf-process-links))
        (async nil)
        (subtreep t)
        (visible-only nil)
        (body-only t)
        (ext-plist '())
        ;; (bf-link-counter 0)
        ;; (url-list (bf-get-link-urls))
        (html))
    (org-html-export-as-html async subtreep visible-only body-only ext-plist)
    ;; now get the output into the org output
    (switch-to-buffer "*Org HTML Export*")
    (end-of-buffer)
    (setq html (buffer-string))
    (kill-buffer "*Org HTML Export*")
    html))

No doubt you could make more complicated ;)

Arun Isaac writes:

>> I think this is the kind of thing you can use a filter for
>
> But, it gets more complicated than that. I have XMP metadata (license,
> caption, etc.)  stored in the image files as well. And, in order to
> export that, I need the path to the source image file. So, my image link
> exporter needs the :base-directory to find the source image file. If I
> try to get the XMP metadata from the published image file, then I
> introduce a race condition with the export of the org file becoming
> dependent on the image file already being published.
>
> Perhaps, filters could be useful. I need to think about it. So far, I
> have generally stayed away from filters because they can only get the
> HTML as text, and have to use some kind of regex to operate on it. HTML
> is structured data, and it would have been good if it was available in
> some kind of S-form tree structure. It would have saved me the trouble
> of parsing the HTML, and I could have used a library like xmlgen to
> generate it.
>
> Regards,
> Arun Isaac


-- 
Professor John Kitchin
Doherty Hall A207F
Department of Chemical Engineering
Carnegie Mellon University
Pittsburgh, PA 15213
412-268-7803
@johnkitchin
http://kitchingroup.cheme.cmu.edu