metanorma-iso 1.8.0 → 1.8.5

data/lib/asciidoctor/iso/validate_image.rb

@@ -0,0 +1,97 @@
+module Asciidoctor
+  module ISO
+    class Converter < Standoc::Converter
+      # DRG directives 3.7; but anticipated by standoc
+      def subfigure_validate(xmldoc)
+        xmldoc.xpath("//figure//figure").each do |f|
+          { footnote: "fn", note: "note", key: "dl" }.each do |k, v|
+            f.xpath(".//#{v}").each do |n|
+              @log.add("Style", n, "#{k} is not permitted in a subfigure")
+            end
+          end
+        end
+      end
+
+      def image_name_prefix(xmldoc)
+        std = xmldoc&.at("//bibdata/ext/structuredidentifier/project-number") or
+          return
+        num = xmldoc&.at("//bibdata/docnumber")&.text or return
+        ed = xmldoc&.at("//bibdata/edition")&.text || "1"
+        prefix = num
+        std["part"] and prefix += "-#{std['part']}"
+        prefix += "_ed#{ed}"
+        amd = std["amendment"] and prefix += "amd#{amd}"
+        prefix
+      end
+
+      def image_name_suffix(xmldoc)
+        case xmldoc&.at("//bibdata/language")&.text
+        when "fr" then "_f"
+        when "de" then "_d"
+        when "ru" then "_r"
+        when "es" then "_s"
+        when "ar" then "_a"
+        when "en" then "_e"
+        else
+          "_e"
+        end
+      end
+
+      def disjunct_error(img, cond1, cond2, msg1, msg2)
+        cond1 && !cond2 and
+          @log.add("Style", img, "image name #{img['src']} #{msg1}")
+        !cond1 && cond2 and
+          @log.add("Style", img, "image name #{img['src']} #{msg2}")
+      end
+
+      def image_name_parse(img, prefix)
+        m = %r[(SL)?#{prefix}fig(?<tab>Tab)?(?<annex>[A-Z])?(Text)?(?<num>\d+)
+            (?<subfig>[a-z])?(?<key>_key\d+)?(?<lang>_[a-z])?$]x
+          .match(File.basename(img["src"], ".*"))
+        m.nil? and
+          @log.add("Style", img,
+                   "image name #{img['src']} does not match DRG requirements")
+        m
+      end
+
+      def image_name_validate1(i, prefix)
+        m = image_name_parse(i, prefix) or return
+        warn i["src"]
+        disjunct_error(i, i.at("./ancestor::table"), !m[:tab].nil?,
+                       "is under a table but is not so labelled",
+                       "is labelled as under a table but is not")
+        disjunct_error(i, i.at("./ancestor::annex"), !m[:annex].nil?,
+                       "is under an annex but is not so labelled",
+                       "is labelled as under an annex but is not")
+        disjunct_error(i, i.xpath("./ancestor::figure").size > 1, !m[:subfig].nil?,
+                       "does not have a subfigure letter but is a subfigure",
+                       "has a subfigure letter but is not a subfigure")
+        lang = image_name_suffix(i.document.root)
+        (m[:lang] || "_e") == lang or
+          @log.add("Style", i,
+                   "image name #{i['src']} expected to have suffix #{lang}")
+      end
+
+      # DRG directives 3.2
+      def image_name_validate(xmldoc)
+        prefix = image_name_prefix(xmldoc) or return
+        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)
+          else
+            @log.add("Style", i,
+                     "image name #{i['src']} does not match DRG requirements: expect #{prefix}fig")
+          end
+        end
+      end
+
+      def figure_validate(xmldoc)
+        image_name_validate(xmldoc)
+        subfigure_validate(xmldoc)
+      end
+    end
+  end
+end

data/lib/asciidoctor/iso/validate_requirements.rb

@@ -1,6 +1,4 @@
 require "metanorma-standoc"
-require "nokogiri"
-require "pp"
 
 module Asciidoctor
   module ISO
