mn-requirements 0.0.1

data/lib/metanorma/modspec/cleanup.rb

@@ -0,0 +1,89 @@
+module Metanorma
+  class Requirements
+    class Modspec < Default
+      def requirement_type_cleanup(reqt)
+        reqt["type"] = case reqt["type"]
+                       when "requirement", "recommendation", "permission"
+                         "general"
+                       when "requirements_class" then "class"
+                       when "conformance_test" then "verification"
+                       when "conformance_class" then "conformanceclass"
+                       when "abstract_test" then "abstracttest"
+                       else reqt["type"]
+                       end
+      end
+
+      def requirement_metadata_component_tags
+        %w(test-purpose test-method test-method-type conditions part description
+           reference step requirement permission recommendation)
+      end
+
+      def requirement_metadata1(reqt, dlist, ins)
+        ins1 = super
+        dlist.xpath("./dt").each do |e|
+          tag = e&.text&.gsub(/ /, "-")&.downcase
+          next unless requirement_metadata_component_tags.include? tag
+
+          ins1.next = requirement_metadata1_component(e, tag)
+          ins1 = ins1.next
+        end
+      end
+
+      def requirement_metadata1_component(term, tag)
+        val = term.at("./following::dd")
+        val.name = tag
+        val.xpath("./dl").each do |d|
+          requirement_metadata1(val, d, d)
+          d.remove
+        end
+        if REQS.include?(term.text) && !val.text.empty?
+          val["label"] = val.text.strip
+          val.children.remove
+        end
+        val
+      end
+
+      # separate from default model requirement_metadata_cleanup,
+      # which extracts model:: ogc into reqt["model"]
+      def requirement_metadata_cleanup(reqt)
+        super
+        requirement_metadata_to_component(reqt)
+        requirement_metadata_to_requirement(reqt)
+        requirement_subparts_to_blocks(reqt)
+        requirement_target_identifiers(reqt)
+      end
+
+      def requirement_target_identifiers(reqt)
+        reqt.xpath("./classification[tag = 'target']/value[link]").each do |v|
+          v.children = v.at("./link/@target").text
+        end
+      end
+
+      def requirement_metadata_to_component(reqt)
+        reqt.xpath(".//test-method | .//test-purpose | .//conditions | "\
+                   ".//part | .//test-method-type | .//step | .//reference")
+          .each do |c|
+          c["class"] = c.name
+          c.name = "component"
+        end
+      end
+
+      def requirement_metadata_to_requirement(reqt)
+        reqt.xpath("./requirement | ./permission | ./recommendation")
+          .each do |c|
+          c["id"] = Metanorma::Utils::anchor_or_uuid
+          c["model"] = reqt["model"] # all requirements must have a model
+        end
+      end
+
+      def requirement_subparts_to_blocks(reqt)
+        reqt.xpath(".//component | .//description").each do |c|
+          next if %w(p ol ul dl table component description)
+            .include?(c&.elements&.first&.name)
+
+          c.children = "<p>#{c.children.to_xml}</p>"
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/modspec/isodoc.rb

