metanorma-document 0.5.1 → 0.5.2.pre.alpha.1

data/lib/metanorma/mirror/handlers/inline/catalog.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module Metanorma
-  module Mirror
-    module Handlers
-      module Inline
-        # Shared declarative table of inline marks whose HTML rendering is
-        # a fixed tag with optional static attrs. It is consumed by
-        # RichHtmlRenderer, which renders Metanorma XML elements to HTML
-        # directly (the fallback / attribute-value path) during the
-        # forward transform into the mirror IR.
-        #
-        # Marks whose attrs vary per instance (link, xref, eref, span)
-        # carry data in mark.attrs and are not in this table; each
-        # consumer keeps custom handlers for those.
-        module Catalog
-          SIMPLE_WRAPS = {
-            "emphasis" => { tag: :em },
-            "strong" => { tag: :strong },
-            "subscript" => { tag: :sub },
-            "superscript" => { tag: :sup },
-            "code" => { tag: :code },
-            "underline" => { tag: :u },
-            "strike" => { tag: :s },
-            "smallcap" => { tag: :span, style: "font-variant: small-caps" },
-            "concept" => { tag: :span, class: "concept" },
-            "bcp14" => { tag: :span, class: "bcp14" },
-            "footnote" => { tag: :sup, class: "footnote-inline" },
-            "stem" => { tag: :span, class: "stem" },
-          }.freeze
-
-          # XML element classes that render via SIMPLE_WRAPS without
-          # per-instance attrs. Maps element class → mark type (catalog
-          # key). RichHtmlRenderer uses this to dispatch simple elements
-          # through the shared table.
-          SIMPLE_ELEMENTS = {
-            Metanorma::Document::Components::Inline::EmRawElement => "emphasis",
-            Metanorma::Document::Components::Inline::StrongRawElement => "strong",
-            Metanorma::Document::Components::Inline::SubElement => "subscript",
-            Metanorma::Document::Components::Inline::SupElement => "superscript",
-            Metanorma::Document::Components::Inline::TtElement => "code",
-            Metanorma::Document::Components::TextElements::UnderlineElement => "underline",
-            Metanorma::Document::Components::TextElements::StrikeElement => "strike",
-            Metanorma::Document::Components::Inline::SmallCapElement => "smallcap",
-            Metanorma::Document::Components::Inline::Bcp14Element => "bcp14",
-            Metanorma::Document::Components::Inline::ConceptElement => "concept",
-          }.freeze
-        end
-      end
-    end
-  end
-end

data/lib/metanorma/mirror/handlers/inline/rich_html_renderer.rb