@@ -19,13 +17,15 @@ module Asciidoctor
            [.,:;]_do_not )
         \\b
       REGEXP
-      REQUIREMENT_RE =
-        Regexp.new(REQUIREMENT_RE_STR.gsub(/\s/, "").gsub(/_/, "\\s"),
-                   Regexp::IGNORECASE)
+
+      def requirement_re
+        Regexp.new(self.class::REQUIREMENT_RE_STR.gsub(/\s/, "")
+          .gsub(/_/, "\\s"), Regexp::IGNORECASE)
+      end
 
       def requirement_check(text)
         text.split(/\.\s+/).each do |t|
-          return t if REQUIREMENT_RE.match t
+          return t if requirement_re.match t
         end
         nil
       end
@@ -37,13 +37,15 @@ module Asciidoctor
             it_is_(not_)?recommended_that
         \\b
       REGEXP
-      RECOMMENDATION_RE =
-        Regexp.new(RECOMMENDATION_RE_STR.gsub(/\s/, "").gsub(/_/, "\\s"),
-                   Regexp::IGNORECASE)
+
+      def recommendation_re
+        Regexp.new(self.class::RECOMMENDATION_RE_STR.gsub(/\s/, "")
+          .gsub(/_/, "\\s"), Regexp::IGNORECASE)
+      end
 
       def recommendation_check(text)
         text.split(/\.\s+/).each do |t|
-          return t if RECOMMENDATION_RE.match t
+          return t if recommendation_re.match t
         end
         nil
       end
@@ -56,13 +58,15 @@ module Asciidoctor
             no\\b[^.,]+\\b(is|are)_required
         \\b
       REGEXP
-      PERMISSION_RE =
-        Regexp.new(PERMISSION_RE_STR.gsub(/\s/, "").gsub(/_/, "\\s"),
-                   Regexp::IGNORECASE)
+
+      def permission_re
+        Regexp.new(self.class::PERMISSION_RE_STR.gsub(/\s/, "")
+          .gsub(/_/, "\\s"), Regexp::IGNORECASE)
+      end
 
       def permission_check(text)
         text.split(/\.\s+/).each do |t|
-          return t if PERMISSION_RE.match t
+          return t if permission_re.match t
         end
         nil
       end
@@ -76,18 +80,20 @@ module Asciidoctor
            it_is_not_possible_to
         \\b
       REGEXP
-      POSSIBILITY_RE =
-        Regexp.new(POSSIBILITY_RE_STR.gsub(/\s/, "").gsub(/_/, "\\s"),
-                   Regexp::IGNORECASE)
 
-      def possibility(text)
-        text.split(/\.\s+/).each { |t| return t if POSSIBILITY_RE.match t }
+      def possibility_re
+        Regexp.new(self.class::POSSIBILITY_RE_STR.gsub(/\s/, "")
+          .gsub(/_/, "\\s"), Regexp::IGNORECASE)
+      end
+
+      def possibility_check(text)
+        text.split(/\.\s+/).each { |t| return t if possibility_re.match t }
         nil
       end
 
       def external_constraint(text)
         text.split(/\.\s+/).each do |t|
-          return t if /\b(must)\b/xi.match t
+          return t if /\b(must)\b/xi.match? t
         end
         nil
       end

data/lib/asciidoctor/iso/validate_section.rb

@@ -50,10 +50,11 @@ module Asciidoctor
       end
 
       def seqcheck(names, msg, accepted)
-        n = names.shift 
+        n = names.shift
         return [] if n.nil?
+
         test = accepted.map { |a| n.at(a) }
-        if test.all? { |a| a.nil? }
+        if test.all?(&:nil?)
           @log.add("Style", nil, msg)
         end
         names
