mn-requirements 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a911bf95744bbdb7de8e2b5b290532b6e0f2d74c033f0bbfb13c9c0f136e4ae
-  data.tar.gz: dac3261957972d66fa56830bb891ecfc29872cc9ab014986630fc02fc33ceb28
+  metadata.gz: d0e6c91b33ab3f3b3eb4ce26df120009dfe92441024891d766115421023630ea
+  data.tar.gz: 800e1d60081b242bd3aa921004839ac0cabbcde5102a6d8c29d1d652e22b5cfc
 SHA512:
-  metadata.gz: a565bdf1f2c03bca4849c4a1d2658c58b7681b62fe0e17497385953013bfb8fd63f8161307a3059476c15688888a208826c33b2a029b5fc250e6f9c297bdc63b
-  data.tar.gz: b1e542ac384b4f0fd7c73969fb4f9f970986fe6eb73f357be17bfb6bc7d358c893ced9813b04137cf64d3c08e76e4acd11ffc3bce776f98e7095ac8f235e08f7
+  metadata.gz: ad9db2b90feb438a6e146cc943585ccaf81b525147b9556860f11175976e65c247b44d2d084cfcae43b9d89fbba7d9b7bab8fef00f5d2051ea7ed1fd450b0c77
+  data.tar.gz: 4d875db98cb7ef2942ead616f49268314a12e592aecd5422b7f586fd98cf8fdf485d752e2fdf522dd9dc4640aab1f5e9e12e5c79dff6debbd9f17687396b3b32

data/README.adoc

@@ -16,11 +16,11 @@ toolset, allowing various models to be processed. The gem currently supports:
 
 == Usage
 
-Within Metanorma, a requirement is specified as being of a particular type; e.g.
+Within Metanorma, a requirement is specified as being of a particular model; e.g.
 
 [source,asciidoc]
 ----
-[requirement,type=ogc]
+[requirement,model=ogc]
 ...
 ...
 ----

data/lib/isodoc/i18n.rb

@@ -0,0 +1,23 @@
+require "yaml"
+require "isodoc-i18n"
+
+module IsoDoc
+  class MnRequirementsI18n < I18n
+    def load_yaml1(lang, script)
+      case lang
+      when "en", "fr", "ru", "de", "es", "ar"
+        load_yaml2(lang)
+      when "zh"
+        if script == "Hans" then load_yaml2("zh-Hans")
+        else load_yaml2("en")
+        end
+      else load_yaml2("en")
+      end
+    end
+
+    def load_yaml2(str)
+      YAML.load_file(File.join(File.dirname(__FILE__),
+                               "../isodoc-yaml/i18n-#{str}.yaml"))
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+requirements:
+  default:
+    requirement: مطلب
+    recommendation: توصية
+    permission: إذن
+    obligation: التزام
+    subject: موضوع
+    inherits: يرث
+  modspec:
+    recommendationtest: اختبار التوصية
+    requirementtest: اختبار المتطلبات
+    permissiontest: اختبار الإذن
+    recommendationclass: فئة التوصيات
+    requirementclass: فئة المتطلبات
+    permissionclass: فئة الأذونات
+    abstracttest: اختبار تجريدي
+    conformanceclass: فئة المطابقة
+    conformancetest: اختبار المطابقة
+    targettype: نوع الهدف
+    target: استهداف
+    testpurpose: هدف الاختبار
+    testmethod: طريقة اختبار
+    dependency: الاعتماد
+    indirectdependency: التبعية غير المباشرة
+    identifier: المعرف
+    included_in: مدرج في

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

@@ -0,0 +1,27 @@
+requirements:
+  default:
+    requirement: Anforderung
+    recommendation: Empfehlung
+    permission: Erlaubnis
+    obligation: Verbindlichkeit
+    subject: Thema
+    inherits: Erbt
+  modspec:
+    recommendationtest: Empfehlungstest
+    requirementtest: Anforderungstest
+    permissiontest: Berechtigungstest
+    recommendationclass: Empfehlungsklasse
+    requirementclass: Anforderungsklasse
+    permissionclass: Berechtigungsklasse
+    abstracttest: Abstrakter Test
+    conformanceclass: Konformitätsklasse
+    conformancetest: Konformitätstest
+    targettype: Zieltyp
+    target: Ziel
+    testpurpose: Testzweck
+    testmethod: Testmethode
+    dependency: Abhängigkeit
+    indirectdependency: Indirekte Abhängigkeit
+    identifier: Kennung
+    included_in: Enthalten in
+

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

