isodoc 3.7.0 → 3.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1704124a224846f711e07140b38b352fe8d9548465654168467b0d892c29867d
-  data.tar.gz: eedf867e52f1ff13d2c7166a4bd9361ac432da5afc688c4d7bfa50f0f91bada5
+  metadata.gz: 3f336d204ef62fe18fa00d602cd7281ef876b14cc63c216e718eb8bf60be0f5d
+  data.tar.gz: 354606fcf812e4d4378a36dac7aa771e875b947fa21ade182faec0b52cff63f9
 SHA512:
-  metadata.gz: 20ce7106f1eb73784cf58ef1ed0bf7bfc7f5bcd6c1a8495f4bec0b19326b70f7228fc2b0886abe4c98df19d2f42cc0456be55c6eba6d90c7806bbbff56bd5cd7
-  data.tar.gz: ca9607aceeafd8d263a6cc779f6311d709b1c35c6be218ec6b0dee2193e86eb1cdc1725b0457d79c8967bcb27e6c4df4b062ca972960e96690e309ab7c9e9503
+  metadata.gz: e29dd8f0a3e9181226c4df3dccc334497a313052b841671bfbf9b342fe577f4778578c3018eee82409a664f7a11cc937f7ed539dec6d74d2d2d8485a9d3f64cf
+  data.tar.gz: 2e1de040cfb8293321f989e31250f31b7b3c8a33167eb0846e34e08ae40d329f9e69342d6010b05b23aae615260457b3023d4f02baf084af5c6429dbe94e115d

data/.rubocop.yml

@@ -2,6 +2,15 @@
 # See https://github.com/metanorma/cimas
 inherit_from:
   - https://raw.githubusercontent.com/riboseinc/oss-guides/main/ci/rubocop.yml
+  # .rubocop_todo.yml MUST be the last entry. inherit_from is last-wins:
+  # if listed before oss-guides, the shared config's stricter Metrics/
+  # (MethodLength, BlockLength, etc.) rules override the todo's per-file
+  # grandfathering, and the todo becomes inert on those cops. Empirically
+  # verified on suma 2026-07-06: with todo listed first, 34 Metrics/* offenses
+  # remained; moved last, cleared. Every gem in the metanorma-org fleet
+  # already ships a `.rubocop_todo.yml` on its live tree (audited 2026-07-06,
+  # 54/54 have it), so this reference is safe to emit unconditionally.
+  - .rubocop_todo.yml
 
 # Rubocop plugins enabled centrally so every metanorma-org gem picks them up
 # on cimas sync — best practice belongs at the shared-template layer, not

data/lib/isodoc/base_style/all.css

@@ -130,6 +130,10 @@ dl dd {
   grid-column-start: 2;
 }
 
+dl:has(dt .stem) {
+  grid-template-columns: fit-content(8em) auto;
+}
+
 b, strong {
   font-weight: bold;
 }
@@ -143,6 +147,11 @@ a.FootnoteRef, span.FootnoteRef {
   vertical-align: super;
 }
 
+a.TableFootnoteRef, a.FootnoteRef, a.footnote-number,
+sup a, a:has(> sup) {
+  vertical-align: baseline;
+}
+
 .addition {
   color: blue;
 }

data/lib/isodoc/base_style/reset.css

@@ -130,6 +130,10 @@ dl dd {
   grid-column-start: 2;
 }
 
+dl:has(dt .stem) {
+  grid-template-columns: fit-content(8em) auto;
+}
+
 b, strong {
   font-weight: bold;
 }

data/lib/isodoc/base_style/reset.scss

@@ -137,6 +137,18 @@ dl {
   }
 }
 
+// metanorma-taste#150: a symbols definition list holds the AsciiMath *source*
+// string in its dt (HTML renders math client-side via async MathJax, which never
+// reflows the grid), so a long source blows out the max-content term column and
+// pushes every definition far right. Cap the term column of stem-bearing dls so
+// the term-to-definition gap stays bounded; plain/abbreviation dls keep
+// max-content, which is correct for them. 8em is a crude, tunable ceiling.
+// STOPGAP: remove this rule and restore plain max-content once HTML emits
+// server-side MathML (the term column will then size to the rendered symbol).
+dl:has(dt .stem) {
+  grid-template-columns: fit-content(8em) auto;
+}
+
 b, strong {
   font-weight: bold;
 }

