metanorma-ieee 0.0.1

data/lib/metanorma/ieee/processor.rb

@@ -0,0 +1,56 @@
+require "metanorma/processor"
+
+module Metanorma
+  module IEEE
+    class Processor < Metanorma::Processor
+      def initialize
+        @short = :ieee
+        @input_format = :asciidoc
+        @asciidoctor_backend = :ieee
+      end
+
+      def output_formats
+        super.merge(
+          html: "html",
+          doc: "doc",
+          pdf: "pdf",
+        )
+      end
+
+      def fonts_manifest
+        {
+          "Arial" => nil,
+          "Courier New" => nil,
+          "Times New Roman" => nil,
+          "Source Han Sans" => nil,
+          "Source Han Sans Normal" => nil,
+          "STIX Two Math" => nil,
+        }
+      end
+
+      def version
+        "Metanorma::IEEE #{Metanorma::IEEE::VERSION}"
+      end
+
+      def output(isodoc_node, inname, outname, format, options = {})
+        case format
+        when :html
+          IsoDoc::IEEE::HtmlConvert.new(options).convert(inname, isodoc_node,
+                                                         nil, outname)
+        when :doc
+          IsoDoc::IEEE::WordConvert.new(options).convert(inname, isodoc_node,
+                                                         nil, outname)
+        when :pdf
+          IsoDoc::IEEE::PdfConvert.new(options).convert(inname, isodoc_node,
+                                                        nil, outname)
+        when :presentation
+          IsoDoc::IEEE::PresentationXMLConvert.new(options).convert(
+            inname, isodoc_node, nil, outname
+          )
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/ieee/reqt.rng

