asciichem 0.3.0

data/lib/asciichem/formatter/mathml.rb

@@ -0,0 +1,309 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module AsciiChem
+  module Formatter
+    # Renders a Model tree as presentation MathML.
+    #
+    # The headline semantic fix lives here: prefix isotopes bind to the
+    # atom, so `^14C` renders as `<msup><mi>C</mi><mn>14</mn></msup>`
+    # (Carbon with 14 as superscript). AsciiMath would emit
+    # `<msup><mi></mi><mn>14</mn></msup><mi>C</mi>` — a phantom base
+    # followed by a sibling atom, which loses the binding.
+    class Mathml < Base
+      MATHML_NS = "http://www.w3.org/1998/Math/MathML".freeze
+
+      def initialize
+        @doc = Nokogiri::XML::Document.new
+      end
+
+      # Model entry point. Returns a `<math>` element as a string.
+      def visit_formula(formula)
+        math = el("math", xmlns: MATHML_NS)
+        mrow = el("mrow")
+        formula.nodes.each { |n| mrow.add_child(render_node(n)) }
+        math.add_child(mrow)
+        @doc.root = math
+        # Native UTF-8 output preserves unicode arrow entities so specs
+        # and downstream consumers see ⇌ and → instead of &#x21CC;.
+        @doc.to_xml(encoding: "UTF-8")
+      end
+
+      def visit_molecule(molecule)
+        mrow = el("mrow")
+        if molecule.stereo
+          mrow.add_child(mtext("(#{molecule.stereo_letter})-"))
+        end
+        mrow.add_child(mn(molecule.coefficient)) if molecule.coefficient
+        molecule.nodes.each { |n| mrow.add_child(render_node(n)) }
+        mrow
+      end
+
+      def visit_atom(atom)
+        base = mi(atom.element)
+        # Isotope is a LEFT superscript per IUPAC (¹⁴C). Use
+        # <mmultiscripts> with <mprescripts/> so the binding stays on
+        # the atom — the AsciiMath `<msup><mi></mi>...<mi>C</mi>`
+        # pattern (empty base + sibling) loses the binding.
+        base = attach_isotope_prefix(base, atom) if atom.isotope
+        base = wrap_lewis_prefix(base, atom)
+        # When the atom has BOTH subscript and a superscript-style
+        # marker (charge, oxidation state, or raw superscript), emit
+        # a single <msubsup> rather than nesting <msub> inside <msup>.
+        base = wrap_sub_and_super(base, atom)
+        base = wrap_lewis_suffix(base, atom)
+        base = wrap_ring_closures(base, atom)
+        base
+      end
+
+      def wrap_ring_closures(base, atom)
+        return base unless atom.ring_closures
+
+        mrow = el("mrow")
+        mrow.add_child(base)
+        mrow.add_child(mn(atom.ring_closures))
+        mrow
+      end
+
+      def attach_isotope_prefix(base, atom)
+        multi = el("mmultiscripts")
+        multi.add_child(base)
+        multi.add_child(el("none"))
+        multi.add_child(el("none"))
+        multi.add_child(Nokogiri::XML::Element.new("mprescripts", @doc))
+        multi.add_child(el("none"))
+        multi.add_child(mn(atom.isotope))
+        multi
+      end
+
+      def wrap_lewis_prefix(base, atom)
+        return base unless atom.lone_pairs
+
+        mrow = el("mrow")
+        mrow.add_child(mtext(":" * atom.lone_pairs))
+        mrow.add_child(base)
+        mrow
+      end
+
+      def wrap_lewis_suffix(base, atom)
+        return base unless atom.radical_electrons
+
+        mrow = el("mrow")
+        mrow.add_child(base)
+        mrow.add_child(mtext("." * atom.radical_electrons))
+        mrow
+      end
+
+      # Combine subscript + superscript-style marker into the right
+      # MathML element. Cases:
+      #   sub + super  -> <msubsup>
+      #   sub only     -> <msub>
+      #   super only   -> <msup> (with charge/oxidation/raw super)
+      #   neither      -> base unchanged
+      def wrap_sub_and_super(base, atom)
+        has_sub = atom.subscript && !atom.subscript.empty?
+        super_node = super_element(atom)
+        return base unless has_sub || super_node
+        return wrap_in_sub(base, mn(atom.subscript)) if has_sub && !super_node
+        return wrap_in_sup(base, super_node) if !has_sub && super_node
+
+        msubsup = el("msubsup")
+        msubsup.add_child(base)
+        msubsup.add_child(mn(atom.subscript))
+        msubsup.add_child(super_node)
+        msubsup
+      end
+
+      # Build the MathML element for whichever superscript-style
+      # marker is set (charge > oxidation_state > raw superscript).
+      # Returns nil if none is set.
+      def super_element(atom)
+        if atom.charge
+          row = charge_row(atom.charge)
+          return row if row
+        end
+        if atom.oxidation_state
+          mrow = el("mrow")
+          mrow.add_child(mi(atom.oxidation_state))
+          return mrow
+        end
+        if atom.superscript
+          return mn(atom.superscript)
+        end
+        nil
+      end
+
+      def charge_row(charge)
+        match = charge.match(/\A(?<n>\d*)(?<sign>[+-])\z/) ||
+                charge.match(/\A(?<sign>[+-])(?<n>\d*)\z/)
+        return nil unless match
+
+        mrow = el("mrow")
+        mrow.add_child(mn(match[:n])) unless match[:n].empty?
+        mrow.add_child(mo(match[:sign]))
+        mrow
+      end
+
+      def visit_group(group)
+        mrow = el("mrow")
+        mrow.add_child(mo(group.open_char))
+        group.nodes.each { |n| mrow.add_child(render_node(n)) }
+        mrow.add_child(mo(group.close_char))
+        return mrow unless group.multiplicity
+
+        msub = el("msub")
+        msub.add_child(mrow)
+        msub.add_child(mn(group.multiplicity))
+        msub
+      end
+
+      def visit_bond(bond)
+        mo(bond.entity)
+      end
+
+      def visit_reaction(reaction)
+        mrow = el("mrow")
+        add_terms(mrow, reaction.reactants)
+        mrow.add_child(render_arrow(reaction))
+        add_terms(mrow, reaction.products)
+        mrow
+      end
+
+      def visit_reaction_cascade(cascade)
+        mrow = el("mrow")
+        return mrow if cascade.steps.empty?
+
+        head = cascade.steps.first
+        add_terms(mrow, head.reactants)
+        cascade.steps.each do |step|
+          mrow.add_child(render_arrow(step))
+          add_terms(mrow, step.products)
+        end
+        mrow
+      end
+
+      def visit_electron_configuration(ec)
+        mrow = el("mrow")
+        ec.orbitals.each_with_index do |(orbital, occupancy), index|
+          mrow.add_child(mo("&#xA0;")) if index.positive?
+          msup = el("msup")
+          msup.add_child(mi(orbital))
+          msup.add_child(mn(occupancy))
+          mrow.add_child(msup)
+        end
+        mrow
+      end
+
+      def visit_embedded_math(em)
+        # Strip the outer <math> wrapper so the embedded fragment slots
+        # into our surrounding <mrow>.
+        fragment = em.formula.to_mathml
+        parsed = Nokogiri::XML(fragment)
+        math = parsed.at_xpath("//m:math", m: MATHML_NS)
+        return el("mrow") unless math
+
+        # Detach children into a fresh <mrow>.
+        mrow = el("mrow")
+        math.children.each { |c| mrow.add_child(c.dup) }
+        mrow
+      end
+
+      def visit_text(text)
+        mtext(text.content)
+      end
+
+      private
+
+      def render_node(node)
+        node.accept(self)
+      end
+
+      def add_terms(parent, terms)
+        terms.each_with_index do |term, index|
+          parent.add_child(mo("+")) if index.positive?
+          parent.add_child(render_node(term))
+        end
+      end
+
+      def render_arrow(reaction)
+        op = mo(reaction.arrow_entity)
+        return op unless reaction.conditions
+
+        above = reaction.conditions.above
+        below = reaction.conditions.below
+        return op unless above || below
+
+        moverunder = el(above && below ? "munderover" : (above ? "mover" : "munder"))
+        moverunder.add_child(op)
+        moverunder.add_child(render_condition(above)) if above
+        moverunder.add_child(render_condition(below)) if below
+        moverunder
+      end
+
+      # Render a reaction-condition string. The condition is captured
+      # as raw text by the grammar, but chemists expect `_N` and `^N`
+      # patterns to render as proper sub/superscripts. We parse the
+      # condition as AsciiChem and use its MathML output. If the parse
+      # fails (e.g. the condition is free-form prose), fall back to
+      # plain <mtext>.
+      def render_condition(text)
+        return mtext("") if text.nil? || text.empty?
+
+        begin
+          inner = AsciiChem.parse(text).to_mathml
+          parsed = Nokogiri::XML(inner)
+          math = parsed.at_xpath("//m:math", m: MATHML_NS)
+          if math
+            mrow = el("mrow")
+            math.children.each { |c| mrow.add_child(c.dup) }
+            return mrow
+          end
+        rescue AsciiChem::ParseError, AsciiChem::Error
+          # fall through to plain text
+        end
+        mtext(text)
+      end
+
+      def wrap_in_sub(base, sub)
+        msub = el("msub")
+        msub.add_child(base)
+        msub.add_child(sub)
+        msub
+      end
+
+      def wrap_in_sup(base, sup)
+        msup = el("msup")
+        msup.add_child(base)
+        msup.add_child(sup)
+        msup
+      end
+
+      # -- Nokogiri element factories ------------------------------------
+
+      def el(name, attrs = {})
+        element = Nokogiri::XML::Element.new(name, @doc)
+        attrs.each { |k, v| element[k.to_s] = v }
+        element
+      end
+
+      def mi(content)
+        e = el("mi", mathvariant: "normal")
+        e.content = content.to_s
+        e
+      end
+
+      def mn(content)
+        e = el("mn"); e.content = content.to_s; e
+      end
+
+      def mo(content)
+        e = el("mo"); e.content = content.to_s; e
+      end
+
+      def mtext(content)
+        e = el("mtext"); e.content = content.to_s; e
+      end
+    end
+  end
+end

