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

data/lib/metanorma/mirror/id_strategy/positional.rb

@@ -1,166 +0,0 @@
-# frozen_string_literal: true
-
-module Metanorma
-  module Mirror
-    module IdStrategy
-      # Assign positional IDs (sec-X.Y.Z, table-N, fig-N, anx-X) to elements
-      # that have UUID IDs. Elements with author-assigned explicit IDs are
-      # preserved. Cross-reference targets are translated to use the new IDs.
-      #
-      # Positional IDs are derived from the element's resolved section number
-      # (the "number" attribute on the presentation XML element), which
-      # represents the document's structural position.
-      #
-      # Example:
-      #   UUID element with number "5.4" → id: "sec-5.4"
-      #   UUID element with number "A.2"  → id: "anx-A.2"
-      #   Explicit id "sec-3.1.3.4"       → id: "sec-3.1.3.4" (unchanged)
-      class Positional < Base
-        @categories = {}
-
-        class << self
-          # Registry of Metanorma model classes → positional-ID category
-          # (:section, :annex, :figure, :table). Adding new flavors or new
-          # model types requires only a new register_category call — no
-          # edits to derive/element_category (OCP).
-          def categories
-            @categories
-          end
-
-          def register_category(model_class, category)
-            categories[model_class] = category
-            self
-          end
-
-          def unregister_category(model_class)
-            categories.delete(model_class)
-            self
-          end
-
-          def category_for(element)
-            return categories[element.class] if categories.key?(element.class)
-
-            categories.each do |klass, category|
-              return category if element.is_a?(klass)
-            end
-            nil
-          end
-        end
-
-        register_category Metanorma::StandardDocument::Sections::ClauseSection,
-                          :section
-        register_category Metanorma::StandardDocument::Sections::ContentSection,
-                          :section
-        register_category Metanorma::StandardDocument::Sections::TermsSection,
-                          :section
-        register_category Metanorma::StandardDocument::Sections::DefinitionSection,
-                          :section
-        register_category Metanorma::StandardDocument::Sections::AnnexSection,
-                          :annex
-        register_category Metanorma::Document::Components::AncillaryBlocks::FigureBlock,
-                          :figure
-        register_category Metanorma::Document::Components::Tables::TableBlock,
-                          :table
-
-        def initialize
-          @id_map = {}
-        end
-
-        def assign_id(element)
-          raw = raw_id(element)
-          return raw unless uuid?(raw)
-
-          positional = derive(element)
-          return raw unless positional
-
-          @id_map[raw] = positional
-          positional
-        end
-
-        def finalize!(document)
-          translate_targets(document)
-          document
-        end
-
-        private
-
-        def raw_id(element)
-          SafeAttr.read(element, :id)
-        end
-
-        def uuid?(id)
-          id&.start_with?("_")
-        end
-
-        def derive(element)
-          number = extract_number(element)
-          return nil unless number && !number.strip.empty?
-
-          case self.class.category_for(element)
-          when :section
-            number.match?(/\A[\d.]+\z/) ? "sec-#{number}" : nil
-          when :annex
-            number.match?(/\A[A-Z]/) ? "anx-#{number}" : nil
-          when :figure
-            "fig-#{number}"
-          when :table
-            "table-#{number}"
-          end
-        end
-
-        def extract_number(element)
-          number = SafeAttr.read(element, :number)
-          return number if number && !number.strip.empty?
-
-          attrs = element.class.attributes
-          return nil unless attrs.key?(:fmt_title)
-
-          fmt_title = element.fmt_title
-          return nil unless fmt_title
-
-          parts = collect_autonum_text(fmt_title)
-          parts.empty? ? nil : parts.join(".")
-        end
-
-        def collect_autonum_text(node)
-          parts = []
-          attrs = node.class.attributes
-
-          if attrs.key?(:semx) && node.semx
-            node.semx.each do |s|
-              next unless s.element_attr == "autonum"
-
-              text = s.text&.join
-              parts << text if text && !text.empty?
-            end
-          end
-
-          if attrs.key?(:span) && node.span
-            node.span.each { |sp| parts.concat(collect_autonum_text(sp)) }
-          end
-
-          parts
-        end
-
-        def translate_targets(node)
-          case node
-          when Model::Text
-            node.marks.each { |mark| translate_mark_target(mark) }
-          when Model::Container
-            node.content.each { |child| translate_targets(child) }
-          end
-        end
-
-        def translate_mark_target(mark)
-          return unless mark.type == "xref"
-
-          target = mark["target"]
-          return unless target
-
-          translated = @id_map[target]
-          mark["target"] = translated if translated
-        end
-      end
-    end
-  end
-end