data/lib/isodoc/function/section_titles.rb

@@ -1,8 +1,19 @@
 module IsoDoc
   module Function
     module Section
+      # Optional per-caption-type delimiter override from i18n: a
+      # +<type>_delimiter+ key, falling back to a shared +caption_delimiter+
+      # key, falling back to the hardcoded default. Uses +@i18n.get+ (hash
+      # lookup, nil for absent keys) rather than +@i18n.<key>+ (which is only
+      # defined for present keys). The keys are absent from the base i18n YAML,
+      # so default behaviour is unchanged unless a flavour or document sets them.
+      def i18n_delim(type, default)
+        @i18n&.get&.dig("#{type}_delimiter") ||
+          @i18n&.get&.dig("caption_delimiter") || default
+      end
+
       def clausedelim
-        "."
+        i18n_delim("clause", ".")
       end
 
       def clausedelimspace(_node, out)

data/lib/isodoc/function/table.rb

@@ -173,7 +173,11 @@ module IsoDoc
         true
       end
 
-      def tr_parse(node, out, ord, totalrows, header)
+      # Defaults cover the bare-tr dispatch in ToWordHtml#parse, which had
+      # called this with two arguments (unsatisfiable) since 2018: a tr
+      # outside tbody/thead context renders as an unbordered plain row
+      # instead of crashing (metanorma-pdfa#84)
+      def tr_parse(node, out, ord = 0, totalrows = 1, header = false)
         out.tr(**attr_code(style: node["style"])) do |r|
           node.elements.each do |td|
             attrs = make_tr_attr(td, ord, totalrows - 1, header,

data/lib/isodoc/init.rb

@@ -35,6 +35,9 @@ module IsoDoc
       toc_init(xml)
       @details_open = xml.at(ns("//metanorma-extension/presentation-metadata/" \
                                 "html-details-open"))&.text != "false"
+      @index_fold_case =
+        xml.at(ns("//metanorma-extension/presentation-metadata/" \
+                  "index-case-sensitive"))&.text != "true"
     end
 
     def doctype_init(docxml)

data/lib/isodoc/metadata_bibdata.rb

@@ -63,11 +63,59 @@ module IsoDoc
       bib = BibdataConfig.from_xml(
         "<metanorma>#{stripped.root.to_xml}</metanorma>",
       ).bibdata or return nil
-      YAML.safe_load(bib.to_yaml, permitted_classes: [Date, Symbol],
-                                  symbolize_names: true)
+      hash = YAML.safe_load(bib.to_yaml, permitted_classes: [Date, Symbol],
+                                         symbolize_names: true)
+      hash and fold_in_bibdata_ext(hash, stripped)
+      hash
     rescue StandardError => e
       warn "Failed to parse bibdata for Liquid template use: #{e.message}"
       nil
     end
+
+    # The Liquid `bibdata` object is built by round-tripping //bibdata through
+    # the Relaton object model, which represents bibliographic-item fields but
+    # not the Metanorma-document extension metadata under bibdata/ext
+    # (coverpage-image, innercoverpage-image, ...). Relaton drops those, so
+    # fold the raw ext subtree back in, using the same serialisation convention
+    # Relaton uses: element text -> :content, attributes -> sibling keys,
+    # repeated elements -> arrays, hyphens -> underscores (as in
+    # schema-version -> schema_version). Relaton-modelled keys win on collision;
+    # :ext is only populated when <ext> is present.
+    def fold_in_bibdata_ext(hash, stripped)
+      ext = stripped.at("//bibdata/ext") or return
+      raw = xml_element_hash(ext)
+      raw.is_a?(Hash) or return
+      modelled = hash[:ext].is_a?(Hash) ? hash[:ext] : {}
+      hash[:ext] = raw.merge(modelled)
+    end
+
+    # Generic Nokogiri element -> nested hash in Relaton's serialisation shape.
+    def xml_element_hash(node)
+      hash = {}
+      node.attribute_nodes.each { |a| hash[ext_hash_key(a.node_name)] = a.value }
+      children = node.element_children
+      if children.empty?
+        text = node.text.strip
+        hash[:content] = text unless text.empty?
+      else
+        children.each do |c|
+          add_ext_child(hash, ext_hash_key(c.node_name), xml_element_hash(c))
+        end
+      end
+      hash
+    end
+
+    def add_ext_child(hash, key, value)
+      if hash.key?(key)
+        hash[key] = [hash[key]] unless hash[key].is_a?(Array)
+        hash[key] << value
+      else
+        hash[key] = value
+      end
+    end
+
+    def ext_hash_key(name)
+      name.tr("-", "_").to_sym
+    end
   end
 end

data/lib/isodoc/presentation_function/annex.rb

@@ -91,7 +91,7 @@ module IsoDoc
     end
 
     def annex_delim(_elem)
-      "<br/><br/>"
+      i18n_delim("annex", "<br/><br/>")
     end
   end
 end

data/lib/isodoc/presentation_function/block.rb

@@ -46,7 +46,8 @@ module IsoDoc
       n = @xrefs.get[elem["id"]] || @xrefs.get[elem["original-id"]]
       lbl = labelled_autonum(@i18n.example, elem["id"] || elem["original-id"],
                              n&.dig(:label))
-      prefix_name(elem, { caption: block_delim }, lbl, "name")
+      prefix_name(elem, { caption: i18n_delim("example", block_delim) }, lbl,
+                  "name")
     end
 
     def note(docxml)
@@ -54,7 +55,7 @@ module IsoDoc
     end
 
     def note_delim(_elem)
-      "<tab/>"
+      i18n_delim("note", "<tab/>")
     end
 
     def note1(elem)
@@ -88,7 +89,8 @@ module IsoDoc
 
     def admonition_options(elem)
       options = { label: admonition_delim(elem) }
-      elem["type"] == "box" and options = { caption: block_delim }
+      elem["type"] == "box" and
+        options = { caption: i18n_delim("admonition", block_delim) }
       options
     end
 
@@ -119,7 +121,7 @@ module IsoDoc
 
     def admonition_delim(elem)
       if elem["type"] == "box"
-        block_delim
+        i18n_delim("admonition", block_delim)
       else
         ""
       end
@@ -157,7 +159,7 @@ module IsoDoc
     end
 
     def table_delim
-      block_delim
+      i18n_delim("table", block_delim)
     end
 
     def table_long_strings_cleanup(docxml)

data/lib/isodoc/presentation_function/concepts.rb

@@ -21,6 +21,9 @@ module IsoDoc
 
     def concept_render(node, defaults)
       opts, render, ref, ret = concept_render_init(node, defaults)
+      # generator-emitted term-resolution failure reports
+      # (metanorma-model-iso#144) render in boldface
+      ret&.xpath(ns(".//errormsg"))&.each { |e| e.name = "strong" }
       ret&.at(ns("./refterm"))&.remove
       ref && opts[:ref] != "false" and render&.next = " "
       concept1_linkmention(ref, render, opts)

data/lib/isodoc/presentation_function/designations.rb

@@ -8,12 +8,17 @@ module IsoDoc
     def related1(node)
       p, ref, orig = related1_prep(node)
       label = @i18n.relatedterms[orig["type"]].upcase
+      err = node.at(ns("./errormsg"))
       ret = if p && ref
               if p.text == ref.text
                 "<em>#{Common::to_xml(ref)}</em>"
               else
                 "<em>#{to_xml(p)}</em> (#{Common::to_xml(ref)})"
               end
+            elsif err
+              # generator-emitted term-resolution failure reports
+              # (metanorma-model-iso#144) render in boldface
+              "<strong>#{to_xml(err.children)}</strong>"
             else "<strong>**RELATED TERM NOT FOUND**</strong>"
             end
       node.children = (l10n("<p><strong>#{label}:</strong> #{ret}</p>"))

data/lib/isodoc/presentation_function/image.rb

@@ -54,12 +54,11 @@ module IsoDoc
     end
 
     def subfigure_delim
-      ""
-      # "<span class='fmt-label-delim'>)</span>"
+      i18n_delim("subfigure", "")
     end
 
     def figure_delim(_elem)
-      block_delim
+      i18n_delim("figure", block_delim)
     end
 
     def figure_name(elem)

data/lib/isodoc/presentation_function/index.rb

@@ -22,16 +22,24 @@ module IsoDoc
     def index1(docxml, indexsect, index)
       c = indexsect.add_child("<ul></ul>").first
       index.keys.sort.each do |k|
-        words = index[k].keys.each_with_object({}) do |w, v|
-          v[sortable(w).downcase] = w
-        end
+        words = index_sort_buckets(index[k].keys)
         words.keys.localize(@lang.to_sym).sort.to_a.each do |w|
-          c.add_child index_entries(words, index[k], w)
+          words[w].each { |w1| c.add_child index_entries(w1, index[k]) }
         end
       end
       index1_cleanup(docxml)
     end
 
+    # Sorting is case-insensitive, so entries differing only in case (or
+    # only in markup, which the sort key strips) share a sort key; they
+    # are kept as distinct entries in a bucket per key, sorted adjacently
+    # (metanorma/metanorma#298: overwriting them lost all but one entry)
+    def index_sort_buckets(keys)
+      keys.compact.each_with_object({}) do |w, v|
+        (v[sortable(w).downcase] ||= []) << w
+      end.transform_values(&:sort)
+    end
+
     def index1_cleanup(docxml)
       docxml.xpath(ns("//indexsect//xref")).each do |x|
         x.children.remove
@@ -48,34 +56,31 @@ module IsoDoc
       { xref_lbl: ", ", see_lbl: ", #{see_lbl}", also_lbl: ", #{also_lbl}" }
     end
 
-    def index_entries(words, index, primary)
-      ret = index_entries_head(words[primary],
-                               index.dig(words[primary], nil, nil),
+    def index_entries(primary, index)
+      ret = index_entries_head(primary, index.dig(primary, nil, nil),
                                index_entries_opt)
-      words2 = index[words[primary]]&.keys&.compact
-        &.each_with_object({}) { |w, v| v[w.downcase] = w }
+      words2 = index_sort_buckets(index[primary].keys)
       unless words2.empty?
         ret += "<ul>"
         words2.keys.localize(@lang.to_sym).sort.to_a.each do |w|
-          ret += index_entries2(words2, index[words[primary]], w)
+          words2[w].each { |w1| ret += index_entries2(w1, index[primary]) }
         end
         ret += "</ul>"
       end
       "#{ret}</li>"
     end
 
-    def index_entries2(words, index, secondary)
-      ret = index_entries_head(words[secondary],
-                               index.dig(words[secondary], nil),
+    def index_entries2(secondary, index)
+      ret = index_entries_head(secondary, index.dig(secondary, nil),
                                index_entries_opt)
-      words3 = index[words[secondary]]&.keys&.compact
-        &.each_with_object({}) { |w, v| v[w.downcase] = w }
+      words3 = index_sort_buckets(index[secondary].keys)
       unless words3.empty?
         ret += "<ul>"
         words3.keys.localize(@lang.to_sym).sort.to_a.each do |w|
-          ret += (index_entries_head(words3[w],
-                                     index[words[secondary]][words3[w]],
-                                     index_entries_opt) + "</li>")
+          words3[w].each do |w1|
+            ret += "#{index_entries_head(w1, index[secondary][w1],
+                                         index_entries_opt)}</li>"
+          end
         end
         ret += "</ul>"
       end
@@ -95,12 +100,9 @@ module IsoDoc
 
     def index_entries_see(entries, label)
       see_sort = entries&.dig(label) or return nil
-      x = see_sort.each_with_object({}) do |w, v|
-        v[sortable(w).downcase] = w
-      end
-      x.keys.localize(@lang.to_sym).sort.to_a.map do |k|
-        # see_sort[k]
-        x[k]
+      x = index_sort_buckets(see_sort)
+      x.keys.localize(@lang.to_sym).sort.to_a.flat_map do |k|
+        @index_fold_case ? [index_fold_head(x[k])] : x[k].uniq
       end.join(", ")
     end
 
@@ -116,12 +118,54 @@ module IsoDoc
       index = extract_indexterms(terms)
       index = extract_indexsee(index, see, :see)
       index = extract_indexsee(index, also, :also)
+      @index_fold_case and index_fold_case(index)
       index.keys.sort.each_with_object({}) do |k, v|
         v[sortable(k)[0].upcase.transliterate] ||= {}
         v[sortable(k)[0].upcase.transliterate][k] = index[k]
       end
     end
 
+    # Entries differing only in case merge into a single headword, the
+    # lowercase spelling, with the union of their subentries and locators:
+    # ((activity)) mid-sentence and ((Activity)) sentence-initially are
+    # the same entry. Suppressed by the :index-case-sensitive: document
+    # attribute for identifier-heavy documents, where Activity and
+    # activity are distinct case-bearing names (metanorma/metanorma#298).
+    # Applied per level: primaries, then secondaries, then tertiaries.
+    def index_fold_case(index)
+      index_fold_level(index)
+      index.each_value do |sec|
+        index_fold_level(sec)
+        sec.each_value { |ter| index_fold_level(ter) }
+      end
+    end
+
+    def index_fold_level(hash)
+      hash.keys.grep(String).group_by { |w| sortable(w).downcase }
+        .each_value { |ws| ws.size > 1 and index_fold_bucket(hash, ws) }
+    end
+
+    def index_fold_bucket(hash, words)
+      head = index_fold_head(words)
+      (words - [head]).each do |w|
+        index_merge(hash[head], hash[w])
+        hash.delete(w)
+      end
+    end
+
+    def index_fold_head(words)
+      words.find { |w| sortable(w) == sortable(w).downcase } || words.min
+    end
+
+    def index_merge(target, other)
+      other.each do |k, v|
+        if !target.key?(k) then target[k] = v
+        elsif v.is_a?(Array) then target[k].concat(v)
+        else index_merge(target[k], v)
+        end
+      end
+    end
+
     def extract_indexsee(val, terms, label)
       terms.each_with_object(val) do |t, v|
         term, term2, term3 = extract_indexterms_init(t)

data/lib/isodoc/presentation_function/list.rb

@@ -68,6 +68,9 @@ module IsoDoc
 
     def ol_label_format(semx, elem)
       template = ol_label_template(elem)[elem.parent["type"].to_sym]
+      # types outside the template set are not decorated, e.g. xml2rfc v2
+      # format strings passed through as ol/@type by metanorma-ietf
+      template or return semx
       template.sub("%", semx)
     end
 

data/lib/isodoc/presentation_function/section.rb

@@ -34,7 +34,7 @@ module IsoDoc
     def clausedelim
       ret = super
       (ret && !ret.empty?) or return ret
-      "<span class='fmt-autonum-delim'>#{ret}</span>"
+      "<span class='fmt-clause-delim'>#{ret}</span>"
     end
 
     def clause1(elem)

data/lib/isodoc/presentation_function/sourcecode.rb

@@ -51,7 +51,19 @@ module IsoDoc
 
     def sourcecode1(elem)
       ret1 = semx_fmt_dup(elem)
-      b = ret1.at(ns(".//body")) and b.replace(b.children)
+      if (b = ret1.at(ns(".//body")))
+        # Remove formatting whitespace *preceding* the body (e.g. the newlines
+        # standoc emits around a <name> with inline markup). Once the body is
+        # unwrapped and the name removed, such stray whitespace would be lexed
+        # as leading blank lines of code. Whitespace after the body and the
+        # verbatim body content itself are untouched, so genuine code
+        # indentation is preserved.
+        b.parent.children.each do |c|
+          c == b and break
+          c.text? && c.text.strip.empty? and c.remove
+        end
+        b.replace(b.children)
+      end
       source_label(elem)
       source_highlight(ret1, elem["linenums"] == "true", elem["lang"])
       callouts(elem)
@@ -163,17 +175,35 @@ module IsoDoc
       lexer = Rouge::Lexer.find(lang || "plaintext") ||
         Rouge::Lexer.find("plaintext")
       l = Rouge::Lexers::Escape.new(start: "{^^{", end: "}^^}", lang: lexer)
+      source_collapse_markup_newlines(elem)
       source = to_xml(elem.children).gsub("<", "{^^{<").gsub(">", ">}^^}")
       l.lang.reset!
       l.lex(@c.decode(source))
     end
 
+    # Embedded markup serialised across multiple lines (e.g. pretty-printed
+    # MathML from stem) would be split across line cells by the line-table
+    # formatter, leaving each cell with unbalanced tags: the string reparse
+    # of the table then cascades mis-nested rows, and rendering crashes on
+    # the orphaned rows (metanorma-pdfa#84). Collapse whitespace inside
+    # embedded elements so each occupies a single code line; code text
+    # outside the elements is untouched.
+    def source_collapse_markup_newlines(elem)
+      elem.elements.each do |e|
+        e.xpath(".//text()").each do |t|
+          /[\n\r]/.match?(t.content) and
+            t.content = t.content.gsub(/\s*[\n\r]+\s*/, " ")
+        end
+      end
+    end
+
     def source_label(elem)
       if !labelled_ancestor(elem) && # do not number if labelled_ancestor
           lbl = @xrefs.anchor(elem["id"], :label, false)
         s = labelled_autonum(lower2cap(@i18n.figure), elem["id"], lbl)&.strip
       end
-      prefix_name(elem, { caption: block_delim }, s, "name")
+      prefix_name(elem, { caption: i18n_delim("sourcecode", block_delim) }, s,
+                  "name")
     end
   end
 end

data/lib/isodoc/presentation_function/terms.rb

@@ -38,7 +38,7 @@ module IsoDoc
     end
 
     def termnote_delim(_elem, lbl)
-      l10n(": ", { prev: lbl })
+      l10n(i18n_delim("termnote", ": "), { prev: lbl })
     end
 
     def termnote1(elem)

data/lib/isodoc/version.rb

@@ -1,3 +1,3 @@
 module IsoDoc
-  VERSION = "3.7.0".freeze
+  VERSION = "3.7.2".freeze
 end

data/lib/isodoc/xref/xref_anchor.rb

@@ -70,9 +70,19 @@ module IsoDoc
                              elem_name)
         ret[:container] = @klass.get_clause_id(node) if opt[:container]
         ret[:value] = stripsemx(lbl)
