metanorma-document 0.2.9 → 0.2.12

data/lib/metanorma/html/renderers/pubid_renderer.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Html
+    module Renderers
+      class PubidRenderer
+        FLAVOR_PUBID_MAP = {
+          "IsoDocument" => :"Pubid::Iso",
+          "IecDocument" => :"Pubid::Iec",
+          "IeeeDocument" => :"Pubid::Ieee",
+          "IhoDocument" => :"Pubid::Iho",
+          "ItuDocument" => :"Pubid::Ithu",
+          "OimlDocument" => :"Pubid::Oiml",
+        }.freeze
+
+        def initialize(coordinator)
+          @coordinator = coordinator
+        end
+
+        def parse_pubid(docidentifier_string)
+          return nil if docidentifier_string.nil? || docidentifier_string.strip.empty?
+
+          flavor_module = resolve_pubid_module
+          return nil unless flavor_module
+
+          flavor_module.parse(docidentifier_string)
+        rescue StandardError
+          nil
+        end
+
+        def pubid_to_html(identifier)
+          return nil unless identifier
+
+          @coordinator.render_liquid("_pubid_identifier.html.liquid", {
+                                       "publisher" => identifier.publisher ? escape_html(identifier.publisher) : nil,
+                                       "number" => identifier.number ? escape_html(identifier.number.to_s) : nil,
+                                       "date" => identifier.date ? escape_html(identifier.date.to_s) : nil,
+                                     })
+        end
+
+        private
+
+        def escape_html(text)
+          @coordinator.escape_html(text)
+        end
+
+        def resolve_pubid_module
+          flavor_name = @coordinator.flavor_name
+          return nil unless flavor_name
+
+          @coordinator.class.ancestors.each do |ancestor|
+            next unless ancestor.is_a?(Class)
+
+            ns = ancestor.name&.split("::")&.detect do |n|
+              FLAVOR_PUBID_MAP.key?(n)
+            end
+            next unless ns
+
+            mod = FLAVOR_PUBID_MAP[ns]
+            return Object.const_get(mod.to_s)
+          end
+          nil
+        rescue NameError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/html/renderers/section_renderer.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Html
+    module Renderers
+      class SectionRenderer
+        def initialize(coordinator)
+          @coordinator = coordinator
+        end
+
+        def render_basic_section(section, level: 1, **_opts)
+          attrs = element_attrs(id: safe_attr(section, :id))
+          title_html = render_section_title(section, level)
+          content = section.blocks&.filter_map do |block|
+            coordinator.render(block)
+          end&.join
+          notes_html = section.notes&.filter_map do |note|
+            coordinator.render_note(note)
+          end&.join
+          render_liquid("_section.html.liquid", {
+                          "attrs" => attrs,
+                          "title" => title_html,
+                          "content" => content,
+                          "notes" => notes_html,
+                        })
+        end
+
+        def render_hierarchical_section(section, level: 1, **_opts)
+          attrs = element_attrs(id: safe_attr(section, :id))
+          title_html = render_section_title(section, level)
+          content = render_section_content(section, level)
+          subsections_html = section.subsections&.filter_map do |sub|
+            coordinator.render(sub, level: level + 1)
+          end&.join
+          render_liquid("_section.html.liquid", {
+                          "attrs" => attrs,
+                          "title" => title_html,
+                          "content" => "#{content}#{subsections_html}",
+                        })
+        end
+
+        def render_content_section(section, level: 1, **_opts)
+          render_hierarchical_section(section, level: level, **_opts)
+        end
+
+        def render_section_title(section, level)
+          titles = section.title
+          return nil unless titles
+          return nil if titles.is_a?(Array) && titles.empty?
+
+          h = "h#{[[level, 6].min, 1].max}"
+          title_text = coordinator.extract_title_text(titles)
+          render_liquid("_heading.html.liquid", "tag" => h, "class_attr" => "",
+                                                "content" => escape_html(title_text))
+        end
+
+        def render_section_content(section, _level)
+          parts = []
+          section.blocks&.each do |block|
+            parts << (coordinator.render(block) || "")
+          end
+          section.notes&.each do |note|
+            parts << (coordinator.render_note(note) || "")
+          end
+          parts.join
+        end
+
+        def collect_ordered_children(section)
+          children = []
+
+          coordinator.walk_ordered(section) do |type, obj|
+            next if %i[text tab].include?(type)
+
+            children << obj
+          end
+
+          supplementary_attrs = %i[terms definitions]
+          supplementary_attrs.each do |attr|
+            val = safe_attr(section, attr)
+            next if val.nil?
+
+            Array(val).each do |v|
+              children << v unless children.include?(v)
+            end
+          end
+
+          children.compact!
+          sort_by_displayorder(children)
+        end
+
+        def render_ordered_content(section, level = 1)
+          children = collect_ordered_children(section)
+          parts = []
+          children.each do |node|
+            next if node.is_a?(String)
+            next if coordinator.is_title_element?(node, section)
+
+            parts << (coordinator.render(node, level: level + 1) || "")
+          end
+          parts.join
+        end
+
+        def sort_by_displayorder(children)
+          children.sort_by do |node|
+            order = if node.is_a?(Lutaml::Model::Serializable) &&
+                node.class.attributes.key?(:displayorder)
+                      node.displayorder
+                    end
+            order &&= order.to_i
+            order || Float::INFINITY
+          end
+        end
+
+        def render_preface(preface, **_opts)
+          order = coordinator.theme.preface_order
+          toc_filters = coordinator.theme.toc_filter_types
+
+          if coordinator.theme.preface_wrap
+            render_wrapped_preface(preface, order, toc_filters)
+          else
+            render_ordered_preface(preface, order, toc_filters)
+          end
+        end
+
+        def render_ordered_preface(preface, order, toc_filters)
+          parts = []
+          order.each do |section_name|
+            case section_name
+            when "clause"
+              clauses = preface_clauses_filtered(preface, toc_filters)
+              clauses&.each do |cl|
+                parts << (coordinator.render(cl, level: 1) || "")
+              end
+            else
+              value = safe_attr(preface, section_name.to_sym)
+              parts << (coordinator.render(value) || "") if value
+            end
+          end
+          parts.join
+        end
+
+        def render_wrapped_preface(preface, order, toc_filters)
+          clauses = preface_clauses_filtered(preface, toc_filters)
+          other_sections = order.reject { |n| n == "clause" }
+          has_others = other_sections.any? do |name|
+            val = safe_attr(preface, name.to_sym)
+            val && !Array(val).empty?
+          end
+
+          return nil if clauses.empty? && !has_others
+
+          coordinator.register_toc_entry(id: "preface", level: 1,
+                                         text: "Preface")
+          content = clauses.filter_map do |cl|
+            coordinator.render(cl, level: 2)
+          end.join
+          render_liquid("_wrapped_preface.html.liquid", content: content)
+        end
+
+        def preface_clauses_filtered(preface, toc_filters)
+          clauses = safe_attr(preface, :clause) || safe_attr(preface, :content)
+          clauses = Array(clauses)
+          return clauses if toc_filters.empty?
+
+          clauses.reject do |cl|
+            cl_type = safe_attr(cl, :type)
+            cl_type && toc_filters.include?(cl_type)
+          end
+        end
+
+        private
+
+        attr_reader :coordinator
+
+        def safe_attr(obj, method_name)
+          coordinator.safe_attr(obj, method_name)
+        end
+
+        def escape_html(text)
+          coordinator.escape_html(text)
+        end
+
+        def element_attrs(**attrs)
+          coordinator.element_attrs(**attrs)
+        end
+
+        def render_liquid(template_name, assigns)
+          coordinator.render_liquid(template_name, assigns)
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/html/renderers.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Html
+    module Renderers
+    end
+  end
+end

