doerg/src/net/deertopia/doerg/render.clj

@@ -57,7 +57,7 @@
 (defn org-document
   "Recursively render an Org-mode document to Hiccup."
   [doc]
-  (tex/binding-tex-worker
+  (tex/binding-temml-worker
     (let [rendered (-> doc gather-footnotes render-tex-snippets
                        org-element-recursive)]
       [:html
@@ -142,7 +142,7 @@
             (Thread/sleep (* 1000 1))
             (doseq [{:keys [promise node]} @promises]
               (try (let [{:keys [value contents]} node]
-                     (deliver promise (tex/render (or contents value))))
+                     (deliver promise (tex/render-temml (or contents value))))
                    (catch Throwable e
                      (prn e)
                      (flush))))
@@ -306,11 +306,14 @@
      (hiccup/raw (-> e ::rendered (deref 2000 "«timed out»")))]
     #_
     [:span.latex-fragment
-     (hiccup/raw (tex/render contents :display? display?))]))
+     (hiccup/raw (tex/render-temml contents :display? display?))]))
 
 (defmethod org-element "latex-environment" [{:keys [value] :as e}]
   [:span.latex-fragment
-   (hiccup/raw (tex/render value :display? true))])
+   (hiccup/raw (-> e ::rendered (deref 2000 "«timed out»")))]
+  #_
+  [:span.latex-fragment
+   (hiccup/raw (tex/render-temml value :display? true))])
 
 (defmethod org-element "example-block" [{:keys [value]}]
   [:pre value])

doerg/src/net/deertopia/doerg/tex.clj

@@ -154,14 +154,14 @@
 
 ;;; Temml
 
-(def ^:dynamic *tex-worker-timeout-duration*
+(def ^:dynamic *temml-worker-timeout-duration*
   "Number of milliseconds to wait before killing the external Uniorg
   process."
   (* 10 1000))
 
-(def ^:dynamic *worker*)
+(def ^:dynamic *temml-worker*)
 
-(defn tex-worker [& {:keys [preamble]}]
+(defn temml-worker [& {:keys [preamble]}]
   (p/process
    {:shutdown p/destroy-tree
     :err (l/log-stream :info "temml/err")}
@@ -170,33 +170,33 @@
    "--preamble"
    "resources/net/deertopia/doerg/prelude.tex"))
 
-(defn finish [tw]
+(defn close-temml-worker [tw]
   (.close (:in tw)))
 
-(defmacro with-tex-worker [tw & body]
-  `(let [~tw (tex-worker)]
+(defmacro with-temml-worker [tw & body]
+  `(let [~tw (temml-worker)]
      (try
        (do ~@body)
        (finally
-         (finish ~tw)
+         (close-temml-worker ~tw)
          (p/destroy-tree ~tw)))))
 
-(defmacro binding-tex-worker [& body]
-  `(binding [*worker* (tex-worker)]
+(defmacro binding-temml-worker [& body]
+  `(binding [*temml-worker* (temml-worker)]
      (try
        ~@body
        (finally
-         (finish *worker*)))))
+         (close-temml-worker *temml-worker*)))))
 
-(defn command [x]
-  (cbor/encode cbor/default-codec (:in *worker*) x)
-  (.flush (:in *worker*))
-  (cbor/decode cbor/default-codec (:out *worker*)))
+(defn command-temml-worker [x]
+  (cbor/encode cbor/default-codec (:in *temml-worker*) x)
+  (.flush (:in *temml-worker*))
+  (cbor/decode cbor/default-codec (:out *temml-worker*)))
 
-(defn render [s & {:keys [display?]}]
+(defn render-temml [s & {:keys [display?]}]
   (if display?
-    (command [s])
-    (command s)))
+    (command-temml-worker [s])
+    (command-temml-worker s)))
 
 ;; hackky....
 (defn erroneous-temml-output? [s]