isodoc 3.7.2 → 3.7.4.pre.alpha.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f336d204ef62fe18fa00d602cd7281ef876b14cc63c216e718eb8bf60be0f5d
-  data.tar.gz: 354606fcf812e4d4378a36dac7aa771e875b947fa21ade182faec0b52cff63f9
+  metadata.gz: f9eca206080376f0d963170e2c45ec57945a257fda3ab170217b9719fb8c25a6
+  data.tar.gz: 10fa45dadb8322115235ab358ada67bb86a64ede4f25d05a10e8f6485773f035
 SHA512:
-  metadata.gz: e29dd8f0a3e9181226c4df3dccc334497a313052b841671bfbf9b342fe577f4778578c3018eee82409a664f7a11cc937f7ed539dec6d74d2d2d8485a9d3f64cf
-  data.tar.gz: 2e1de040cfb8293321f989e31250f31b7b3c8a33167eb0846e34e08ae40d329f9e69342d6010b05b23aae615260457b3023d4f02baf084af5c6429dbe94e115d
+  metadata.gz: 3e360b76748e8e03283b2b280363c7bf7a7b0c696e2bba62f9daf621e0006dfd791bc8ae5989d3a8229b9445fd02559f644ce6460ed31a9ca77ae495e6fe7323
+  data.tar.gz: 91162667360c2a04cd6142e78297c13d4c256f6bc908c1fdd1fc43e35da9e7ac1b4c75ba0cd96abf4e382239823bb5fee41e1fd2b1958fe069e335616d7ce3e0

data/.gitignore

@@ -1 +1,26 @@
 spec/assets/img.svg
+
+# Generated test output
+test.doc
+test.err.html
+test.html
+test.presentation.xml
+test_*_files/
+test_*_htmlimages/
+_test_attachments/
+spec/test.html
+spec/test_*_htmlimages/
+spec/assets/iso.doc
+spec/assets/iso.headless.html
+spec/assets/odf1.emf
+spec/assets/test.html
+
+# Tooling
+coverage/
+pkg/
+.rspec_status
+.rubocop-https---*
+.rubocop-remote-*
+
+# Gem library: resolve at install time
+Gemfile.lock

data/README.adoc

@@ -85,3 +85,18 @@ NOTE: In the HTML stylesheets specific to standards, the Cover page and Intro pa
 This gem relies on https://github.com/metanorma/html2doc[html2doc] to generate Microsoft Word documents.
 
 Please see https://github.com/metanorma/html2doc#converting-document-output-to-native-word-docx[this post-processing procedure] to convert output into a native-`docx` document.
+
+== Stylesheet compilation and `sassc-embedded`
+
+The `.scss` stylesheets under `lib/` are **precompiled to `.css` when this gem is packaged**, not at consumer render time:
+
+* `lib/isodoc/gem_tasks.rb` enhances the standard `rake build` with a `build_scss` step: every `lib/**/*.scss` is compiled to a sibling `.css` (using `sassc-embedded`), the compiled files are packed into the released `.gem`, and are then removed from the git working tree. Compiled stylesheets are never committed.
+
+At runtime, `lib/isodoc/css.rb#precompiled_style_or_original` prefers the sibling `.css` shipped inside the installed gem. **Consumers of released isodoc gems therefore never load `sassc-embedded`** — which is why the gemspec does not declare it.
+
+The runtime SCSS compilation path (`css.rb#convert_scss`, which `require`s `sassc-embedded`) only runs when the sibling `.css` is absent, which is the case when:
+
+* working from a git checkout of this repository (no compiled `.css` on disk), or
+* a downstream project resolves isodoc from git (e.g. `gem "isodoc", github: "metanorma/isodoc"`): bundler installs the gemspec's file list, which carries only `.scss`
+
+NOTE: Downstream maintainers: if your Gemfile pins isodoc from git, your HTML renders will `require "sassc-embedded"` at runtime even though released-gem consumers never do. A downstream `gem "sassc-embedded"` line in that setup is load-bearing, not dead weight — and it becomes droppable once you revert to a released isodoc gem.

