metanorma-document 0.2.9 → 0.2.12

data/lib/metanorma/mirror/output/html_renderers/table_renderers.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Mirror
+    module Output
+      module HtmlRenderers
+        module TableRenderers
+          WRAPPER_TAGS = {
+            "table_head" => "thead",
+            "table_foot" => "tfoot",
+            "table_body" => "tbody",
+          }.freeze
+
+          def self.register(registry)
+            registry.register_node_handler("table",
+                                           instance_method(:render_table))
+            registry.register_node_handler("table_head",
+                                           instance_method(:render_table_section))
+            registry.register_node_handler("table_body",
+                                           instance_method(:render_table_section))
+            registry.register_node_handler("table_foot",
+                                           instance_method(:render_table_section))
+          end
+
+          def render_table(node, depth: 0)
+            sections = node.content.grep(Model::Container)
+
+            HtmlRenderers.build do |doc|
+              attrs = { class: "mn-table" }
+              attrs[:id] = node.attrs["id"] if node.attrs["id"]
+              doc.div(attrs) do
+                if node.attrs["title"]
+                  doc.div(class: "mn-table__header") do
+                    doc.text node.attrs["title"]
+                  end
+                end
+                doc.table do
+                  sections.each do |section|
+                    HtmlRenderers.embed(doc, build_table_section(section))
+                  end
+                end
+              end
+            end
+          end
+
+          def render_table_section(node, depth: 0)
+            build_table_section(node)
+          end
+
+          private
+
+          def build_table_section(section)
+            wrapper_tag = WRAPPER_TAGS[section.type] || "tbody"
+            cell_tag = wrapper_tag == "thead" ? "th" : "td"
+
+            HtmlRenderers.build do |doc|
+              doc.public_send(wrapper_tag) do
+                section.content.each do |row|
+                  next unless row.is_a?(Model::Container) && row.type == "table_row"
+
+                  doc.tr do
+                    row.content.each do |cell|
+                      next unless cell.is_a?(Model::Container)
+
+                      HtmlRenderers.embed(doc, build_table_cell(cell, cell_tag))
+                    end
+                  end
+                end
+              end
+            end
+          end
+
+          def build_table_cell(cell, cell_tag)
+            HtmlRenderers.build do |doc|
+              attrs = {}
+              attrs[:colspan] = cell.attrs["colspan"] if cell.attrs["colspan"]
+              attrs[:rowspan] = cell.attrs["rowspan"] if cell.attrs["rowspan"]
+              doc.public_send(cell_tag, attrs) do
+                HtmlRenderers.embed(doc, render_inline(cell.content))
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module Metanorma
+  module Mirror
+    module Output
+      module HtmlRenderers
+        autoload :StructuralRenderers,
+                 "#{__dir__}/html_renderers/structural_renderers"
+        autoload :SectionRenderers,
+                 "#{__dir__}/html_renderers/section_renderers"
+        autoload :BlockRenderers, "#{__dir__}/html_renderers/block_renderers"
+        autoload :ListRenderers, "#{__dir__}/html_renderers/list_renderers"
+        autoload :TableRenderers, "#{__dir__}/html_renderers/table_renderers"
+        autoload :InlineRenderer, "#{__dir__}/html_renderers/inline_renderer"
+        autoload :MarkRenderers, "#{__dir__}/html_renderers/mark_renderers"
+
+        MODULES = %i[
+          StructuralRenderers
+          SectionRenderers
+          BlockRenderers
+          ListRenderers
+          TableRenderers
+          InlineRenderer
+          MarkRenderers
+        ].freeze
+
+        def self.register_all(renderer_class)
+          MODULES.each do |mod_name|
+            const_get(mod_name).register(renderer_class)
+          end
+        end
+
+        # Build a single HTML root element via Nokogiri::HTML4::Builder.
+        # Returns the rendered HTML string.
+        def self.build(&)
+          builder = Nokogiri::HTML4::Builder.new(&)
+          builder.doc.root.to_html
+        end
+
+        # Build an HTML fragment (multiple roots permitted) via
+        # Nokogiri::HTML4::Builder. Returns the rendered HTML string.
+        def self.build_fragment(&)
+          fragment = Nokogiri::HTML4::DocumentFragment.parse("")
+          Nokogiri::HTML4::Builder.with(fragment, &)
+          fragment.to_html
+        end
+
+        # Embed a pre-rendered HTML string under the current builder node
+        # without re-escaping.
+        def self.embed(doc, html_string)
+          return if html_string.nil? || html_string.to_s.empty?
+
+          doc << Nokogiri::HTML4::DocumentFragment.parse(html_string.to_s)
+        end
+
+        # Wrap a pre-rendered HTML string in a tag. Used by mark handlers.
+        def self.wrap(tag, inner_html, **attrs)
+          Nokogiri::HTML4::Builder.new do |doc|
+            doc.public_send(tag, attrs) do
+              doc.parent.inner_html = inner_html.to_s
+            end
+          end.doc.root.to_html
+        end
+
+        # Escape text for safe inclusion in HTML body content.
+        def self.escape_text(text)
+          return "" unless text
+
+          CGI.escapeHTML(text.to_s)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Mirror
+    module Output
+      class Pipeline
+        attr_reader :steps, :context
+
+        def initialize(xml_path:, steps: nil, flavor: nil, title: nil,
+id_strategy: nil)
+          @steps = steps || [Steps::ParseXml, Steps::TransformMirror, Steps::AttachMetadata]
+          @context = PipelineContext.new(
+            xml_path: xml_path,
+            flavor: flavor,
+            title: title || File.basename(xml_path, ".*"),
+            id_strategy: id_strategy,
+          )
+        end
+
+        def process
+          @steps.each { |step_class| step_class.new.call(@context) }
+          Model::Guide.new(
+            content: @context.content,
+            meta: @context.meta,
+            title: @context.title,
+          )
+        end
+
+        module Steps
+          class ParseXml
+            def call(context)
+              flavor = context.flavor || infer_flavor(context.xml_path)
+              doc_class = flavor_class(flavor)
+              xml_content = File.read(context.xml_path)
+              context.parsed = doc_class.from_xml(xml_content)
+            end
+
+            def self.flavor_map
+              @flavor_map ||= Metanorma.constants.each_with_object({}) do |c, map|
+                next unless c.to_s.end_with?("Document")
+
+                flavor = c.to_s.delete_suffix("Document").downcase
+                map[flavor] = c.to_s
+              end.freeze
+            end
+
+            def infer_flavor(xml_path)
+              basename = File.basename(xml_path, ".*")
+              from_name = basename.split("-").first.to_s.downcase
+              return from_name if self.class.flavor_map.key?(from_name)
+
+              File.dirname(xml_path).split("/").reverse_each do |seg|
+                prefix = seg.split("-").first.to_s.downcase
+                return prefix if self.class.flavor_map.key?(prefix)
+              end
+
+              nil
+            end
+
+            def flavor_class(flavor)
+              class_name = self.class.flavor_map[flavor] || "StandardDocument"
+              Metanorma.const_get(class_name).const_get(:Root)
+            end
+          end
+
+          class TransformMirror
+            def call(context)
+              id_strategy = context.id_strategy || Mirror::DEFAULT_ID_STRATEGY
+              transformer = Mirror::Transformer.new(id_strategy: id_strategy)
+              context.content = transformer.from_metanorma(context.parsed)
+            end
+          end
+
+          class AttachMetadata
+            def call(context)
+              parsed = context.parsed
+              return unless parsed
+
+              bibdata = SafeAttr.read(parsed, :bibdata)
+              return unless bibdata
+
+              meta = {}
+              meta["title"] = Metadata.title_from_bibdata(bibdata)
+              meta["flavor"] = context.flavor if context.flavor
+              context.meta = meta
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Mirror
+    module Output
+      class PipelineContext
+        attr_reader :xml_path, :flavor, :title, :id_strategy
+        attr_accessor :parsed, :content, :meta
+
+        def initialize(xml_path:, flavor: nil, title: nil, id_strategy: nil)
+          @xml_path = xml_path
+          @flavor = flavor
+          @title = title
+          @id_strategy = id_strategy
+          @parsed = nil
+          @content = nil
+          @meta = {}
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/mirror/output.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Mirror
+    module Output
+      autoload :Pipeline, "#{__dir__}/output/pipeline"
+      autoload :PipelineContext, "#{__dir__}/output/pipeline_context"
+      autoload :Builder, "#{__dir__}/output/builder"
+      autoload :HtmlRenderers, "#{__dir__}/output/html_renderers"
+      autoload :HtmlRenderer, "#{__dir__}/output/html_renderer"
+      autoload :Formats, "#{__dir__}/output/formats"
+    end
+  end
+end

