metanorma-document 0.2.5 → 0.2.7

data/lib/metanorma/html/component/index_section.rb

@@ -4,10 +4,11 @@ module Metanorma
   module Html
     module Component
       class IndexSection < Base
-        def render(collector, **opts)
+        def render(collector, **_opts)
           return if collector.nil? || collector.empty?
 
-          output << tag(:div, %( id="index" class="index-section" data-component="index")) do
+          output << tag(:div,
+                        %( id="index" class="index-section" data-component="index")) do
             html = tag(:h2) { "Index" }
             html << render_quicknav(collector.sorted_groups)
             html << render_letter_groups(collector.sorted_groups)
@@ -31,7 +32,8 @@ module Metanorma
         end
 
         def render_letter_group(group)
-          tag(:div, %( class="index-letter-group" id="index-letter-#{escape_html(group.letter)}")) do
+          tag(:div,
+              %( class="index-letter-group" id="index-letter-#{escape_html(group.letter)}")) do
             html = tag(:h3, %( class="index-letter")) { group.letter }
             html << group.entries.map { |e| render_entry(e, "primary") }.join
             html
@@ -41,32 +43,48 @@ module Metanorma
         def render_entry(entry, level)
           tag(:div, %( class="index-entry index-entry--#{level}")) do
             html = +""
-            html << tag(:span, %( class="index-term")) { escape_html(entry.term) }
+            html << tag(:span, %( class="index-term")) do
+              escape_html(entry.term)
+            end
             html << render_locators(entry.locators)
             html << render_see(entry.see) if entry.see
             html << render_see_also(entry.see_also_entries) unless entry.see_also_entries.empty?
-            html << entry.children.map { |c| render_entry(c, next_level(level)) }.join unless entry.children.empty?
+            unless entry.children.empty?
+              html << entry.children.map { |c|
+                render_entry(c, next_level(level))
+              }.join
+            end
             html
           end
         end
 
         def render_locators(locators)
           links = locators.map do |loc|
-            tag(:a, %( href="##{escape_html(loc.id)}")) { escape_html(loc.text) }
+            tag(:a, %( href="##{escape_html(loc.id)}")) do
+              escape_html(loc.text)
+            end
           end
           tag(:span, %( class="index-locator")) { links.join(", ") }
         end
 
         def render_see(term)
-          tag(:div, %( class="index-see")) { "<em>see</em> #{escape_html(term)}" }
+          tag(:div, %( class="index-see")) do
+            "<em>see</em> #{escape_html(term)}"
+          end
         end
 
         def render_see_also(terms)
-          tag(:div, %( class="index-see-also")) { "<em>see also</em> #{terms.map { |t| escape_html(t) }.join(', ')}" }
+          tag(:div,
+              %( class="index-see-also")) do
+            "<em>see also</em> #{terms.map do |t|
+              escape_html(t)
+            end.join(', ')}"
+          end
         end
 
         def next_level(level)
-          { "primary" => "secondary", "secondary" => "tertiary" }[level] || "tertiary"
+          { "primary" => "secondary",
+            "secondary" => "tertiary" }[level] || "tertiary"
         end
       end
     end

data/lib/metanorma/html/component/index_term_collector.rb

@@ -17,7 +17,7 @@ module Metanorma
             see: see,
             see_also: see_also,
             target_id: target_id,
-            target_text: target_text
+            target_text: target_text,
           )
         end
 
@@ -67,7 +67,7 @@ module Metanorma
                              keyword_init: true)
 
       IndexEntry = Struct.new(:term, :locators, :see, :see_also_entries, :children,
-                               keyword_init: true) do
+                              keyword_init: true) do
         def initialize(*)
           super
           self.locators ||= []
@@ -76,7 +76,12 @@ module Metanorma
         end
 
         def add_locator(id, text)
-          locators << IndexLocator.new(id: id, text: text) if id && !locators.any? { |l| l.id == id }
+          if id && locators.none? do |l|
+            l.id == id
+          end
+            locators << IndexLocator.new(id: id,
+                                         text: text)
+          end
         end
 
         def add_see_also(term)