@@ -0,0 +1,27 @@
+requirements:
+  default:
+    requirement: Requirement
+    recommendation: Recommendation
+    permission: Permission
+    obligation: Obligation
+    subject: Subject
+    inherits: Inherits
+  modspec:
+    recommendationtest: Recommendation test
+    requirementtest: Requirement test
+    permissiontest: Permission test
+    recommendationclass: Recommendations class
+    requirementclass: Requirements class
+    permissionclass: Permissions class
+    abstracttest: Abstract test
+    conformanceclass: Conformance class
+    conformancetest: Conformance test
+    targettype: Target type
+    target: Target
+    testpurpose: Test purpose
+    testmethod: Test method
+    dependency: Dependency
+    indirectdependency: Indirect Dependency
+    identifier: Identifier
+    included_in: Included in
+

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

@@ -0,0 +1,27 @@
+requirements:
+  default:
+    requirement: Requerimiento
+    recommendation: Recomendación
+    permission: Permiso
+    obligation: Obligación
+    subject: Tema
+    inherits: Hereda
+  modspec:
+    recommendationtest: Prueba de recomendación
+    requirementtest: Prueba de requerimiento
+    permissiontest: Prueba de permiso
+    recommendationclass: Clase de recomendaciones
+    requirementclass: Clase de requerimientos
+    permissionclass: Clase de permisos
+    abstracttest: Prueba abstracta
+    conformanceclass: Clase de conformidad
+    conformancetest: Prueba de conformidad
+    targettype: Tipo de objetivo
+    target: Objetivo
+    testpurpose: Propósito de prueba
+    testmethod: Método de prueba
+    dependency: Dependencia
+    indirectdependency: Dependencia indirecta
+    identifier: Identificador
+    included_in: Incluido en
+

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

@@ -0,0 +1,27 @@
+requirements:
+  default:
+    requirement: Exigence
+    recommendation: Recommandation
+    permission: Autorisation
+    obligation: Obligation
+    subject: Sujet
+    inherits: Hérite
+  modspec:
+    recommendationtest: Test de recommendation
+    requirementtest: Test d’exigence
+    permissiontest: Test d’autorisation
+    recommendationclass: Classe de recommendations
+    requirementclass: Classe d’exigences
+    permissionclass: Classe d’autorisations
+    abstracttest: Test abstrait
+    conformanceclass: Classe de confirmité
+    conformancetest: Test de conformité
+    targettype: Type de cible
+    target: Cible
+    testpurpose: Objectif du test
+    testmethod: Méthode du test
+    dependency: Dépendance
+    indirectdependency: Dépendance indirecte
+    identifier: Identifiant
+    included_in: Inclus dans
+

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

@@ -0,0 +1,27 @@
+requirements:
+  default:
+    requirement: Требование
+    recommendation: Рекомендация
+    permission: Разрешение
+    obligation: Обязательство
+    subject: Тема
+    inherits: Наследует
+  modspec:
+    recommendationtest: Проверка рекомендации
+    requirementtest: Проверка требований
+    permissiontest: Проверка разрешения
+    recommendationclass: Класс рекомендаций
+    requirementclass: Класс требований
+    permissionclass: Класс разрешений
+    abstracttest: Абстрактная проверка
+    conformanceclass: Класс соответствия
+    conformancetest: Проверка на соответствие
+    targettype: Тип цели
+    target: Цель
+    testpurpose: Цель теста
+    testmethod: Метод теста
+    dependency: Зависимость
+    indirectdependency: Косвенная зависимость
+    identifier: Идентификатор
+    included_in: Входит в
+

data/lib/isodoc-yaml/i18n-zh-Hans.yaml

@@ -0,0 +1,27 @@
+requirements:
+  default:
+    requirement: 要求
+    recommendation: 建议
+    permission: 容許
+    obligation: 义务
+    subject: 主体
+    inherits: 继承自
+  modspec:
+    recommendationtest: 推荐测试
+    requirementtest: 需求测试
+    permissiontest: 权限测试
+    recommendationclass: 推荐类
+    requirementclass: 需求类
+    permissionclass: 权限类
+    abstracttest: 抽象测试
+    conformanceclass: 一致性等级
+    conformancetest: 一致性测试
+    targettype: 目标类型
+    target: 目标
+    testpurpose: 测试目的
+    testmethod: 测试方法
+    dependency: 依赖
+    indirectdependency: 间接依赖
+    identifier: 标识符
+    included_in: 包含在
+