data/isodoc.gemspec

@@ -28,15 +28,22 @@ Gem::Specification.new do |spec|
   end
   spec.required_ruby_version = Gem::Requirement.new(">= 3.3.0")
 
-  spec.add_dependency "base64"
+  spec.add_dependency "base64", ">= 0.1.0"
   spec.add_dependency "bigdecimal"
   spec.add_dependency "html2doc", "~> 1.12"
-  # spec.add_dependency "isodoc-i18n", "~> 1.1.0" # already in relaton-render and mn-requirements
-  spec.add_dependency "relaton-cli", "~> 2.1.0"
-  # spec.add_dependency "metanorma-utils", "~> 1.5.0" # already in isodoc-i18n
+  # spec.add_dependency "isodoc-i18n", "~> 1.5" # already in relaton-render and mn-requirements
+  spec.add_dependency "relaton-cli", ">= 3.0.0.pre.alpha", "< 3.1.0"
+  # spec.add_dependency "metanorma-utils", "~> 2.0" # already in isodoc-i18n
   spec.add_dependency "mn2pdf", ">= 2.13"
   spec.add_dependency "mn-requirements", "~> 0.5.0"
-  spec.add_dependency "relaton-render", "~> 1.3.0"
+  # Allowance for the relaton 3.0.0.pre family (mirrors the relaton-cli
+  # allowance in #824): relaton 3.0.0.pre requires relaton-render
+  # 3.0.0.pre, which joins the family's versioning and restores the 1.x
+  # leaves as deprecated shims, so flavor stacks boot against it.
+  # Released isodoc lines keep resolving relaton-render 1.3.0; only a
+  # stack that explicitly adopts the relaton prerelease co-resolves
+  # 3.0.0.pre.
+  spec.add_dependency "relaton-render", "~> 3.0.0.pre.alpha", "< 5"
   spec.add_dependency "roman-numerals"
   spec.add_dependency "rouge", "~> 4.0"
   spec.add_dependency "thread_safe"

data/lib/isodoc/convert.rb

@@ -44,7 +44,7 @@ module IsoDoc
     # bare: do not insert any prefatory material (coverpage, boilerplate)
     # tocfigures: add ToC for figures
     # toctables: add ToC for tables
-    # tocrecommendations: add ToC for rcommendations
+    # tocrecommendations: add ToC for recommendations
     # tocexamples: add ToC for examples
     # fonts: fontist fonts to install
     # fontlicenseagreement: fontist font license agreement

data/lib/isodoc/gem_tasks.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-require "sassc-embedded"
-require "isodoc/sassc_importer"
+# sassc-embedded / sassc_importer load lazily in load_scss_paths: every
+# flavor Rakefile requires this file, but only scss compilation needs the
+# (undeclared) sassc dependency.
 require "rake/clean"
 require "tmpdir"
 

data/lib/isodoc/init.rb

@@ -7,6 +7,7 @@ module IsoDoc
     def xref_init(lang, script, _klass, i18n, options)
       html = HtmlConvert.new(language: @lang, script: @script)
       @xrefs = Xref.new(lang, script, html, i18n, options)
+      @xrefs
     end
 
     def i18n_init(lang, script, locale, i18nyaml = nil)

data/lib/isodoc/metadata.rb

@@ -141,14 +141,27 @@ module IsoDoc
       set(:edition_display,
           isoxml.at(ns("//bibdata/edition#{currlang}"))&.text)
       set(:docyear, isoxml.at(ns("//bibdata/copyright/from"))&.text)
-      set(:draft, isoxml.at(ns("//bibdata/version"))&.text)
-      revdate = isoxml.at(ns("//bibdata/date[@type='updated']/on"))&.text
+      ver = isoxml.at(ns("//bibdata/version"))
+      set(:draft, draft_from_version(ver))
+      revdate = ver&.at(ns("./revision-date"))&.text ||
+        isoxml.at(ns("//bibdata/date[@type='updated']/on"))&.text
       set(:revdate, revdate)
       set(:revdate_monthyear, monthyr(revdate))
       set(:draftinfo,
           draftinfo(get[:draft], get[:revdate]))
     end
 
