metanorma-iso 2.0.4 → 2.0.5

data/lib/isodoc/iso/presentation_xml_convert.rb

@@ -47,37 +47,74 @@ module IsoDoc
 
       def eref_delim(delim, type)
         if delim == ";" then ";"
-        else type == "list" ? "" : delim
+        else type == "list" ? " " : delim
         end
       end
 
-      def eref_localities1_zh(target, type, from, upto, node, delim)
-        subsection = from&.text&.match(/\./)
-        ret = eref_delim(delim, type)
-        ret += " 第#{from.text}" if from
-        ret += "–#{upto.text}" if upto
-        loc = (@i18n.locality[type] || type.sub(/^locality:/, "").capitalize)
-        ret += " #{loc}" unless (subsection && type == "clause") ||
-          type == "list" || target.match(/^IEV$|^IEC 60050-/) ||
-          node["droploc"] == "true"
+      def can_conflate_eref_rendering?(refs)
+        super or return false
+
+        first = subclause?(nil, refs.first.at(ns("./locality/@type"))&.text,
+                           refs.first.at(ns("./locality/referenceFrom"))&.text)
+        refs.all? do |r|
+          subclause?(nil, r.at(ns("./locality/@type"))&.text,
+                     r.at(ns("./locality/referenceFrom"))&.text) == first
+        end
+      end
+
+      def locality_delimiter(loc)
+        loc&.next_element&.attribute("type")&.text == "list" and return " "
+        super
+      end
+
+      def eref_localities_conflated(refs, target, node)
+        droploc = node["droploc"]
+        node["droploc"] = true
+        ret = resolve_eref_connectives(eref_locality_stacks(refs, target,
+                                                            node))
+        node["droploc"] = droploc
+        eref_localities1(target,
+                         prefix_clause(target, refs.first.at(ns("./locality"))),
+                         l10n(ret[1..-1].join), nil, node, @lang)
+      end
+
+      def prefix_clause(target, loc)
+        loc["type"] == "clause" or return loc["type"]
+
+        if subclause?(target, loc["type"], loc&.at(ns("./referenceFrom"))&.text)
+          ""
+        else
+          "clause"
+        end
+      end
+
+      def subclause?(target, type, from)
+        (from&.match?(/\./) && type == "clause") ||
+          type == "list" || target&.match(/^IEV$|^IEC 60050-/)
+      end
+
+      def eref_localities1_zh(target, type, from, upto, node)
+        ret = " 第#{from}" if from
+        ret += "–#{upto}" if upto
+        if node["droploc"] != "true" && !subclause?(target, type, from)
+          ret += eref_locality_populate(type, node)
+        end
         ret += ")" if type == "list"
         ret
       end
 
-      def eref_localities1(target, type, from, upto, delim, node, lang = "en")
-        return "" if type == "anchor"
+      def eref_localities1(target, type, from, upto, node, lang = "en")
+        return nil if type == "anchor"
 
-        subsection = from&.text&.match(/\./)
         type = type.downcase
         lang == "zh" and
-          return l10n(eref_localities1_zh(target, type, from, upto, node,
-                                          delim))
-        ret = eref_delim(delim, type)
-        ret += eref_locality_populate(type, node) unless (subsection &&
-          type == "clause") || type == "list" ||
-          target.match(/^IEV$|^IEC 60050-/)
-        ret += " #{from.text}" if from
-        ret += "–#{upto.text}" if upto
+          return l10n(eref_localities1_zh(target, type, from, upto, node))
+        ret = if node["droploc"] != "true" && !subclause?(target, type, from)
+                eref_locality_populate(type, node)
+              else ""
+              end
+        ret += " #{from}" if from
+        ret += "–#{upto}" if upto
         ret += ")" if type == "list"
         l10n(ret)
       end

data/lib/metanorma/iso/cleanup.rb

@@ -37,13 +37,11 @@ module Metanorma
       end
 
       def get_id_prefix(xmldoc)
-        prefix = []
         xmldoc.xpath("//bibdata/contributor[role/@type = 'publisher']"\
-                     "/organization").each do |x|
+                     "/organization").each_with_object([]) do |x, prefix|
           x1 = x.at("abbreviation")&.text || x.at("name")&.text
           (x1 == "ISO" and prefix.unshift("ISO")) or prefix << x1
         end
-        prefix
       end
 
       # ISO as a prefix goes first