data/lib/metanorma/mirror/rewriter.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Mirror
+    # Rewrites a mirror Model graph with configurable type-skipping and
+    # per-type customization. Despite living in the reverse-conversion
+    # namespace, this class produces a Model graph (not Metanorma XML) —
+    # the output is a fully model-driven representation that can be
+    # serialized via Model#to_h or rendered via Output::HtmlRenderer.
+    #
+    # Instance API:
+    #   Rewriter.new(skip: Set.new(%w[review footnotes]))
+    #   rewriter.skip("my_type")
+    #   rewriter.register("my_type") { |n, r| ... }
+    #
+    # Class API (seeds defaults copied into each new instance):
+    #   Rewriter.skip("review")        # adds to defaults
+    #   Rewriter.register("my_type") { |n, r| ... }
+    #
+    # Two Rewriter instances do not share state. Class-level mutation only
+    # affects instances created afterwards (the default snapshot is copied
+    # at `new` time).
+    class Rewriter
+      DEFAULT_SKIPPED_TYPES = %w[review footnotes].freeze
+
+      class << self
+        # Default skip set, copied into each new instance.
+        def default_skipped_types
+          @default_skipped_types ||= Set.new(DEFAULT_SKIPPED_TYPES)
+        end
+
+        # Default builder map, copied into each new instance.
+        def default_builders
+          @default_builders ||= {}
+        end
+
+        # Add a type to the default skip set. Affects instances created
+        # afterwards; existing instances are unchanged.
+        def skip(type)
+          default_skipped_types << type
+          self
+        end
+
+        # Register a builder for a type at the default level. Affects
+        # instances created afterwards; existing instances are unchanged.
+        def register(type, &block)
+          default_builders[type] = block
+          self
+        end
+      end
+
+      def initialize(skip: nil, builders: nil)
+        @skipped_types = skip || self.class.default_skipped_types.dup
+        @builders = builders || self.class.default_builders.dup
+      end
+
+      attr_reader :skipped_types, :builders
+
+      def skip(type)
+        skipped_types << type
+        self
+      end
+
+      def skipped?(type)
+        skipped_types.include?(type)
+      end
+
+      def register(type, &block)
+        builders[type] = block
+        self
+      end
+
+      def call(mirror_node)
+        build(mirror_node)
+      end
+
+      def build(node)
+        return nil unless node
+
+        return rewrite_string(node) if node.is_a?(String)
+
+        node.accept_rewriter(self)
+      end
+
+      def rewrite_container(node)
+        return nil if skipped?(node.type)
+
+        builder = builders[node.type]
+        return builder.call(node, self) if builder
+
+        Model::Container.new(
+          type: node.type,
+          attrs: node.attrs,
+          content: build_children(node.content),
+        )
+      end
+
+      def rewrite_leaf(node)
+        return nil if skipped?(node.type)
+
+        Model::Leaf.new(type: node.type, attrs: node.attrs)
+      end
+
+      def rewrite_text(node)
+        Model::Text.new(text: node.text, marks: node.marks)
+      end
+
+      def rewrite_soft_break(_node)
+        Model::SoftBreak.new
+      end
+
+      def rewrite_string(string)
+        Model::Text.new(text: string)
+      end
+
+      def build_children(content)
+        Array(content).filter_map { |child| build(child) }
+      end
+    end
+  end
+end

