metanorma-document 0.2.9 → 0.2.12

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

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Mirror
+    module Model
+      class Guide
+        attr_reader :content, :meta, :title
+
+        def initialize(content:, meta: {}, title: nil)
+          @content = content
+          @meta = meta
+          @title = title
+        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

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

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

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

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

@@ -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,81 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "nokogiri"
+
+module Metanorma
+  module Mirror
+    module Output
+      module Formats
+        class InlineFormat < BaseFormat
+          def write(output_path, guide, title: "Metanorma")
+            FileUtils.mkdir_p(File.dirname(output_path))
+
+            data_script = "window.METANORMA_DATA = #{safe_json(guide)};"
+            ssr_body = HtmlRenderer.new(guide).render
+            head_parts = []
+            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
+
+          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

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Mirror
+    module Output
+      class HtmlRenderer
+        include HtmlRenderers::StructuralRenderers
+        include HtmlRenderers::SectionRenderers
+        include HtmlRenderers::BlockRenderers
+        include HtmlRenderers::ListRenderers
+        include HtmlRenderers::TableRenderers
+        include HtmlRenderers::InlineRenderer
+        include HtmlRenderers::MarkRenderers
+
+        class << self
+          def node_handlers
+            @node_handlers ||= {}
+          end
+
+          def mark_handlers
+            @mark_handlers ||= {}
+          end
+
+          def register_node_handler(type, unbound_method)
+            node_handlers[type] = unbound_method
+          end
+
+          def register_mark_handler(mark_type, handler)
+            mark_handlers[mark_type] = handler
+          end
+        end
+
+        def initialize(guide, numbering: {})
+          @content = extract_content(guide)
+          @numbering = numbering
+        end
+
+        def render
+          render_nodes(@content)
+        end
+
+        def render_nodes(nodes, depth: 0)
+          nodes.filter_map { |node| render_node(node, depth:) }.join("\n")
+        end
+
+        def render_node(node, depth: 0)
+          case node
+          when String
+            HtmlRenderers.escape_text(node)
+          when Model::Text
+            render_text_node(node)
+          when Model::Container, Model::Leaf, Model::SoftBreak
+            render_typed_node(node, depth:)
+          else
+            ""
+          end
+        end
+
+        def render_typed_node(node, depth: 0)
+          unbound = self.class.node_handlers[node.type]
+          return unbound.bind_call(self, node, depth:) if unbound
+
+          render_generic(node, depth:)
+        end
+
+        def render_generic(node, depth: 0)
+          children = node.content if node.is_a?(Model::Container)
+          return "" unless children && !children.empty?
+
+          render_children(node, depth:)
+        end
+
+        def render_children(node, depth: 0)
+          children = node.is_a?(Model::Container) ? node.content : []
+          render_nodes(children, depth:)
+        end
+
+        private
+
+        def extract_content(guide)
+          case guide
+          when Model::Guide
+            guide.content.is_a?(Model::Container) ? guide.content.content : Array(guide.content)
+          when Model::Container
+            guide.content
+          else
+            raise ArgumentError, "Unsupported guide type: #{guide.class}"
+          end
+        end
+      end
+
+      HtmlRenderers.register_all(HtmlRenderer)
+    end
+  end
+end