@@ -140,8 +138,7 @@ module Metanorma
 
       def unpub_footnotes(xmldoc)
         xmldoc.xpath("//bibitem/note[@type = 'Unpublished-Status']").each do |n|
-          id = n.parent["id"]
-          e = xmldoc.at("//eref[@bibitemid = '#{id}']") or next
+          e = xmldoc.at("//eref[@bibitemid = '#{n.parent['id']}']") or next
           fn = n.children.to_xml
           n&.elements&.first&.name == "p" or fn = "<p>#{fn}</p>"
           e.next = "<fn>#{fn}</fn>"
@@ -151,21 +148,46 @@ module Metanorma
       def bibitem_cleanup(xmldoc)
         super
         unpublished_note(xmldoc)
+        withdrawn_note(xmldoc)
       end
 
       def unpublished_note(xmldoc)
-        xmldoc.xpath("//bibitem[not(note[@type = 'Unpublished-Status'])]")
-          .each do |b|
+        xmldoc.xpath("//bibitem[not(./ancestor::bibitem)]"\
+                     "[not(note[@type = 'Unpublished-Status'])]").each do |b|
           next if pub_class(b) > 2
           next unless (s = b.at("./status/stage")) && (s.text.to_i < 60)
 
           id = b.at("docidentifier").text
