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

data/lib/metanorma/mirror/output/formats/base_format.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-require "nokogiri"
-
-module Metanorma
-  module Mirror
-    module Output
-      module Formats
-        class BaseFormat
-          attr_reader :dist_dir
-
-          def initialize(dist_dir: nil)
-            @dist_dir = dist_dir || self.class.default_dist_dir
-          end
-
-          def write(output_path, guide, title: "Metanorma")
-            raise NotImplementedError, "#{self.class}#write not implemented"
-          end
-
-          class << self
-            attr_accessor :configured_dist_dir
-
-            def default_dist_dir
-              @configured_dist_dir || File.expand_path(
-                "../../../../../frontend/dist", __dir__
-              )
-            end
-          end
-
-          protected
-
-          def safe_json(data)
-            JSON.generate(data).gsub("</script", '<\\/script')
-          end
-
-          def html_boilerplate(title:, body_content:, head_extra: "",
-                               script_data: nil, app_mount_id: nil)
-            Nokogiri::HTML5::Builder.new do |doc|
-              doc.html(lang: "en") do
-                build_head(doc, title:, head_extra:, script_data:)
-                build_body(doc, body_content:, app_mount_id:)
-              end
-            end.doc.to_html
-          end
-
-          def iife_bundle_path
-            File.join(@dist_dir, "app.iife.js")
-          end
-
-          def iife_css_path
-            File.join(@dist_dir, "app.css")
-          end
-
-          def iife_bundle_exists?
-            File.exist?(iife_bundle_path)
-          end
-
-          private
-
-          def build_head(doc, title:, head_extra:, script_data:)
-            doc.head do
-              doc.meta(charset: "UTF-8")
-              doc.meta(name: "viewport",
-                       content: "width=device-width, initial-scale=1.0")
-              doc.title { doc.text title.to_s }
-              if script_data
-                doc.script { doc.text script_data }
-              end
-              next unless head_extra && !head_extra.empty?
-
-              doc << Nokogiri::HTML5::DocumentFragment.parse(head_extra)
-            end
-          end
-
-          def build_body(doc, body_content:, app_mount_id:)
-            doc.body do
-              if app_mount_id
-                doc.div(id: app_mount_id) do
-                  doc << Nokogiri::HTML5::DocumentFragment.parse(body_content.to_s)
-                end
-              else
-                doc << Nokogiri::HTML5::DocumentFragment.parse(body_content.to_s)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/metanorma/mirror/output/formats/inline_format.rb