+    # <version> carries either its draft directly (legacy hand-built
+    # documents) or revision-date/draft children (the semantic
+    # pipeline's serialization).
+    def draft_from_version(ver)
+      return nil if ver.nil?
+
+      draft = ver.at(ns("./draft"))&.text
+      draft ||= ver.children.select(&:text?).join.strip
+      draft&.empty? ? nil : draft
+    end
+
     def title(isoxml, _out)
       main = isoxml.at(ns("//bibdata/title[@language='#{@lang}']"))
         &.children and set(:doctitle, to_xml(main))

data/lib/isodoc/metadata_bibdata.rb

@@ -16,7 +16,10 @@ module IsoDoc
 
     def bibdata_from_xml(model, node)
       node or return
-      model.bibdata = Relaton::Cli.parse_xml(node.adapter_node.native)
+      # Cli.parse_xml's contract is a Nokogiri::XML::Document
+      # (remove_namespaces!, at); under the moxml/leptris adapter the
+      # mapping node's native is not Nokogiri. Convert via markup.
+      model.bibdata = Relaton::Cli.parse_xml(Nokogiri::XML(node.to_xml))
     end
 
     def bibdata_to_xml(model, parent, doc); end
@@ -60,6 +63,7 @@ module IsoDoc
       # meta[:bibdata] with the resolved docidentifier.
       # See https://github.com/metanorma/metanorma/issues/558.
       stripped.xpath("//docidentifier[@boilerplate = 'true']").each(&:remove)
+      collapse_lang_variants!(stripped.root)
       bib = BibdataConfig.from_xml(
         "<metanorma>#{stripped.root.to_xml}</metanorma>",
       ).bibdata or return nil
@@ -72,6 +76,36 @@ module IsoDoc
       nil
     end
 
+    # Relaton models these fields as singular. Presentation i18n
+    # (PresentationXMLConvert#tag_translate, JIS #edition_integer?)
+    # intentionally emits language-variant siblings — language="",
+    # language="ja", numberonly="true", … — for rendering; feeding them
+    # to Relaton yields an Array and CollectionTrueMissingError /
+    # IncorrectModelError. Keep the canonical node (no @language, not
+    # @numberonly) so Liquid still sees the source value, matching
+    # Metadata#edition / #docstatus which read the NOLANG node.
+    SINGULAR_LANG_VARIANT_XPATHS = [
+      "./edition",
+      "./status/stage",
+      "./status/substage",
+      "./ext/doctype",
+    ].freeze
+
+    def collapse_lang_variants!(root)
+      SINGULAR_LANG_VARIANT_XPATHS.each do |xpath|
+        collapse_singular_nodes!(root, xpath)
+      end
+    end
+
+    def collapse_singular_nodes!(root, xpath)
+      nodes = root.xpath(xpath)
+      nodes.size > 1 or return
+      keep = nodes.find { |n| n["language"].to_s.empty? && n["numberonly"] != "true" } ||
+             nodes.find { |n| n["language"].to_s.empty? } ||
+             nodes.first
+      nodes.each { |n| n.remove unless n.equal?(keep) }
+    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

data/lib/isodoc/presentation_function/docid.rb

@@ -10,7 +10,7 @@ module IsoDoc
       bib["suppress_identifier"] == "true" and return nil
       ret = bib.xpath(ns("./docidentifier[@scope = 'biblio-tag']"))
       ret.empty? or return ret.map { |x| to_xml(x.children) }
-      ret = pref_ref_code_parse(bib) or return nil
+      ret = pref_ref_code_markup(bib) || pref_ref_code_parse(bib) or return nil
       ins = bib.at(ns("./docidentifier[last()]"))
       ret.reverse_each do |r|
         id = docid_l10n(r, citation: false)
@@ -19,6 +19,18 @@ module IsoDoc
       ret
     end
 