-          b.at("./language | ./script | ./abstract | ./status")
-            .previous = %(<note type="Unpublished-Status">
-                          <p>#{@i18n.under_preparation.sub(/%/, id)}</p></note>)
+          insert_unpub_note(b, @i18n.under_preparation.sub(/%/, id))
         end
       end
 
+      def withdrawn_note(xmldoc)
+        xmldoc.xpath("//bibitem[not(note[@type = 'Unpublished-Status'])]")
+          .each do |b|
+            next if pub_class(b) > 2
+            next unless (s = b.at("./status/stage")) && (s.text.to_i >= 90)
+
+            if id = replacement_standard(b)
+              insert_unpub_note(b, @i18n.cancelled_and_replaced.sub(/%/, id))
+            else
+              insert_unpub_note(b, @i18n.withdrawn)
+            end
+          end
+      end
+
+      def replacement_standard(biblio)
+        r = biblio.at("./relation[@type = 'updates']/bibitem") or return nil
+        id = r.at("./formattedref | ./docidentifier[@primary = 'true'] | "\
+                  "./docidentifier | ./formattedref") or return nil
+        id.text
+      end
+
+      def insert_unpub_note(biblio, msg)
+        biblio.at("./language | ./script | ./abstract | ./status")
+          .previous = %(<note type="Unpublished-Status"><p>#{msg}</p></note>)
+      end
+
       def termdef_boilerplate_insert(xmldoc, isodoc, once = false)
         once = true
         super
@@ -175,6 +197,11 @@ module Metanorma
         @vocab and src.empty? and return
         super
       end
+
+      def section_names_terms_cleanup(xml)
+        @vocab and return
+        super
+      end
     end
   end
 end

data/lib/metanorma/iso/processor.rb

@@ -45,19 +45,26 @@ module Metanorma
       def output(isodoc_node, inname, outname, format, options={})
         case format
         when :html
-          IsoDoc::Iso::HtmlConvert.new(options).convert(inname, isodoc_node, nil, outname)
+          IsoDoc::Iso::HtmlConvert.new(options)
+            .convert(inname, isodoc_node, nil, outname)
         when :html_alt
-          IsoDoc::Iso::HtmlConvert.new(options.merge(alt: true)).convert(inname, isodoc_node, nil, outname)
+          IsoDoc::Iso::HtmlConvert.new(options.merge(alt: true))
+            .convert(inname, isodoc_node, nil, outname)
         when :doc
-          IsoDoc::Iso::WordConvert.new(options).convert(inname, isodoc_node, nil, outname)
+          IsoDoc::Iso::WordConvert.new(options)
+            .convert(inname, isodoc_node, nil, outname)
         when :pdf
-          IsoDoc::Iso::PdfConvert.new(options).convert(inname, isodoc_node, nil, outname)
+          IsoDoc::Iso::PdfConvert.new(options)
+            .convert(inname, isodoc_node, nil, outname)
         when :sts
-          IsoDoc::Iso::StsConvert.new(options).convert(inname, isodoc_node, nil, outname)
+          IsoDoc::Iso::StsConvert.new(options)
+            .convert(inname, isodoc_node, nil, outname)
         when :isosts
-          IsoDoc::Iso::IsoStsConvert.new(options).convert(inname, isodoc_node, nil, outname)
+          IsoDoc::Iso::IsoStsConvert.new(options)
+            .convert(inname, isodoc_node, nil, outname)
         when :presentation
-          IsoDoc::Iso::PresentationXMLConvert.new(options).convert(inname, isodoc_node, nil, outname)
+          IsoDoc::Iso::PresentationXMLConvert.new(options)
+            .convert(inname, isodoc_node, nil, outname)
         else
           super
         end

data/lib/metanorma/iso/validate.rb

@@ -4,6 +4,7 @@ require_relative "./validate_requirements"
 require_relative "./validate_section"
 require_relative "./validate_title"
 require_relative "./validate_image"
+require_relative "./validate_list"
 require "nokogiri"
 require "jing"
 require "iev"
@@ -35,7 +36,7 @@ module Metanorma
             /\b(see| refer to)\s*\Z/mi.match(preceding)
 
           (target = root.at("//*[@id = '#{t['target']}']")) || next
-          if target&.at("./ancestor-or-self::*[@obligation = 'normative']")
+          if target.at("./ancestor-or-self::*[@obligation = 'normative']")
             @log.add("Style", t,
                      "'see #{t['target']}' is pointing to a normative section")
           end
@@ -75,6 +76,30 @@ module Metanorma
         regex.match(text) && @log.add("Style", elem, "#{term}: #{msg}")
       end
 
+      # https://www.iso.org/ISO-house-style.html#iso-hs-s-text-r-r-ref_clause3
+      def term_xrefs_validate(xmldoc)
+        termids = xmldoc
+          .xpath("//sections/terms | //sections/clause[.//terms] | "\
+                 "//annex[.//terms]").each_with_object({}) do |t, m|
+          t.xpath(".//*/@id").each { |a| m[a.text] = true }
+          t.name == "terms" and m[t["id"]] = true
+        end
+        xmldoc.xpath(".//xref").each do |x|
+          term_xrefs_validate1(x, termids)
+        end
+      end
+
+      def term_xrefs_validate1(xref, termids)
+        (termids[xref["target"]] && !termids[xref.parent["id"]]) and
+          @log.add("Style", xref,
+                   "only terms clauses can cross-reference terms clause "\
+                   "(#{xref['target']})")
+        (!termids[xref["target"]] && termids[xref.parent["id"]]) and
+          @log.add("Style", xref,
+                   "non-terms clauses cannot cross-reference terms clause "\
+                   "(#{xref['target']})")
+      end
+
       # ISO/IEC DIR 2, 16.5.6
       def termdef_style(xmldoc)
         xmldoc.xpath("//term").each do |t|
@@ -139,11 +164,14 @@ module Metanorma
         onlychild_clause_validate(doc.root)
         termdef_style(doc.root)
         see_xrefs_validate(doc.root)
+        term_xrefs_validate(doc.root)
         see_erefs_validate(doc.root)
         locality_erefs_validate(doc.root)
         bibdata_validate(doc.root)
         bibitem_validate(doc.root)
         figure_validate(doc.root)
+        listcount_validate(doc)
+        list_punctuation(doc)
       end
 
       def bibitem_validate(xmldoc)

data/lib/metanorma/iso/validate_image.rb

@@ -78,9 +78,9 @@ module Metanorma
         xmldoc.xpath("//image").each do |i|
           next if i["src"].start_with?("data:")
 
-          if /^ISO_\d+_/.match?(File.basename(i["src"]))
-          elsif /^(SL)?#{prefix}fig/.match?(File.basename(i["src"]))
-            image_name_validate1(i, prefix)
+          case File.basename(i["src"])
+          when /^ISO_\d+_/
+          when /^(SL)?#{prefix}fig/ then image_name_validate1(i, prefix)
           else
             @log.add("Style", i,
                      "image name #{i['src']} does not match DRG requirements: expect #{prefix}fig")

data/lib/metanorma/iso/validate_list.rb

@@ -0,0 +1,107 @@
+module Metanorma
+  module ISO
+    class Converter < Standoc::Converter
+      # https://www.iso.org/ISO-house-style.html#iso-hs-s-text-r-p-lists
+      def listcount_validate(doc)
+        return if @novalid
+
+        ol_count_validate(doc)
+        li_depth_validate(doc)
+      end
+
+      def ol_count_validate(doc)
+        doc.xpath("//clause | //annex").each do |c|
+          next if c.xpath(".//ol").empty?
+
+          ols = c.xpath(".//ol") -
+            c.xpath(".//ul//ol | .//ol//ol | .//clause//ol")
+          ols.size > 1 and
+            style_warning(c, "More than 1 ordered list in a numbered clause",
+                          nil)
+        end
+      end
+
+      def li_depth_validate(doc)
+        doc.xpath("//li//li//li//li").each do |l|
+          l.at(".//li") and
+            style_warning(l, "List more than four levels deep", nil)
+        end
+      end
+
+      # https://www.iso.org/ISO-house-style.html#iso-hs-s-text-r-p-lists
+      def list_punctuation(doc)
+        return if @novalid
+
+        ((doc.xpath("//ol") - doc.xpath("//ul//ol | //ol//ol")) +
+         (doc.xpath("//ul") - doc.xpath("//ul//ul | //ol//ul"))).each do |list|
+          next if skip_list_punctuation(list)
+
+          prec = list.at("./preceding::text()[normalize-space(.) != ''][1]")
+          list_punctuation1(list, prec&.text)
+        end
+      end
+
+      def skip_list_punctuation(list)
+        return true if list.at("./ancestor::table")
+
+        list.xpath(".//li").each do |entry|
+          l = entry.dup
+          l.xpath(".//ol | .//ul").each(&:remove)
+          l.text.split.size > 2 and return false
+        end
+        true
+      end
+
+      def list_punctuation1(list, prectext)
+        prectext ||= ""
+        entries = list.xpath(".//li")
+        case prectext.strip.chars.last
+        when ":", "" then list_after_colon_punctuation(list, entries)
+        when "." then entries.each { |li| list_full_sentence(li) }
+        else style_warning(list, "All lists must be preceded by "\
+                                 "colon or full stop", prectext)
+        end
+      end
+
+      # if first list entry starts lowercase, treat as sentence broken up
+      def list_after_colon_punctuation(list, entries)
+        lower = list.at(".//li").text.match?(/^[^A-Za-z]*[a-z]/)
+        entries.each_with_index do |li, i|
+          if lower
+            list_semicolon_phrase(li, i == entries.size - 1)
+          else
+            list_full_sentence(li)
+          end
+        end
+      end
+
+      def list_semicolon_phrase(elem, last)
+        text = elem.text.strip
+        text.match?(/^[^A-Za-z]*[a-z]/) or
+          style_warning(elem, "List entry of broken up sentence must start "\
+                              "with lowercase letter", text)
+        punct = text.sub(/^.*?(\S)\s*$/, "\\1")
+        if last
+          punct == "." or
+            style_warning(elem, "Final list entry of broken up "\
+                                "sentence must end with full stop", text)
+        else
+          punct == ";" or
+            style_warning(elem, "List entry of broken up sentence must "\
+                                "end with semicolon", text)
+        end
+      end
+
+      def list_full_sentence(elem)
+        text = elem.text.strip
+        text.match?(/^[^A-Za-z]*[A-Z]/) or
+          style_warning(elem, "List entry of separate sentences must start "\
+                              "with uppercase letter", text)
+        punct = text.sub(/^.*?(\S)\s*$/, "\\1")
+        punct == "." or
+          style_warning(elem, "List entry of separate sentences must "\
+                              "end with full stop", text)
+      end
+    end
+  end
+end

data/lib/metanorma/iso/validate_section.rb

@@ -14,6 +14,7 @@ module Metanorma
         end
         section_style(doc.root)
         subclause_validate(doc.root)
+        @vocab and vocab_terms_titles_validate(doc.root)
         super
       end
 
@@ -33,7 +34,6 @@ module Metanorma
 
       ONE_SYMBOLS_WARNING = "Only one Symbols and Abbreviated "\
                             "Terms section in the standard".freeze
-
       NON_DL_SYMBOLS_WARNING = "Symbols and Abbreviated Terms can "\
                                "only contain a definition list".freeze
 
@@ -42,11 +42,12 @@ module Metanorma
         f.empty? && return
         (f.size == 1 || @vocab) or
           @log.add("Style", f.first, ONE_SYMBOLS_WARNING)
-        f.first.elements.each do |e|
-          unless %w(title dl).include? e.name
-            @log.add("Style", f.first, NON_DL_SYMBOLS_WARNING)
-            return
-          end
+        f.first.elements.reject { |e| %w(title dl).include? e.name }.empty? or
+          @log.add("Style", f.first, NON_DL_SYMBOLS_WARNING)
+        @vocab and f.each do |f1|
+          f1.at("./ancestor::annex") or
+            @log.add("Style", f1, "In vocabulary documents, Symbols and "\
+                                  "Abbreviated Terms are only permitted in annexes")
         end
       end
 
@@ -72,26 +73,17 @@ module Metanorma
 
       # spec of permissible section sequence
       # we skip normative references, it goes to end of list
-      SEQ =
-        [
-          {
-            msg: "Initial section must be (content) Foreword",
-            val: ["./self::foreword"],
-          },
-          {
-            msg: "Prefatory material must be followed by (clause) Scope",
-            val: ["./self::introduction", "./self::clause[@type = 'scope']"],
-          },
-          {
-            msg: "Prefatory material must be followed by (clause) Scope",
-            val: ["./self::clause[@type = 'scope']"],
-          },
-          {
-            msg: "Normative References must be followed by "\
-                 "Terms and Definitions",
-            val: ["./self::terms | .//terms"],
-          },
-        ].freeze
+      SEQ = [
+        { msg: "Initial section must be (content) Foreword",
+          val: ["./self::foreword"] },
+        { msg: "Prefatory material must be followed by (clause) Scope",
+          val: ["./self::introduction", "./self::clause[@type = 'scope']"] },
+        { msg: "Prefatory material must be followed by (clause) Scope",
+          val: ["./self::clause[@type = 'scope']"] },
+        { msg: "Normative References must be followed by "\
+               "Terms and Definitions",
+          val: ["./self::terms | .//terms"] },
+      ].freeze
 
       SECTIONS_XPATH =
         "//foreword | //introduction | //sections/terms | .//annex | "\
@@ -198,11 +190,6 @@ module Metanorma
         end
       end
 
-      ASSETS_TO_STYLE =
-        "//termsource | //formula | //termnote | "\
-        "//p[not(ancestor::boilerplate)] | //li[not(p)] | //dt | "\
-        "//dd[not(p)] | //td[not(p)] | //th[not(p)]".freeze
-
       NORM_BIBITEMS =
         "//references[@normative = 'true']/bibitem".freeze
 
@@ -217,7 +204,9 @@ module Metanorma
 
       def asset_style(root)
         root.xpath("//example | //termexample").each { |e| example_style(e) }
-        root.xpath("//definition/verbal-definition").each { |e| definition_style(e) }
+        root.xpath("//definition/verbal-definition").each do |e|
+          definition_style(e)
+        end
         root.xpath("//note").each { |e| note_style(e) }
         root.xpath("//fn").each { |e| footnote_style(e) }
         root.xpath(ASSETS_TO_STYLE).each { |e| style(e, extract_text(e)) }
@@ -243,6 +232,24 @@ module Metanorma
           @log.add("Style", nil, "#{location}: subclause is only child")
         end
       end
+
+      # https://www.iso.org/ISO-house-style.html#iso-hs-s-formatting-r-vocabulary
+      def vocab_terms_titles_validate(root)
+        terms = root.xpath("//sections/terms | //sections/clause[.//terms]")
+        if terms.size == 1
+          ((t = terms.first.at("./title")) && (t&.text == @i18n.termsdef)) or
+            @log.add("Style", terms.first,
+                     "Single terms clause in vocabulary document "\
+                     "should have normal Terms and definitions heading")
+        elsif terms.size > 1
+          terms.each do |x|
+            ((t = x.at("./title")) && /^#{@i18n.termsrelated}/.match?(t&.text)) or
+              @log.add("Style", x,
+                       "Multiple terms clauses in vocabulary document "\
+                       "should have 'Terms related to' heading")
+          end
+        end
+      end
     end
   end
 end

data/lib/metanorma/iso/validate_style.rb

@@ -70,8 +70,8 @@ module Metanorma
         style(node, extract_text(node))
       end
 
-      def style_regex(regex, warning, n, text)
-        (m = regex.match(text)) && style_warning(n, warning, m[:num])
+      def style_regex(regex, warning, node, text)
+        (m = regex.match(text)) && style_warning(node, warning, m[:num])
       end
 
       # style check with a regex on a token
@@ -96,10 +96,12 @@ module Metanorma
         style_percent(node, text)
         style_abbrev(node, text)
         style_units(node, text)
+        style_punct(node, text)
       end
 
       # ISO/IEC DIR 2, 9.1
       # ISO/IEC DIR 2, Table B.1
+      # https://www.iso.org/ISO-house-style.html#iso-hs-s-text-r-n-numbers
       def style_number(node, text)
         style_two_regex_not_prev(
           node, text, /^(?<num>-?[0-9]{4,}[,0-9]*)\Z/,
@@ -110,6 +112,8 @@ module Metanorma
                     "possible decimal point", node, text)
         style_regex(/\b(?<num>billions?)\b/i,
                     "ambiguous number", node, text)
+        style_regex(/(^|\s)(?<num>-[0-9][0-9,.]*)/i,
+                    "hyphen instead of minus sign U+2212", node, text)
       end
 
       # ISO/IEC DIR 2, 9.2.1
@@ -158,6 +162,15 @@ module Metanorma
         end
       end
 
+      # https://www.iso.org/ISO-house-style.html#iso-hs-s-text-r-p-and
+      # https://www.iso.org/ISO-house-style.html#iso-hs-s-text-r-p-andor
+      def style_punct(node, text)
+        style_regex(/\b(?<num>and\/?or)\b/i,
+                    "Use 'either x or y, or both'", node, text)
+        style_regex(/\s(?<num>&)\s/i,
+                    "Avoid ampersand in ordinary text'", node, text)
+      end
+
       def style_warning(node, msg, text = nil)
         return if @novalid
 
@@ -165,6 +178,23 @@ module Metanorma
         w += ": #{text}" if text
         @log.add("Style", node, w)
       end
+
+      ASSETS_TO_STYLE =
+        "//termsource | //formula | //termnote | "\
+        "//p[not(ancestor::boilerplate)] | //li[not(p)] | //dt | "\
+        "//dd[not(p)] | //td[not(p)] | //th[not(p)]".freeze
+
+      def asset_style(root)
+        root.xpath("//example | //termexample").each { |e| example_style(e) }
+        root.xpath("//definition/verbal-definition").each do |e|
+          definition_style(e)
+        end
+        root.xpath("//note").each { |e| note_style(e) }
+        root.xpath("//fn").each { |e| footnote_style(e) }
+        root.xpath(ASSETS_TO_STYLE).each { |e| style(e, extract_text(e)) }
+        norm_bibitem_style(root)
+        super
+      end
     end
   end
 end

data/lib/metanorma/iso/validate_title.rb

@@ -68,7 +68,7 @@ module Metanorma
           title = s&.at("./title")&.text || s.name
           s.xpath("./clause | ./terms | ./references").each do |ss|
             subtitle = ss.at("./title")
-            !subtitle.nil? && !subtitle&.text&.empty? or
+            (!subtitle.nil? && !subtitle&.text&.empty?) or
               @log.add("Style", ss,
                        "#{title}: each first-level subclause must have a title")
           end
@@ -91,6 +91,17 @@ module Metanorma
                    "#{label}: all subclauses must have a title, or none")
       end
 
+      # https://www.iso.org/ISO-house-style.html#iso-hs-s-text-r-p-full
+      def title_no_full_stop_validate(root)
+        root.xpath("//preface//title | //sections//title | //annex//title | "\
+                   "//references/title | //preface//name | //sections//name | "\
+                   "//annex//name").each do |t|
+          style_regex(/\A(?<num>.+\.\Z)/i,
+                      "No full stop at end of title or caption",
+                      t, t.text.strip)
+        end
+      end
+
       def title_validate(root)
         title_intro_validate(root)
         title_main_validate(root)
@@ -99,6 +110,7 @@ module Metanorma
         title_names_type_validate(root)
         title_first_level_validate(root)
         title_all_siblings(root.xpath(SECTIONS_XPATH), "(top level)")
+        title_no_full_stop_validate(root)
       end
     end
   end

data/lib/metanorma/iso/version.rb

@@ -1,5 +1,5 @@
 module Metanorma
   module ISO
-    VERSION = "2.0.4".freeze
+    VERSION = "2.0.5".freeze
   end
 end