metanorma-mirror 1.0.0

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Mirror
+    module Model
+      class Container < Node
+        def initialize(type: nil, attrs: {}, content: [], **)
+          super(type: type, attrs: attrs, **)
+          self.content = Array(content)
+        end
+
+        def container?
+          true
+        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
+      end
+
+      # content is declared after the sibling node classes exist: the
+      # union member list references Container itself, and lutaml-model
+      # resolves union members eagerly at declaration time. Deserialized
+      # children dispatch through Factory (the child's shape — content
+      # array vs leaf vs text — picks the class), which is why the union
+      # never receives raw hashes on the way in.
+      class Container
+        attribute :content, [Text, SoftBreak, Leaf, Container, :string],
+                  collection: true, default: -> { [] }
+
+        key_value do
+          map "content", to: :content, render_empty: false,
+                         with: { from: :content_from_mapping }
+        end
+
+        def content_from_mapping(model, value)
+          model.content = Array(value).map do |child|
+            child.is_a?(Hash) ? Factory.from_hash(child) : child
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Mirror
+    module Model
+      # Semantic dispatcher: the wire's "type" and "content" shape pick
+      # the model class; deserialization itself is the framework's
+      # from_hash on the chosen class.
+      class Factory
+        INVALID_INPUT = "Factory.from_hash expects a Hash, got %<class>s"
+        MISSING_TYPE = "Factory.from_hash requires a 'type' key, got %<hash>s"
+
+        def self.from_hash(hash)
+          unless hash.is_a?(Hash)
+            raise ArgumentError, format(INVALID_INPUT, class: hash.class)
+          end
+
+          case hash["type"]
+          when "text" then Text.from_hash(hash)
+          when "soft_break" then SoftBreak.from_hash(hash)
+          when nil
+            raise ArgumentError, format(MISSING_TYPE, hash: hash.inspect)
+          else
+            if hash["content"].is_a?(Array)
+              Container.from_hash(hash)
+            else
+              Leaf.from_hash(hash)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Mirror
+    module Model
+      class Guide < Lutaml::Model::Serializable
+        attribute :content, [Container, :string]
+        attribute :meta, :hash, default: -> { {} }
+        attribute :title, :string
+
+        key_value do
+          map "content", to: :content
+          map "meta", to: :meta, render_empty: false
+          map "title", to: :title, render_nil: false
+        end
+
+        # the parsed source document rides along for output formats; it
+        # is deliberately outside the serialization contract
+        attr_accessor :document
+
+        def initialize(content: nil, meta: {}, title: nil, document: nil,
+                       **)
+          super(content: content, meta: meta, title: title, **)
+          self.document = document
+        end
+      end
+    end
+  end
+end

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

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Mirror
+    module Model
+      class Mark < Lutaml::Model::Serializable
+        attribute :type, :string
+        attribute :attrs, :hash, default: -> { {} }
+
+        key_value do
+          map "type", to: :type
+          map "attrs", to: :attrs, render_empty: false
+        end
+
+        def initialize(type: nil, attrs: {}, **)
+          # wire keys are strings; handlers build attrs with symbol keys
+          super(type: type, attrs: (attrs || {}).transform_keys(&:to_s), **)
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Mirror
+    module Model
+      class Node < Lutaml::Model::Serializable
+        attribute :type, :string
+        attribute :attrs, :hash, default: -> { {} }
+
+        key_value do
+          map "type", to: :type
+          map "attrs", to: :attrs, render_empty: false
+        end
+
+        # **options carries framework construction kwargs
+        # (e.g. lutaml_register) through to the base serializer
+        def initialize(type: nil, attrs: {}, **)
+          # wire keys are strings; handlers and the transformer build
+          # attrs with symbol keys
+          super(type: type, attrs: (attrs || {}).transform_keys(&:to_s), **)
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Mirror
+    module Model
+      class SoftBreak < Lutaml::Model::Serializable
+        attribute :type, :string, default: -> { "soft_break" }
+
+        key_value do
+          map "type", to: :type, render_default: true
+        end
+
+        # rewriter contract: a soft break carries no attrs or content
+        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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Mirror
+    module Model
+      class Text < Lutaml::Model::Serializable
+        attribute :type, :string, default: -> { "text" }
+        attribute :text, :string, default: -> { "" }
+        attribute :marks, Mark, collection: true, default: -> { [] }
+
+        key_value do
+          map "type", to: :type, render_default: true
+          map "text", to: :text, render_default: true, render_empty: true
+          map "marks", to: :marks, render_empty: false
+        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

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

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

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

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

@@ -0,0 +1,142 @@
+# 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_hash)};"
+            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

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