data/lib/metanorma/mirror/id_strategy/preserve.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module Metanorma
-  module Mirror
-    module IdStrategy
-      # Preserve all IDs as-is (default behavior).
-      # UUID elements keep their UUID IDs. Explicit IDs are unchanged.
-      class Preserve < Base
-      end
-    end
-  end
-end

data/lib/metanorma/mirror/id_strategy.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module Metanorma
-  module Mirror
-    module IdStrategy
-      autoload :Preserve, "#{__dir__}/id_strategy/preserve"
-      autoload :Positional, "#{__dir__}/id_strategy/positional"
-
-      # Base class for ID assignment strategies.
-      #
-      # A strategy controls how element IDs are assigned during mirror
-      # generation. Subclasses override assign_id and finalize!.
-      #
-      # assign_id(element)  — called per element during node construction
-      # finalize!(document) — called once after the full mirror tree is built
-      #
-      # Adding a new strategy = adding a new class. No changes to handlers
-      # or the converter (OCP).
-      class Base
-        # Returns the ID string to assign to the mirror node for this element.
-        def assign_id(element)
-          SafeAttr.read(element, :id)
-        end
-
-        # Post-process the completed mirror document after all IDs are assigned.
-        # Use this to translate cross-reference targets, etc.
-        # Returns the (possibly modified) document.
-        def finalize!(document)
-          document
-        end
-      end
-    end
-  end
-end

data/lib/metanorma/mirror/math_util.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module Metanorma
-  module Mirror
-    # MathUtil is the single home for math-content extraction helpers.
-    #
-    # These helpers convert mathML XML objects into strings (stripped of
-    # XML declarations) and extract asciimath from stem elements. They
-    # are used by handlers and renderers that need to carry math content
-    # through the mirror pipeline.
-    module MathUtil
-      STRIP_XML_DECL_PATTERN = /\A<\?xml[^?]*\?>\s?/
-      private_constant :STRIP_XML_DECL_PATTERN
-
-      def self.strip_xml_decl(math_xml)
-        math_xml.sub(STRIP_XML_DECL_PATTERN, "")
-      end
-
-      def self.mathml_from_math(math)
-        xml = math.is_a?(Array) ? math.map(&:to_xml).join : math.to_xml
-        strip_xml_decl(xml)
-      end
-
-      # Extract asciimath text from a stem element. Returns nil if no
-      # asciimath is present.
-      def self.asciimath_from_stem(stem)
-        asciimath = SafeAttr.read(stem, :asciimath)
-        return nil unless asciimath.is_a?(Array)
-
-        parts = asciimath.filter_map do |a|
-          next a if a.is_a?(String)
-          next SafeAttr.read(a, :text).to_s if a.is_a?(Lutaml::Model::Serializable)
-
-          nil
-        end
-        joined = parts.join.strip
-        joined.empty? ? nil : joined
-      end
-
-      # Best-effort plain-text extraction from a stem element. Tries
-      # asciimath first; falls back to SafeAttr :text.
-      def self.text_from_stem(stem)
-        asciimath = asciimath_from_stem(stem)
-        return asciimath if asciimath
-
-        text = SafeAttr.read(stem, :text)
-        return text.to_s if text.is_a?(String) && !text.strip.empty?
-
-        ""
-      end
-    end
-  end
-end

