metanorma-document 0.3.0 → 0.4.0

data/lib/metanorma/mirror/output/html_renderer.rb

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-module Metanorma
-  module Mirror
-    module Output
-      class HtmlRenderer
-        include HtmlRenderers::StructuralRenderers
-        include HtmlRenderers::SectionRenderers
-        include HtmlRenderers::BlockRenderers
-        include HtmlRenderers::ListRenderers
-        include HtmlRenderers::TableRenderers
-        include HtmlRenderers::InlineRenderer
-        include HtmlRenderers::MarkRenderers
-
-        class << self
-          def node_handlers
-            @node_handlers ||= {}
-          end
-
-          def mark_handlers
-            @mark_handlers ||= {}
-          end
-
-          def register_node_handler(type, unbound_method)
-            node_handlers[type] = unbound_method
-          end
-
-          def register_mark_handler(mark_type, handler)
-            mark_handlers[mark_type] = handler
-          end
-        end
-
-        def initialize(guide, numbering: {})
-          @content = extract_content(guide)
-          @numbering = numbering
-        end
-
-        def render
-          render_nodes(@content)
-        end
-
-        def render_nodes(nodes, depth: 0)
-          nodes.filter_map { |node| render_node(node, depth:) }.join("\n")
-        end
-
-        def render_node(node, depth: 0)
-          case node
-          when String
-            HtmlRenderers.escape_text(node)
-          when Model::Text
-            render_text_node(node)
-          when Model::Container, Model::Leaf, Model::SoftBreak
-            render_typed_node(node, depth:)
-          else
-            ""
-          end
-        end
-
-        def render_typed_node(node, depth: 0)
-          unbound = self.class.node_handlers[node.type]
-          return unbound.bind_call(self, node, depth:) if unbound
-
-          render_generic(node, depth:)
-        end
-
-        def render_generic(node, depth: 0)
-          children = node.content if node.is_a?(Model::Container)
-          return "" unless children && !children.empty?
-
-          render_children(node, depth:)
-        end
-
-        def render_children(node, depth: 0)
-          children = node.is_a?(Model::Container) ? node.content : []
-          render_nodes(children, depth:)
-        end
-
-        private
-
-        def extract_content(guide)
-          case guide
-          when Model::Guide
-            guide.content.is_a?(Model::Container) ? guide.content.content : Array(guide.content)
-          when Model::Container
-            guide.content
-          else
-            raise ArgumentError, "Unsupported guide type: #{guide.class}"
-          end
-        end
-      end
-
-      HtmlRenderers.register_all(HtmlRenderer)
-    end
-  end
-end

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

@@ -1,178 +0,0 @@
-# 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

@@ -1,61 +0,0 @@
-# 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

@@ -1,96 +0,0 @@
-# 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

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module Metanorma
-  module Mirror
-    module Output
-      module HtmlRenderers
-        module MarkRenderers
-          def self.register(registry)
-            # Simple-wrap marks: tag and attrs come from the shared Catalog
-            # so the Model-side renderer and the XML-side RichHtmlRenderer
-            # agree on HTML output.
-            Handlers::Inline::Catalog::SIMPLE_WRAPS.each do |mark_type, spec|
-              tag = spec[:tag]
-              attrs = spec.except(:tag)
-              registry.register_mark_handler(mark_type, ->(inner, _mark) {
-                HtmlRenderers.wrap(tag, inner, **attrs)
-              })
-            end
-
-            # Dynamic marks: attrs come from mark.attrs per instance.
-            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("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

@@ -1,129 +0,0 @@
-# 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

@@ -1,80 +0,0 @@
-# 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