metanorma-document 0.2.9 → 0.2.12

data/lib/metanorma/mirror/output/html_renderers/block_renderers.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Mirror
+    module Output
+      module HtmlRenderers
+        module BlockRenderers
+          ADMONITION_TITLES = {
+            "danger" => "Danger", "caution" => "Caution",
+            "warning" => "Warning", "important" => "Important",
+            "safety precautions" => "Safety Precautions",
+            "editorial" => "Editorial",
+            "tip" => "Tip", "note" => "Note",
+            "commentary" => "Commentary"
+          }.freeze
+
+          def self.register(registry)
+            registry.register_node_handler("paragraph",
+                                           instance_method(:render_paragraph))
+            registry.register_node_handler("note",
+                                           instance_method(:render_note))
+            registry.register_node_handler("admonition",
+                                           instance_method(:render_admonition))
+            registry.register_node_handler("example",
+                                           instance_method(:render_example))
+            registry.register_node_handler("figure",
+                                           instance_method(:render_figure))
+            registry.register_node_handler("image",
+                                           instance_method(:render_image))
+            registry.register_node_handler("sourcecode",
+                                           instance_method(:render_sourcecode))
+            registry.register_node_handler("formula",
+                                           instance_method(:render_formula))
+            registry.register_node_handler("quote",
+                                           instance_method(:render_quote))
+            registry.register_node_handler("review",
+                                           instance_method(:render_review))
+            registry.register_node_handler("term",
+                                           instance_method(:render_term))
+          end
+
+          def render_paragraph(node, depth: 0)
+            HtmlRenderers.build do |doc|
+              attrs = { class: "mn-paragraph" }
+              attrs[:id] = node.attrs["id"] if node.attrs["id"]
+              doc.p(attrs) do
+                HtmlRenderers.embed(doc, render_inline(node.content))
+              end
+            end
+          end
+
+          def render_note(node, depth: 0)
+            HtmlRenderers.build do |doc|
+              attrs = { class: "mn-note" }
+              attrs[:id] = node.attrs["id"] if node.attrs["id"]
+              doc.div(attrs) do
+                doc.div(class: "note-title") { doc.text "Note" }
+                HtmlRenderers.embed(doc, render_children(node, depth:))
+              end
+            end
+          end
+
+          def render_admonition(node, depth: 0)
+            adm_type = node.attrs["type"] || "note"
+            title = ADMONITION_TITLES[adm_type] || adm_type.capitalize
+
+            HtmlRenderers.build do |doc|
+              attrs = { class: "mn-admonition mn-admonition--#{adm_type}" }
+              attrs[:id] = node.attrs["id"] if node.attrs["id"]
+              doc.div(attrs) do
+                doc.div(class: "admonition-content") do
+                  doc.div(class: "admonition-title") { doc.text title }
+                  HtmlRenderers.embed(doc, render_children(node, depth:))
+                end
+              end
+            end
+          end
+
+          def render_example(node, depth: 0)
+            HtmlRenderers.build do |doc|
+              attrs = { class: "mn-example" }
+              attrs[:id] = node.attrs["id"] if node.attrs["id"]
+              doc.div(attrs) do
+                HtmlRenderers.embed(doc, render_children(node, depth:))
+              end
+            end
+          end
+
+          def render_figure(node, depth: 0)
+            HtmlRenderers.build do |doc|
+              attrs = { class: "mn-figure" }
+              attrs[:id] = node.attrs["id"] if node.attrs["id"]
+              doc.figure(attrs) do
+                HtmlRenderers.embed(doc, render_children(node, depth:))
+                if node.attrs["title"]
+                  doc.figcaption { doc.text node.attrs["title"] }
+                end
+              end
+            end
+          end
+
+          def render_image(node, depth: 0)
+            HtmlRenderers.build do |doc|
+              attrs = {
+                src: node.attrs["src"] || "",
+                alt: node.attrs["alt"] || "",
+                loading: "lazy",
+              }
+              attrs[:height] = node.attrs["height"] if node.attrs["height"]
+              attrs[:width] = node.attrs["width"] if node.attrs["width"]
+              doc.img(attrs)
+            end
+          end
+
+          def render_sourcecode(node, depth: 0)
+            lang = node.attrs["language"]
+            lang_class = lang ? " language-#{lang}" : ""
+
+            HtmlRenderers.build do |doc|
+              attrs = { class: "mn-sourcecode#{lang_class}" }
+              attrs[:id] = node.attrs["id"] if node.attrs["id"]
+              doc.div(attrs) do
+                doc.span(class: "code-language-badge") { doc.text lang } if lang
+                doc.pre(class: "code-block") do
+                  doc.code { doc.text node.attrs["text"] || "" }
+                end
+              end
+            end
+          end
+
+          def render_formula(node, depth: 0)
+            HtmlRenderers.build do |doc|
+              attrs = { class: "mn-formula" }
+              attrs[:id] = node.attrs["id"] if node.attrs["id"]
+              doc.div(attrs) do
+                doc.span(class: "formula-math") do
+                  math = node.attrs["mathml"]
+                  if math
+                    HtmlRenderers.embed(doc, math)
+                  elsif node.attrs["asciimath"]
+                    doc.text node.attrs["asciimath"]
+                  else
+                    doc.text node.attrs["math_text"] || ""
+                  end
+                end
+              end
+            end
+          end
+
+          def render_quote(node, depth: 0)
+            HtmlRenderers.build do |doc|
+              attrs = { class: "mn-quote" }
+              attrs[:id] = node.attrs["id"] if node.attrs["id"]
+              doc.blockquote(attrs) do
+                HtmlRenderers.embed(doc, render_children(node))
+              end
+            end
+          end
+
+          def render_review(_node, depth: 0)
+            ""
+          end
+
+          def render_term(node, depth: 0)
+            HtmlRenderers.build do |doc|
+              attrs = { class: "mn-term" }
+              attrs[:id] = node.attrs["id"] if node.attrs["id"]
+              doc.div(attrs) do
+                HtmlRenderers.embed(doc,
+                                    render_children(node, depth: depth + 1))
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/mirror/output/html_renderers/inline_renderer.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Mirror
+    module Output
+      module HtmlRenderers
+        module InlineRenderer
+          def self.register(registry); end
+
+          def render_inline(content)
+            return "" unless content
+            return "" if content.empty?
+
+            HtmlRenderers.build_fragment do |doc|
+              content.each do |node|
+                case node
+                when String
+                  doc.text node
+                when Model::Text
+                  HtmlRenderers.embed(doc, render_text_node(node))
+                when Model::SoftBreak
+                  doc.br
+                when Model::Container
+                  if node.type == "footnote_marker"
+                    HtmlRenderers.embed(doc, render_footnote_marker(node))
+                  else
+                    HtmlRenderers.embed(doc, render_node(node))
+                  end
+                end
+              end
+            end
+          end
+
+          def render_text_node(node)
+            inner_html = HtmlRenderers.escape_text(node.text)
+            node.marks.reduce(inner_html) do |current, mark|
+              apply_mark(current, mark)
+            end
+          end
+
+          def apply_mark(inner_html, mark)
+            handler = self.class.mark_handlers[mark.type]
+            handler ? handler.call(inner_html, mark) : inner_html
+          end
+
+          def render_footnote_marker(node)
+            HtmlRenderers.build do |doc|
+              doc.sup(class: "footnote-marker") do
+                attrs = {}
+                attrs[:id] = node.attrs["id"] if node.attrs["id"]
+                doc.a(attrs.merge(href: "##{node.attrs['ref_id'] || ''}")) do
+                  doc.text node.attrs["number"] || "*"
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/mirror/output/html_renderers/list_renderers.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Mirror
+    module Output
+      module HtmlRenderers
+        module ListRenderers
+          def self.register(registry)
+            registry.register_node_handler("bullet_list",
+                                           instance_method(:render_bullet_list))
+            registry.register_node_handler("ordered_list",
+                                           instance_method(:render_ordered_list))
+            registry.register_node_handler("dl", instance_method(:render_dl))
+            registry.register_node_handler("list_item",
+                                           instance_method(:render_list_item))
+            registry.register_node_handler("dt", instance_method(:render_dt))
+            registry.register_node_handler("dd", instance_method(:render_dd))
+          end
+
+          def render_bullet_list(node, depth: 0)
+            render_list(node, "ul", "mn-bullet-list")
+          end
+
+          def render_ordered_list(node, depth: 0)
+            render_list(node, "ol", "mn-ordered-list")
+          end
+
+          def render_list_item(node, depth: 0)
+            HtmlRenderers.build do |doc|
+              doc.li(class: "mn-list-item") do
+                HtmlRenderers.embed(doc, render_inline(node.content))
+              end
+            end
+          end
+
+          def render_dl(node, depth: 0)
+            HtmlRenderers.build do |doc|
+              doc.dl(class: "mn-definition-list") do
+                node.content.each do |item|
+                  next unless item.is_a?(Model::Container) || item.is_a?(Model::Leaf)
+
+                  case item.type
+                  when "dt"
+                    doc.dt(class: "mn-dt") do
+                      HtmlRenderers.embed(doc, render_inline(item.content))
+                    end
+                  when "dd"
+                    doc.dd(class: "mn-dd") do
+                      HtmlRenderers.embed(doc, render_children(item))
+                    end
+                  else
+                    HtmlRenderers.embed(doc, render_node(item))
+                  end
+                end
+              end
+            end
+          end
+
+          def render_dt(node, depth: 0)
+            HtmlRenderers.build do |doc|
+              doc.dt(class: "mn-dt") do
+                HtmlRenderers.embed(doc, render_inline(node.content))
+              end
+            end
+          end
+
+          def render_dd(node, depth: 0)
+            HtmlRenderers.build do |doc|
+              doc.dd(class: "mn-dd") do
+                HtmlRenderers.embed(doc, render_children(node))
+              end
+            end
+          end
+
+          private
+
+          def render_list(node, tag, css_class)
+            HtmlRenderers.build do |doc|
+              doc.public_send(tag, class: css_class) do
+                node.content.each do |item|
+                  if item.is_a?(Model::Container) && item.type == "list_item"
+                    doc.li(class: "mn-list-item") do
+                      HtmlRenderers.embed(doc, render_inline(item.content))
+                    end
+                  else
+                    HtmlRenderers.embed(doc, render_node(item))
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/mirror/output/html_renderers/mark_renderers.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Mirror
+    module Output
+      module HtmlRenderers
+        module MarkRenderers
+          def self.register(registry)
+            registry.register_mark_handler("emphasis", ->(inner, _mark) {
+              HtmlRenderers.wrap(:em, inner)
+            })
+            registry.register_mark_handler("strong", ->(inner, _mark) {
+              HtmlRenderers.wrap(:strong, inner)
+            })
+            registry.register_mark_handler("subscript", ->(inner, _mark) {
+              HtmlRenderers.wrap(:sub, inner)
+            })
+            registry.register_mark_handler("superscript", ->(inner, _mark) {
+              HtmlRenderers.wrap(:sup, inner)
+            })
+            registry.register_mark_handler("code", ->(inner, _mark) {
+              HtmlRenderers.wrap(:code, inner)
+            })
+            registry.register_mark_handler("underline", ->(inner, _mark) {
+              HtmlRenderers.wrap(:u, inner)
+            })
+            registry.register_mark_handler("strike", ->(inner, _mark) {
+              HtmlRenderers.wrap(:s, inner)
+            })
+            registry.register_mark_handler("smallcap", ->(inner, _mark) {
+              HtmlRenderers.wrap(:span, inner, style: "font-variant: small-caps")
+            })
+            registry.register_mark_handler("link", ->(inner, mark) {
+              HtmlRenderers.wrap(:a, inner, href: mark.attrs["href"] || "#")
+            })
+            registry.register_mark_handler("xref", ->(inner, mark) {
+              HtmlRenderers.wrap(:a, inner, href: "##{mark.attrs['target'] || ''}")
+            })
+            registry.register_mark_handler("eref", ->(inner, mark) {
+              HtmlRenderers.wrap(:a, inner, class: "eref", cite: mark.attrs["citeas"] || "")
+            })
+            registry.register_mark_handler("footnote", ->(inner, _mark) {
+              HtmlRenderers.wrap(:sup, inner, class: "footnote-inline")
+            })
+            registry.register_mark_handler("stem", ->(inner, _mark) {
+              HtmlRenderers.wrap(:span, inner, class: "stem")
+            })
+            registry.register_mark_handler("concept", ->(inner, _mark) {
+              HtmlRenderers.wrap(:span, inner, class: "concept")
+            })
+            registry.register_mark_handler("bcp14", ->(inner, _mark) {
+              HtmlRenderers.wrap(:span, inner, class: "bcp14")
+            })
+            registry.register_mark_handler("span", ->(inner, mark) {
+              cls = mark.attrs["class_attr"]
+              attrs = cls ? { class: cls } : {}
+              HtmlRenderers.wrap(:span, inner, **attrs)
+            })
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/mirror/output/html_renderers/section_renderers.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Mirror
+    module Output
+      module HtmlRenderers
+        module SectionRenderers
+          def self.register(registry)
+            registry.register_node_handler("clause",
+                                           instance_method(:render_clause))
+            registry.register_node_handler("annex",
+                                           instance_method(:render_annex))
+            registry.register_node_handler("content_section",
+                                           instance_method(:render_content_section))
+            registry.register_node_handler("abstract",
+                                           instance_method(:render_content_section))
+            registry.register_node_handler("foreword",
+                                           instance_method(:render_content_section))
+            registry.register_node_handler("introduction",
+                                           instance_method(:render_content_section))
+            registry.register_node_handler("acknowledgements",
+                                           instance_method(:render_content_section))
+            registry.register_node_handler("terms",
+                                           instance_method(:render_terms))
+            registry.register_node_handler("definitions",
+                                           instance_method(:render_definitions))
+            registry.register_node_handler("references",
+                                           instance_method(:render_references))
+            registry.register_node_handler("floating_title",
+                                           instance_method(:render_floating_title))
+          end
+
+          def render_clause(node, depth: 0)
+            title = node.attrs["title"]
+            number = node.attrs["number"] || @numbering[node.attrs["id"]]
+
+            HtmlRenderers.build do |doc|
+              attrs = { class: "mn-clause" }
+              attrs[:id] = node.attrs["id"] if node.attrs["id"]
+              doc.section(attrs) do
+                if title
+                  heading_attrs = { class: "mn-clause__title" }
+                  heading_attrs[:id] = node.attrs["id"] if node.attrs["id"]
+                  render_heading(doc, depth + 2, heading_attrs) do
+                    doc.text "#{number} " if number
+                    doc.text title
+                  end
+                end
+                HtmlRenderers.embed(doc,
+                                    render_children(node, depth: depth + 1))
+              end
+            end
+          end
+
+          def render_annex(node, depth: 0)
+            title = node.attrs["title"]
+
+            HtmlRenderers.build do |doc|
+              attrs = { class: "mn-annex" }
+              attrs[:id] = node.attrs["id"] if node.attrs["id"]
+              doc.section(attrs) do
+                if title
+                  heading_attrs = { class: "mn-annex__title" }
+                  heading_attrs[:id] = node.attrs["id"] if node.attrs["id"]
+                  doc.h2(heading_attrs) { doc.text title }
+                end
+                HtmlRenderers.embed(doc,
+                                    render_children(node, depth: depth + 1))
+              end
+            end
+          end
+
+          def render_content_section(node, depth: 0)
+            title = node.attrs["title"]
+            css_class = "mn-#{node.type}"
+
+            HtmlRenderers.build do |doc|
+              attrs = { class: css_class }
+              attrs[:id] = node.attrs["id"] if node.attrs["id"]
+              doc.section(attrs) do
+                if title
+                  heading_attrs = { class: "#{css_class}__title" }
+                  heading_attrs[:id] = node.attrs["id"] if node.attrs["id"]
+                  doc.h2(heading_attrs) { doc.text title }
+                end
+                HtmlRenderers.embed(doc, render_children(node, depth:))
+              end
+            end
+          end
+
+          def render_terms(node, depth: 0)
+            render_content_section(node, depth:)
+          end
+
+          def render_definitions(node, depth: 0)
+            render_content_section(node, depth:)
+          end
+
+          def render_references(node, depth: 0)
+            render_content_section(node, depth:)
+          end
+
+          def render_floating_title(node, depth: 0)
+            title = node.attrs["title"]
+            heading_depth = node.attrs["depth"] || 2
+
+            return "" unless title
+
+            HtmlRenderers.build do |doc|
+              attrs = { class: "mn-floating-title" }
+              attrs[:id] = node.attrs["id"] if node.attrs["id"]
+              render_heading(doc, heading_depth, attrs) { doc.text title }
+            end
+          end
+
+          def render_heading(doc, level, attrs, &)
+            case level.to_i
+            when 3 then doc.h3(attrs, &)
+            when 4 then doc.h4(attrs, &)
+            when 5 then doc.h5(attrs, &)
+            when 6 then doc.h6(attrs, &)
+            else doc.h2(attrs, &)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/mirror/output/html_renderers/structural_renderers.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Mirror
+    module Output
+      module HtmlRenderers
+        module StructuralRenderers
+          def self.register(registry)
+            registry.register_node_handler("doc", instance_method(:render_doc))
+            registry.register_node_handler("preface",
+                                           instance_method(:render_preface))
+            registry.register_node_handler("sections",
+                                           instance_method(:render_sections))
+            registry.register_node_handler("bibliography",
+                                           instance_method(:render_bibliography))
+            registry.register_node_handler("footnotes",
+                                           instance_method(:render_footnotes))
+            registry.register_node_handler("soft_break",
+                                           instance_method(:render_soft_break))
+          end
+
+          def render_doc(node, depth: 0)
+            HtmlRenderers.build do |doc|
+              HtmlRenderers.embed(doc, render_children(node, depth:))
+            end
+          end
+
+          def render_preface(node, depth: 0)
+            HtmlRenderers.build do |doc|
+              doc.section(class: "mn-preface") do
+                HtmlRenderers.embed(doc, render_children(node, depth:))
+              end
+            end
+          end
+
+          def render_sections(node, depth: 0)
+            HtmlRenderers.build do |doc|
+              doc.section(class: "mn-sections") do
+                HtmlRenderers.embed(doc, render_children(node, depth:))
+              end
+            end
+          end
+
+          def render_bibliography(node, depth: 0)
+            HtmlRenderers.build do |doc|
+              doc.section(class: "mn-bibliography") do
+                HtmlRenderers.embed(doc, render_children(node, depth:))
+              end
+            end
+          end
+
+          def render_footnotes(node, depth: 0)
+            HtmlRenderers.build do |doc|
+              doc.div(class: "footnotes") do
+                doc.ol do
+                  node.content.each do |fn|
+                    next unless fn.is_a?(Model::Container)
+
+                    fn_attrs = {}
+                    fn_attrs[:id] = fn.attrs["id"] if fn.attrs["id"]
+                    doc.li(fn_attrs) do
+                      HtmlRenderers.embed(doc, render_children(fn))
+                      if fn.attrs["ref_id"]
+                        doc.a(href: "##{fn.attrs['ref_id']}") { doc.text "↩" }
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+
+          def render_soft_break(_node, depth: 0)
+            HtmlRenderers.build(&:br)
+          end
+        end
+      end
+    end
+  end
+end