data/lib/metanorma/mirror/metadata.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module Metanorma
-  module Mirror
-    # Extracts metadata (title, etc.) from a parsed Metanorma document's
-    # bibdata. This is a standalone service that the pipeline and other
-    # consumers can use without depending on the Handlers layer.
-    module Metadata
-      # Returns the first title string from a bibdata object, or nil.
-      # The bibdata must respond to `title` and return a String, an Array
-      # of Strings, or an Array of Lutaml::Model::Serializables with
-      # `content`.
-      def self.title_from_bibdata(bibdata)
-        return nil unless bibdata
-
-        title = bibdata.title
-        return nil unless title
-
-        case title
-        when String then title
-        when Array
-          first = title.first
-          return nil unless first
-
-          if first.is_a?(String)
-            first
-          elsif first.is_a?(Lutaml::Model::Serializable)
-            Array(first.content).join
-          else
-            first.to_s
-          end
-        else title.to_s
-        end
-      end
-    end
-  end
-end

data/lib/metanorma/mirror/model/container.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module Metanorma
-  module Mirror
-    module Model
-      class Container < Node
-        attr_reader :content
-
-        def initialize(type:, attrs: {}, content: [])
-          super(type: type, attrs: attrs)
-          @content = Array(content)
-        end
-
-        def container?
-          true
-        end
-
-        def to_h
-          h = super
-          unless @content.empty?
-            h["content"] = @content.map { |c| serialize_child(c) }
-          end
-          h
-        end
-
-        def text_content
-          @content.map do |item|
-            item.is_a?(String) ? item : item.text_content
-          end.join
-        end
-
-        def accept_rewriter(rewriter)
-          rewriter.rewrite_container(self)
-        end
-
-        private
-
-        def serialize_child(child)
-          case child
-          when String then child
-          else child.to_h
-          end
-        end
-      end
-    end
-  end
-end

data/lib/metanorma/mirror/model/factory.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module Metanorma
-  module Mirror
-    module Model
-      class Factory
-        INVALID_INPUT = "Factory.from_h expects a Hash, got %<class>s"
-
-        def self.from_h(hash)
-          unless hash.is_a?(Hash)
-            raise ArgumentError,
-                  format(INVALID_INPUT, class: hash.class)
-          end
-
-          type = hash["type"]
-
-          case type
-          when "text"
-            build_text(hash)
-          when "soft_break"
-            SoftBreak.new
-          when nil
-            raise ArgumentError,
-                  "Factory.from_h requires a 'type' key, got #{hash.inspect}"
-          else
-            build_node(hash, type)
-          end
-        end
-
-        class << self
-          private
-
-          def build_text(hash)
-            marks = Array(hash["marks"]).map { |m| Mark.from_h(m) }
-            Text.new(text: hash["text"] || "", marks: marks)
-          end
-
-          def build_node(hash, type)
-            content = hash["content"]
-            if content.is_a?(Array)
-              children = content.map { |c| c.is_a?(Hash) ? from_h(c) : c }
-              Container.new(type: type, attrs: hash["attrs"] || {},
-                            content: children)
-            else
-              Leaf.new(type: type, attrs: hash["attrs"] || {})
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/metanorma/mirror/model/guide.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module Metanorma
-  module Mirror
-    module Model
-      class Guide
-        attr_reader :content, :meta, :title, :document
-
-        def initialize(content:, meta: {}, title: nil, document: nil)
-          @content = content
-          @meta = meta
-          @title = title
-          @document = document
-        end
-
-        def to_h
-          h = {}
-          h["content"] = @content.is_a?(Container) ? @content.to_h : @content
-          h["meta"] = @meta unless @meta.nil? || @meta.empty?
-          h["title"] = @title if @title
-          h
-        end
-      end
-    end
-  end
-end

data/lib/metanorma/mirror/model/leaf.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module Metanorma
-  module Mirror
-    module Model
-      class Leaf < Node
-        def leaf?
-          true
-        end
-
-        def accept_rewriter(rewriter)
-          rewriter.rewrite_leaf(self)
-        end
-      end
-    end
-  end
-end

data/lib/metanorma/mirror/model/mark.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module Metanorma
-  module Mirror
-    module Model
-      class Mark
-        attr_reader :type, :attrs
-
-        def initialize(type:, attrs: {})
-          @type = type
-          @attrs = normalize_attrs(attrs)
-        end
-
-        def to_h
-          h = { "type" => type }
-          h["attrs"] = @attrs.dup unless @attrs.empty?
-          h
-        end
-
-        def [](key)
-          @attrs[key.to_s]
-        end
-
-        def []=(key, value)
-          @attrs[key.to_s] = value
-        end
-
-        def set_attr(key, value)
-          @attrs[key.to_s] = value
-          self
-        end
-
-        def fetch(key, default = nil, &)
-          @attrs.fetch(key.to_s, default, &)
-        end
-
-        def self.from_h(hash)
-          return nil unless hash
-
-          new(type: hash["type"], attrs: hash["attrs"] || {})
-        end
-
-        private
-
-        def normalize_attrs(attrs)
-          return {} if attrs.nil?
-
-          attrs.transform_keys(&:to_s)
-        end
-      end
-    end
-  end
-end