data/lib/metanorma/mirror/safe_attr.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Mirror
+    module SafeAttr
+      def self.read(element, attr_name)
+        return nil unless element.is_a?(Lutaml::Model::Serializable)
+
+        klass = element.class
+        return nil unless klass.attributes.key?(attr_name)
+
+        element.public_send(attr_name)
+      end
+    end
+  end
+end

data/lib/metanorma/mirror/serialization/json_serializer.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Metanorma
+  module Mirror
+    module Serialization
+      class JsonSerializer
+        def self.serialize(node)
+          data = node.is_a?(Model::Container) ? node.to_h : node
+          data.to_json
+        end
+
+        def self.serialize_pretty(node)
+          data = node.is_a?(Model::Container) ? node.to_h : node
+          JSON.pretty_generate(data)
+        end
+
+        def self.deserialize(json_string)
+          Model::Factory.from_h(JSON.parse(json_string))
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/mirror/serialization/yaml_serializer.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Metanorma
+  module Mirror
+    module Serialization
+      class YamlSerializer
+        def self.serialize(node)
+          data = node.is_a?(Model::Container) ? node.to_h : node
+          data.to_yaml
+        end
+
+        def self.deserialize(yaml_string)
+          Model::Factory.from_h(YAML.safe_load(yaml_string))
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/mirror/serialization.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Mirror
+    module Serialization
+      autoload :JsonSerializer, "#{__dir__}/serialization/json_serializer"
+      autoload :YamlSerializer, "#{__dir__}/serialization/yaml_serializer"
+    end
+  end
+end