+    # Markup-preserving identifier: when the source docidentifier itself
+    # carries inline structure (semx, sup, sub...), keep that markup for
+    # the biblio-tag instead of the renderer's flat text, which would
+    # drop presentation structure like the sup in "ISO 712<sup>1</sup>".
+    def pref_ref_code_markup(bib)
+      ids = bib.xpath(ns("./docidentifier[not(@scope)]"))
+        .reject { |x| %w(metanorma metanorma-ordinal).include?(x["type"]) }
+        .select { |x| x.elements.any? }
+      ids.empty? and return nil
+      [to_xml(ids.first.children)]
+    end
+
     def pref_ref_code_parse(bib)
       data, = @bibrender.parse(bib)
       ret = data[:authoritative_identifier] or return nil

data/lib/isodoc/presentation_function/docid_semantic.rb

@@ -16,18 +16,78 @@ module IsoDoc
     end
 
     def std_docid_semantic_parse(id)
-      parsed = Pubid::Registry.parse(id)
+      result = pubid_parse(id)
       # Pubid::Ieee in particular happily parses any "letters+digits" token
       # as an IEEE Std identifier and synthesises an "IEEE Std" prefix that
       # wasn't in the input (e.g. "REF4" -> "IEEE Std REF4"). Refuse to
       # annotate when the parser has invented structure not present in the
       # input -- detected by a non-identity round-trip.
-      return id if parsed.to_s != id
-      parsed.to_s(annotated: true)
-    rescue Pubid::Core::Errors::ParseError
+      return std_docid_semantic_full(id) if result.nil?
+
+      result
+    rescue StandardError
       std_docid_semantic_full(id)
     end
 
+    # pubid 2 has no universal Pubid::Registry.parse: try each registered
+    # flavor. Outcomes:
+    #   1. A flavor round-trips the input AND renders annotation markup —
+    #      return it (some flavors' renderers ignore annotated: and
+    #      return plain text; those need the regex fallback below).
+    #   2. A flavor parses but synthesizes structure the input lacks
+    #      (e.g. "REF4" -> "IEEE Std REF4") — return the input unchanged
+    #      (1.x's round-trip guard).
+    #   3. Nothing parses, a round-tripper renders plain, or the parse
+    #      only canonicalizes FORM (e.g. em-dash year -> "--") — nil, so
+    #      the caller uses the regex fallback, which preserves the
+    #      original string (1.x's ParseError path).
+    def pubid_parse(string)
+      Pubid.eager_load_flavors!
+      parsed_any = false
+      plain_roundtrip = false
+      canonicalized = false
+      Pubid::Registry.flavors.each_value do |flavor|
+        next unless flavor.respond_to?(:parse)
+
+        begin
+          parsed = flavor.parse(string)
+          next if publisher_replaced?(string, parsed)
+
+          parsed_any = true
+          if parsed.to_s == string
+            annotated = parsed.to_s(annotated: true)
+            return annotated if annotated != parsed.to_s
+
+            plain_roundtrip = true
+          elsif dash_normalize(parsed.to_s) == dash_normalize(string)
+            canonicalized = true
+          end
+        rescue StandardError
+          next
+        end
+      end
+      return string if parsed_any && !plain_roundtrip && !canonicalized
+
+      nil
+    end
+
+    # Compare strings ignoring dash FORM (em-dash / double dash / single
+    # dash), so a parse that only canonicalizes punctuation is not
+    # mistaken for structure synthesis.
+    def dash_normalize(string)
+      string.tr("—", "-").gsub("--", "-")
+    end
+
+    # A parser that replaces the input's own leading publisher token
+    # with its own (ASHRAE parsing "IETF 6281" as "ASHRAE Standard
+    # 6281") has not parsed the identifier at all: keep trying, so the
+    # identifier reaches the regex fallback rather than the
+    # plain-string refusal
+    def publisher_replaced?(string, parsed)
+      own = string[/\A[A-Za-z][A-Za-z.-]*(?=\s)/] or return false
+      parsed.to_s[/\A[A-Za-z][A-Za-z.-]*(?=\s)/] != own
+    end
+
     # Regex-based fallback when Pubid::Registry cannot parse the id. Emits
     # the same generic class names that Pubid uses (publisher, docnumber,
     # part, year) so that flavors' `std_docid_span_classes` remaps work

