metanorma-document 0.2.12 → 0.2.13

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,225 +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"
-
-        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

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

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

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

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

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