data/lib/metanorma/html/ribose_renderer.rb

@@ -2,52 +2,8 @@
 
 module Metanorma
   module Html
-    # Renders RiboseDocument components to HTML.
-    # Extends IsoRenderer with Ribose branding.
     class RiboseRenderer < IsoRenderer
-      def flavor_publishers(_doc_id)
-        ["Ribose"]
-      end
-
-      def flavor_publisher_name
-        "Ribose"
-      end
-
-      def publisher_logo_map
-        {}
-      end
-
-      def theme
-        @theme ||= Theme.new.tap do |t|
-          t.font_body      = '"Noto Serif", "Georgia", serif'
-          t.font_sans      = '"Noto Sans", "Helvetica Neue", Arial, sans-serif'
-          t.font_mono      = '"JetBrains Mono", "Fira Code", monospace'
-          t.font_url       = "https://fonts.googleapis.com/css2?family=Noto+Serif:ital,wght@0,400;0,500;0,600;0,700;1,400&family=Noto+Sans:wght@400;500;600;700&family=JetBrains+Mono:wght@400;500&display=swap"
-          t.primary        = "#2d1b69"
-          t.accent         = "#7c3aed"
-          t.accent_deep    = "#5b21b6"
-          t.gradient       = "linear-gradient(135deg, #1a0e3e 0%, #2d1b69 50%, #5b21b6 100%)"
-          t.primary_light  = "#f3eeff"
-          t.accent_light   = "#ede5ff"
-          t.warm           = "#e8912e"
-          t.warm_light     = "#fef4e8"
-          t.header_background = "linear-gradient(135deg, #1a0e3e 0%, #2d1b69 50%, #5b21b6 100%)"
-          t.cover_background  = "linear-gradient(175deg, #0f0826 0%, #1a0e3e 25%, #2d1b69 55%, #5b21b6 80%, #7c3aed 100%)"
-          t.cover_before_bg   = "background: radial-gradient(ellipse at 30% 20%, rgba(124,58,237,0.2) 0%, transparent 50%), radial-gradient(ellipse at 70% 80%, rgba(232,145,46,0.15) 0%, transparent 40%)"
-          t.cover_after_bg    = "height: 3px; background: linear-gradient(90deg, transparent, #7c3aed, transparent)"
-          t.progress_bar_color = "#7c3aed"
-          t.note_border     = "#7c3aed"
-          t.note_bg         = "#ede5ff"
-          t.note_color      = "#7c3aed"
-          t.example_border  = "#2d1b69"
-          t.example_bg      = "#f3eeff"
-          t.example_color   = "#2d1b69"
-          t.admonition_border = "#e8912e"
-          t.admonition_color  = "#e8912e"
-          t.footer_border_color = "#7c3aed"
-          t.cover_separator_color = "rgba(124,58,237,0.25)"
-        end
-      end
+      register_render Metanorma::RiboseDocument::Root, :render_document
     end
   end
 end