@@ -0,0 +1,226 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<grammar xmlns="http://relaxng.org/ns/structure/1.0" datatypeLibrary="http://www.w3.org/2001/XMLSchema-datatypes">
+  <!--
+    Presupposes isodoc.rnc, is included in it
+    include "isodoc.rnc" { }
+  -->
+  <define name="requirement">
+    <element name="requirement">
+      <ref name="RequirementType"/>
+    </element>
+  </define>
+  <define name="recommendation">
+    <element name="recommendation">
+      <ref name="RequirementType"/>
+    </element>
+  </define>
+  <define name="permission">
+    <element name="permission">
+      <ref name="RequirementType"/>
+    </element>
+  </define>
+  <define name="RequirementType">
+    <optional>
+      <attribute name="obligation">
+        <ref name="ObligationType"/>
+      </attribute>
+    </optional>
+    <optional>
+      <attribute name="unnumbered">
+        <data type="boolean"/>
+      </attribute>
+    </optional>
+    <optional>
+      <attribute name="number"/>
+    </optional>
+    <optional>
+      <attribute name="subsequence"/>
+    </optional>
+    <optional>
+      <attribute name="keep-with-next">
+        <data type="boolean"/>
+      </attribute>
+    </optional>
+    <optional>
+      <attribute name="keep-lines-together">
+        <data type="boolean"/>
+      </attribute>
+    </optional>
+    <attribute name="id">
+      <data type="ID"/>
+    </attribute>
+    <optional>
+      <attribute name="filename"/>
+    </optional>
+    <optional>
+      <attribute name="model"/>
+    </optional>
+    <optional>
+      <attribute name="type"/>
+    </optional>
+    <optional>
+      <attribute name="tag"/>
+    </optional>
+    <optional>
+      <attribute name="multilingual-rendering">
+        <ref name="MultilingualRenderingType"/>
+      </attribute>
+    </optional>
+    <optional>
+      <ref name="reqtitle"/>
+    </optional>
+    <optional>
+      <ref name="label"/>
+    </optional>
+    <zeroOrMore>
+      <ref name="subject"/>
+    </zeroOrMore>
+    <zeroOrMore>
+      <ref name="reqinherit"/>
+    </zeroOrMore>
+    <zeroOrMore>
+      <ref name="classification"/>
+    </zeroOrMore>
+    <zeroOrMore>
+      <choice>
+        <ref name="measurementtarget"/>
+        <ref name="specification"/>
+        <ref name="verification"/>
+        <ref name="import"/>
+        <ref name="description"/>
+        <ref name="component"/>
+      </choice>
+    </zeroOrMore>
+    <optional>
+      <ref name="reqt_references"/>
+    </optional>
+    <zeroOrMore>
+      <choice>
+        <ref name="requirement"/>
+        <ref name="recommendation"/>
+        <ref name="permission"/>
+      </choice>
+    </zeroOrMore>
+  </define>
+  <define name="reqtitle">
+    <element name="title">
+      <ref name="FormattedString"/>
+    </element>
+  </define>
+  <define name="label">
+    <element name="label">
+      <oneOrMore>
+        <ref name="TextElement"/>
+      </oneOrMore>
+    </element>
+  </define>
+  <define name="subject">
+    <element name="subject">
+      <oneOrMore>
+        <ref name="TextElement"/>
+      </oneOrMore>
+    </element>
+  </define>
+  <define name="reqinherit">
+    <element name="inherit">
+      <oneOrMore>
+        <ref name="TextElement"/>
+      </oneOrMore>
+    </element>
+  </define>
+  <define name="measurementtarget">
+    <element name="measurement-target">
+      <ref name="RequirementSubpart"/>
+    </element>
+  </define>
+  <define name="specification">
+    <element name="specification">
+      <ref name="RequirementSubpart"/>
+    </element>
+  </define>
+  <define name="verification">
+    <element name="verification">
+      <ref name="RequirementSubpart"/>
+    </element>
+  </define>
+  <define name="import">
+    <element name="import">
+      <ref name="RequirementSubpart"/>
+    </element>
+  </define>
+  <define name="description">
+    <element name="description">
+      <ref name="RequirementSubpart"/>
+    </element>
+  </define>
+  <define name="component">
+    <element name="component">
+      <attribute name="class"/>
+      <ref name="RequirementSubpart"/>
+    </element>
+  </define>
+  <define name="reqt_references">
+    <element name="references">
+      <oneOrMore>
+        <ref name="bibitem"/>
+      </oneOrMore>
+    </element>
+  </define>
+  <define name="RequirementSubpart">
+    <optional>
+      <attribute name="type"/>
+    </optional>
+    <optional>
+      <attribute name="exclude">
+        <data type="boolean"/>
+      </attribute>
+    </optional>
+    <optional>
+      <attribute name="keep-with-next">
+        <data type="boolean"/>
+      </attribute>
+    </optional>
+    <optional>
+      <attribute name="keep-lines-together">
+        <data type="boolean"/>
+      </attribute>
+    </optional>
+    <optional>
+      <attribute name="tag"/>
+    </optional>
+    <optional>
+      <attribute name="multilingual-rendering">
+        <ref name="MultilingualRenderingType"/>
+      </attribute>
+    </optional>
+    <oneOrMore>
+      <choice>
+        <ref name="BasicBlock"/>
+        <ref name="component"/>
+      </choice>
+    </oneOrMore>
+  </define>
+  <define name="ObligationType">
+    <choice>
+      <value>requirement</value>
+      <value>recommendation</value>
+      <value>permission</value>
+    </choice>
+  </define>
+  <define name="classification">
+    <element name="classification">
+      <ref name="classification_tag"/>
+      <ref name="classification_value"/>
+    </element>
+  </define>
+  <define name="classification_tag">
+    <element name="tag">
+      <text/>
+    </element>
+  </define>
+  <define name="classification_value">
+    <element name="value">
+      <text/>
+    </element>
+  </define>
+</grammar>

data/lib/metanorma/ieee/validate.rb