data/lib/metanorma/mirror/transformer.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Mirror
+    class Transformer
+      def initialize(registry: Mirror.default_registry, id_strategy: Mirror::DEFAULT_ID_STRATEGY)
+        @registry = registry
+        @id_strategy = id_strategy
+      end
+
+      def from_metanorma(root)
+        document = MetanormaToMirror.new(registry: @registry,
+                                         id_strategy: @id_strategy).call(root)
+        @id_strategy.finalize!(document)
+      end
+
+      def rewrite(mirror_node)
+        Rewriter.new.call(mirror_node)
+      end
+    end
+  end
+end

data/lib/metanorma/mirror.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Mirror
+    class Error < StandardError; end
+
+    autoload :SafeAttr, "#{__dir__}/mirror/safe_attr"
+    autoload :MathUtil, "#{__dir__}/mirror/math_util"
+    autoload :Metadata, "#{__dir__}/mirror/metadata"
+    autoload :Model, "#{__dir__}/mirror/model"
+    autoload :HandlerResult, "#{__dir__}/mirror/handler_result"
+    autoload :Transformer, "#{__dir__}/mirror/transformer"
+    autoload :MetanormaToMirror, "#{__dir__}/mirror/metanorma_to_mirror"
+    autoload :Rewriter, "#{__dir__}/mirror/rewriter"
+    autoload :HandlerRegistry, "#{__dir__}/mirror/handler_registry"
+    autoload :Handlers, "#{__dir__}/mirror/handlers"
+    autoload :IdStrategy, "#{__dir__}/mirror/id_strategy"
+    autoload :Output, "#{__dir__}/mirror/output"
+    autoload :Serialization, "#{__dir__}/mirror/serialization"
+    autoload :DefaultRegistry, "#{__dir__}/mirror/default_registry"
+
+    DEFAULT_ID_STRATEGY = IdStrategy::Preserve.new
+
+    def self.default_registry
+      @default_registry ||= build_default_registry
+    end
+
+    def self.build_default_registry
+      DefaultRegistry.build
+    end
+  end
+end

data/lib/metanorma/standard_document/annotation.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module StandardDocument
+    class AnnotationContainer < Lutaml::Model::Serializable
+      class Annotation < Lutaml::Model::Serializable
+        attribute :id, :string
+        attribute :reviewer, :string
+        attribute :from, :string
+        attribute :to, :string
+        attribute :type, :string
+        attribute :date, :string
+        attribute :paragraphs,
+                  Metanorma::Document::Components::Paragraphs::ParagraphBlock,
+                  collection: true
+
+        xml do
+          element "annotation"
+          map_attribute "id", to: :id
+          map_attribute "reviewer", to: :reviewer
+          map_attribute "from", to: :from
+          map_attribute "to", to: :to
+          map_attribute "type", to: :type
+          map_attribute "date", to: :date
+          map_element "p", to: :paragraphs
+        end
+      end
+
+      attribute :annotations, Annotation, collection: true
+
+      xml do
+        element "annotation-container"
+        map_element "annotation", to: :annotations
+      end
+    end
+  end
+end