+        t = asset_title(node) and ret[:title] = t
         ret
       end
 
+      # Caption of a numbered asset (its <name>, or a modspec requirement's
+      # <title>), semx-wrapped, so that xrefstyle=full can render
+      # "Table 3, caption" the way clauses render "Clause 6, Title". Returns nil
+      # when the asset has no caption, so anchor_xref_full falls back to short.
+      def asset_title(node)
+        n = node.at(ns("./name")) || node.at(ns("./title")) or return nil
+        semx(node, n.children.to_xml, n.name)
+      end
+
       include ::IsoDoc::XrefGen::Util
     end
   end

data/lib/isodoc-yaml/i18n-en.yaml

@@ -135,6 +135,7 @@ title_prefixes:
 locality: {
                       section: Section,
                       clause: Clause,
+                      definition: Definition,
                       part: Part,
                       paragraph: Paragraph,
                       chapter: Chapter,
@@ -174,6 +175,9 @@ inflection:
   Clause:
     sg: Clause
     pl: Clauses
+  Definition:
+    sg: Definition
+    pl: Definitions
   Annex:
     sg: Annex
     pl: Annexes

data/lib/isodoc-yaml/i18n-fr.yaml

@@ -131,6 +131,7 @@ title_prefixes:
 locality: {
                       section: Section,
                       clause: Article,
+                      definition: Définition,
                       part: Partie,
                       paragraph: Alinéa,
                       chapter: Chapitre,
@@ -170,6 +171,9 @@ inflection:
   Clause:
     sg: Article
     pl: Articles
+  Definition:
+    sg: Définition
+    pl: Définitions
   Annex:
     sg: Annexe
     pl: Annexes

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: isodoc
 version: !ruby/object:Gem::Version
-  version: 3.7.0
+  version: 3.7.2
 platform: ruby
 authors:
 - Ribose Inc.
@@ -351,7 +351,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.16
 specification_version: 4
 summary: Convert documents in IsoDoc into Word and HTML in AsciiDoc.
 test_files: []