Make TeX rendering use the standard Markdown notation

Author: sockeye-d

core/src/main/kotlin/dev/fishies/coho/Utilities.kt

@@ -11,13 +11,10 @@ import org.apache.batik.dom.GenericDOMImplementation
 import org.apache.batik.svggen.SVGGeneratorContext
 import org.apache.batik.svggen.SVGGraphics2D
 import org.apache.commons.text.StringEscapeUtils
-import org.scilab.forge.jlatexmath.TeXConstants
-import org.scilab.forge.jlatexmath.TeXFormula
-import org.scilab.forge.jlatexmath.TeXIcon
+import org.scilab.forge.jlatexmath.*
 import org.w3c.dom.DOMImplementation
 import org.w3c.dom.Document
 import java.awt.Dimension
-import java.awt.Insets
 import java.io.StringWriter
 import java.nio.file.Path
 import kotlin.io.path.absolute
@@ -270,25 +267,60 @@ fun parseMarkdownFrontmatter(srcText: String): Pair<Map<String?, Any?>?, String>
     return frontmatter to srcText.substring(nextSeparator + 4)
 }
 
-fun renderTeX(string: String): String {
-    val formula = TeXFormula(string)
-    val icon: TeXIcon = formula.createTeXIcon(TeXConstants.STYLE_DISPLAY, 20f)
-    icon.setForeground(java.awt.Color.WHITE)
+enum class TeXStyle(val intStyle: Int) {
+    /**
+     * The large versions of big operators are used and limits are placed under and over
+     * these operators (default). Symbols are rendered in the largest size.
+     */
+    Display(TeXConstants.STYLE_DISPLAY),
 
-    val domImpl: DOMImplementation = GenericDOMImplementation.getDOMImplementation()
-    val document: Document = domImpl.createDocument(null, "svg", null)
-    val svgGenerator = SVGGraphics2D(SVGGeneratorContext.createDefault(document).apply {
-        graphicContextDefaults = SVGGeneratorContext.GraphicContextDefaults().apply {
-            paint = java.awt.Color.WHITE
-        }
-    }, true)
+    /**
+     * The small versions of big operators are used and limits are attached to
+     * these operators as scripts (default). The same size as in the display style
+     * is used to render symbols.
+     */
+    Text(TeXConstants.STYLE_TEXT),
+
+    /**
+     * The same as the text style, but symbols are rendered in a smaller size.
+     */
+    Script(TeXConstants.STYLE_SCRIPT),
+
+    /**
+     * The same as the script style, but symbols are rendered in a smaller size.
+     */
+    SmallScript(TeXConstants.STYLE_SCRIPT_SCRIPT),
+}
+
+fun renderTeX(string: String, style: TeXStyle = TeXStyle.Display): String? {
+    try {
+        val formula = TeXFormula(string)
+        val icon: TeXIcon = formula.createTeXIcon(style.intStyle, 20f)
+        icon.setForeground(java.awt.Color.WHITE)
 
-    svgGenerator.setSVGCanvasSize(Dimension(icon.iconWidth, icon.iconHeight))
-    icon.paintIcon(null, svgGenerator, 0, 0)
+        val domImpl: DOMImplementation = GenericDOMImplementation.getDOMImplementation()
+        val document: Document = domImpl.createDocument(null, "svg", null)
+        val svgGenerator = SVGGraphics2D(SVGGeneratorContext.createDefault(document).apply {
+            graphicContextDefaults = SVGGeneratorContext.GraphicContextDefaults().apply {
+                paint = java.awt.Color.WHITE
+            }
+        }, true)
+
+        svgGenerator.setSVGCanvasSize(Dimension(icon.iconWidth, icon.iconHeight))
+        icon.paintIcon(null, svgGenerator, 0, 0)
 
-    val writer = StringWriter()
-    svgGenerator.stream(writer)
-    return writer.toString().replace(
-        "<svg", """<svg data-formula="${string.escapeXml()}" class="latex"""""
-    )
+        val writer = StringWriter()
+        svgGenerator.stream(writer)
+        return writer.toString().replace(
+            "<svg", """<svg data-formula="${string.escapeXml()}" class="latex"""""
+        )
+    } catch (e: JMathTeXException) {
+        val lineCount = string.lines().size
+        if (lineCount == 1) {
+            err("TeX formula $string failed to parse: ${e.message}")
+        } else {
+            err("TeX formula\n${string.prependIndent("  ")}\nfailed to parse: ${e.message}")
+        }
+        return null
+    }
 }

core/src/main/kotlin/dev/fishies/coho/markdown/MarkdownFile.kt

@@ -1,18 +1,15 @@
 package dev.fishies.coho.markdown
 
 import dev.fishies.coho.*
-import jdk.javadoc.internal.doclets.formats.html.markup.HtmlStyle
 import org.intellij.markdown.*
 import org.intellij.markdown.ast.ASTNode
 import org.intellij.markdown.ast.getTextInNode
 import org.intellij.markdown.flavours.MarkdownFlavourDescriptor
+import org.intellij.markdown.flavours.gfm.GFMElementTypes
 import org.intellij.markdown.flavours.gfm.GFMFlavourDescriptor
 import org.intellij.markdown.html.*
 import org.intellij.markdown.parser.LinkMap
 import org.intellij.markdown.parser.MarkdownParser
-import org.scilab.forge.jlatexmath.LaTeXAtom
-import org.scilab.forge.jlatexmath.TeXFormulaParser
-import org.scilab.forge.jlatexmath.TeXParser
 import java.nio.file.Path
 import java.util.regex.Pattern.compile
 import kotlin.io.path.*
@@ -78,26 +75,36 @@ private val highlightedCodeFenceProvider = object : GeneratingProvider {
                 state = 1
             }
         }