@@ -0,0 +1,238 @@
+require_relative "xrefs"
+require_relative "reqt_label"
+
+module Metanorma
+  class Requirements
+    class Modspec < Default
+      def requirement_render1(node)
+        requirement_table_cleanup(super)
+      end
+
+      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["type"] = recommend_class(node)
+        recommendation_component_labels(node)
+        out
+      end
+
+      def recommendation_component_labels(node)
+        node.xpath(ns("./component[@class = 'part']")).each_with_index do |c, i|
+          c["label"] = (i + "A".ord).chr.to_s
+        end
+        node.xpath(ns("./component[not(@class = 'part')]")).each do |c|
+          c["label"] = recommend_component_label(c)
+        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")))
+        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
+        title = node.at(ns("./title"))
+        return unless title &&
+          node.ancestors("requirement, recommendation, permission").empty?
+
+        b << l10n(": ") if name
+        title.children.each { |n| b << n }
+      end
+
+      def recommendation_attributes(node, out)
+        ins = out.add_child("<tbody></tbody>").first
+        recommend_title(node, ins)
+        recommendation_attributes1(node).each do |i|
+          ins.add_child("<tr><td>#{i[0]}</td><td>#{i[1]}</td></tr>")
+        end
+        ins
+      end
+
+      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
+      end
+
+      def recommendation_attributes1(node)
+        ret = recommendation_attributes1_head(node, [])
+        node.xpath(ns("./classification")).each do |c|
+          line = recommendation_attr_keyvalue(c, "tag",
+                                              "value") and ret << line
+        end
+        ret
+      end
+
+      def recommendation_attributes1_head(node, head)
+        oblig = node["obligation"] and head << ["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 << [
+            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]
+        recommendation_attributes1_dependencies(node, head)
+      end
+
+      def recommendation_attributes1_dependencies(node, head)
+        node.xpath(ns("./inherit")).each do |i|
+          head << ["Dependency",
+                   recommendation_id(node.document, 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]
+        end
+        head
+      end
+
+      def recommendation_steps(node)
+        node.elements.each { |e| recommendation_steps(e) }
+        return node unless node.at(ns("./component[@class = 'step']"))
+
+        d = node.at(ns("./component[@class = 'step']"))
+        d = d.replace("<ol class='steps'><li>#{d.children.to_xml}</li></ol>")
+          .first
+        node.xpath(ns("./component[@class = 'step']")).each do |f|
+          f = f.replace("<li>#{f.children.to_xml}</li>").first
+          d << f
+        end
+        node
+      end
+
+      def recommendation_attributes1_component(node, out)
+        node = recommendation_steps(node)
+        out << "<tr><td>#{node['label']}</td><td>#{node.children}</td></tr>"
+        out
+      end
+
+      def recommendation_attr_keyvalue(node, key, value)
+        tag = node.at(ns("./#{key}"))
+        value = node.at(ns("./#{value}"))
+        (tag && value && !%w(target
+                             indirect-dependency).include?(tag.text)) or
+          return nil
+        [tag.text.capitalize, value.children]
+      end
+
+      def reqt_component_type(node)
+        klass = node.name
+        klass == "component" and klass = node["class"]
+        "requirement-#{klass}"
+      end
+
+      def preserve_in_nested_table?(node)
+        %w(recommendation requirement permission
+           table ol dl ul).include?(node.name)
+      end
+
+      def requirement_component_parse(node, out)
+        return out if node["exclude"] == "true"
+
+        node.elements.size == 1 && node.first_element_child.name == "dl" and
+          return reqt_dl(node.first_element_child, out)
+        node.name == "component" and
+          return recommendation_attributes1_component(node, out)
+        out.add_child("<tr><td colspan='2'></td></tr>").first
+          .at(ns(".//td")) <<
+          (preserve_in_nested_table?(node) ? node : node.children)
+        out
+      end
+
+      def reqt_dl(node, out)
+        node.xpath(ns("./dt")).each do |dt|
+          dd = dt.next_element
+          dd&.name == "dd" or next
+          out.add_child("<tr><td>#{dt.children.to_xml}</td>"\
+                        "<td>#{dd.children.to_xml}</td></tr>")
+        end
+        out
+      end
+
+      def requirement_table_cleanup(table)
+        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)
+        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"
+        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"
+        end
+      end
+
+      def recommend_class(node)
+        case node["type"]
+        when "verification", "abstracttest" then "recommendtest"
+        when "class", "conformanceclass" then "recommendclass"
+        else "recommend"
+        end
+      end
+
+      def recommend_name_class(node)
+        if %w(verification abstracttest).include?(node["type"])
+          "RecommendationTestTitle"
+        else "RecommendationTitle"
+        end
+      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
+      end
+    end
+  end
+end

data/lib/metanorma/modspec/modspec.rb

@@ -0,0 +1,9 @@
+require_relative "cleanup"
+require_relative "isodoc"
+
+module Metanorma
+  class Requirements
+    class Modspec < Default
+    end
+  end
+end

data/lib/metanorma/modspec/reqt_label.rb