@@ -1,158 +0,0 @@
-# frozen_string_literal: true
-
-require "nokogiri"
-
-module Metanorma
-  module Mirror
-    module Handlers
-      module Inline
-        # Renders inline Metanorma elements as HTML strings. Used when an HTML
-        # representation of inline content is required (e.g., attribute values,
-        # fallback rendering). All HTML construction goes through
-        # Nokogiri::HTML5::Builder to guarantee well-formed, escaped output.
-        #
-        # Simple-wrap elements (em, strong, sub, sup, code, u, s, smallcap,
-        # bcp14, concept) take their tag-and-attrs mapping from the shared
-        # Inline::Catalog table.
-        module RichHtmlRenderer
-          # Complex element handlers — these have per-instance attrs or
-          # multi-step rendering and bypass the shared Catalog.
-          COMPLEX_RENDERERS = {
-            Metanorma::Document::Components::Inline::StemInlineElement => ->(el) {
-              for_stem(el)
-            },
-            Metanorma::Document::Components::TextElements::StemElement => ->(el) {
-              for_stem(el)
-            },
-            Metanorma::Document::Components::Inline::XrefElement => ->(el) {
-              for_xref(el)
-            },
-            Metanorma::Document::Components::Inline::LinkElement => ->(el) {
-              for_link(el)
-            },
-            Metanorma::Document::Components::Inline::ErefElement => ->(el) {
-              for_eref(el)
-            },
-            Metanorma::Document::Components::Inline::FnElement => ->(el) {
-              for_fn(el)
-            },
-            Metanorma::Document::Components::Inline::SpanElement => ->(el) {
-              for_span(el)
-            },
-            Metanorma::Document::Components::Inline::BrElement => ->(_el) {
-              wrap(&:br)
-            },
-          }.freeze
-
-          def self.extract(element)
-            return "" unless element
-
-            unless element.is_a?(Lutaml::Model::Serializable)
-              return CGI.escapeHTML(element.to_s)
-            end
-
-            parts = []
-            element.each_mixed_content { |node| parts << render_node(node) }
-            result = parts.join.strip
-            result.empty? ? TextExtractor.extract_element_text(element) : result
-          end
-
-          def self.render_node(node)
-            case node
-            when String
-              CGI.escapeHTML(node)
-            when Lutaml::Model::Serializable
-              render_element(node)
-            else
-              ""
-            end
-          end
-
-          def self.render_element(element)
-            complex = COMPLEX_RENDERERS[element.class]
-            return complex.call(element) if complex
-
-            mark_type = Catalog::SIMPLE_ELEMENTS[element.class]
-            return render_simple(mark_type, element) if mark_type
-
-            extract(element)
-          end
-
-          def self.render_simple(mark_type, element)
-            spec = Catalog::SIMPLE_WRAPS[mark_type]
-            attrs = spec.except(:tag)
-            wrap do |d|
-              if attrs.empty?
-                d.public_send(spec[:tag]) { d << raw(extract(element)) }
-              else
-                d.public_send(spec[:tag], attrs) { d << raw(extract(element)) }
-              end
-            end
-          end
-
-          def self.for_stem(element)
-            math = SafeAttr.read(element, :math)
-            return TextExtractor.extract_element_text(element) unless math
-
-            mathml = MathUtil.mathml_from_math(math)
-              .sub(/\s*xmlns(:\w+)?="[^"]*"\s*/, " ")
-              .gsub(/\s+/, " ")
-              .strip
-            spec = Catalog::SIMPLE_WRAPS["stem"]
-            wrap do |d|
-              d.public_send(spec[:tag], spec.except(:tag)) { d << raw(mathml) }
-            end
-          end
-
-          def self.for_xref(element)
-            target = SafeAttr.read(element, :target) || ""
-            label = TextExtractor.extract_formatted_text(element)
-            label = target if label.strip.empty?
-            wrap { |d| d.a(href: "##{target}") { d.text label } }
-          end
-
-          def self.for_link(element)
-            href = SafeAttr.read(element,
-                                 :target) || SafeAttr.read(element, :href) || ""
-            label = TextExtractor.extract_formatted_text(element)
-            wrap { |d| d.a(href: href) { d.text label } }
-          end
-
-          def self.for_eref(element)
-            citeas = SafeAttr.read(element, :citeas) || ""
-            label = TextExtractor.extract_formatted_text(element)
-            wrap { |d| d.a(class: "eref", cite: citeas) { d.text label } }
-          end
-
-          def self.for_fn(element)
-            reference = SafeAttr.read(element, :reference) || ""
-            spec = Catalog::SIMPLE_WRAPS["footnote"]
-            wrap do |d|
-              d.public_send(spec[:tag], spec.except(:tag)) { d.text reference }
-            end
-          end
-
-          def self.for_span(element)
-            cls = SafeAttr.read(element, :class_attr)
-            inner = extract(element)
-            wrap do |d|
-              if cls
-                d.span(class: cls) { d << raw(inner) }
-              else
-                d.span { d << raw(inner) }
-              end
-            end
-          end
-
-          def self.wrap(&)
-            Nokogiri::HTML5::Builder.new(&).doc.root.to_html
-          end
-
-          def self.raw(html_string)
-            Nokogiri::HTML5::DocumentFragment.parse(html_string.to_s)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/metanorma/mirror/handlers/inline/text_extractor.rb