@@ -74,57 +75,65 @@ module Asciidoctor
         [
           {
             msg: "Initial section must be (content) Foreword",
-            val:  ["./self::foreword"]
+            val: ["./self::foreword"],
           },
           {
             msg: "Prefatory material must be followed by (clause) Scope",
-            val: ["./self::introduction", "./self::clause[@type = 'scope']" ]
+            val: ["./self::introduction", "./self::clause[@type = 'scope']"],
           },
           {
             msg: "Prefatory material must be followed by (clause) Scope",
-            val: ["./self::clause[@type = 'scope']" ]
+            val: ["./self::clause[@type = 'scope']"],
           },
           {
             msg: "Normative References must be followed by "\
             "Terms and Definitions",
-            val: ["./self::terms | .//terms"]
+            val: ["./self::terms | .//terms"],
           },
-      ].freeze
+        ].freeze
 
       SECTIONS_XPATH =
         "//foreword | //introduction | //sections/terms | .//annex | "\
-        "//sections/definitions | //sections/clause | //references[not(parent::clause)] | "\
+        "//sections/definitions | //sections/clause | "\
+        "//references[not(parent::clause)] | "\
         "//clause[descendant::references][not(parent::clause)]".freeze
 
       def sections_sequence_validate(root)
+        vocab = root&.at("//bibdata/ext/subdoctype")&.text == "vocabulary"
         names = root.xpath(SECTIONS_XPATH)
-        names = seqcheck(names, SEQ[0][:msg], SEQ[0][:val]) 
+        names = seqcheck(names, SEQ[0][:msg], SEQ[0][:val])
         n = names[0]
-        names = seqcheck(names, SEQ[1][:msg], SEQ[1][:val]) 
+        names = seqcheck(names, SEQ[1][:msg], SEQ[1][:val])
         if n&.at("./self::introduction")
-          names = seqcheck(names, SEQ[2][:msg], SEQ[2][:val]) 
+          names = seqcheck(names, SEQ[2][:msg], SEQ[2][:val])
         end
-        names = seqcheck(names, SEQ[3][:msg], SEQ[3][:val]) 
+        names = seqcheck(names, SEQ[3][:msg], SEQ[3][:val])
         n = names.shift
         if n&.at("./self::definitions")
           n = names.shift
         end
         if n.nil? || n.name != "clause"
-          @log.add("Style", nil, "Document must contain at least one clause")
+          @log.add("Style", n, "Document must contain at least one clause")
         end
         n&.at("./self::clause") ||
-          @log.add("Style", nil, "Document must contain clause after "\
+          @log.add("Style", n, "Document must contain clause after "\
                    "Terms and Definitions")
         n&.at("./self::clause[@type = 'scope']") &&
-          @log.add("Style", nil, "Scope must occur before Terms and Definitions")
-        n = names.shift 
-        while n&.name == "clause"
+          @log.add("Style", n, "Scope must occur before Terms and Definitions")
+        n = names.shift
+        while n&.name == "clause" || (vocab && n&.name == "terms")
           n&.at("./self::clause[@type = 'scope']")
-          @log.add("Style", nil, "Scope must occur before Terms and Definitions")
-          n = names.shift 
+          @log.add("Style", n, "Scope must occur before Terms and Definitions")
+          n = names.shift
         end
-        unless %w(annex references).include? n&.name
-          @log.add("Style", nil, "Only annexes and references can follow clauses")
+        if vocab
+          unless %w(annex references terms).include? n&.name
+            @log.add("Style", n, "Only terms, annexes and references can follow clauses")
+          end
+        else
+          unless %w(annex references).include? n&.name
+            @log.add("Style", n, "Only annexes and references can follow clauses")
+          end
         end
         while n&.name == "annex"
           n = names.shift
@@ -138,13 +147,14 @@ module Asciidoctor
                    "Normative References")
         n = names&.shift
         n&.at("./self::references[@normative = 'false']") ||
-          @log.add("Style", nil, "Final section must be (references) Bibliography")
+          @log.add("Style", n, "Final section must be (references) Bibliography")
         names.empty? ||
-          @log.add("Style", nil, "There are sections after the final Bibliography")
+          @log.add("Style", n, "There are sections after the final Bibliography")
       end
 
       def style_warning(node, msg, text = nil)
         return if @novalid
+
         w = msg
         w += ": #{text}" if text
         @log.add("Style", node, w)