data/lib/isodoc/presentation_function/refs.rb

@@ -14,6 +14,11 @@ module IsoDoc
       bib["suppress_identifier"] == true and
         bib.xpath(ns("./docidentifier")).each(&:remove)
       bib["type"] ||= "standard"
+      # The renderer takes flat identifier text; inline markup (semx, sup)
+      # in the source docidentifier yields an empty composition.
+      bib.xpath("./docidentifier").each do |d|
+        d.elements.any? and d.children = d.text
+      end
     end
 
     def bibitem(bib, renderings)
@@ -50,7 +55,8 @@ module IsoDoc
     def bibrender_formattedref(formattedref, bib); end
 
     def bibrender_relaton(bib, renderings)
-      f = renderings[bib["id"]][:formattedref] or return
+      r = renderings[bib["id"]] or return
+      f = r[:formattedref] or return
       f &&= "<formattedref>#{f}</formattedref>"
       if x = bib.at(ns("./formattedref"))
         x.replace(f)

data/lib/isodoc/spec_helpers/canon_html_input_guard.rb

@@ -1,25 +1,45 @@
 # frozen_string_literal: true
 
 require "canon"
+require "nokogiri"
 
-# Guard against leading "<?xml ?>" processing instructions in HTML
-# input strings passed to Canon's be_html_equivalent_to /
-# be_html4_equivalent_to / be_html5_equivalent_to matchers.
+# Guards Canon's serialization matchers against input shapes that
+# Canon's XML pretty-printer (preprocessing: :format in the metanorma
+# profile) and the moxml/leptris backend cannot digest.
 #
-# WHY: Nokogiri::HTML5.fragment parses a leading "<?xml ?>" as a bogus
-# Nokogiri::XML::Comment at index 0 of the fragment.  In Canon's
-# verbose mode (used by the matchers) comments are intentionally not
-# filtered, so the bogus comment shifts fragment child indices and
-# causes Canon's diff report to blame elements at the tail of the
-# document for an offence at the head — an "uninterpretable report"
-# remote from the actual cause.  Canon's maintainer has chosen not to
-# normalise this at the input boundary (closed PR lutaml/canon#124);
-# this guard is the local defence.
+# 1. Leading "<?xml ?>" processing instructions in HTML input strings
+#    passed to Canon's be_html_equivalent_to / be_html4_equivalent_to /
+#    be_html5_equivalent_to matchers.
+#
+#    WHY: Nokogiri::HTML5.fragment parses a leading "<?xml ?>" as a
+#    bogus Nokogiri::XML::Comment at index 0 of the fragment.  In
+#    Canon's verbose mode (used by the matchers) comments are
+#    intentionally not filtered, so the bogus comment shifts fragment
+#    child indices and causes Canon's diff report to blame elements at
+#    the tail of the document for an offence at the head — an
+#    "uninterpretable report" remote from the actual cause.  Canon's
+#    maintainer has chosen not to normalise this at the input boundary
+#    (closed PR lutaml/canon#124); this guard is the local defence.
+#
+# 2. XML fragments (zero or many top-level nodes) and recoverable
+#    malformations (unclosed tags) passed to be_xml_equivalent_to.
+#    IsoDoc specs routinely compare such input — e.g. "<span>…</span>
+#    <semx>…</semx>" anchor labels, a Word <body> extract with the
+#    closing tag stripped, or an empty string for "nothing left after
+#    stripping Word chrome".  Canon.format / PrettyPrinter::Xml#moxml_format
+#    runs Moxml::Context#parse in strict mode, which raises
+#    Moxml::ParseError ("malformed input" at the second root, "empty
+#    input", or an unclosed tag) instead of comparing the fragments.
+#    Wrapping both sides in a synthetic root makes them
+#    single-document inputs; when the wrapped form is still not
+#    well-formed, a Nokogiri recover-mode round-trip closes the
+#    unclosed tags.  The transformation is identical on both sides, so
+#    equivalence of the original fragments is preserved.
 #
 # WHEN: required for the side effect.  Requiring this file installs a
