metanorma-document 0.3.0 → 0.4.0

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