data/lib/metanorma/html/component.rb

@@ -4,7 +4,8 @@ module Metanorma
   module Html
     module Component
       autoload :Base, "metanorma/html/component/base"
-      autoload :IndexTermCollector, "metanorma/html/component/index_term_collector"
+      autoload :IndexTermCollector,
+               "metanorma/html/component/index_term_collector"
       autoload :IndexSection, "metanorma/html/component/index_section"
       autoload :FootnoteCollector, "metanorma/html/component/footnote_collector"
     end

data/lib/metanorma/html/drops/admonition_drop.rb

@@ -9,7 +9,8 @@ module Metanorma
           id = renderer.safe_attr(admonition, :id)
 
           content_html = renderer.capture_output do
-            admonition.paragraphs&.each { |para| renderer.render_paragraph(para) }
+            renderer.render_block_children(admonition,
+                                           children: BaseRenderer::SIMPLE_CHILDREN)
           end
 
           new(

data/lib/metanorma/html/drops/example_drop.rb

@@ -9,17 +9,8 @@ module Metanorma
           label = renderer.extract_block_label(example, "EXAMPLE")
 
           content_html = renderer.capture_output do
-            if example.paragraphs && !example.paragraphs.empty?
-              example.paragraphs.each { |para| renderer.render_paragraph(para) }
-            end
-            example.ul&.each { |ul| renderer.render_unordered_list(ul) }
-            example.ol&.each { |ol| renderer.render_ordered_list(ol) }
-            example.dl&.each { |dl| renderer.render_definition_list(dl) }
-            example.sourcecode&.each { |sc| renderer.render_sourcecode(sc) }
-            example.table&.each { |t| renderer.render_table(t) }
-            example.figure&.each { |f| renderer.render_figure(f) }
-            example.quote&.each { |q| renderer.render_quote(q) }
-            example.formula&.each { |f| renderer.render_formula(f) }
+            renderer.render_block_children(example,
+                                           children: BaseRenderer::BLOCK_CHILDREN)
           end
 
           new(

data/lib/metanorma/html/drops/figure_drop.rb

@@ -8,9 +8,13 @@ module Metanorma
 
         def self.from_model(figure, renderer:)
           id = renderer.safe_attr(figure, :id)
-          fig_name = renderer.safe_attr(figure, :fmt_name) || renderer.safe_attr(figure, :name)
+          fig_name = renderer.safe_attr(figure,
+                                        :fmt_name) || renderer.safe_attr(
+                                          figure, :name
+                                        )
           if id && fig_name
-            renderer.register_figure_entry(id: id, text: renderer.extract_plain_text(fig_name))
+            renderer.register_figure_entry(id: id,
+                                           text: renderer.extract_plain_text(fig_name))
           end
 
           image_html = renderer.capture_output do
@@ -24,7 +28,8 @@ module Metanorma
 
           caption_html = if fig_name || renderer.safe_attr(figure, :name)
                            renderer.capture_output do
-                             el = renderer.safe_attr(figure, :fmt_name) || figure.name
+                             el = renderer.safe_attr(figure,
+                                                     :fmt_name) || figure.name
                              renderer.render_inline_element(el)
                            end
                          end
@@ -34,8 +39,12 @@ module Metanorma
           end
 
           key_html = renderer.capture_output do
-            renderer.safe_attr(figure, :note)&.each { |n| renderer.render_note(n) }
-            renderer.safe_attr(figure, :dl)&.then { |dl| renderer.render_definition_list(dl) }
+            renderer.safe_attr(figure, :note)&.each do |n|
+              renderer.render_note(n)
+            end
+            renderer.safe_attr(figure, :dl)&.then do |dl|
+              renderer.render_definition_list(dl)
+            end
           end
 
           new(

data/lib/metanorma/html/drops/formula_drop.rb

@@ -25,9 +25,14 @@ module Metanorma
             formula.dl&.then { |dl| renderer.render_definition_list(dl) }
           end
 
-          name_el = renderer.safe_attr(formula, :fmt_name) || renderer.safe_attr(formula, :name)
+          name_el = renderer.safe_attr(formula,
+                                       :fmt_name) || renderer.safe_attr(
+                                         formula, :name
+                                       )
           number_html = if name_el
-                          renderer.capture_output { renderer.render_inline_element(name_el) }
+                          renderer.capture_output do
+                            renderer.render_inline_element(name_el)
+                          end
                         end
 
           new(

data/lib/metanorma/html/drops/note_drop.rb

@@ -14,9 +14,8 @@ module Metanorma
             else
               renderer.render_mixed_inline(note)
             end
-            note.ul&.each { |ul| renderer.render_unordered_list(ul) }
-            note.ol&.each { |ol| renderer.render_ordered_list(ol) }
-            note.dl&.then { |dl| renderer.render_definition_list(dl) }
+            renderer.render_block_children(note,
+                                           children: BaseRenderer::NOTE_CHILDREN)
           end
 
           new(

data/lib/metanorma/html/drops/sourcecode_drop.rb

@@ -11,7 +11,9 @@ module Metanorma
           lang = renderer.safe_attr(sc, :lang)
 
           name_html = if sc.name
-                        renderer.capture_output { renderer.render_inline_element(sc.name) }
+                        renderer.capture_output do
+                          renderer.render_inline_element(sc.name)
+                        end
                       end
 
           code_text = if sc.body&.content
@@ -21,7 +23,9 @@ module Metanorma
                       else
                         ""
                       end
-          raw_text = code_text.gsub("&lt;", "<").gsub("&gt;", ">").gsub("&amp;", "&").gsub("&quot;", "\"")
+          raw_text = code_text.gsub("&lt;", "<").gsub("&gt;", ">").gsub("&amp;", "&").gsub(
+            "&quot;", "\""
+          )
 
           new(
             id: id,

data/lib/metanorma/html/drops.rb

@@ -12,7 +12,8 @@ module Metanorma
       autoload :FormulaDrop, "metanorma/html/drops/formula_drop"
       autoload :FigureDrop, "metanorma/html/drops/figure_drop"
       autoload :TocEntryDrop, "metanorma/html/drops/toc_entry_drop"
-      autoload :FigureListEntryDrop, "metanorma/html/drops/figure_list_entry_drop"
+      autoload :FigureListEntryDrop,
+               "metanorma/html/drops/figure_list_entry_drop"
     end
   end
 end

data/lib/metanorma/html/generator.rb

@@ -19,7 +19,7 @@ module Metanorma
           @tastes << [model_class, publisher_abbrev, renderer_class]
         end
 
-        def generate(document, **options)
+        def generate(document, **_options)
           setup! unless @setup
           renderer_for(document).new.generate_full_document(document)
         end
@@ -43,7 +43,8 @@ module Metanorma
         def find_taste(document)
           @tastes.each do |model_class, publisher_abbrev, renderer_class|
             next unless document.is_a?(model_class)
-            return renderer_class if taste_publisher?(document, publisher_abbrev)
+            return renderer_class if taste_publisher?(document,
+                                                      publisher_abbrev)
           end
           nil
         end
@@ -51,25 +52,39 @@ module Metanorma
         def taste_publisher?(document, abbrev)
           bibdata = document.bibdata if document.is_a?(Lutaml::Model::Serializable)
           return false unless bibdata
+
           contributors = bibdata.contributor
           return false unless contributors
-          contributors.any? do |c|
-            next false unless c.role&.any? { |r| r&.type == "author" } rescue false
-            org = c.organization
-            next false unless org
-            org_abbrev = org.abbreviation
-            if org_abbrev.is_a?(String)
-              org_abbrev == abbrev
-            elsif org_abbrev.is_a?(Lutaml::Model::Serializable)
-              safe_attr(org_abbrev, :content) == abbrev
-            else
-              org_abbrev.to_s == abbrev
+
+          begin
+            contributors.any? do |c|
+              begin
+                next false unless c.role&.any? do |r|
+                  r&.type == "author"
+                end
+              rescue StandardError
+                false
+              end
+              org = c.organization
+              next false unless org
+
+              org_abbrev = org.abbreviation
+              if org_abbrev.is_a?(String)
+                org_abbrev == abbrev
+              elsif org_abbrev.is_a?(Lutaml::Model::Serializable)
+                safe_attr(org_abbrev, :content) == abbrev
+              else
+                org_abbrev.to_s == abbrev
+              end
             end
-          end rescue false
+          rescue StandardError
+            false
+          end
         end
 
         def setup!
           return if @setup
+
           @setup = true
 
           # Trigger autoloads by referencing constants
@@ -105,8 +120,10 @@ module Metanorma
           register Metanorma::RiboseDocument::Root,     RiboseRenderer
 
           # Register tastes (publisher-based dispatch within same model)
-          register_taste Metanorma::IsoDocument::Root,    "ICC",            IccRenderer
-          register_taste Metanorma::RiboseDocument::Root, "PDF Association", PdfaRenderer
+          register_taste Metanorma::IsoDocument::Root,    "ICC",
+                         IccRenderer
+          register_taste Metanorma::RiboseDocument::Root, "PDF Association",
+                         PdfaRenderer
         end
       end
     end

data/lib/metanorma/html/iec_renderer.rb

@@ -4,7 +4,6 @@ module Metanorma
   module Html
     # IEC brand: #0061a9 blue from logo
     class IecRenderer < IsoRenderer
-
       def flavor_publishers(_doc_id)
         ["IEC"]
       end

data/lib/metanorma/html/ieee_renderer.rb

@@ -5,7 +5,6 @@ module Metanorma
     # Renders IeeeDocument components to HTML.
     # Extends IsoRenderer with IEEE branding.
     class IeeeRenderer < IsoRenderer
-
       def flavor_publishers(_doc_id)
         ["IEEE"]
       end

data/lib/metanorma/html/ietf_renderer.rb

@@ -5,7 +5,6 @@ module Metanorma
     # Renders IetfDocument components to HTML.
     # Extends IsoRenderer with IETF/RFC branding.
     class IetfRenderer < IsoRenderer
-
       def flavor_publishers(_doc_id)
         ["IETF"]
       end

data/lib/metanorma/html/iho_renderer.rb

@@ -4,7 +4,6 @@ module Metanorma
   module Html
     # IHO brand: #00AAA9 teal + #05164D navy + #FEDC5B gold from logo
     class IhoRenderer < IsoRenderer
-
       def flavor_publishers(_doc_id)
         ["IHO"]
       end
@@ -44,7 +43,7 @@ module Metanorma
           t.example_bg      = "#eaf5f5"
           t.example_color   = "#008887"
           t.admonition_border = "#FEDC5B"
-          t.admonition_bg   = "#fff9e6"
+          t.admonition_bg = "#fff9e6"
           t.admonition_color = "#b8860b"
           t.footer_border_color = "#00AAA9"
           t.cover_separator_color = "rgba(0,170,169,0.3)"

data/lib/metanorma/html/iso_renderer.rb

@@ -52,19 +52,28 @@ module Metanorma
       end
 
       register_render Metanorma::IsoDocument::Root, :render_document
-      register_render Metanorma::IsoDocument::Sections::IsoPreface, :render_preface
-      register_render Metanorma::IsoDocument::Sections::IsoSections, :render_sections
-      register_render Metanorma::IsoDocument::Sections::IsoClauseSection, :render_clause
-      register_render Metanorma::IsoDocument::Sections::IsoAnnexSection, :render_annex
-      register_render Metanorma::IsoDocument::Sections::IsoTermsSection, :render_terms_section
-      register_render Metanorma::IsoDocument::Sections::IsoForewordSection, :render_foreword
-      register_render Metanorma::IsoDocument::Sections::IsoAbstractSection, :render_abstract
+      register_render Metanorma::IsoDocument::Sections::IsoPreface,
+                      :render_preface
+      register_render Metanorma::IsoDocument::Sections::IsoSections,
+                      :render_sections
+      register_render Metanorma::IsoDocument::Sections::IsoClauseSection,
+                      :render_clause
+      register_render Metanorma::IsoDocument::Sections::IsoAnnexSection,
+                      :render_annex
+      register_render Metanorma::IsoDocument::Sections::IsoTermsSection,
+                      :render_terms_section
+      register_render Metanorma::IsoDocument::Sections::IsoForewordSection,
+                      :render_foreword
+      register_render Metanorma::IsoDocument::Sections::IsoAbstractSection,
+                      :render_abstract
       register_render Metanorma::IsoDocument::Terms::IsoTerm, :render_term
       register_render Metanorma::IsoDocument::Terms::TermNote, :render_term_note
-      register_render Metanorma::IsoDocument::Terms::TermExample, :render_term_example
+      register_render Metanorma::IsoDocument::Terms::TermExample,
+                      :render_term_example
       register_render Metanorma::IsoDocument::Boilerplate, :render_boilerplate
 
-      register_inline_render Metanorma::IsoDocument::Terms::TermOrigin, :render_term_origin
+      register_inline_render Metanorma::IsoDocument::Terms::TermOrigin,
+                             :render_term_origin
 
       def render_term_origin(element)
         text = extract_text_value(element)
@@ -82,7 +91,9 @@ module Metanorma
         return result if result && !result.empty?
 
         if titles.is_a?(Metanorma::IsoDocument::Metadata::TitleCollection) && !titles.items.empty?
-          raw = titles.items.find { |t| t.language == "en" } || titles.items.first
+          raw = titles.items.find do |t|
+            t.language == "en"
+          end || titles.items.first
           return raw.value.to_s if raw&.value
         end
         nil
@@ -195,8 +206,13 @@ module Metanorma
 
         pub_date = nil
         bibdata.date&.each do |date|
-          date_type = extract_text_value(safe_attr(date, :type_attr) || safe_attr(date, :type))
-          date_val = extract_text_value(date.is_a?(Metanorma::Document::Relaton::BibliographicDate) ? date.on : safe_attr(date, :text))
+          date_type = extract_text_value(safe_attr(date,
+                                                   :type_attr) || safe_attr(
+                                                     date, :type
+                                                   ))
+          date_val = extract_text_value(date.is_a?(Metanorma::Document::Relaton::BibliographicDate) ? date.on : safe_attr(
+            date, :text
+          ))
           if date_type == "published" && date_val
             pub_date = date_val
           end
@@ -350,8 +366,14 @@ module Metanorma
         term_name = extract_term_name(term)
         term_def = extract_term_definition(term)
         data_attrs = {}
-        data_attrs["data-term-name"] = term_name if term_name && !term_name.empty?
-        data_attrs["data-term-definition"] = term_def if term_def && !term_def.empty?
+        if term_name && !term_name.empty?
+          data_attrs["data-term-name"] =
+            term_name
+        end
+        if term_def && !term_def.empty?
+          data_attrs["data-term-definition"] =
+            term_def
+        end
         attrs = element_attrs(id: safe_attr(term, :id), **data_attrs)
         tag("div", attrs) do
           # In presentation mode, use fmt_* elements
@@ -372,23 +394,37 @@ module Metanorma
 
           # Preferred designations — use fmt-preferred if available
           if term.fmt_preferred && !term.fmt_preferred.empty?
-            term.fmt_preferred.each { |fp| fp.p&.each { |para| render_paragraph(para) } }
+            term.fmt_preferred.each do |fp|
+              fp.p&.each do |para|
+                render_paragraph(para)
+              end
+            end
           elsif term.preferred && !term.preferred.empty?
-            term.preferred&.each { |designation| render_term_designation(designation, "preferred") }
+            term.preferred&.each do |designation|
+              render_term_designation(designation, "preferred")
+            end
           end
 
           # Admitted designations — use fmt-admitted if available
           if term.fmt_admitted && !term.fmt_admitted.empty?
-            term.fmt_admitted.each { |fa| fa.p&.each { |para| render_paragraph(para) } }
+            term.fmt_admitted.each do |fa|
+              fa.p&.each do |para|
+                render_paragraph(para)
+              end
+            end
           elsif term.admitted && !term.admitted.empty?
-            term.admitted&.each { |designation| render_term_designation(designation, "admitted") }
+            term.admitted&.each do |designation|
+              render_term_designation(designation, "admitted")
+            end
           end
 
           # Deprecated designations — use fmt-deprecates if available
           if term.fmt_deprecates
             term.fmt_deprecates.p&.each { |para| render_paragraph(para) }
           elsif term.deprecates && !term.deprecates.empty?
-            term.deprecates&.each { |designation| render_term_designation(designation, "deprecated") }
+            term.deprecates&.each do |designation|
+              render_term_designation(designation, "deprecated")
+            end
           end
 
           # Domain — only render separately when fmt-definition is absent
@@ -450,11 +486,17 @@ module Metanorma
 
       def extract_term_definition(term)
         if term.fmt_definition
-          rendered = capture_output { render_ordered_content(term.fmt_definition) }
+          rendered = capture_output do
+            render_ordered_content(term.fmt_definition)
+          end
           return strip_html(rendered).gsub(/\s+/, " ").strip
         end
         if term.p && !term.p.empty?
-          rendered = capture_output { term.p.each { |para| render_paragraph(para) } }
+          rendered = capture_output do
+            term.p.each do |para|
+              render_paragraph(para)
+            end
+          end
           return strip_html(rendered).gsub(/\s+/, " ").strip
         end
         nil
@@ -564,7 +606,9 @@ module Metanorma
         # Remap XML class names to HTML-specific class names
         boilerplate_doc = Nokogiri::HTML::DocumentFragment.parse(clean)
         boilerplate_doc.css("[class]").each do |el|
-          el["class"] = el["class"].split(/\s+/).map { |c| html_class_for_span(c) }.join(" ")
+          el["class"] = el["class"].split(/\s+/).map do |c|
+            html_class_for_span(c)
+          end.join(" ")
         end
 
         @output << boilerplate_doc.inner_html.strip
@@ -603,7 +647,8 @@ module Metanorma
       # --- Helpers ---
 
       def render_title(section, level)
-        title_element = safe_attr(section, :fmt_title) || safe_attr(section, :title)
+        title_element = safe_attr(section,
+                                  :fmt_title) || safe_attr(section, :title)
         return unless title_element
 
         section_id = safe_attr(section, :id)

data/lib/metanorma/html/itu_renderer.rb

@@ -4,7 +4,6 @@ module Metanorma
   module Html
     # ITU brand: #0e99d5 blue from logo
     class ItuRenderer < IsoRenderer
-
       def flavor_publishers(_doc_id)
         ["ITU"]
       end

data/lib/metanorma/html/ogc_renderer.rb

@@ -5,7 +5,6 @@ module Metanorma
     # Renders OgcDocument components to HTML.
     # Extends IsoRenderer with OGC-specific branding (geospatial, OGC cyan-blue #00b1ff).
     class OgcRenderer < IsoRenderer
-
       def flavor_publishers(_doc_id)
         ["OGC"]
       end

data/lib/metanorma/html/oiml_renderer.rb

@@ -5,7 +5,6 @@ module Metanorma
     # Renders OimlDocument (OIML) components to HTML.
     # Extends IsoRenderer with OIML branding.
     class OimlRenderer < IsoRenderer
-
       def flavor_publishers(_doc_id)
         ["OIML"]
       end

data/lib/metanorma/html/pdfa_renderer.rb

@@ -5,7 +5,6 @@ module Metanorma
     # Renders PDF Association (PDFA) taste documents to HTML.
     # PDFA brand: #cf9c1d gold + #d03544 red + #4992b2 steel blue from logo
     class PdfaRenderer < IsoRenderer
-
       def flavor_publishers(_doc_id)
         ["PDF Association"]
       end

data/lib/metanorma/html/ribose_renderer.rb

@@ -5,7 +5,6 @@ module Metanorma
     # Renders RiboseDocument components to HTML.
     # Extends IsoRenderer with Ribose branding.
     class RiboseRenderer < IsoRenderer
-
       def flavor_publishers(_doc_id)
         ["Ribose"]
       end