-# Module#prepend on Canon::RSpecMatchers::SerializationMatcher's
-# matches? method that raises IsoDoc::SpecHelpers::CanonGuardError if
-# either side of an HTML-format comparison begins with an XML PI.
+# Module#prepend on Canon::RSpecMatchers::SerializationMatcher that
+# raises IsoDoc::SpecHelpers::CanonGuardError on the HTML PI condition
+# and wraps XML-fragment inputs before comparison.
 #
 # REUSE: downstream gems that build on isodoc's spec idioms (metanorma
 # family, mn2pdf, etc.) can opt in by adding a single line to their
@@ -34,10 +54,16 @@ module IsoDoc
     class CanonGuardError < StandardError; end
 
     # Prepended onto Canon::RSpecMatchers::SerializationMatcher to
-    # intercept matches? before Canon's own implementation runs.
+    # intercept matches? / compute_equivalent before Canon's own
+    # implementation runs.
     module CanonHtmlInputGuard
       ILLEGAL_HTML_PREFIX = /\A\s*<\?xml\b/i.freeze
 
+      # Synthetic root used to give multi-node / empty XML fragments a
+      # single document element. Deliberately ugly so it cannot be
+      # confused with real IsoDoc vocabulary.
+      XML_FRAG_ROOT = "canon-xml-frag-root"
+
       def matches?(target)
         if html_format? &&
             (illegal_prefix?(@expected) || illegal_prefix?(target))
@@ -47,8 +73,74 @@ module IsoDoc
         super
       end
 
+      # This prepend's frames sit between the spec and canon's matcher;
+      # canon's rebaseliner resolves its rewrite target from the first
+      # non-rspec/non-canon frame, which would land here. Drop these
+      # frames so resolution reaches the actual spec call site.
+      def attempt_rebaseline
+        if Canon::Rebaseliner.enabled? && @rebaseliner_caller
+          @rebaseliner_caller = @rebaseliner_caller.drop_while do |loc|
+            (loc.absolute_path || loc.path).to_s.end_with?(
+              "canon_html_input_guard.rb",
+            )
+          end
+        end
+        super
+      end
+
       private
 
+      # Canon's Comparison already understands DocumentFragment nodes,
+      # but NodeParser parses strings as full documents — a multi-root
+      # fragment or an empty string then blows up in the :format
+      # preprocessing pretty-printer (strict Moxml parse) before the
+      # comparator ever runs. Wrap both sides so they parse as one
+      # document; the wrapper is shared, so it cannot create false
+      # equivalences.
+      def compute_equivalent(target)
+        if xml_format?
+          @expected = wrap_xml_fragment(@expected)
+          target = wrap_xml_fragment(target)
+        end
+        super(target)
+      end
+
+      def xml_format?
+        @format == :xml
+      end
+
+      def wrap_xml_fragment(value)
+        return value unless value.is_a?(String)
+        return value if already_wrapped?(value)
+
+        wrapped = "<#{XML_FRAG_ROOT}>#{value}</#{XML_FRAG_ROOT}>"
+        strict_parse_ok?(wrapped) ? wrapped : recover_wrap(wrapped)
+      end
+
+      # Nokogiri's recover-mode parse closes unclosed tags (Word body
+      # extracts routinely omit "</body>"). Applied only when the
+      # wrapped input is not already well-formed, because the recover
+      # round-trip also rewrites entities and can add xml:lang — both
+      # harmless when the input is already broken, both destructive
+      # when it is not.
+      def recover_wrap(wrapped)
+        Nokogiri::XML(wrapped).to_xml
+      rescue StandardError
+        wrapped
+      end
+
+      def strict_parse_ok?(xml)
+        Canon::XmlParsing.moxml_context.parse(xml, readonly: true, strict: true)
+        true
+      rescue StandardError
+        false
+      end
+
+      def already_wrapped?(value)
+        value.include?("<#{XML_FRAG_ROOT}") ||
+          value.match?(/\A\s*<\?xml\b[^>]*>\s*<#{XML_FRAG_ROOT}/)
+      end
+
       def html_format?
         %i[html html4 html5].include?(@format)
       end

data/lib/isodoc/version.rb

@@ -1,3 +1,3 @@
 module IsoDoc
-  VERSION = "3.7.2".freeze
+  VERSION = "3.7.4.pre.alpha.1".freeze
 end

data/lib/isodoc/xref/xref_gen_seq.rb

@@ -105,6 +105,7 @@ module IsoDoc
       end
 
       def sequential_permission_names(clause, container: true)
+        @reqt_models or (warn "reqt_models not set, skipping permission numbering" and return)
         clause.xpath(ns(first_lvl_req)).noblank
           .each_with_object(ReqCounter.new) do |t, c|
             m = @reqt_models.model(t["model"])
@@ -117,6 +118,7 @@ module IsoDoc
       end
 
       def sequential_permission_children(elem, lbl, klass, container: false)
+        @reqt_models or (warn "reqt_models not set, skipping permission children numbering" and return)
         elem.xpath(ns(req_children)).noblank
           .each_with_object(ReqCounter.new) do |t, c|
             m = @reqt_models.model(t["model"])
@@ -229,6 +231,7 @@ container: false)
       end
 
       def hierarchical_permission_names(clauses, num)