data/lib/metanorma/mirror/model/node.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module Metanorma
-  module Mirror
-    module Model
-      class Node
-        attr_reader :type, :attrs
-
-        def initialize(type:, attrs: {})
-          @type = type
-          @attrs = normalize_attrs(attrs)
-        end
-
-        def to_h
-          h = { "type" => type }
-          h["attrs"] = @attrs.dup unless @attrs.empty?
-          h
-        end
-
-        def leaf?
-          false
-        end
-
-        def container?
-          false
-        end
-
-        def text_content
-          ""
-        end
-
-        def accept_rewriter(_rewriter)
-          raise NotImplementedError,
-                "#{self.class}#accept_rewriter not implemented"
-        end
-
-        private
-
-        def normalize_attrs(attrs)
-          return {} if attrs.nil?
-
-          attrs.transform_keys(&:to_s)
-        end
-      end
-    end
-  end
-end

data/lib/metanorma/mirror/model/soft_break.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module Metanorma
-  module Mirror
-    module Model
-      class SoftBreak
-        def type
-          "soft_break"
-        end
-
-        def to_h
-          { "type" => "soft_break" }
-        end
-
-        def attrs
-          {}
-        end
-
-        def content
-          []
-        end
-
-        def text_content
-          ""
-        end
-
-        def accept_rewriter(rewriter)
-          rewriter.rewrite_soft_break(self)
-        end
-      end
-    end
-  end
-end

data/lib/metanorma/mirror/model/text.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module Metanorma
-  module Mirror
-    module Model
-      class Text
-        attr_reader :text, :marks
-
-        def initialize(text:, marks: [])
-          @text = text.to_s
-          @marks = Array(marks)
-        end
-
-        def type
-          "text"
-        end
-
-        def to_h
-          h = { "type" => "text", "text" => @text }
-          h["marks"] = @marks.map(&:to_h) unless @marks.empty?
-          h
-        end
-
-        def text_content
-          @text
-        end
-
-        def accept_rewriter(rewriter)
-          rewriter.rewrite_text(self)
-        end
-      end
-    end
-  end
-end

data/lib/metanorma/mirror/model.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module Metanorma
-  module Mirror
-    module Model
-      autoload :Node, "#{__dir__}/model/node"
-      autoload :Container, "#{__dir__}/model/container"
-      autoload :Leaf, "#{__dir__}/model/leaf"
-      autoload :Text, "#{__dir__}/model/text"
-      autoload :SoftBreak, "#{__dir__}/model/soft_break"
-      autoload :Mark, "#{__dir__}/model/mark"
-      autoload :Guide, "#{__dir__}/model/guide"
-      autoload :Factory, "#{__dir__}/model/factory"
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require "fileutils"
-
-module Metanorma
-  module Mirror
-    module Output
-      class Builder
-        attr_reader :xml_path, :output_path, :format, :options
-
-        def initialize(xml_path:, output_path:, format: :inline, **options)
-          @xml_path = xml_path
-          @output_path = output_path
-          @format = format
-          @options = options
-        end
-
-        def build
-          pipeline = Pipeline.new(
-            xml_path: @xml_path,
-            flavor: @options[:flavor],
-            title: @options[:title] || File.basename(@xml_path, ".*"),
-            id_strategy: @options[:id_strategy],
-          )
-
-          guide = pipeline.process
-
-          format_class = Formats.lookup(@format)
-          raise ArgumentError, "Unknown format: #{@format}" unless format_class
-
-          formatter = format_class.new(dist_dir: @options[:dist_dir])
-          formatter.write(@output_path, guide, title: @options[:title])
-
-          @output_path
-        end
-      end
-    end
-  end
-end