data/lib/metanorma/standard_document/block_attributes.rb

@@ -52,14 +52,27 @@ module Metanorma
     end
 
     # Provides `blocks` method for ordered-content section types.
-    # Returns child nodes in document order via `each_mixed_content`.
+    # Returns child block-level nodes in document order via `each_mixed_content`,
+    # excluding metadata/inline elements like titles and annotations.
     module OrderedContent
+      NON_BLOCK_TYPES = [
+        Metanorma::Document::Components::Inline::TitleWithAnnotationElement,
+        Metanorma::Document::Components::Inline::FmtTitleElement,
+        Metanorma::Document::Components::Inline::VariantTitleElement,
+        Metanorma::Document::Components::Inline::FmtXrefLabelElement,
+        Metanorma::Document::Components::Inline::FmtAnnotationStartElement,
+        Metanorma::Document::Components::Inline::FmtAnnotationEndElement,
+      ].freeze
+
       def blocks
         @blocks ||=
           begin
             result = []
             each_mixed_content do |node|
-              result << node unless node.is_a?(String)
+              next if node.is_a?(String)
+              next if NON_BLOCK_TYPES.any? { |t| node.is_a?(t) }
+
+              result << node
             end
             result
           end

data/lib/metanorma/standard_document/blocks/block_source.rb

@@ -3,29 +3,6 @@
 module Metanorma
   module StandardDocument
     module Blocks
-      # Reference origin within a block source: <origin bibitemid="..." citeas="...">
-      # Schema: isodoc.rnc — origin = element origin { erefType | termref }
-      class SourceOriginElement < Lutaml::Model::Serializable
-        attribute :bibitemid, :string
-        attribute :type, :string
-        attribute :citeas, :string
-        attribute :locality_stack, Metanorma::Document::Relaton::LocalityStack,
-                  collection: true
-
-        xml do
-          element "origin"
-          map_attribute "bibitemid", to: :bibitemid
-          map_attribute "type", to: :type
-          map_attribute "citeas", to: :citeas
-          map_element "localityStack", to: :locality_stack
-        end
-      end
-
-      # Bibliographic source for a block: <source status="..." type="...">
-      #   <origin bibitemid="..." citeas="..."/>
-      #   <modification>...</modification>?
-      # </source>
-      # Schema: isodoc.rnc BlockSource = source*
       class BlockSourceElement < Lutaml::Model::Serializable
         attribute :status, :string
         attribute :type, :string

data/lib/metanorma/standard_document/blocks/source_origin_element.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module StandardDocument
+    module Blocks
+      class SourceOriginElement < Lutaml::Model::Serializable
+        attribute :bibitemid, :string
+        attribute :type, :string
+        attribute :citeas, :string
+        attribute :locality_stack, Metanorma::Document::Relaton::LocalityStack,
+                  collection: true
+
+        xml do
+          element "origin"
+          map_attribute "bibitemid", to: :bibitemid
+          map_attribute "type", to: :type
+          map_attribute "citeas", to: :citeas
+          map_element "localityStack", to: :locality_stack
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/standard_document/blocks.rb

@@ -6,7 +6,7 @@ module Metanorma
       autoload :AmendBlock, "#{__dir__}/blocks/amend_block"
       autoload :AmendContentBlock, "#{__dir__}/blocks/amend_content_block"
       autoload :BlockSourceElement, "#{__dir__}/blocks/block_source"
-      autoload :SourceOriginElement, "#{__dir__}/blocks/block_source"
+      autoload :SourceOriginElement, "#{__dir__}/blocks/source_origin_element"
       autoload :AutoNumber, "#{__dir__}/blocks/auto_number"
       autoload :ChangeType, "#{__dir__}/blocks/change_type"
       autoload :ElementName, "#{__dir__}/blocks/element_name"