@@ -165,15 +175,18 @@ module Asciidoctor
 
       def tech_report_style(root)
         root.at("//bibdata/ext/doctype")&.text == "technical-report" or return
-        root.xpath("//sections/clause[not(@type = 'scope')] | //annex").each do |s|
-          r = requirement_check(extract_text(s))
-          style_warning(s, "Technical Report clause may contain requirement", r) if r
+        root.xpath("//sections/clause[not(@type = 'scope')] | //annex")
+          .each do |s|
+          r = requirement_check(extract_text(s)) and
+            style_warning(s,
+                          "Technical Report clause may contain requirement", r)
         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
+        "//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
@@ -198,10 +211,23 @@ module Asciidoctor
       end
 
       def subclause_validate(root)
-        root.xpath("//clause/clause/clause/clause/clause/clause/clause/clause").each do |c|
+        root.xpath("//clause/clause/clause/clause/clause/clause/clause/clause")
+          .each do |c|
           style_warning(c, "Exceeds the maximum clause depth of 7", nil)
         end
       end
+
+      # ISO/IEC DIR 2, 22.3.2
+      def onlychild_clause_validate(root)
+        root.xpath(Standoc::Utils::SUBCLAUSE_XPATH).each do |c|
+          next unless c.xpath("../clause").size == 1
+
+          title = c.at("./title")
+          location = c["id"] || "#{c.text[0..60]}..."
+          location += ":#{title.text}" if c["id"] && !title.nil?
+          @log.add("Style", nil, "#{location}: subclause is only child")
+        end
+      end
     end
   end
 end

data/lib/asciidoctor/iso/validate_style.rb

@@ -7,28 +7,32 @@ module Asciidoctor
     class Converter < Standoc::Converter
       def extract_text(node)
         return "" if node.nil?
+
         node1 = Nokogiri::XML.fragment(node.to_s)
         node1.xpath("//link | //locality | //localityStack").each(&:remove)
         ret = ""
         node1.traverse { |x| ret += x.text if x.text? }
-        ret
+        HTMLEntities.new.decode(ret)
       end
 
       # ISO/IEC DIR 2, 12.2
       def foreword_style(node)
         return if @novalid
+
         style_no_guidance(node, extract_text(node), "Foreword")
       end
 
       # ISO/IEC DIR 2, 14.2
       def scope_style(node)
         return if @novalid
+
         style_no_guidance(node, extract_text(node), "Scope")
       end
 
       # ISO/IEC DIR 2, 13.2
       def introduction_style(node)
         return if @novalid
+
         r = requirement_check(extract_text(node))
         style_warning(node, "Introduction may contain requirement", r) if r
       end
@@ -36,6 +40,7 @@ module Asciidoctor
       # ISO/IEC DIR 2, 16.5.6
       def definition_style(node)
         return if @novalid
+
         r = requirement_check(extract_text(node))
         style_warning(node, "Definition may contain requirement", r) if r
       end
@@ -44,6 +49,7 @@ module Asciidoctor
       # ISO/IEC DIR 2, 25.5
       def example_style(node)
         return if @novalid
+
         style_no_guidance(node, extract_text(node), "Example")
         style(node, extract_text(node))
       end
@@ -51,6 +57,7 @@ module Asciidoctor
       # ISO/IEC DIR 2, 24.5
       def note_style(node)
         return if @novalid
+
         style_no_guidance(node, extract_text(node), "Note")
         style(node, extract_text(node))
       end
@@ -58,6 +65,7 @@ module Asciidoctor
       # ISO/IEC DIR 2, 26.5
       def footnote_style(node)
         return if @novalid
+
         style_no_guidance(node, extract_text(node), "Footnote")
         style(node, extract_text(node))
       end
@@ -70,6 +78,7 @@ module Asciidoctor
       # and a negative match on its preceding token
       def style_two_regex_not_prev(n, text, re, re_prev, warning)
         return if text.nil?
