metanorma-document 0.2.12 → 0.2.13

data/lib/metanorma/mirror/metanorma_to_mirror.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-module Metanorma
-  module Mirror
-    class MetanormaToMirror
-      attr_reader :registry, :id_strategy
-
-      def initialize(registry: Mirror.default_registry,
-id_strategy: Mirror.DEFAULT_ID_STRATEGY)
-        @registry = registry
-        @id_strategy = id_strategy
-      end
-
-      def call(root)
-        attrs = {}
-        attrs[:flavor] = root.flavor if root.flavor
-        attrs[:type] = root.type if root.type
-        attrs[:schema_version] = root.schema_version if root.schema_version
-
-        title = extract_root_title(root)
-        attrs[:title] = title if title
-
-        content = []
-
-        preface = root.preface
-        if preface
-          result = @registry.handle(preface, context: self)
-          result.append_to(content)
-        end
-
-        sections = root.sections
-        if sections
-          result = @registry.handle(sections, context: self)
-          result.append_to(content)
-        end
-
-        annex = root.annex
-        annex&.each do |a|
-          result = @registry.handle(a, context: self)
-          result.append_to(content)
-        end
-
-        bibliography = root.bibliography
-        if bibliography
-          result = @registry.handle(bibliography, context: self)
-          result.append_to(content)
-        end
-
-        Handlers.build_node("doc", attrs: attrs, content: content)
-      end
-
-      def extract_blocks(element)
-        content = []
-
-        element.each_mixed_content do |node|
-          next if node.is_a?(String)
-
-          result = @registry.handle(node, context: self)
-          result.append_to(content)
-        end
-        content
-      end
-
-      def extract_section_children(element)
-        content = []
-        %i[clause terms definitions references floating_title].each do |attr|
-          collection = SafeAttr.read(element, attr)
-          next unless collection
-
-          collection.each do |child|
-            result = @registry.handle(child, context: self)
-            result.append_to(content)
-          end
-        end
-        content
-      end
-
-      def extract_named_collections(element, collection_attrs)
-        content = []
-        collection_attrs.each do |attr|
-          collection = SafeAttr.read(element, attr)
-          next unless collection
-
-          collection.each do |child|
-            result = @registry.handle(child, context: self)
-            result.append_to(content)
-          end
-        end
-        content
-      end
-
-      def text_node(text, marks: [])
-        Handlers.build_text(text, marks: marks)
-      end
-
-      def extract_root_title(root)
-        Metadata.title_from_bibdata(SafeAttr.read(root, :bibdata))
-      end
-    end
-  end
-end

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

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module Metanorma
-  module Mirror
-    module Model
-      class Container < Node
-        attr_reader :content
-
-        def initialize(type:, attrs: {}, content: [])
-          super(type: type, attrs: attrs)
-          @content = Array(content)
-        end
-
-        def container?
-          true
-        end
-
-        def to_h
-          h = super
-          unless @content.empty?
-            h["content"] = @content.map { |c| serialize_child(c) }
-          end
-          h
-        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
-
-        private
-
-        def serialize_child(child)
-          case child
-          when String then child
-          else child.to_h
-          end
-        end
-      end
-    end
-  end
-end

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

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

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

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

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

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

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

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

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

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

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

@@ -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