data/lib/metanorma/default/default.rb

@@ -94,6 +94,8 @@ module Metanorma
           end
         end.join("\n")
       end
+
+      def validate(reqt, log); end
     end
   end
 end

data/lib/metanorma/default/isodoc.rb

@@ -56,12 +56,12 @@ module Metanorma
 
       def recommendation_attributes1(node, out)
         oblig = node["obligation"] and
-          out << l10n("#{@labels['obligation']}: #{oblig}")
+          out << l10n("#{@labels['default']['obligation']}: #{oblig}")
         node.xpath(ns("./subject")).each do |subj|
-          out << l10n("#{@labels['subject']}: #{subj.text}")
+          out << l10n("#{@labels['default']['subject']}: #{subj.text}")
         end
         node.xpath(ns("./inherit")).each do |i|
-          out << recommendation_attr_parse(i, @labels["inherits"])
+          out << recommendation_attr_parse(i, @labels["default"]["inherits"])
         end
         node.xpath(ns("./classification")).each do |c|
           out << recommendation_attr_keyvalue(c, "tag", "value")

data/lib/metanorma/default/xrefs.rb

@@ -7,22 +7,22 @@ module Metanorma
 
       def req_class_paths
         [
-          { klass: "permission", label: "permission",
+          { klass: "permission", label: @labels["default"]["permission"],
             xpath: "permission" },
-          { klass: "requirement", label: "requirement",
+          { klass: "requirement", label: @labels["default"]["requirement"],
             xpath: "requirement" },
-          { klass: "recommendation", label: "recommendation",
+          { klass: "recommendation", label: @labels["default"]["recommendation"],
             xpath: "recommendation" },
         ]
       end
 
       def req_nested_class_paths
         [
-          { klass: "permission", label: "permission",
+          { klass: "permission", label: @labels["default"]["permission"],
             xpath: "permission" },
-          { klass: "requirement", label: "requirement",
+          { klass: "requirement", label: @labels["default"]["requirement"],
             xpath: "requirement" },
-          { klass: "recommendation", label: "recommendation",
+          { klass: "recommendation", label: @labels["default"]["recommendation"],
             xpath: "recommendation" },
         ]
       end

data/lib/metanorma/modspec/cleanup.rb

@@ -37,8 +37,7 @@ module Metanorma
           d.remove
         end
         if REQS.include?(term.text) && !val.text.empty?
-          val["label"] = val.text.strip
-          val.children.remove
+          val.children = "<identifier>#{val.text.strip}</identifier>"
         end
         val
       end

data/lib/metanorma/modspec/isodoc.rb

@@ -5,16 +5,17 @@ module Metanorma
   class Requirements
     class Modspec < Default
       def requirement_render1(node)
+        init_lookups(node.document)
         requirement_table_cleanup(super)
       end
 
-      def recommendation_base(node, klass)
+      def recommendation_base(node, _klass)
         out = node.document.create_element("table")
         out.default_namespace = node.namespace.href
         %w(id keep-with-next keep-lines-together unnumbered).each do |x|
           out[x] = node[x] if node[x]
         end
-        out["class"] = klass
+        out["class"] = "modspec"
         out["type"] = recommend_class(node)
         recommendation_component_labels(node)
         out
@@ -29,24 +30,30 @@ module Metanorma
         end
       end
 
-      def recommendation_header(recommend, out)
-        h = out.add_child("<thead><tr><th scope='colgroup' colspan='2'>"\
-                          "</th></tr></thead>").first
-        recommendation_name(recommend, h.at(ns(".//th")))
+      def recommendation_header(reqt, out)
+        n = recommendation_name(reqt, nil)
+        x = if reqt.ancestors("requirement, recommendation, permission").empty?
+              "<thead><tr><th scope='colgroup' colspan='2'>"\
+                "<p class='#{recommend_name_class(reqt)}'>#{n}</p>"\
+                "</th></tr></thead>"
+            else
+              "<thead><tr><td>#{recommendation_class_label(reqt)}</td>"\
+                "<td>#{n}</td></tr></thead>"
+            end
+        out << x
         out
       end
 
-      def recommendation_name(node, out)
-        b = out.add_child("<p class='#{recommend_name_class(node)}'></p>").first
-        name = node.at(ns("./name")) and name.children.each do |n|
-          b << n
-        end
+      def recommendation_name(node, _out)
+        ret = ""
+        name = node.at(ns("./name")) and ret += name.children.to_xml
         title = node.at(ns("./title"))
-        return unless title &&
+        return ret unless title &&
           node.ancestors("requirement, recommendation, permission").empty?
 
-        b << l10n(": ") if name
-        title.children.each { |n| b << n }
+        ret += l10n(": ") if name
+        ret += title.children.to_xml
+        ret
       end
 
       def recommendation_attributes(node, out)
@@ -60,10 +67,8 @@ module Metanorma
 
       def recommend_title(node, out)
         label = node.at(ns("./identifier")) or return
-        b = out.add_child("<tr><td colspan='2'><p></p></td></tr>")
-        p = b.at(ns(".//p"))
-        p["class"] = "RecommendationLabel"
-        p << label.children.to_xml
+        out.add_child("<tr><td>#{@labels['modspec']['identifier']}</td>"\
+                      "<td><tt>#{label.children.to_xml}</tt></td>")
       end
 
       def recommendation_attributes1(node)
@@ -76,30 +81,42 @@ module Metanorma
       end
 
       def recommendation_attributes1_head(node, head)
-        oblig = node["obligation"] and head << ["Obligation", oblig]
+        oblig = node["obligation"] and
+          head << [@labels["default"]["obligation"], oblig]
         subj = node.at(ns("./subject"))&.children and
           head << [rec_subj(node), subj]
         node.xpath(ns("./classification[tag = 'target']/value")).each do |v|
-          xref = recommendation_id(node.document, v.text) and head << [
+          xref = recommendation_id(v.text) and head << [
             rec_target(node), xref
           ]
         end
-        %w(general class).include?(node["type"]) and
-          xref = recommendation_link(node.document,
-                                     node.at(ns("./identifier"))&.text) and
-          head << ["Conformance test", xref]
+        head += recommendation_backlinks(node)
         recommendation_attributes1_dependencies(node, head)
       end
 
+      def recommendation_backlinks(node)
+        ret = []
+        id = node.at(ns("./identifier")) or return ret
+        %w(general class).include?(node["type"]) and
+          xref = recommendation_link_test(id.text) and
+          ret << [@labels["modspec"]["conformancetest"], xref]
+        ret
+        (node["type"].nil? || node["type"].empty? ||
+        node["type"] == "verification") and
+          xref = recommendation_link_class(id.text) and
+          ret << [@labels["modspec"]["included_in"], xref]
+        ret
+      end
+
       def recommendation_attributes1_dependencies(node, head)
         node.xpath(ns("./inherit")).each do |i|
-          head << ["Dependency",
-                   recommendation_id(node.document, i.children.to_xml)]
+          head << [@labels["modspec"]["dependency"],
+                   recommendation_id(i.children.to_xml)]
         end
         node.xpath(ns("./classification[tag = 'indirect-dependency']/value"))
           .each do |v|
-          xref = recommendation_id(node.document, v.children.to_xml) and
-            head << ["Indirect Dependency", xref]
+          xref = recommendation_id(v.children.to_xml) and
+            head << [@labels["modspec"]["indirectdependency"], xref]
         end
         head
       end
@@ -171,43 +188,25 @@ module Metanorma
         return table unless table["type"] == "recommendclass"
 
         table.xpath(ns("./tbody/tr/td/table")).each do |t|
-          t.xpath(ns("./thead | ./tbody |./tfoot")).each do |x|
-            x.replace(x.children)
-          end
-          (x = t.at(ns("./tr/th[@colspan = '2']"))) &&
-            (y = t.at(ns("./tr/td[@colspan = '2']"))) and
-            requirement_table_cleanup1(x, y)
-          t.parent.parent.replace(t.children)
+          x = t.at(ns("./thead/tr")) or next
+          t.parent.parent.replace(x)
         end
         table
       end
 
-      # table nested in table: merge label and caption into a single row
-      def requirement_table_cleanup1(outer, inner)
-        outer.delete("colspan")
-        outer.delete("scope")
-        inner.delete("colspan")
-        inner.delete("scope")
-        outer.name = "td"
-        p = outer.at(ns("./p[@class = 'RecommendationTitle']")) and
-          p.delete("class")
-        outer.parent << inner.dup
-        inner.parent.remove
-      end
-
       def rec_subj(node)
         case node["type"]
-        when "class" then "Target type"
-        else "Subject"
+        when "class" then @labels["modspec"]["targettype"]
+        else @labels["default"]["subject"]
         end
       end
 
       def rec_target(node)
         case node["type"]
-        when "class" then "Target type"
-        when "conformanceclass" then "Requirements class"
-        when "verification", "abstracttest" then "Requirement"
-        else "Target"
+        when "class" then @labels["modspec"]["targettype"]
+        when "conformanceclass" then @labels["modspec"]["requirementclass"]
+        when "verification", "abstracttest" then @labels["default"]["requirement"]
+        else @labels["modspec"]["target"]
         end
       end
 
@@ -227,11 +226,13 @@ module Metanorma
       end
 
       def recommend_component_label(node)
-        case node["class"]
-        when "test-purpose" then "Test purpose"
-        when "test-method" then "Test method"
-        else Metanorma::Utils.strict_capitalize_first(node["class"])
-        end
+        c = case node["class"]
+            when "test-purpose" then "Test purpose"
+            when "test-method" then "Test method"
+            else node["class"]
+            end
+        @labels["default"][c] || @labels["modspec"][c] ||
+          Metanorma::Utils.strict_capitalize_first(c)
       end
     end
   end

data/lib/metanorma/modspec/modspec.rb

@@ -1,4 +1,5 @@
 require_relative "cleanup"
+require_relative "validate"
 require_relative "isodoc"
 
 module Metanorma

data/lib/metanorma/modspec/reqt_label.rb

@@ -2,42 +2,61 @@ module Metanorma
   class Requirements
     class Modspec < Default
       def recommendation_label(elem, type, xrefs)
+        @xrefs ||= xrefs.dup
+        init_lookups(elem.document)
+
         label = elem.at(ns("./identifier"))&.text
         if inject_crossreference_reqt?(elem, label)
-          number = xrefs.anchor(reqtlabels(elem.document, label), :xref, false)
-          number.nil? ? type : number
+          recommendation_label_xref(elem, label, xrefs)
         else
           type = recommendation_class_label(elem)
           super
         end
       end
 
-      def reqtlabels(doc, label)
-        @reqtlabels ||= doc
-          .xpath(ns("//requirement | //recommendation | //permission"))
+      def recommendation_label_xref(elem, label, xrefs)
+        id = @reqtlabels[label]
+        number = xrefs.anchor(id, :xref, false)
+        number.nil? and return type
+        elem.ancestors("requirement, recommendation, permission").empty? and
+          return number
+        "<xref target='#{id}'>#{number}</xref>"
+      end
+
+      def init_lookups(doc)
+        return if @init_lookups
+
+        @init_lookups = true
+        @reqtlabels = reqtlabels(doc)
+        @reqt_ids = reqt_ids(doc)
+        @reqt_links_class = reqt_links_class(doc)
+        @reqt_links_test = reqt_links_test(doc)
+      end
+
+      def reqtlabels(doc)
+        doc.xpath(ns("//requirement | //recommendation | //permission"))
           .each_with_object({}) do |r, m|
-            l = r.at(ns("./label"))&.text and m[l] = r["id"]
+            l = r.at(ns("./identifier"))&.text and m[l] = r["id"]
           end
-        @reqtlabels[label]
       end
 
-      # embedded reqts xref to top level reqts via label lookup
+      # embedded reqts xref to reqts via label lookup
       def inject_crossreference_reqt?(node, label)
-        !node.ancestors("requirement, recommendation, permission").empty? &&
-          reqtlabels(node.document, label)
+        !node.ancestors("requirement, recommendation, permission").empty? and
+          @reqtlabels[label]
       end
 
       def recommendation_class_label(node)
         case node["type"]
-        when "verification" then @labels["#{node.name}test"]
-        when "class" then @labels["#{node.name}class"]
-        when "abstracttest" then @labels["abstracttest"]
-        when "conformanceclass" then @labels["conformanceclass"]
+        when "verification" then @labels["modspec"]["#{node.name}test"]
+        when "class" then @labels["modspec"]["#{node.name}class"]
+        when "abstracttest" then @labels["modspec"]["abstracttest"]
+        when "conformanceclass" then @labels["modspec"]["conformanceclass"]
         else
           case node.name
-          when "recommendation" then @labels["recommendation"]
-          when "requirement" then @labels["requirement"]
-          when "permission" then @labels["permission"]
+          when "recommendation" then @labels["default"]["recommendation"]
+          when "requirement" then @labels["default"]["requirement"]
+          when "permission" then @labels["default"]["permission"]
           end
         end
       end
@@ -50,28 +69,49 @@ module Metanorma
           end
       end
 
-      def reqt_links(docxml)
+      def reqt_links_test(docxml)
         docxml.xpath(ns("//requirement | //recommendation | //permission"))
           .each_with_object({}) do |r, m|
             next unless %w(conformanceclass
                            verification).include?(r["type"])
 
             subj = r.at(ns("./classification[tag = 'target']/value"))
-            id = r.at(ns("./identifier"))
-            next unless subj && id
+            id = r.at(ns("./identifier")) or next
+            lbl = @xrefs.anchor(@reqt_ids[id.text.strip], :xref, false)
+            next unless subj && lbl
+
+            m[subj.text] = { lbl: lbl, id: r["id"] }
+          end
+      end
+
+      def recommendation_link_test(ident)
+        test = @reqt_links_test[ident&.strip] or return nil
+        "<xref target='#{test[:id]}'>#{test[:lbl]}</xref>"
+      end
+
+      def reqt_links_class(docxml)
+        docxml.xpath(ns("//requirement | //recommendation | //permission"))
+          .each_with_object({}) do |r, m|
+            next unless %w(class conformanceclass).include?(r["type"])
+
+            id = r.at(ns("./identifier")) or next
+            r.xpath(ns("./requirement | ./recommendation | ./permission"))
+              .each do |r1|
+              id1 = r1.at(ns("./identifier")) or next
+              lbl = @xrefs.anchor(@reqt_ids[id.text.strip], :xref, false)
+              next unless lbl
 
-            m[subj.text] = { lbl: id.text, id: r["id"] }
+              m[id1.text] = { lbl: lbl, id: r["id"] }
+            end
           end
       end
 
-      def recommendation_link(docxml, ident)
-        @reqt_links ||= reqt_links(docxml)
-        test = @reqt_links[ident&.strip] or return nil
+      def recommendation_link_class(ident)
+        test = @reqt_links_class[ident&.strip] or return nil
         "<xref target='#{test[:id]}'>#{test[:lbl]}</xref>"
       end
 
-      def recommendation_id(docxml, ident)
-        @reqt_ids ||= reqt_ids(docxml)
+      def recommendation_id(ident)
         test = @reqt_ids[ident&.strip] or return ident&.strip
         "<xref target='#{test}'>#{ident.strip}</xref>"
       end

data/lib/metanorma/modspec/validate.rb

@@ -0,0 +1,111 @@
+module Metanorma
+  class Requirements
+    class Modspec < Default
+      def validate(reqt, log)
+        @log ||= log
+        @ids ||= reqt_links(reqt.document)
+        reqt_link_validate(reqt)
+      end
+
+      def nested_reqt?(reqt)
+        reqt.at("./ancestor::requirement | ./ancestor::recommendation | "\
+                "./ancestor::permission")
+      end
+
+      def reqt_link_validate(reqt)
+        return if nested_reqt?(reqt)
+
+        reqt_to_conformance(reqt, "general", "verification")
+        reqt_to_conformance(reqt, "class", "conformanceclass")
+        conformance_to_reqt(reqt, "general", "verification")
+        conformance_to_reqt(reqt, "class", "conformanceclass")
+        class_to_children(reqt, "class", "general")
+        class_to_children(reqt, "conformanceclass", "verification")
+        children_to_class(reqt, "verification", "conformanceclass")
+      end
+
+      def type2validate(reqt)
+        type = reqt["type"]
+        type = "general" if type.nil? || type.empty?
+        type
+      end
+
+      CLASS2LABEL = {
+        general: "Requirement",
+        verification: "Conformance test",
+        class: "Requirement class",
+        conformanceclass: "Conformance class",
+      }.freeze
+
+      def log_reqt(reqt, leftclass, rightclass)
+        @log.add("Requirements", reqt[:elem],
+                 "#{CLASS2LABEL[leftclass.to_sym]} #{reqt[:label] || reqt[:id]} "\
+                 "has no corresponding #{CLASS2LABEL[rightclass.to_sym]}")
+      end
+
+      def reqt_to_conformance(reqt, reqtclass, confclass)
+        return unless type2validate(reqt) == reqtclass
+
+        r = @ids[:id][reqt["id"]]
+        (r[:label] && @ids[:class][confclass]&.any? do |x|
+           x[:subject] == r[:label]
+         end) and return
+        log_reqt(r, reqtclass, confclass)
+      end
+
+      def conformance_to_reqt(reqt, reqtclass, confclass)
+        return unless type2validate(reqt) == confclass
+
+        r = @ids[:id][reqt["id"]]
+        (r[:subject] && @ids[:class][reqtclass]&.any? do |x|
+           r[:subject] == x[:label]
+         end) and return
+        log_reqt(r, confclass, reqtclass)
+      end
+
+      def class_to_children(reqt, type, childclass)
+        return unless type2validate(reqt) == type
+
+        r = @ids[:id][reqt["id"]]
+        !r[:child].empty? and return
+        log_reqt(r, type, childclass)
+      end
+
+      def children_to_class(reqt, childclass, parentclass)
+        return unless type2validate(reqt) == childclass
+
+        r = @ids[:id][reqt["id"]]
+        (r[:label] && @ids[:class][parentclass]&.any? do |x|
+           x[:child].include?(r[:label])
+         end) and return
+        log_reqt(r, childclass, parentclass)
+      end
+
+      def reqt_links(docxml)
+        docxml.xpath("//requirement | //recommendation | //permission")
+          .each_with_object({ id: {}, class: {} }) do |r, m|
+            next if nested_reqt?(r)
+
+            reqt_links1(r, m)
+          end
+      end
+
+      def reqt_links1(reqt, hash)
+        type = type2validate(reqt)
+        hash[:id][reqt["id"]] = reqt_links_struct(reqt)
+        hash[:class][type] ||= []
+        hash[:class][type] << hash[:id][reqt["id"]]
+        hash
+      end
+
+      def reqt_links_struct(reqt)
+        { id: reqt["id"], elem: reqt, label: reqt.at("./identifier")&.text,
+          subject: reqt.at("./classification[tag = 'target']/value")&.text,
+          child: reqt.xpath("./requirement | ./recommendation | ./permission")
+            .map do |r|
+                   r.at("./identifier")&.text
+                 end }
+      end
+    end
+  end
+end

data/lib/metanorma/modspec/xrefs.rb

@@ -3,38 +3,38 @@ module Metanorma
     class Modspec < Default
       def req_class_paths
         [
-          { klass: "permissionclass", label: "permissionclass",
+          { klass: "permissionclass", label: @labels["modspec"]["permissionclass"],
             xpath: "permission[@type = 'class']" },
-          { klass: "requirementclass", label: "requirementclass",
+          { klass: "requirementclass", label: @labels["modspec"]["requirementclass"],
             xpath: "requirement[@type = 'class']" },
-          { klass: "recommendationclass", label: "recommendationclass",
+          { klass: "recommendationclass", label: @labels["modspec"]["recommendationclass"],
             xpath: "recommendation[@type = 'class']" },
-          { klass: "permissiontest", label: "permissiontest",
+          { klass: "permissiontest", label: @labels["modspec"]["permissiontest"],
             xpath: "permission[@type = 'verification']" },
-          { klass: "recommendationtest", label: "recommendationtest",
+          { klass: "recommendationtest", label: @labels["modspec"]["recommendationtest"],
             xpath: "recommendation[@type = 'verification']" },
-          { klass: "requirementtest", label: "requirementtest",
+          { klass: "requirementtest", label: @labels["modspec"]["requirementtest"],
             xpath: "requirement[@type = 'verification']" },
-          { klass: "abstracttest", label: "abstracttest",
+          { klass: "abstracttest", label: @labels["modspec"]["abstracttest"],
             xpath: "permission[@type = 'abstracttest']" },
-          { klass: "abstracttest", label: "abstracttest",
+          { klass: "abstracttest", label: @labels["modspec"]["abstracttest"],
             xpath: "requirement[@type = 'abstracttest']" },
-          { klass: "abstracttest", label: "abstracttest",
+          { klass: "abstracttest", label: @labels["modspec"]["abstracttest"],
             xpath: "recommendation[@type = 'abstracttest']" },
-          { klass: "conformanceclass", label: "conformanceclass",
+          { klass: "conformanceclass", label: @labels["modspec"]["conformanceclass"],
             xpath: "permission[@type = 'conformanceclass']" },
-          { klass: "conformanceclass", label: "conformanceclass",
+          { klass: "conformanceclass", label: @labels["modspec"]["conformanceclass"],
             xpath: "requirement[@type = 'conformanceclass']" },
-          { klass: "conformanceclass", label: "conformanceclass",
+          { klass: "conformanceclass", label: @labels["modspec"]["conformanceclass"],
             xpath: "recommendation[@type = 'conformanceclass']" },
-          { klass: "permission", label: "permission",
+          { klass: "permission", label: @labels["default"]["permission"],
             xpath: "permission[not(@type = 'verification' or @type = 'class' "\
                    "or @type = 'abstracttest' or @type = 'conformanceclass')]" },
-          { klass: "recommendation", label: "recommendation",
+          { klass: "recommendation", label: @labels["default"]["recommendation"],
             xpath: "recommendation[not(@type = 'verification' or "\
                    "@type = 'class' or @type = 'abstracttest' or "\
                    "@type = 'conformanceclass')]" },
-          { klass: "requirement", label: "requirement",
+          { klass: "requirement", label: @labels["default"]["requirement"],
             xpath: "requirement[not(@type = 'verification' or @type = 'class' "\
                    "or @type = 'abstracttest' or @type = 'conformanceclass')]" },
         ]

data/lib/metanorma/requirements/selector.rb

@@ -1,6 +1,6 @@
 require_relative "../default/default"
 require_relative "../modspec/modspec"
-require "isodoc-i18n"
+require_relative "../../isodoc/i18n"
 
 module Metanorma
   class Requirements
@@ -8,9 +8,10 @@ module Metanorma
 
     def initialize(options)
       @default = options[:default]
-      @i18n = ::IsoDoc::I18n.new(options[:lang] || "en",
-                                 options[:script] || "Latn")
-      @labels = options[:labels]
+      @i18n = i18n_klass(options[:lang] || "en",
+                         options[:script] || "Latn",
+                         options[:i18nhash])
+      @labels = @i18n.get.merge(options[:labels] || {})["requirements"]
       @models = {}
       model_names.each { |k| @models[k] = create(k) }
     end
@@ -19,6 +20,10 @@ module Metanorma
       %i[default ogc]
     end
 
+    def i18n_klass(lang = "en", script = "Latn", i18nhash = nil)
+      ::IsoDoc::MnRequirementsI18n.new(lang, script, i18nhash: i18nhash)
+    end
+
     # all roles that can be assigned to an example to make it a reqt,
     # across all models (because the model may not be an attribute but
     # embedded in the definition list). Mapped to obligation

data/lib/metanorma/requirements/version.rb

@@ -1,5 +1,5 @@
 module Metanorma
   class Requirements
-    VERSION = "0.0.2".freeze
-  end 
-end 
+    VERSION = "0.1.0".freeze
+  end
+end

data/mn-requirements.gemspec

@@ -25,7 +25,7 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = Gem::Requirement.new(">= 2.5.0")
 
   spec.add_dependency "isodoc-i18n", "~> 1.0.0"
-  spec.add_dependency "metanorma-utils", "~> 1.3.0"
+  spec.add_dependency "metanorma-utils", "~> 1.3.2"
 
   spec.add_development_dependency "debug"
   spec.add_development_dependency "equivalent-xml", "~> 0.6"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mn-requirements
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-08-23 00:00:00.000000000 Z
+date: 2022-08-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: isodoc-i18n
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.3.0
+        version: 1.3.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.3.0
+        version: 1.3.2
 - !ruby/object:Gem::Dependency
   name: debug
   requirement: !ruby/object:Gem::Requirement
@@ -227,6 +227,14 @@ files:
 - bin/console
 - bin/rspec
 - bin/setup
+- lib/isodoc-yaml/i18n-ar.yaml
+- lib/isodoc-yaml/i18n-de.yaml
+- lib/isodoc-yaml/i18n-en.yaml
+- lib/isodoc-yaml/i18n-es.yaml
+- lib/isodoc-yaml/i18n-fr.yaml
+- lib/isodoc-yaml/i18n-ru.yaml
+- lib/isodoc-yaml/i18n-zh-Hans.yaml
+- lib/isodoc/i18n.rb
 - lib/metanorma/default/cleanup.rb
 - lib/metanorma/default/default.rb
 - lib/metanorma/default/isodoc.rb
@@ -236,6 +244,7 @@ files:
 - lib/metanorma/modspec/isodoc.rb
 - lib/metanorma/modspec/modspec.rb
 - lib/metanorma/modspec/reqt_label.rb
+- lib/metanorma/modspec/validate.rb
 - lib/metanorma/modspec/xrefs.rb
 - lib/metanorma/requirements/selector.rb
 - lib/metanorma/requirements/version.rb