+        visitor.consumeHtml("<pre class=\"codeblock\">")
+        visitor.consumeTagOpen(node, "code", *attributes.toTypedArray())
+        val highlighted = language?.run { content.toString().highlight(this) } ?: content.toString().escapeHtml()
+        visitor.consumeHtml(highlighted)
 
-        if (language == "latex") {
-            visitor.consumeHtml(renderTeX(content.toString()))
-        } else {
-            visitor.consumeHtml("<pre class=\"codeblock\">")
+        if (state == 0) {
             visitor.consumeTagOpen(node, "code", *attributes.toTypedArray())
-            val highlighted = language?.run { content.toString().highlight(this) } ?: content.toString().escapeHtml()
-            visitor.consumeHtml(highlighted)
+        }
+        if (lastChildWasContent) {
+            visitor.consumeHtml("\n")
+        }
+        visitor.consumeHtml("</code></pre>")
+    }
+}
 
-            if (state == 0) {
-                visitor.consumeTagOpen(node, "code", *attributes.toTypedArray())
-            }
-            if (lastChildWasContent) {
-                visitor.consumeHtml("\n")
-            }
-            visitor.consumeHtml("</code></pre>")
+private fun createMathProvider(inline: Boolean) = object : GeneratingProvider {
+    override fun processNode(visitor: HtmlGenerator.HtmlGeneratingVisitor, text: String, node: ASTNode) {
+        val nodes = node.children.subList(1, node.children.size - 1)
+        val output = nodes.joinToString(separator = "") { it.getTextInNode(text) }.trim()
+        renderTeX(output, if (inline) TeXStyle.Text else TeXStyle.Display)?.let {
+            visitor.consumeHtml("<span class=\"latex\">")
+            visitor.consumeHtml(it)
+            visitor.consumeHtml("</span>")
         }
     }
 }
 
+private val blockMathProvider by lazy { createMathProvider(inline = false) }
+private val inlineMathProvider by lazy { createMathProvider(inline = true) }
+
 /**
  * Hacked together Markdown flavor descriptor to highlight codeblocks with Prism4j.
  */
@@ -108,7 +115,9 @@ open class SyntaxHighlightedGFMFlavourDescriptor(
         val base = super.createHtmlGeneratingProviders(linkMap, baseURI)
         return base + mapOf(
             MarkdownElementTypes.CODE_SPAN to highlightedCodeSpanProvider,
-            MarkdownElementTypes.CODE_FENCE to highlightedCodeFenceProvider
+            MarkdownElementTypes.CODE_FENCE to highlightedCodeFenceProvider,
+            GFMElementTypes.BLOCK_MATH to blockMathProvider,
+            GFMElementTypes.INLINE_MATH to inlineMathProvider,
         )
     }
 }