metanorma-mirror 1.0.0

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

@@ -0,0 +1,114 @@
+# 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)
+            substitution = Mirror.inline_text_substitutions.lookup(node)
+            if substitution
+              substitution
+            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

@@ -0,0 +1,155 @@
+# 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"
+
+        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 = []
+          iterator = Mirror.inline_content_iterator or
+            raise Error, "no inline content iterator registered; " \
+                         "the document seed must provide one"
+          iterator.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 = Mirror.mark_builders.lookup(element)
+          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)
+          !Mirror.semx_elements.lookup(element).nil?
+        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
+                   body.decoded_content
+                 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