@@ -1,142 +0,0 @@
-# frozen_string_literal: true
-
-require "fileutils"
-require "nokogiri"
-
-module Metanorma
-  module Mirror
-    module Output
-      module Formats
-        class InlineFormat < BaseFormat
-          # Classic content styles inlined for the no-JS SSR body: reset +
-          # typography + block/inline component styles from the classic
-          # asset pipeline. Page chrome (layout, print, transitions, dark,
-          # cover, header, footer, toc, search, progress, shortcuts,
-          # glossary panel, flavor modules) is owned by the SPA and
-          # excluded.
-          CONTENT_CSS_MODULES = %w[
-            base/_reset
-            base/_typography
-            components/section
-            components/note
-            components/example
-            components/sourcecode
-            components/formula
-            components/admonition
-            components/table
-            components/footnote
-            components/figure
-            components/term
-            components/bibliography
-            components/inline
-            components/index
-          ].freeze
-
-          class << self
-            attr_accessor :missing_bundle_warned
-          end
-
-          def write(output_path, guide, title: "Metanorma")
-            FileUtils.mkdir_p(File.dirname(output_path))
-
-            warn_missing_bundle unless iife_bundle_exists?
-
-            data_script = "window.METANORMA_DATA = #{safe_json(guide.to_h)};"
-            ssr_body = render_ssr_body(guide)
-            head_parts = [build_style(classic_content_css)]
-            css_inline = read_css_inline
-            if css_inline && !css_inline.empty?
-              head_parts << build_style(css_inline)
-            end
-            head_parts << build_script_src("app.iife.js") if iife_bundle_exists?
-            head_extra = head_parts.join("\n")
-
-            html = html_boilerplate(
-              title: title,
-              body_content: ssr_body,
-              head_extra: head_extra,
-              script_data: data_script,
-              app_mount_id: iife_bundle_exists? ? "metanorma-app" : nil,
-            )
-
-            File.write(output_path, html)
-
-            if iife_bundle_exists?
-              copy_if_exists(iife_bundle_path,
-                             File.join(File.dirname(output_path),
-                                       "app.iife.js"))
-            end
-
-            output_path
-          end
-
-          private
-
-          # SSR body is the classic renderer's document body: identical to
-          # the static HTML output, embedded as the no-JS / first-paint
-          # placeholder the SPA replaces on mount.
-          def render_ssr_body(guide)
-            document = guide.document
-            unless document
-              raise ArgumentError,
-                    "InlineFormat requires a Guide carrying its source document"
-            end
-
-            renderer = Metanorma::Html::Generator.renderer_for(document).new
-            renderer.generate_body(document)
-          end
-
-          def classic_content_css
-            css_dir = Metanorma::Html::AssetPipeline::CSS_DIR
-            CONTENT_CSS_MODULES.filter_map do |mod|
-              path = File.join(css_dir, "#{mod}.css")
-              File.read(path) if File.exist?(path)
-            end.join("\n")
-          end
-
-          def warn_missing_bundle
-            return if self.class.missing_bundle_warned
-
-            warn "metanorma-document: #{iife_bundle_path} not found — " \
-                 "writing static HTML without the interactive SPA. " \
-                 "Run `rake build_frontend` to build it."
-            self.class.missing_bundle_warned = true
-          end
-
-          def build_style(css)
-            Nokogiri::HTML5::Builder.new do |doc|
-              doc.style { doc.text css }
-            end.doc.root.to_html
-          end
-
-          def build_script_src(src)
-            Nokogiri::HTML5::Builder.new do |doc|
-              doc.script(src: src)
-            end.doc.root.to_html
-          end
-
-          def read_css_inline
-            path = iife_css_path
-            File.exist?(path) ? File.read(path) : ""
-          end
-
-          def copy_if_exists(src, dst)
-            return unless File.exist?(src)
-
-            unless File.exist?(dst) && FileUtils.identical?(
-              src, dst
-            )
-              FileUtils.cp(src,
-                           dst)
-            end
-          end
-        end
-      end
-    end
-  end
-end
-
-Metanorma::Mirror::Output::Formats.register(
-  :inline,
-  Metanorma::Mirror::Output::Formats::InlineFormat,
-)

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

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module Metanorma
-  module Mirror
-    module Output
-      module Formats
-        autoload :BaseFormat, "#{__dir__}/formats/base_format"
-        autoload :InlineFormat, "#{__dir__}/formats/inline_format"
-
-        # All format modules that should be auto-registered. Adding a new
-        # format = adding one entry here. No edits to lookup logic.
-        REGISTERED = %i[InlineFormat].freeze
-
-        class << self
-          # Returns the format class registered under `name`, or nil.
-          # Triggers autoload of all known format modules on first call.
-          def lookup(name)
-            ensure_loaded
-            format_map[name]
-          end
-
-          def registered?(name)
-            ensure_loaded
-            format_map.key?(name)
-          end
-
-          def register(name, format_class)
-            format_map[name] = format_class
-            self
-          end
-
-          def unregister(name)
-            format_map.delete(name)
-            self
-          end
-
-          private
-
-          def format_map
-            @format_map ||= {}
-          end
-
-          def ensure_loaded
-            return if @loaded
-
-            REGISTERED.each { |mod_name| const_get(mod_name) }
-            @loaded = true
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,93 +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,
-            document: @context.parsed,
-          )
-        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,12 +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 :Formats, "#{__dir__}/output/formats"
-    end
-  end
-end

data/lib/metanorma/mirror/rewriter.rb

@@ -1,123 +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 embedded into HTML output by
-    # Output::Formats::InlineFormat (which renders the source document
-    # through the classic Metanorma::Html renderer).
-    #
-    # 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