@@ -1,116 +0,0 @@
-# frozen_string_literal: true
-
-module Metanorma
-  module Mirror
-    module Handlers
-      module Inline
-        module TextExtractor
-          def self.extract_element_text(element)
-            return "" unless element.is_a?(Lutaml::Model::Serializable)
-
-            text = SafeAttr.read(element, :text)
-            if text.is_a?(Array)
-              joined = text.join.strip
-              return joined unless joined.empty?
-            elsif text.is_a?(String) && !text.strip.empty?
-              return text
-            end
-
-            content = SafeAttr.read(element, :content)
-            if content.is_a?(Array)
-              parts = content.filter_map do |c|
-                next c.to_s if c.is_a?(String)
-                next extract_element_text(c) if c.is_a?(Lutaml::Model::Serializable)
-
-                nil
-              end
-              joined = parts.join.strip
-              return joined unless joined.empty?
-            elsif content.is_a?(String) && !content.strip.empty?
-              return content
-            end
-
-            ""
-          end
-
-          def self.extract_formatted_text(element)
-            return "" unless element
-            return element.to_s unless element.is_a?(Lutaml::Model::Serializable)
-
-            parts = []
-            element.each_mixed_content do |node|
-              case node
-              when String
-                parts << node
-              when Lutaml::Model::Serializable
-                inner = extract_formatted_text(node)
-                parts << inner if inner && !inner.empty?
-              end
-            end
-            result = parts.join.strip
-            result.empty? ? extract_element_text(element) : result
-          end
-
-          def self.extract_text_from_model(node)
-            case node
-            when Metanorma::Document::Components::Inline::TabElement
-              " "
-            when Metanorma::Document::Components::Inline::BrElement
-              "\n"
-            else
-              text = extract_formatted_text(node)
-              text.empty? ? extract_element_text(node) : text
-            end
-          end
-
-          def self.extract_fn_label(element)
-            label = SafeAttr.read(element, :fmt_fn_label)
-            return extract_element_text(element) unless label
-
-            extract_formatted_text(label)
-          end
-
-          def self.extract_stem_text(element)
-            asciimath = MathUtil.asciimath_from_stem(element)
-            return asciimath if asciimath
-
-            extract_element_text(element)
-          end
-
-          def self.extract_span_text(element)
-            text = extract_element_text(element)
-            return text unless text.strip.empty?
-
-            extract_formatted_text(element)
-          end
-
-          def self.extract_name_text(name)
-            return name if name.is_a?(String)
-
-            text = SafeAttr.read(name, :text)
-            return text.to_s if text.is_a?(String) && !text.strip.empty?
-
-            stems = SafeAttr.read(name, :stem)
-            if stems.is_a?(Array) && !stems.empty?
-              parts = Array(text).dup
-              stems.each_with_index do |s, i|
-                stem_text = MathUtil.text_from_stem(s)
-                parts.insert(i + 1, stem_text) if stem_text && !stem_text.empty?
-              end
-              joined = parts.join.strip
-              return joined unless joined.empty?
-            end
-
-            return Array(text).join if text.is_a?(Array) && !text.empty?
-
-            ""
-          end
-
-          def self.extract_bibdata_title(bibdata)
-            Metadata.title_from_bibdata(bibdata)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/metanorma/mirror/handlers/inline.rb