@@ -0,0 +1,198 @@
+require_relative "validate_section"
+require_relative "validate_style"
+
+module Metanorma
+  module IEEE
+    class Converter < Standoc::Converter
+      def validate(doc)
+        content_validate(doc)
+        schema_validate(formattedstr_strip(doc.dup),
+                        File.join(File.dirname(__FILE__), "ieee.rng"))
+      end
+
+      def content_validate(doc)
+        super
+        bibdata_validate(doc.root)
+        title_validate(doc.root)
+        locality_erefs_validate(doc.root)
+        bibitem_validate(doc.root)
+        listcount_validate(doc)
+        table_style(doc)
+        figure_validate(doc)
+      end
+
+      def bibdata_validate(doc)
+        doctype_validate(doc)
+        # stage_validate(doc)
+        # substage_validate(doc)
+      end
+
+      def doctype_validate(xmldoc)
+        doctype = xmldoc&.at("//bibdata/ext/doctype")&.text
+        %w(standard recommended-practice guide
+           amendment technical-corrigendum).include? doctype or
+          @log.add("Document Attributes", nil,
+                   "#{doctype} is not a recognised document type")
+      end
+
+      def title_validate(xml)
+        title_validate_type(xml)
+        title_validate_capitalisation(xml)
+      end
+
+      # Style Manual 11.3
+      def title_validate_type(xml)
+        title = xml.at("//bibdata/title") or return
+        draft = xml.at("//bibdata//draft")
+        type = xml.at("//bibdata/ext/doctype")
+        subtype = xml.at("//bibdata/ext/subdoctype")
+        target = draft ? "Draft " : ""
+        target += subtype ? "#{strict_capitalize_phrase(subtype.text)} " : ""
+        target += type ? "#{strict_capitalize_phrase(type.text)} " : ""
+        /^#{target}/.match?(title.text) or
+          @log.add("Style", title,
+                   "Expected title to start as: #{target}")
+      end
+
+      def strict_capitalize_phrase(str)
+        ret = str.split(/[ -]/).map do |w|
+          letters = w.chars
+          letters.first.upcase! unless /^[ -]/.match?(w)
+          letters.join
+        end.join(" ")
+        ret = "Trial-Use" if ret == "Trial Use"
+        ret
+      end
+
+      # Style Manual 11.3
+      def title_validate_capitalisation(xml)
+        title = xml.at("//bibdata/title") or return
+        found = false
+        title.text.split(/[ -]/).each do |w|
+          /^[[:upper:]]/.match?(w) or preposition?(w) or
+            found = true
+        end
+        found and @log.add("Style", title,
+                           "Title contains uncapitalised word other than preposition")
+      end
+
+      def preposition?(word)
+        %w(aboard about above across after against along amid among anti around
+           as at before behind below beneath beside besides between beyond but
+           by concerning considering despite down during except excepting
+           excluding following for from in inside into like minus near of off
+           on onto opposite outside over past per plus regarding round save
+           since than through to toward towards under underneath unlike until
+           up upon versus via with within without a an the).include?(word)
+      end
+
+      # Style manual 12.3.2
+      def locality_erefs_validate(root)
+        root.xpath("//eref[descendant::locality]").each do |t|
+          if !/[:-](\d+{4})$/.match?(t["citeas"])
+            @log.add("Style", t,
+                     "undated reference #{t['citeas']} should not contain "\
+                     "specific elements")
+          end
+        end
+      end
+
+      def bibitem_validate(root)
+        normative_dated_refs(root)
+      end
+
+      # Style manual 12.3.1
+      def normative_dated_refs(root)
+        root.xpath("//references[@normative = 'true']/bibitem").each do |b|
+          b.at(".//date") or
+            @log.add("Style", b,
+                     "Normative reference #{b&.at('./@id')&.text} is not dated.")
+        end
+      end
+
+      # Style manual 13.3
+      def listcount_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
+
+      # Style manual 17.1
+      def figure_validate(xmldoc)
+        xrefs = xrefs(xmldoc)
+        figure_name_validate(xmldoc, xrefs)
+        table_figure_name_validate(xmldoc, xrefs)
+        table_figure_quantity_validate(xmldoc)
+      end
+
+      def xrefs(xmldoc)
+        klass = IsoDoc::IEEE::HtmlConvert.new(language: @lang, script: @script)
+        xrefs = IsoDoc::IEEE::Xref
+          .new(@lang, @script, klass, IsoDoc::IEEE::I18n.new(@lang, @script),
+               { hierarchical_assets: @hierarchical_assets })
+        xrefs.parse(Nokogiri::XML(xmldoc.to_xml))
+        xrefs
+      end
+
+      def image_name_prefix(xmldoc)
+        num = xmldoc.at("//bibdata/docnumber") or return
+        yr = xmldoc.at("//bibdata/date[@type = 'published']") ||
+          xmldoc.at("//bibdata/date[@type = 'issued']") ||
+          xmldoc.at("//bibdata/copyright/from")
+        yr = yr&.text || Date.now.year
+        "#{num.text}-#{yr.sub(/-*$/, '')}"
+      end
+
+      def figure_name_validate(xmldoc, xrefs)
+        pref = image_name_prefix(xmldoc)
+        (xmldoc.xpath("//figure") - xmldoc.xpath("//table//figure"))
+          .each do |f|
+            i = f.at("./image") or next
+            next if i["src"].start_with?("data:")
+
+            num = xrefs.anchor(f["id"], :label)
+            File.basename(i["src"], ".*") == "#{pref}_fig#{num}" or
+              @log.add("Style", i,
+                       "image name #{i['src']} is expected to be #{pref}_fig#{num}")
+          end
+      end
+
+      def table_figure_name_validate(xmldoc, xrefs)
+        xmldoc.xpath("//table[.//figure]").each do |t|
+          xmldoc.xpath(".//figure").each do |f|
+            i = f.at("./image") or next
+            next if i["src"].start_with?("data:")
+
+            num = tablefigurenumber(t, f, xrefs)
+            File.basename(i["src"]) == num or
+              @log.add("Style", i,
+                       "image name #{i['src']} is expected to be #{num}")
+          end
+        end
+      end
+
+      def tablefigurenumber(table, figure, xrefs)
+        tab = xrefs.anchor(table["id"], :label)
+        td = figure.at("./ancestor::td | ./ancestor::th")
+        cols = td.xpath("./preceding-sibling::td | ./preceding-sibling::td")
+        rows = td.parent.xpath("./preceding::tr") &
+          td.at("./ancestor::table").xpath(".//tr")
+        "Tab#{tab}Row#{rows.size + 1}Col#{cols.size + 1}"
+      end
+
+      def table_figure_quantity_validate(xmldoc)
+        xmldoc.xpath("//td[.//image] | //th[.//image]").each do |d|
+          d.xpath(".//image").size > 1 and
+            @log.add("Style", d,
+                     "More than one image in the table cell")
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/ieee/validate_section.rb