@@ -0,0 +1,80 @@
+module Metanorma
+  class Requirements
+    class Modspec < Default
+      def recommendation_label(elem, type, xrefs)
+        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
+        else
+          type = recommendation_class_label(elem)
+          super
+        end
+      end
+
+      def reqtlabels(doc, label)
+        @reqtlabels ||= doc
+          .xpath(ns("//requirement | //recommendation | //permission"))
+          .each_with_object({}) do |r, m|
+            l = r.at(ns("./label"))&.text and m[l] = r["id"]
+          end
+        @reqtlabels[label]
+      end
+
+      # embedded reqts xref to top level reqts via label lookup
+      def inject_crossreference_reqt?(node, label)
+        !node.ancestors("requirement, recommendation, permission").empty? &&
+          reqtlabels(node.document, 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"]
+        else
+          case node.name
+          when "recommendation" then @labels["recommendation"]
+          when "requirement" then @labels["requirement"]
+          when "permission" then @labels["permission"]
+          end
+        end
+      end
+
+      def reqt_ids(docxml)
+        docxml.xpath(ns("//requirement | //recommendation | //permission"))
+          .each_with_object({}) do |r, m|
+            id = r.at(ns("./identifier")) or next
+            m[id.text] = r["id"]
+          end
+      end
+
+      def reqt_links(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
+
+            m[subj.text] = { lbl: id.text, id: r["id"] }
+          end
+      end
+
+      def recommendation_link(docxml, ident)
+        @reqt_links ||= reqt_links(docxml)
+        test = @reqt_links[ident&.strip] or return nil
+        "<xref target='#{test[:id]}'>#{test[:lbl]}</xref>"
+      end
+
+      def recommendation_id(docxml, ident)
+        @reqt_ids ||= reqt_ids(docxml)
+        test = @reqt_ids[ident&.strip] or return ident&.strip
+        "<xref target='#{test}'>#{ident.strip}</xref>"
+      end
+    end
+  end
+end

data/lib/metanorma/modspec/xrefs.rb

@@ -0,0 +1,66 @@
+module Metanorma
+  class Requirements
+    class Modspec < Default
+      def req_class_paths
+        [
+          { klass: "permissionclass", label: "permissionclass",
+            xpath: "permission[@type = 'class']" },
+          { klass: "requirementclass", label: "requirementclass",
+            xpath: "requirement[@type = 'class']" },
+          { klass: "recommendationclass", label: "recommendationclass",
+            xpath: "recommendation[@type = 'class']" },
+          { klass: "permissiontest", label: "permissiontest",
+            xpath: "permission[@type = 'verification']" },
+          { klass: "recommendationtest", label: "recommendationtest",
+            xpath: "recommendation[@type = 'verification']" },
+          { klass: "requirementtest", label: "requirementtest",
+            xpath: "requirement[@type = 'verification']" },
+          { klass: "abstracttest", label: "abstracttest",
+            xpath: "permission[@type = 'abstracttest']" },
+          { klass: "abstracttest", label: "abstracttest",
+            xpath: "requirement[@type = 'abstracttest']" },
+          { klass: "abstracttest", label: "abstracttest",
+            xpath: "recommendation[@type = 'abstracttest']" },
+          { klass: "conformanceclass", label: "conformanceclass",
+            xpath: "permission[@type = 'conformanceclass']" },
+          { klass: "conformanceclass", label: "conformanceclass",
+            xpath: "requirement[@type = 'conformanceclass']" },
+          { klass: "conformanceclass", label: "conformanceclass",
+            xpath: "recommendation[@type = 'conformanceclass']" },
+          { klass: "permission", label: "permission",
+            xpath: "permission[not(@type = 'verification' or @type = 'class' "\
+                   "or @type = 'abstracttest' or @type = 'conformanceclass')]" },
+          { klass: "recommendation", label: "recommendation",
+            xpath: "recommendation[not(@type = 'verification' or "\
+                   "@type = 'class' or @type = 'abstracttest' or "\
+                   "@type = 'conformanceclass')]" },
+          { klass: "requirement", label: "requirement",
+            xpath: "requirement[not(@type = 'verification' or @type = 'class' "\
+                   "or @type = 'abstracttest' or @type = 'conformanceclass')]" },
+        ]
+      end
+
+      def req_nested_class_paths
+        req_class_paths
+      end
+
+      def permission_parts(block, block_id, label, klass)
+        block.xpath(ns("./component[@class = 'part']"))
+          .each_with_index.with_object([]) do |(c, i), m|
+          next if c["id"].nil? || c["id"].empty?
+
+          m << { id: c["id"], number: l10n("#{block_id} #{(i + 'A'.ord).chr}"),
+                 elem: c, label: label, klass: klass }
+        end
+      end
+
+      def postprocess_anchor_struct(block, anchor)
+        super
+        if l = block.at(ns("./identifier"))&.text
+          anchor[:xref] += l10n(": ") + "<tt>#{l}</tt>"
+        end
+        anchor
+      end
+    end
+  end
+end

data/lib/metanorma/requirements/selector.rb

@@ -0,0 +1,94 @@
+require_relative "../default/default"
+require_relative "../modspec/modspec"
+require "isodoc-i18n"
+
+module Metanorma
+  class Requirements
+    attr_accessor :i18n, :labels
+
+    def initialize(options)
+      @default = options[:default]
+      @i18n = ::IsoDoc::I18n.new(options[:lang] || "en",
+                                 options[:script] || "Latn")
+      @labels = options[:labels]
+      @models = {}
+      model_names.each { |k| @models[k] = create(k) }
+    end
+
+    def model_names
+      %i[default ogc]
+    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
+    # TODO may need to make it conditional on model
+    def requirement_roles
+      {
+        recommendation: "recommendation",
+        requirement: "requirement",
+        permission: "permission",
+        requirements_class: "requirement",
+        conformance_test: "requirement",
+        conformance_class: "requirement",
+        abstract_test: "requirement",
+      }
+    end
+
+    def create(type)
+      case type
+      when :modspec, :ogc
+        Metanorma::Requirements::Modspec.new(parent: self)
+      else Metanorma::Requirements::Default.new(parent: self)
+      end
+    end
+
+    def model(type)
+      @models[type&.to_sym] || @models[@default]
+    end
+
+    REQRECPER = "//requirement | //recommendation | //permission".freeze
+
+    # all cleanup steps by all possible models are included here, and each model
+    # can skip a given step. This class iterates through the entire document,
+    # and picks the model for each requirement; then that model's method is
+    # applied to that particular requirement instance
+    def requirement_cleanup(xmldoc)
+      requirement_metadata_cleanup(xmldoc)
+      requirement_type_cleanup(xmldoc)
+      requirement_inherit_cleanup(xmldoc)
+      requirement_descriptions_cleanup(xmldoc)
+      requirement_identifier_cleanup(xmldoc)
+    end
+
+    def requirement_type_cleanup(xmldoc)
+      xmldoc.xpath(REQRECPER).each do |r|
+        model(r["model"]).requirement_type_cleanup(r)
+      end
+    end
+
+    def requirement_metadata_cleanup(xmldoc)
+      xmldoc.xpath(REQRECPER).each do |r|
+        model(r["model"]).requirement_metadata_cleanup(r)
+      end
+    end
+
+    def requirement_inherit_cleanup(xmldoc)
+      xmldoc.xpath(REQRECPER).each do |r|
+        model(r["model"]).requirement_inherit_cleanup(r)
+      end
+    end
+
+    def requirement_descriptions_cleanup(xmldoc)
+      xmldoc.xpath(REQRECPER).each do |r|
+        model(r["model"]).requirement_descriptions_cleanup(r)
+      end
+    end
+
+    def requirement_identifier_cleanup(xmldoc)
+      xmldoc.xpath(REQRECPER).each do |r|
+        model(r["model"]).requirement_identifier_cleanup(r)
+      end
+    end
+  end
+end

data/lib/metanorma/requirements/version.rb

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

data/lib/mn-requirements.rb

@@ -0,0 +1,2 @@
+require_relative "metanorma/requirements/selector"
+require_relative "metanorma/requirements/version"

data/mn-requirements.gemspec

@@ -0,0 +1,42 @@
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "metanorma/requirements/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "mn-requirements"
+  spec.version       = Metanorma::Requirements::VERSION
+  spec.authors       = ["Ribose Inc."]
+  spec.email         = ["open.source@ribose.com"]
+
+  spec.summary       = "Requirements processing and rendering according to different models"
+  spec.description   = <<~DESCRIPTION
+    Requirements processing and rendering according to different models
+  DESCRIPTION
+
+  spec.homepage      = "https://github.com/metanorma/mn-requirements"
+  spec.license       = "BSD-2-Clause"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  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_development_dependency "debug"
+  spec.add_development_dependency "equivalent-xml", "~> 0.6"
+  spec.add_development_dependency "guard", "~> 2.14"
+  spec.add_development_dependency "guard-rspec", "~> 4.7"
+  spec.add_development_dependency "isodoc", "~> 2"
+  spec.add_development_dependency "metanorma-standoc", "~> 2"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rspec", "~> 3.6"
+  spec.add_development_dependency "rubocop", "~> 1.5.2"
+  spec.add_development_dependency "sassc", "2.4.0"
+  spec.add_development_dependency "simplecov", "~> 0.15"
+  spec.add_development_dependency "timecop", "~> 0.9"
+end