metanorma-document 0.2.9 → 0.2.12

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

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

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

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

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Mirror
+    module Handlers
+      module Paragraph
+        EXTRA = { alignment: nil, keep_with_next: nil,
+                  keep_with_previous: nil }.freeze
+
+        def self.call(element, context:)
+          attrs = Handlers.extract_attrs(element, extra_attrs: EXTRA)
+          content = Inline.extract_inline(element, context:)
+
+          Handlers.build_node("paragraph", attrs: attrs, content: content)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Mirror
+    module Handlers
+      module Quote
+        def self.call(element, context:)
+          attrs = Handlers.extract_attrs(element)
+          content = context.extract_blocks(element)
+
+          Handlers.build_node("quote", attrs: attrs, content: content)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Mirror
+    module Handlers
+      module Review
+        EXTRA = { date: nil, from: nil, to: nil, reviewer: nil,
+                  display: nil }.freeze
+
+        def self.call(element, context:)
+          attrs = Handlers.extract_attrs(element, extra_attrs: EXTRA)
+          content = context.extract_blocks(element)
+
+          Handlers.build_node("review", attrs: attrs, content: content)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Mirror
+    module Handlers
+      module Section
+        def self.clause(element, context:)
+          attrs = section_attrs(element, context:)
+          content = context.extract_blocks(element)
+
+          Handlers.build_node("clause", attrs: attrs, content: content)
+        end
+
+        def self.annex(element, context:)
+          attrs = section_attrs(element, context:)
+          attrs[:commentary] = SafeAttr.read(element, :commentary)
+          attrs[:language] = SafeAttr.read(element, :language)
+          attrs[:script] = SafeAttr.read(element, :script)
+
+          content = context.extract_blocks(element)
+
+          Handlers.build_node("annex", attrs: attrs.compact, content: content)
+        end
+
+        def self.content_section(element, context:)
+          attrs = section_attrs(element, context:)
+          content = context.extract_blocks(element)
+
+          subsection = SafeAttr.read(element, :subsection)
+          subsection&.each do |sub|
+            result = context.registry.handle(sub, context: context)
+            result.append_to(content)
+          end
+
+          Handlers.build_node("content_section", attrs: attrs, content: content)
+        end
+
+        def self.terms(element, context:)
+          attrs = section_attrs(element, context:)
+          content = context.extract_named_collections(element,
+                                                      %i[p term dl example
+                                                         admonition])
+          children = context.extract_section_children(element)
+
+          Handlers.build_node("terms", attrs: attrs,
+                                       content: content + children)
+        end
+
+        def self.definitions(element, context:)
+          attrs = section_attrs(element, context:)
+          content = context.extract_blocks(element)
+
+          Handlers.build_node("definitions", attrs: attrs, content: content)
+        end
+
+        def self.references(element, context:)
+          attrs = section_attrs(element, context:)
+          attrs[:normative] = SafeAttr.read(element, :normative)
+          attrs[:hidden] = SafeAttr.read(element, :hidden)
+
+          # Prefatory paragraphs (e.g. "The following documents are referred to...")
+          content = context.extract_named_collections(element,
+                                                      %i[p])
+
+          # Bibliographic items
+          refs = SafeAttr.read(element, :references)
+          refs&.each do |ref|
+            text = extract_biblio_text(ref)
+            next if text.strip.empty?
+
+            content << Handlers.build_node("paragraph",
+                                           attrs: { id: SafeAttr.read(ref,
+                                                                      :id) }.compact,
+                                           content: [context.text_node(text)])
+          end
+
+          Handlers.build_node("references", attrs: attrs, content: content)
+        end
+
+        def self.extract_biblio_text(ref)
+          parts = []
+
+          tag = SafeAttr.read(ref, :biblio_tag)
+          if tag
+            tag_text = Inline.extract_formatted_text(tag).strip
+            parts << tag_text unless tag_text.empty?
+          end
+
+          formatted = SafeAttr.read(ref, :formatted_ref)
+          if formatted
+            fmt_text = Inline.extract_formatted_text(formatted).strip
+            parts << fmt_text unless fmt_text.empty?
+          end
+
+          return parts.join(" ") unless parts.empty?
+
+          docid = SafeAttr.read(ref, :docidentifier)
+          if docid
+            text = Inline.extract_formatted_text(docid)
+            return text unless text.strip.empty?
+          end
+
+          ""
+        end
+
+        def self.floating_title(element, context:)
+          attrs = {}
+          attrs[:id] = context.id_strategy.assign_id(element)
+          attrs[:depth] = SafeAttr.read(element, :depth)
+          attrs[:semx_id] = SafeAttr.read(element, :semx_id)
+
+          title = extract_title(element)
+          attrs[:title] = title if title
+
+          Handlers.build_node("floating_title", attrs: attrs.compact)
+        end
+
+        def self.section_attrs(element, context:)
+          attrs = {}
+          attrs[:id] = context.id_strategy.assign_id(element)
+          attrs[:number] = SafeAttr.read(element, :number)
+          attrs[:obligation] = SafeAttr.read(element, :obligation)
+          attrs[:unnumbered] = SafeAttr.read(element, :unnumbered)
+          attrs[:toc] = SafeAttr.read(element, :toc)
+          attrs[:type] = SafeAttr.read(element, :type)
+          attrs[:semx_id] = SafeAttr.read(element, :semx_id)
+          attrs[:autonum] = SafeAttr.read(element, :autonum)
+          attrs[:displayorder] = SafeAttr.read(element, :displayorder)
+
+          title = extract_title(element)
+          attrs[:title] = title if title
+          attrs.compact
+        end
+
+        def self.extract_title(element)
+          title = SafeAttr.read(element, :title)
+          return nil unless title
+
+          case title
+          when String then title
+          else
+            rich = Inline.extract_rich_html(title)
+            rich.empty? ? Inline.extract_element_text(title) : rich
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Mirror
+    module Handlers
+      module Sourcecode
+        EXTRA = { language: :lang, filename: nil, linenums: nil }.freeze
+
+        def self.call(element, context:)
+          attrs = Handlers.extract_attrs(element, extra_attrs: EXTRA)
+
+          body = SafeAttr.read(element, :body)
+          text = if body
+                   Array(body.content).join
+                 elsif SafeAttr.read(element, :content).is_a?(String)
+                   SafeAttr.read(element, :content)
+                 else
+                   ""
+                 end
+          attrs[:text] = text
+
+          Handlers.build_node("sourcecode", attrs: attrs.compact)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Mirror
+    module Handlers
+      module Structural
+        def self.preface(element, context:)
+          attrs = {}
+          attrs[:semx_id] = SafeAttr.read(element, :semx_id)
+          attrs[:displayorder] = SafeAttr.read(element, :displayorder)
+
+          content = []
+          %i[abstract foreword introduction acknowledgements
+             executivesummary].each do |attr|
+            child = SafeAttr.read(element, attr)
+            next unless child
+
+            result = context.registry.handle(child, context: context)
+            result.append_to(content)
+          end
+
+          element_content = SafeAttr.read(element, :content)
+          Array(element_content).each do |child|
+            result = context.registry.handle(child, context: context)
+            result.append_to(content)
+          end
+
+          Handlers.build_node("preface", attrs: attrs.compact, content: content)
+        end
+
+        def self.sections(element, context:)
+          attrs = {}
+          attrs[:semx_id] = SafeAttr.read(element, :semx_id)
+          attrs[:displayorder] = SafeAttr.read(element, :displayorder)
+
+          content = []
+          %i[clause terms definitions references floating_title].each do |attr|
+            collection = SafeAttr.read(element, attr)
+            next unless collection
+
+            Array(collection).each do |child|
+              result = context.registry.handle(child, context: context)
+              result.append_to(content)
+            end
+          end
+
+          Handlers.build_node("sections", attrs: attrs.compact,
+                                          content: content)
+        end
+
+        def self.bibliography(element, context:)
+          attrs = {}
+          attrs[:semx_id] = SafeAttr.read(element, :semx_id)
+
+          content = []
+          refs = SafeAttr.read(element, :references)
+          Array(refs).each do |ref|
+            result = context.registry.handle(ref, context: context)
+            result.append_to(content)
+          end
+
+          Handlers.build_node("bibliography", attrs: attrs.compact,
+                                              content: content)
+        end
+      end
+    end
+  end
+end