@@ -0,0 +1,119 @@
+module Metanorma
+  module IEEE
+    class Converter < Standoc::Converter
+      def section_validate(doc)
+        doctype = doc&.at("//bibdata/ext/doctype")&.text
+        unless %w(amendment technical-corrigendum).include? doctype
+          sections_presence_validate(doc.root)
+          sections_sequence_validate(doc.root)
+        end
+        subclause_validate(doc.root)
+        onlychild_clause_validate(doc.root)
+        super
+      end
+
+      def sections_presence_validate(root)
+        root.at("//sections/clause[@type = 'overview']") or
+          @log.add("Style", nil, "Overview clause missing")
+        root.at("//sections/clause[@type = 'overview']/clause[@type = 'scope']") or
+          @log.add("Style", nil, "Scope subclause missing")
+        root.at("//sections/clause[@type = 'overview']/clause[@type = 'word-usage']") or
+          @log.add("Style", nil, "Word Usage subclause missing")
+        root.at("//references[@normative = 'true']") or
+          @log.add("Style", nil, "Normative references missing")
+        root.at("//terms") or
+          @log.add("Style", nil, "Definitions missing")
+      end
+
+      def seqcheck(names, msg, accepted)
+        n = names.shift
+        return [] if n.nil?
+
+        test = accepted.map { |a| n.at(a) }
+        if test.all?(&:nil?)
+          @log.add("Style", nil, msg)
+        end
+        names
+      end
+
+      # spec of permissible section sequence
+      # we skip normative references, it goes to end of list
+      SEQ = [
+        { msg: "Initial section must be (content) Abstract",
+          val: ["./self::abstract"] },
+        { msg: "Prefatory material must be followed by (clause) Overview",
+          val: ["./self::clause[@type = 'overview']"] },
+        { msg: "Normative References must be followed by "\
+               "Definitions",
+          val: ["./self::terms | .//terms"] },
+      ].freeze
+
+      SECTIONS_XPATH =
+        "//preface/abstract | //sections/terms | .//annex | "\
+        "//sections/definitions | //sections/clause | "\
+        "//references[not(parent::clause)] | "\
+        "//clause[descendant::references][not(parent::clause)]".freeze
+
+      def sections_sequence_validate(root)
+        names, n = sections_sequence_validate_start(root)
+        names, n = sections_sequence_validate_body(names, n)
+        sections_sequence_validate_end(names, n)
+      end
+
+      def sections_sequence_validate_start(root)
+        names = root.xpath(SECTIONS_XPATH)
+        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[2][:msg], SEQ[2][:val])
+        n = names.shift
+        n = names.shift if n&.at("./self::definitions")
+        [names, n]
+      end
+
+      def sections_sequence_validate_body(names, elem)
+        [names, elem]
+      end
+
+      def sections_sequence_validate_end(names, elem)
+        while elem&.name == "annex"
+          elem = names.shift
+          if elem.nil?
+            @log.add("Style", nil, "Document must include (references) "\
+                                   "Normative References")
+          end
+        end
+        elem&.at("./self::references[@normative = 'true']") ||
+          @log.add("Style", nil, "Document must include (references) "\
+                                 "Normative References")
+        elem = names&.shift
+        elem&.at("./self::references[@normative = 'false']") ||
+          @log.add("Style", elem,
+                   "Final section must be (references) Bibliography")
+        names.empty? ||
+          @log.add("Style", elem,
+                   "There are sections after the final Bibliography")
+      end
+
+      # Style manual 13.1
+      def subclause_validate(root)
+        root.xpath("//clause/clause/clause/clause/clause/clause")
+          .each do |c|
+          style_warning(c, "Exceeds the maximum clause depth of 5", nil)
+        end
+      end
+
+      # Style manual 13.1
+      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