+        @reqt_models or (warn "reqt_models not set, skipping hierarchical permission numbering" and return)
         nodeSet(clauses).each_with_object(ReqCounter.new) do |clause, c|
           clause.xpath(ns(first_lvl_req)).noblank.each do |t|
             m = @reqt_models.model(t["model"])

data/lib/relaton/render-isodoc/general.rb

@@ -5,15 +5,11 @@ module Relaton
   module Render
     module IsoDoc
       class General < ::Relaton::Render::General
-        Hash.include Metanorma::Utils::Hash
+        STYLE_PATH = File.join(__dir__, "styles/isodoc.yml")
 
-        def config_loc
-          YAML.load_file(File.join(File.dirname(__FILE__),
-                                   "config.yml"))
-        end
-
-        def read_config
-          super.deep_merge(config_loc)
+        def initialize(options = {})
+          options[:style] ||= STYLE_PATH
+          super
         end
       end
     end

data/lib/relaton/render-isodoc/styles/isodoc.yml

@@ -0,0 +1,23 @@
+# The IsoDoc presentation citation style: the author-date reference
+# composition with (a) markup delimiters instead of plain-text
+# emphasis — IsoDoc references embed into PresentationXML, where
+# emphasis is an element (<em>), not the plain-text convention — and
+# (b) no authoritative identifier in the reference composition: the
+# identifier renders as the biblio-tag ahead of the formattedref
+# ("ISO 712, _Cereals_ ..."), never duplicated inside it. Patents
+# keep theirs: the patent number is the citation itself.
+name: "IsoDoc (ISO 690, presentation markup)"
+extends: author-date
+templates:
+  titleOpen: "<em>"
+  titleClose: "</em>"
+  reference: "{{creator}}. {{title}}. {{medium}}. {{edition}}. {{series}}. {{production}}, {{date}}. {{location}}."
+perType:
+  - type: monograph
+    template: "{{creator}}. {{title}}. {{edition}}. {{series}}. {{production}}, {{date}}. {{location}}."
+  - type: report
+    template: "{{creator}}. {{title}}. {{numeration}}. {{edition}}. {{series}}. {{production}}, {{date}}. {{location}}."
+  - type: continuing
+    template: "{{creator}}. {{title}}. {{componentPart}}. {{medium}}. {{edition}}. {{production}}, {{date}}. {{numeration}}. {{location}}."
+  - type: online
+    template: "{{creator}}. {{title}}. {{date}}. {{location}}."