data/lib/asciichem/formatter/structural_svg.rb

@@ -0,0 +1,286 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+
+module AsciiChem
+  module Formatter
+    # Renders a Model tree as a 2D structural SVG diagram using
+    # elkrb-computed atom positions. Bonds render as parallel lines
+    # (single/double/triple/quadruple), wedges, hashes, or arrows
+    # depending on kind.
+    #
+    # Falls back to the linear `Svg` formatter for inputs that don't
+    # contain a molecule with bonds (formulae, reactions, etc.).
+    class StructuralSvg < Base
+      ATOM_RADIUS     = 14
+      BOND_SPACING    = 4
+      WEDGE_WIDTH     = 6
+      HASH_DASH_COUNT = 5
+      ATOM_COLORS = {
+        'C' => '#1a1a1a',
+        'H' => '#555',
+        'O' => '#b91c1c',
+        'N' => '#1e40af',
+        'S' => '#a16207',
+        'Cl' => '#16a34a',
+        'F' => '#15803d',
+        'Br' => '#7c2d12',
+        'I' => '#6b21a8',
+        'P' => '#a16207'
+      }.freeze
+      DEFAULT_ATOM_COLOR = '#0c4a3e'
+
+      def visit_formula(formula)
+        molecule = formula.nodes.find { |n| n.is_a?(AsciiChem::Model::Molecule) }
+        return visit_formula_linear(formula) unless molecule
+
+        has_bonds = molecule.nodes.any?(AsciiChem::Model::Bond)
+        return visit_formula_linear(formula) unless has_bonds
+
+        result = AsciiChem::Layout.layout(molecule)
+        return visit_formula_linear(formula) if result.empty?
+
+        render_svg(result)
+      end
+
+      private
+
+      def visit_formula_linear(formula)
+        AsciiChem::Formatter::Svg.new.render(formula)
+      end
+
+      def render_svg(result)
+        doc = Nokogiri::XML::Document.new
+        svg = build_svg_root(doc, result)
+        bonds_first_then_atoms(result, doc, svg)
+        doc.root = svg
+        doc.to_xml
+      end
+
+      def build_svg_root(doc, result)
+        svg = Nokogiri::XML::Element.new('svg', doc)
+        svg['xmlns'] = 'http://www.w3.org/2000/svg'
+        svg['width'] = result.width.to_s
+        svg['height'] = result.height.to_s
+        svg['viewBox'] = "0 0 #{result.width} #{result.height}"
+        svg['role'] = 'img'
+        title = Nokogiri::XML::Element.new('title', doc)
+        title.content = title_text(result)
+        svg.add_child(title)
+        svg
+      end
+
+      def bonds_first_then_atoms(result, doc, svg)
+        result.bonds.each do |bond|
+          from = result.atoms_by_id[bond.from_id]
+          to = result.atoms_by_id[bond.to_id]
+          next unless from && to
+
+          BondRenderer.new(doc, from, to, bond.kind).render_into(svg)
+        end
+        result.atoms.each do |atom|
+          AtomRenderer.new(doc, atom).render_into(svg)
+        end
+      end
+
+      def title_text(result)
+        elements = result.atoms.map(&:element).uniq
+        "#{result.atoms.length} atoms (#{elements.join(', ')})"
+      end
+
+      # Renders a single atom as a labeled circle. Color comes from
+      # the per-element palette (CPK-inspired, simplified) so common
+      # elements are visually distinguishable.
+      class AtomRenderer
+        def initialize(doc, atom)
+          @doc = doc
+          @atom = atom
+        end
+
+        def render_into(parent)
+          group = Nokogiri::XML::Element.new('g', @doc)
+          group.add_child(circle)
+          group.add_child(label)
+          parent.add_child(group)
+        end
+
+        private
+
+        def circle
+          el = Nokogiri::XML::Element.new('circle', @doc)
+          el['cx'] = @atom.x.to_s
+          el['cy'] = @atom.y.to_s
+          el['r'] = StructuralSvg::ATOM_RADIUS.to_s
+          el['fill'] = 'white'
+          el['stroke'] = color
+          el['stroke-width'] = '1.5'
+          el
+        end
+
+        def label
+          el = Nokogiri::XML::Element.new('text', @doc)
+          el['x'] = @atom.x.to_s
+          el['y'] = (@atom.y + 4).to_s
+          el['text-anchor'] = 'middle'
+          el['font-family'] = 'serif'
+          el['font-size'] = '14'
+          el['fill'] = color
+          el.content = @atom.element
+          el
+        end
+
+        def color
+          StructuralSvg::ATOM_COLORS.fetch(@atom.element, StructuralSvg::DEFAULT_ATOM_COLOR)
+        end
+      end
+      private_constant :AtomRenderer
+
+      # Renders a single bond between two positioned atoms. Dispatches
+      # on bond kind via a registry of Procs. Each Proc receives the
+      # renderer (for its public line/offset helpers) and returns an
+      # array of Nokogiri elements. Adding a new bond style is a new
+      # Proc + one registry entry — no edits to existing renderers.
+      class BondRenderer
+        def initialize(doc, from_atom, to_atom, kind)
+          @doc = doc
+          @from = from_atom
+          @to = to_atom
+          @kind = kind
+        end
+
+        def render_into(parent)
+          renderer = RENDERERS.fetch(@kind, RENDERERS[:single])
+          Array(renderer.call(self)).each { |node| parent.add_child(node) }
+        end
+
+        # -- Public helpers used by the strategy Procs ---------------
+
+        def base_line
+          line(@from.x, @from.y, @to.x, @to.y)
+        end
+
+        def offset_line(distance)
+          dx = @to.x - @from.x
+          dy = @to.y - @from.y
+          length = Math.sqrt((dx * dx) + (dy * dy))
+          return nil if length.zero?
+
+          px = -dy / length
+          py = dx / length
+          line(@from.x + (px * distance), @from.y + (py * distance),
+               @to.x + (px * distance), @to.y + (py * distance))
+        end
+
+        def line(start_x, start_y, end_x, end_y)
+          el = Nokogiri::XML::Element.new('line', @doc)
+          el['x1'] = start_x.to_s
+          el['y1'] = start_y.to_s
+          el['x2'] = end_x.to_s
+          el['y2'] = end_y.to_s
+          el['stroke'] = '#1a1a1a'
+          el['stroke-width'] = '1.5'
+          el
+        end
+
+        def polygon(points, fill:)
+          el = Nokogiri::XML::Element.new('polygon', @doc)
+          el['points'] = points.map { |x, y| "#{x},#{y}" }.join(' ')
+          el['fill'] = fill
+          el
+        end
+
+        def from_point
+          [@from.x, @from.y]
+        end
+
+        def to_point
+          [@to.x, @to.y]
+        end
+
+        def unit_perpendicular
+          dx = @to.x - @from.x
+          dy = @to.y - @from.y
+          length = Math.sqrt((dx * dx) + (dy * dy))
+          return [0.0, 0.0] if length.zero?
+
+          [-dy / length, dx / length]
+        end
+
+        # -- Strategy registry --------------------------------------
+        #
+        # Each entry maps a bond kind symbol to a Proc that takes the
+        # renderer and returns an array of Nokogiri elements. Procs
+        # use the public helpers above; nothing reaches into private
+        # state.
+
+        SPACING = StructuralSvg::BOND_SPACING
+        WEDGE_HALF = StructuralSvg::WEDGE_WIDTH / 2.0
+        HASH_COUNT = StructuralSvg::HASH_DASH_COUNT
+
+        RENDERERS = {
+          single: ->(r) { [r.base_line] },
+
+          double: ->(r) { [-SPACING, 0, SPACING].map { |d| r.offset_line(d) }.compact },
+
+          triple: ->(r) { [0, -SPACING * 1.5, SPACING * 1.5].map { |d| r.offset_line(d) }.compact },
+
+          quadruple: ->(r) { [0, -SPACING, SPACING, -SPACING * 2.5].map { |d| r.offset_line(d) }.compact },
+
+          wedge: lambda do |r|
+            px, py = r.unit_perpendicular
+            fx, fy = r.from_point
+            tx, ty = r.to_point
+            [r.polygon([[fx, fy],
+                        [tx + (px * WEDGE_HALF), ty + (py * WEDGE_HALF)],
+                        [tx - (px * WEDGE_HALF), ty - (py * WEDGE_HALF)]],
+                       fill: '#1a1a1a')]
+          end,
+
+          hash: lambda do |r|
+            px, py = r.unit_perpendicular
+            fx, fy = r.from_point
+            tx, ty = r.to_point
+            dx = tx - fx
+            dy = ty - fy
+            nodes = []
+            (1..HASH_COUNT).each do |i|
+              t = i / HASH_COUNT.to_f
+              cx = fx + (dx * t)
+              cy = fy + (dy * t)
+              w = WEDGE_HALF * t
+              nodes << r.line(cx + (px * w), cy + (py * w),
+                              cx - (px * w), cy - (py * w))
+            end
+            nodes
+          end,
+
+          dative: ->(r) { [r.base_line.tap { |l| l['marker-end'] = 'url(#aci-dative-arrow)' }] },
+
+          wavy: lambda do |r|
+            fx, fy = r.from_point
+            tx, ty = r.to_point
+            dx = tx - fx
+            dy = ty - fy
+            px, py = r.unit_perpendicular
+            segments = 8
+            amplitude = 3.0
+            prev_x = fx
+            prev_y = fy
+            nodes = []
+            (1..segments).each do |i|
+              t = i / segments.to_f
+              offset = Math.sin(t * Math::PI * 2) * amplitude
+              x = fx + (dx * t) + (px * offset)
+              y = fy + (dy * t) + (py * offset)
+              nodes << r.line(prev_x, prev_y, x, y)
+              prev_x = x
+              prev_y = y
+            end
+            nodes
+          end
+        }.freeze
+      end
+      private_constant :BondRenderer
+    end
+  end
+end