+
         arr = Tokenizer::WhitespaceTokenizer.new.tokenize(text)
         arr.each_index do |i|
           m = re.match arr[i]
@@ -80,43 +89,45 @@ module Asciidoctor
         end
       end
 
-      def style(n, t)
+      def style(node, text)
         return if @novalid
-        style_number(n, t)
-        style_percent(n, t)
-        style_abbrev(n, t)
-        style_units(n, t)
+
+        style_number(node, text)
+        style_percent(node, text)
+        style_abbrev(node, text)
+        style_units(node, text)
       end
 
       # ISO/IEC DIR 2, 9.1
       # ISO/IEC DIR 2, Table B.1
-      def style_number(n, t)
+      def style_number(node, text)
         style_two_regex_not_prev(
-          n, t, /^(?<num>-?[0-9]{4,}[,0-9]*)$/,
+          node, text, /^(?<num>-?[0-9]{4,}[,0-9]*)$/,
           %r{\b(ISO|IEC|IEEE/|(in|January|February|March|April|May|June|August|September|October|November|December)\b)$},
-          "number not broken up in threes")
+          "number not broken up in threes"
+        )
         style_regex(/\b(?<num>[0-9]+\.[0-9]+)/i,
-                    "possible decimal point", n, t)
-        style_regex(/\b(?<num>billion[s]?)\b/i,
-                    "ambiguous number", n, t)
+                    "possible decimal point", node, text)
+        style_regex(/\b(?<num>billions?)\b/i,
+                    "ambiguous number", node, text)
       end
 
       # ISO/IEC DIR 2, 9.2.1
-      def style_percent(n, t)
+      def style_percent(node, text)
         style_regex(/\b(?<num>[0-9.,]+%)/,
-                    "no space before percent sign", n, t)
+                    "no space before percent sign", node, text)
         style_regex(/\b(?<num>[0-9.,]+ \u00b1 [0-9,.]+ %)/,
-                    "unbracketed tolerance before percent sign", n, t)
+                    "unbracketed tolerance before percent sign", node, text)
       end
 
       # ISO/IEC DIR 2, 8.4
       # ISO/IEC DIR 2, 9.3
-      def style_abbrev(n, t)
+      def style_abbrev(node, text)
         style_regex(/(^|\s)(?!e\.g\.|i\.e\.)
                     (?<num>[a-z]{1,2}\.([a-z]{1,2}|\.))\b/ix,
-                      "no dots in abbreviations", n, t)
+                    "no dots in abbreviations", node, text)
         style_regex(/\b(?<num>ppm)\b/i,
-                    "language-specific abbreviation", n, t)
+                    "language-specific abbreviation", node, text)
       end
 
       # leaving out as problematic: N J K C S T H h d B o E
@@ -125,12 +136,13 @@ module Asciidoctor
         "bit|kB|MB|Hart|nat|Sh|var)".freeze
 
       # ISO/IEC DIR 2, 9.3
-      def style_units(n, t)
+      def style_units(node, text)
         style_regex(/\b(?<num>[0-9][0-9,]*\s+[\u00b0\u2032\u2033])/,
-                    "space between number and degrees/minutes/seconds", n, t)
+                    "space between number and degrees/minutes/seconds",
+                    node, text)
         style_regex(/\b(?<num>[0-9][0-9,]*#{SI_UNIT})\b/,
-                    "no space between number and SI unit", n, t)
-        style_non_std_units(n, t)
+                    "no space between number and SI unit", node, text)
+        style_non_std_units(node, text)
       end
 
       NONSTD_UNITS = {
@@ -139,10 +151,10 @@ module Asciidoctor
       }.freeze
 
       # ISO/IEC DIR 2, 9.3
-      def style_non_std_units(n, t)
+      def style_non_std_units(node, text)
         NONSTD_UNITS.each do |k, v|
           style_regex(/\b(?<num>[0-9][0-9,]*\s+#{k})\b/,
-                      "non-standard unit (should be #{v})", n, t)
+                      "non-standard unit (should be #{v})", node, text)
         end
       end
     end