metanorma-document 0.2.12 → 0.2.13

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

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-module Metanorma
-  module Mirror
-    module Output
-      module HtmlRenderers
-        module StructuralRenderers
-          def self.register(registry)
-            registry.register_node_handler("doc", instance_method(:render_doc))
-            registry.register_node_handler("preface",
-                                           instance_method(:render_preface))
-            registry.register_node_handler("sections",
-                                           instance_method(:render_sections))
-            registry.register_node_handler("bibliography",
-                                           instance_method(:render_bibliography))
-            registry.register_node_handler("footnotes",
-                                           instance_method(:render_footnotes))
-            registry.register_node_handler("soft_break",
-                                           instance_method(:render_soft_break))
-          end
-
-          def render_doc(node, depth: 0)
-            HtmlRenderers.build do |doc|
-              HtmlRenderers.embed(doc, render_children(node, depth:))
-            end
-          end
-
-          def render_preface(node, depth: 0)
-            HtmlRenderers.build do |doc|
-              doc.section(class: "mn-preface") do
-                HtmlRenderers.embed(doc, render_children(node, depth:))
-              end
-            end
-          end
-
-          def render_sections(node, depth: 0)
-            HtmlRenderers.build do |doc|
-              doc.section(class: "mn-sections") do
-                HtmlRenderers.embed(doc, render_children(node, depth:))
-              end
-            end
-          end
-
-          def render_bibliography(node, depth: 0)
-            HtmlRenderers.build do |doc|
-              doc.section(class: "mn-bibliography") do
-                HtmlRenderers.embed(doc, render_children(node, depth:))
-              end
-            end
-          end
-
-          def render_footnotes(node, depth: 0)
-            HtmlRenderers.build do |doc|
-              doc.div(class: "footnotes") do
-                doc.ol do
-                  node.content.each do |fn|
-                    next unless fn.is_a?(Model::Container)
-
-                    fn_attrs = {}
-                    fn_attrs[:id] = fn.attrs["id"] if fn.attrs["id"]
-                    doc.li(fn_attrs) do
-                      HtmlRenderers.embed(doc, render_children(fn))
-                      if fn.attrs["ref_id"]
-                        doc.a(href: "##{fn.attrs['ref_id']}") { doc.text "↩" }
-                      end
-                    end
-                  end
-                end
-              end
-            end
-          end
-
-          def render_soft_break(_node, depth: 0)
-            HtmlRenderers.build(&:br)
-          end
-        end
-      end
-    end
-  end
-end

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,37 +0,0 @@
-# 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/blocks/source_origin_element.rb

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