@@ -1,226 +0,0 @@
-# frozen_string_literal: true
-
-module Metanorma
-  module Mirror
-    module Handlers
-      module Inline
-        autoload :TextExtractor, "#{__dir__}/inline/text_extractor"
-        autoload :RichHtmlRenderer, "#{__dir__}/inline/rich_html_renderer"
-        autoload :Catalog, "#{__dir__}/inline/catalog"
-
-        MARK_BUILDERS = {
-          Metanorma::Document::Components::Inline::EmRawElement => ->(_el) {
-            Handlers.build_mark("emphasis")
-          },
-          Metanorma::Document::Components::Inline::StrongRawElement => ->(_el) {
-            Handlers.build_mark("strong")
-          },
-          Metanorma::Document::Components::Inline::SubElement => ->(_el) {
-            Handlers.build_mark("subscript")
-          },
-          Metanorma::Document::Components::Inline::SupElement => ->(_el) {
-            Handlers.build_mark("superscript")
-          },
-          Metanorma::Document::Components::Inline::TtElement => ->(_el) {
-            Handlers.build_mark("code")
-          },
-          Metanorma::Document::Components::TextElements::UnderlineElement => ->(_el) {
-            Handlers.build_mark("underline")
-          },
-          Metanorma::Document::Components::TextElements::StrikeElement => ->(_el) {
-            Handlers.build_mark("strike")
-          },
-          Metanorma::Document::Components::Inline::SmallCapElement => ->(_el) {
-            Handlers.build_mark("smallcap")
-          },
-          Metanorma::Document::Components::Inline::Bcp14Element => ->(_el) {
-            Handlers.build_mark("bcp14")
-          },
-          Metanorma::Document::Components::Inline::LinkElement => ->(el) {
-            attrs = {
-              href: SafeAttr.read(el, :target) || SafeAttr.read(el, :href),
-            }.compact
-            Handlers.build_mark("link", attrs: attrs)
-          },
-          Metanorma::Document::Components::Inline::XrefElement => ->(el) {
-            attrs = { target: SafeAttr.read(el, :target) }.compact
-            Handlers.build_mark("xref", attrs: attrs)
-          },
-          Metanorma::Document::Components::Inline::ErefElement => ->(el) {
-            attrs = {
-              bibitemid: SafeAttr.read(el, :bibitemid),
-              citeas: SafeAttr.read(el, :citeas),
-            }.compact
-            Handlers.build_mark("eref", attrs: attrs)
-          },
-          Metanorma::Document::Components::Inline::FnElement => ->(el) {
-            attrs = {
-              id: SafeAttr.read(el, :id),
-              reference: SafeAttr.read(el, :reference),
-            }.compact
-            Handlers.build_mark("footnote", attrs: attrs)
-          },
-          Metanorma::Document::Components::Inline::StemInlineElement => ->(el) {
-            attrs = { stem_type: SafeAttr.read(el, :stem_type) || "MathML" }
-            math = SafeAttr.read(el, :math)
-            attrs[:mathml] = MathUtil.mathml_from_math(math) if math
-            Handlers.build_mark("stem", attrs: attrs.compact)
-          },
-          Metanorma::Document::Components::Inline::ConceptElement => ->(el) {
-            attrs = {
-              refterm: SafeAttr.read(el, :refterm),
-              renderterm: SafeAttr.read(el, :renderterm),
-            }.compact
-            Handlers.build_mark("concept", attrs: attrs)
-          },
-          Metanorma::Document::Components::Inline::SpanElement => ->(el) {
-            attrs = {
-              class_attr: SafeAttr.read(el, :class_attr),
-              style: SafeAttr.read(el, :style),
-            }.compact
-            Handlers.build_mark("span", attrs: attrs)
-          },
-        }.freeze
-
-        SEMX_MARK_CONFIG = {
-          "xref" => { mark_type: "xref", target_attr: :target,
-                      fmt_attr: :fmt_xref },
-          "eref" => { mark_type: "eref", target_attr: :target,
-                      fmt_attr: :fmt_xref },
-          "link" => { mark_type: "link", target_attr: :target,
-                      fmt_attr: :fmt_link },
-        }.freeze
-
-        CROSSREF_MARKS = %w[xref eref link].to_set.freeze
-
-        # Delegates to TextExtractor
-        def self.extract_element_text(element)
-          TextExtractor.extract_element_text(element)
-        end
-
-        def self.extract_formatted_text(element)
-          TextExtractor.extract_formatted_text(element)
-        end
-
-        def self.extract_text_from_model(node)
-          TextExtractor.extract_text_from_model(node)
-        end
-
-        # Delegates to RichHtmlRenderer
-        def self.extract_rich_html(element)
-          RichHtmlRenderer.extract(element)
-        end
-
-        # Primary entry point: extract inline content from a mixed-content element.
-        # Iterates semantic children only — `fmt-*` rendered siblings are skipped
-        # to avoid emitting duplicate marks for the same logical content.
-        def self.extract_inline(element, context:)
-          nodes = []
-          Metanorma::Document::Components::Inline::SemanticContent.each(element) do |node|
-            case node
-            when String
-              nodes << context.text_node(node) unless node.empty?
-            else
-              handle_inline_element(node, nodes, context:)
-            end
-          end
-          filter_empty_crossrefs(nodes)
-        end
-
-        def self.handle_inline_element(element, nodes, context:)
-          if semx_element?(element)
-            handle_semx(element, nodes, context:)
-            return
-          end
-
-          if block_in_inline?(element, context)
-            handle_block_in_inline(element, nodes, context:)
-            return
-          end
-
-          mark_builder = MARK_BUILDERS[element.class]
-          if mark_builder
-            mark = mark_builder.call(element)
-            text = extract_marked_text(mark.type, element)
-            nodes << context.text_node(text, marks: [mark])
-          else
-            handle_structured_inline(element, nodes, context:)
-          end
-        end
-
-        def self.handle_semx(element, nodes, context:)
-          config = SEMX_MARK_CONFIG[element.element_attr]
-          if config
-            handle_semx_crossref(element, config, nodes, context:)
-          else
-            handle_structured_inline(element, nodes, context:)
-          end
-        end
-
-        def self.handle_semx_crossref(element, config, nodes, context:)
-          fmt_children = SafeAttr.read(element, config[:fmt_attr])
-          fmt_child = fmt_children&.first
-
-          mark_attrs = {}
-          if fmt_child && config[:target_attr]
-            mark_attrs[config[:target_attr]] = SafeAttr.read(fmt_child, :target)
-          end
-
-          if element.element_attr == "eref" && fmt_child
-            mark_attrs[:citeas] = extract_formatted_text(fmt_child)
-          end
-
-          text = extract_formatted_text(fmt_child || element)
-          mark = Handlers.build_mark(config[:mark_type],
-                                     attrs: mark_attrs.compact)
-          nodes << context.text_node(text, marks: [mark])
-        end
-
-        def self.handle_block_in_inline(element, nodes, context:)
-          result = context.registry.handle(element, context: context)
-          result.append_to(nodes)
-        end
-
-        def self.handle_structured_inline(element, nodes, context:)
-          if element.is_a?(Lutaml::Model::Serializable)
-            inner_nodes = extract_inline(element, context:)
-            nodes.concat(inner_nodes)
-          else
-            text = element.text
-            nodes << context.text_node(text) if text.is_a?(String) && !text.strip.empty?
-          end
-        end
-
-        def self.mark_text_extractors
-          @mark_text_extractors ||= {
-            "footnote" => TextExtractor.method(:extract_fn_label),
-            "stem" => TextExtractor.method(:extract_stem_text),
-            "span" => TextExtractor.method(:extract_span_text),
-          }
-        end
-
-        def self.extract_marked_text(mark_type, element)
-          extractor = mark_text_extractors[mark_type]
-          return extractor.call(element) if extractor
-
-          TextExtractor.extract_element_text(element)
-        end
-
-        def self.semx_element?(element)
-          element.is_a?(Metanorma::Document::Components::Inline::SemxElement)
-        end
-
-        def self.block_in_inline?(element, context)
-          context.registry.registered?(element.class)
-        end
-
-        def self.filter_empty_crossrefs(nodes)
-          nodes.reject do |n|
-            n.is_a?(Model::Text) && n.text.strip.empty? &&
-              n.marks.any? { |m| CROSSREF_MARKS.include?(m.type) }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/metanorma/mirror/handlers/list.rb

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-module Metanorma
-  module Mirror
-    module Handlers
-      module List
-        def self.bullet(element, context:)
-          attrs = list_attrs(element)
-          items = extract_items(element, context:)
-
-          Handlers.build_node("bullet_list", attrs: attrs, content: items)
-        end
-
-        def self.ordered(element, context:)
-          attrs = list_attrs(element)
-          attrs[:type] = SafeAttr.read(element, :type)
-          attrs[:start] = SafeAttr.read(element, :start)
-          attrs[:group] = SafeAttr.read(element, :group)
-          items = extract_items(element, context:)
-
-          Handlers.build_node("ordered_list", attrs: attrs.compact,
-                                              content: items)
-        end
-
-        def self.definition(element, context:)
-          attrs = list_attrs(element)
-          attrs[:key] = SafeAttr.read(element, :key)
-          items = extract_definition_items(element, context:)
-
-          Handlers.build_node("dl", attrs: attrs.compact, content: items)
-        end
-
-        def self.list_item(element, context:)
-          attrs = {}
-          attrs[:id] = SafeAttr.read(element, :id)
-          attrs[:checkbox] = SafeAttr.read(element, :checkbox)
-          attrs[:checkedcheckbox] = SafeAttr.read(element, :checkedcheckbox)
-
-          content = []
-          text = SafeAttr.read(element, :text)
-          if text.is_a?(Array)
-            text.each do |t|
-              next if t.is_a?(String) && t.strip.empty?
-
-              content << context.text_node(t.to_s)
-            end
-          end
-
-          %i[paragraphs unordered_lists ordered_lists sourcecode figure example
-             note quote table].each do |attr|
-            collection = SafeAttr.read(element, attr)
-            next unless collection
-
-            collection.each do |child|
-              result = context.registry.handle(child, context: context)
-              result.append_to(content)
-            end
-          end
-
-          Handlers.build_node("list_item", attrs: attrs.compact,
-                                           content: content)
-        end
-
-        def self.extract_items(element, context:)
-          Array(element.listitem).filter_map do |li|
-            result = context.registry.handle(li, context: context)
-            result.nodes
-          end
-        end
-
-        def self.extract_definition_items(element, context:)
-          items = []
-          dts = Array(element.dt)
-          dds = Array(element.dd)
-
-          dts.each_with_index do |dt, idx|
-            dt_attrs = {}
-            dt_attrs[:id] = SafeAttr.read(dt, :id)
-            dt_content = Inline.extract_inline(dt, context:)
-            items << Handlers.build_node("dt", attrs: dt_attrs.compact,
-                                               content: dt_content)
-
-            dd = dds[idx]
-            next unless dd
-
-            dd_attrs = {}
-            dd_attrs[:id] = SafeAttr.read(dd, :id)
-            dd_content = context.extract_named_collections(dd,
-                                                           %i[p ul ol
-                                                              sourcecode figure example note table formula quote dl])
-            items << Handlers.build_node("dd", attrs: dd_attrs.compact,
-                                               content: dd_content)
-          end
-          items
-        end
-
-        def self.list_attrs(element)
-          attrs = {}
-          attrs[:id] = SafeAttr.read(element, :id)
-          attrs[:nobullet] = SafeAttr.read(element, :nobullet)
-          attrs[:bare] = SafeAttr.read(element, :bare)
-          attrs[:spacing] = SafeAttr.read(element, :spacing)
-          attrs[:indent] = SafeAttr.read(element, :indent)
-          attrs[:semx_id] = SafeAttr.read(element, :semx_id)
-          attrs.compact
-        end
-      end
-    end
-  end
-end

data/lib/metanorma/mirror/handlers/note.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module Metanorma
-  module Mirror
-    module Handlers
-      module Note
-        EXTRA = { type_attr: :type_attr, remove_in_rfc: nil }.freeze
-
-        def self.call(element, context:)
-          attrs = Handlers.extract_attrs(element, extra_attrs: EXTRA)
-
-          content = []
-          element_content = SafeAttr.read(element, :content)
-          if element_content.is_a?(Array)
-            element_content.each do |p|
-              result = context.registry.handle(p, context: context)
-              result.append_to(content)
-            end
-          end
-
-          Handlers.build_node("note", attrs: attrs, content: content)
-        end
-      end
-    end
-  end
-end