mn-requirements 0.4.3 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a12dad7f5d6cb715ade06167544dc2966581c8b9692b4d67de71664ddf401f23
-  data.tar.gz: 04cff2ddfd3116155014720376fbcf98c2d88bece77a12c748cd0726814d4c2e
+  metadata.gz: 5d557ae4ed71baabb926e12c579a4c1e07f14f0573caacd8cea6b3f2be33057b
+  data.tar.gz: 0f2f09d925e1fbe06fbe782545d21823a34f687345b0993aa0e27c2c27436e1e
 SHA512:
-  metadata.gz: dfc9ce13b9304cd254e0d2f941f04d48607041922aa0333417f57d61867495c4c486c2f2be459cbb46de52509a46e0f5b8f5460c6319310ee166864e2aac7797
-  data.tar.gz: f7a0989cc2212bc9186acf262a75bac6712bb9e7bdc7ae0d5c417446bce63f40dc7c8af9568b144a59a95914a0ff82f116af49586c75887697b079f7afa386a5
+  metadata.gz: ee8c23fab75c8bfbfb679942af6053898eb1aa4f0c365fdc7244e6eb39541b05e59b1afa668628d9f6d4a4cb51e61e0d0059446640265717695dbbf61635c29d
+  data.tar.gz: 4e84dae849f84ab1392e3f25e571e3c0ff8a6328c885b468e834eec9e287e158a72bc4e59c98effe38eeff86e5185f64b04886436c53fe1e81760cabb52ee8a1

data/lib/metanorma/default/isodoc.rb

@@ -5,12 +5,42 @@ module Metanorma
         @i18n.l10n(text)
       end
 
+      # TODO: move to metanorma-utils
+def semx_fmt_dup(elem)
+      elem["id"] ||= "_#{UUIDTools::UUID.random_create}"
+      new = Nokogiri::XML(<<~XML).root
+        <semx xmlns='#{elem.namespace.href}' element='#{elem.name}' source='#{elem['original-id'] || elem['id']}'>#{to_xml(elem.children)}</semx>
+      XML
+      strip_duplicate_ids(nil, elem, new)
+      new
+    end
+
+    def gather_all_ids(elem)
+      elem.xpath(".//*[@id]").each_with_object([]) do |i, m|
+        m << i["id"]
+      end
+    end
+
+    # remove ids duplicated between sem_title and pres_title
+    # index terms are assumed transferred to pres_title from sem_title
+    def strip_duplicate_ids(_node, sem_title, pres_title)
+      sem_title && pres_title or return
+      ids = gather_all_ids(pres_title)
+      sem_title.xpath(".//*[@id]").each do |x|
+        ids.include?(x["id"]) or next
+        x["original-id"] = x["id"]
+        x.delete("id")
+      end
+      sem_title.xpath(ns(".//index")).each(&:remove)
+    end
+
       def recommendation_label(elem, type, xrefs)
         label, title = recommendation_labels(elem)
         type = "<span class='fmt-element-name'>#{type}</span>"
         num = xrefs.anchor(elem["id"], :label, false)
         num &&= "<semx element='autonum' source='#{elem['id']}'>#{num}</semx>"
-        ret = "#{type} #{num}".strip
+        ret = num
+        /<span class='fmt-element-name'>/.match?(ret) or ret = "#{type} #{num}".strip
         label || title and
           ret += recommendation_label_add(elem, label, title)
         ret
@@ -36,13 +66,22 @@ module Metanorma
       end
 
       def requirement_render1(node)
-        out = recommendation_base(node, node.name)
+        out = recommendation_base(node, "fmt-provision")
         ins = recommendation_header(node, out)
         ins = recommendation_attributes(node, ins)
         node.elements.reject do |n|
           reqt_metadata_node?(n)
         end.each { |n| ins = requirement_component_parse(n, ins) }
-        out
+        requirement_presentation(node, out)
+      end
+
+      def requirement_presentation(node, out)
+        out.default_namespace = node.namespace.href
+        node.xpath(ns("./*//fmt-name | ./*//fmt-xref-label")).each(&:remove)
+        node.xpath(ns(".//fmt-sourcecode")).each(&:remove)
+        ret = node.dup
+        ret << out
+        ret
       end
 
       def recommendation_header(_node, out)
@@ -54,15 +93,13 @@ module Metanorma
         node.attributes.each do |k, v|
           out[k] = v
         end
-        n = node.at(ns("./fmt-name")) and out << n
-        n = node.at(ns("./fmt-xref-label")) and out << n
         out
       end
 
       def recommendation_labels(node)
         [node.at(ns("./identifier")), node.at(ns("./title"))]
           .map do |n|
-          to_xml(n&.children)
+           to_xml(n&.children)
         end
       end
 
@@ -70,7 +107,8 @@ module Metanorma
         oblig = node["obligation"] and
           out << l10n("#{@labels['default']['obligation']}: #{oblig}")
         node.xpath(ns("./subject")).each do |subj|
-          out << l10n("#{@labels['default']['subject']}: #{subj.text}")
+          #out << l10n("#{@labels['default']['subject']}: #{subj.text}")
+          out << l10n("#{@labels['default']['subject']}: #{to_xml(semx_fmt_dup(subj))}")
         end
         node.xpath(ns("./inherit")).each do |i|
           out << recommendation_attr_parse(i, @labels["default"]["inherits"])
@@ -82,14 +120,16 @@ module Metanorma
       end
 
       def recommendation_attr_parse(node, label)
-        l10n("#{label}: #{to_xml(node.children)}")
+        #l10n("#{label}: #{to_xml(node.children)}")
+        l10n("#{label}: #{to_xml(semx_fmt_dup(node))}")
       end
 
       def recommendation_attr_keyvalue(node, key, value)
         tag = node.at(ns("./#{key}")) or return nil
         value = node.at(ns("./#{value}")) or return nil
-        l10n("#{Metanorma::Utils.strict_capitalize_first tag.text}: " \
-             "#{to_xml(value.children)}")
+        lbl = semx_fmt_dup(tag)
+        lbl.children = Metanorma::Utils.strict_capitalize_first(lbl.text)
+        l10n("#{to_xml(lbl)}: #{to_xml(semx_fmt_dup(value))}")
       end
 
       def recommendation_attributes(node, out)
@@ -108,29 +148,37 @@ module Metanorma
 
       def requirement_component_parse(node, out)
         node["exclude"] == "true" and return out
-        ret = node.dup
-        if reqt_subpart?(node.name)
-          ret["type"] = reqt_component_type(node)
-          ret.name = "div"
-        end
-        descr_classif_render(ret)
-        out << ret
+        reqt_subpart?(node.name) and type = reqt_component_type(node)
+        ret = semx_fmt_dup(node)
+        descr_classif_render(node, ret)
+        t = copy_style_attributes(node)
+        type and t += " type='#{type}'"
+        out << "<div#{t}>#{to_xml(ret)}</div>"
         out
       end
 
-      def descr_classif_render(reqt)
-        reqt.at(ns("./classification")) or return
+      def copy_style_attributes(node)
+        t = ""
+        %w(style keep-with-next keep-lines-together).each do |x|
+          node[x] and t += " #{x}='#{node[x]}'"
+        end
+        t
+      end
+
+      def descr_classif_render(node, reqt)
+        c = reqt.xpath(ns("./classification"))
+        c.empty? and return
         ins = reqt.at(ns("./classification")).before("<dl/>").previous
-        descr_classif_extract(reqt, ins)
+        descr_classif_extract(node, ins)
+        c.each(&:remove)
       end
 
       def descr_classif_extract(desc, ins)
         dlist = desc.xpath(ns("./classification"))
         dlist.each do |x|
-          x.at(ns("./tag")).name = "dt"
-          x.at(ns("./value")).name = "dd"
-          ins << x.children
-          x.remove
+          dt = semx_fmt_dup(x.at(ns("./tag")))
+          dd = semx_fmt_dup(x.at(ns("./value")))
+          ins << "<dt>#{to_xml dt}</dt><dd>#{to_xml dd}</dd>"
         end
       end
     end

data/lib/metanorma/modspec/isodoc.rb

@@ -9,16 +9,25 @@ module Metanorma
         init_lookups(node.document)
         ret = requirement_guidance_parse(node, super)
         out = requirement_table_cleanup(node, ret)
-        out["class"] = "modspec" # deferred; node["class"] is labelling class
+        truncate_id_base_fmtxreflabel(out)
         out
       end
 
+      def requirement_presentation(node, out)
+        ret = node.document.create_element("fmt-provision")
+        ret << out
+        out = ret
+        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
+        node["original-id"] = node["id"]
+        node.delete("id")
         out["type"] = recommend_class(node)
         recommendation_component_labels(node)
         out
@@ -34,7 +43,7 @@ module Metanorma
       end
 
       def recommendation_header(reqt, out)
-        n = reqt.at(ns("./fmt-name"))
+        n = to_xml(reqt.at(ns("./fmt-name")))&.strip
         x = if reqt.ancestors("requirement, recommendation, permission").empty?
               <<~THEAD
                 <thead><tr><th scope='colgroup' colspan='2'><p class='#{recommend_name_class(reqt)}'>#{n}</p></th></tr></thead>
@@ -47,20 +56,6 @@ module Metanorma
         out
       end
 
-=begin
-      def recommendation_name(node, _out)
-        ret = ""
-        name = node.at(ns("./fmt-name")) and ret += name.children.to_xml
-        title = node.at(ns("./fmt-title"))
-        return ret unless title &&
-          node.ancestors("requirement, recommendation, permission").empty?
-
-        ret += ": " unless !name || name.text.empty?
-        ret += title.children.to_xml
-        l10n(ret)
-      end
-=end
-
       def recommendation_label_add(elem, _label, title)
         title or return ""
         r = recommendation_label_caption_delim
@@ -92,7 +87,7 @@ module Metanorma
         label = node.at(ns("./identifier")) or return
         ret = <<~OUTPUT
           <tr><th>#{@labels['modspec']['identifier']}</th>
-          <td><tt><modspec-ident>#{to_xml(label.children)}</modspec-ident></tt></td>
+          <td><tt><modspec-ident>#{to_xml(semx_fmt_dup(label))}</modspec-ident></tt></td>
         OUTPUT
         out.add_child(ret)
       end
@@ -100,8 +95,8 @@ module Metanorma
       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
+          line = recommendation_attr_keyvalue(c, "tag", "value") and
+            ret << line
         end
         ret
       end
@@ -109,8 +104,8 @@ module Metanorma
       def recommendation_attributes1_head(node, head)
         oblig = node["obligation"] and
           head << [@labels["default"]["obligation"], oblig]
-        subj = node.at(ns("./subject"))&.children and
-          head << [rec_subj(node), subj]
+        subj = node.at(ns("./subject")) and
+          head << [rec_subj(node), semx_fmt_dup(subj)]
         head = recommendation_attributes1_target(node, head)
         head += recommendation_backlinks(node)
         recommendation_attributes1_dependencies(node, head)
@@ -119,7 +114,7 @@ module Metanorma
       def recommendation_attributes1_target(node, head)
         node.xpath(ns("./classification[tag][value]")).each do |c|
           c.at(ns("./tag")).text.casecmp("target").zero? or next
-          xref = recommendation_id(c.at(ns("./value")).text) and
+          xref = recommendation_id(semx_fmt_dup(c.at(ns("./value")))) and
             head << [rec_target(node), xref]
         end
         head
@@ -140,7 +135,7 @@ module Metanorma
       def recommendation_attributes1_inherit(node, head)
         node.xpath(ns("./inherit")).each do |i|
           head << [@labels["modspec"]["dependency"],
-                   recommendation_id(to_xml(i.children))]
+                   recommendation_id(semx_fmt_dup(i))]
         end
         head
       end
@@ -149,7 +144,7 @@ module Metanorma
         %w(indirect-dependency implements).each do |x|
           node.xpath(ns("./classification[tag][value]")).each do |c|
             c.at(ns("./tag")).text.casecmp(x).zero? or next
-            xref = recommendation_id(to_xml(c.at(ns("./value")).children)) and
+            xref = recommendation_id(semx_fmt_dup(c.at(ns("./value")))) and
               head << [@labels["modspec"][x.delete("-")], xref]
           end
         end
@@ -157,94 +152,167 @@ module Metanorma
       end
 
       def id_attr(node)
-        node["id"] ? " id='#{node['id']}'" : ""
+        id = node["id"] || node["original-id"]
+        id ? " id='#{id}'" : ""
       end
 
-      def recommendation_steps(node)
+      # KILL
+      def recommendation_stepsX(node)
         node.elements.each { |e| recommendation_steps(e) }
-        return node unless node.at(ns("./component[@class = 'step']"))
-
+        node.at(ns("./component[@class = 'step']")) or return node
         d = node.at(ns("./component[@class = 'step']"))
         d = d.replace("<ol class='steps'><li#{id_attr(d)}>" \
-                      "#{to_xml(d.children)}</li></ol>").first
+        "#{to_xml(d.children)}</li></ol>").first
         node.xpath(ns("./component[@class = 'step']")).each do |f|
           f = f.replace("<li#{id_attr(f)}>#{to_xml(f.children)}</li>").first
           d << f
         end
-        node
+          node
       end
 
-      def recommendation_attributes1_component(node, out)
-        return out if node["class"] == "guidance"
 
-        node = recommendation_steps(node)
-        out << "<tr#{id_attr(node)}><th>#{node['label']}</th>" \
-               "<td>#{node.children}</td></tr>"
-        out
-      end
+        def recommendation_steps(node, ret)
+          ret.elements.each_with_index do |e, i|
+            e1 = nil
+            #require "debug"; e.name == "component" && e["class"] == "step" and binding.b
+            e.name == "component" && e["class"] == "step" and
+              e1 = e.replace(semx_fmt_dup(node.elements[i]))
+            #require "debug"; e.name == "component" && e["class"] == "step" and binding.b
+            recommendation_steps(node.elements[i], e1 || e)
+          end
+          node.name == "component" && node["class"] == "step" and ret["inlist"] = "true"
+          #require "debug"; node.name == "component" && node["class"] == "step" and binding.b
+          d = ret.at(ns("./semx[@inlist]")) or return ret
+          d.delete("inlist")
+          d = d.replace("<ol class='steps'><li#{id_attr(d)}>" \
+                        "#{to_xml(d)}</li></ol>").first
+          ret.xpath(ns("./semx[@inlist]")).each do |f|
+            f.delete("inlist")
+            f = f.replace("<li#{id_attr(f)}>#{to_xml(f)}</li>").first
+            d << f
+          end
+          ret
+        end
 
-      def recommendation_attr_keyvalue(node, key, value)
-        tag = node.at(ns("./#{key}")) or return nil
-        value = node.at(ns("./#{value}")) or return nil
-        !%w(target indirect-dependency identifier-base
+        def recommendation_attributes1_component(node, ret, out)
+          node["class"] == "guidance" and return out
+          ret = recommendation_steps(node, ret)
+          out << "<tr#{id_attr(node)}><th>#{node['label']}</th>" \
+            "<td>#{to_xml(ret)}</td></tr>"
+          node.delete("label") # inserted in recommendation_component_labels
+          out
+        end
+
+        def recommendation_attr_keyvalue(node, key, value)
+          tag = node.at(ns("./#{key}")) or return nil
+          value = node.at(ns("./#{value}")) or return nil
+          !%w(target indirect-dependency identifier-base
             implements).include?(tag.text.downcase) or
-          return nil
-        [Metanorma::Utils.strict_capitalize_first(tag.text), value.children]
-      end
+            return nil
+            lbl = semx_fmt_dup(tag)
+            lbl.children = Metanorma::Utils.strict_capitalize_first(lbl.text)
+            [to_xml(lbl), semx_fmt_dup(value)]
+        end
 
-      def reqt_component_type(node)
-        klass = node.name
-        klass == "component" and klass = node["class"]
-        "requirement-#{klass}"
-      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
+        # KILL
+        def preserve_in_nested_table?(node)
+          %w(recommendation requirement permission
            table ol dl ul).include?(node.name)
-      end
+        end
 
-      def requirement_component_parse(node, out)
-        node["exclude"] == "true" and return out
-        descr_classif_render(node)
-        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)
-        node.name == "description" and
-          return requirement_description_parse(node, out)
-        out.add_child("<tr#{id_attr(node)}><td colspan='2'></td></tr>").first
-          .at(ns(".//td")) <<
-          (preserve_in_nested_table?(node) ? node : node.children)
-        out
-      end
+        # KILL
+        def requirement_component_parse(node, out)
+          node["exclude"] == "true" and return out
+          ret = semx_fmt_dup(node)
+          descr_classif_render(node, ret)
+          ret.elements.size == 1 && ret.first_element_child.name == "dl" and
+            return reqt_dl(ret.first_element_child, out)
+          node.name == "component" and
+            return recommendation_attributes1_component(node, ret, out)
+          node.name == "description" and
+            return requirement_description_parse(node, ret, out)
+          id = node["id"] || node["original-id"]
+          !preserve_in_nested_table?(node) && id and attr = " id='#{id}'"
+          out.add_child("<tr#{id_attr(node)}><td colspan='2'#{attr}></td></tr>").first
+            .at(ns(".//td")) <<
+          (preserve_in_nested_table?(node) ? node.dup : ret)
+          out
+        end
 
-      def requirement_description_parse(node, out)
-        lbl = "description"
-        recommend_class(node.parent) == "recommend" and
-          lbl = "statement"
-        out << "<tr><th>#{@labels['modspec'][lbl]}</th>" \
-               "<td>#{to_xml(node.children)}</td></tr>"
-        out
-      end
+          def preserve_in_nested_table?(node)
+          #%w(recommendation requirement permission table ol dl ul hr br p).include?(node.name)
+          !%w(subject inherit identifier measurement-target specification verification import description component).include?(node.name)
+        end
 
-      def requirement_guidance_parse(node, out)
-        ins = out.at(ns("./tbody"))
-        node.xpath(ns("./component[@class = 'guidance']")).each do |f|
-          ins << "<tr#{id_attr(f)}><th>#{@labels['modspec']['guidance']}</th>" \
-                 "<td>#{f.children}</td></tr>"
+         def requirement_component_parse(node, out)
+          node["exclude"] == "true" and return out
+          ret = semx_fmt_dup(node)
+          descr_classif_render(node, ret)
+          id = node["id"] || node["original-id"]
+          id and attr = " id='#{id}'"
+          preserve = preserve_in_nested_table?(node)
+          if id == node["id"]
+            if node["original-id"]
+              attr = " id='#{node["original-id"]}'"
+            else
+            node["original-id"] = node["id"]
+            end
+            node.delete("id")
+          end
+          if preserve
+            n = Nokogiri::XML::Node.new(node.name, node.document)
+            node.attributes.each { |k, v| n[k] = v }
+            node.children.empty? or n << ret
+            ret = n
+          end
+          ret.elements.size == 1 && ret.first_element_child.name == "dl" and
+            return reqt_dl(ret.first_element_child, out)
+          node.name == "component" and
+            return recommendation_attributes1_component(node, ret, out)
+          node.name == "description" and
+            return requirement_description_parse(node, ret, out)
+          #!preserve_in_nested_table?(node) && id and attr = " id='#{id}'"
+          out.add_child("<tr#{attr}><td colspan='2'></td></tr>").first
+            .at(ns(".//td")) << (%(permission requirement recommendation).include?(node.name) ? node.dup : ret)
+          #(preserve_in_nested_table?(node) ? node.dup : ret)
+          out
         end
-        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><th>#{to_xml(dt.children)}</th>" \
-                        "<td>#{to_xml(dd.children)}</td></tr>")
+        def requirement_description_parse(node, ret, out)
+          lbl = "description"
+          recommend_class(node.parent) == "recommend" and
+            lbl = "statement"
+          out << "<tr><th>#{@labels['modspec'][lbl]}</th>" \
+            "<td>#{to_xml(ret)}</td></tr>"
+          out
+        end
+
+        def requirement_guidance_parse(node, out)
+          ins = out.at(ns("./fmt-provision/table/tbody"))
+          origs = node.xpath(ns("./component[@class = 'guidance']"))
+          out.xpath(ns("./component[@class = 'guidance']")).each_with_index do |f, i|
+            f.delete("label")
+            ins << "<tr#{id_attr(f)}><th>#{@labels['modspec']['guidance']}</th>" \
+              "<td>#{to_xml(semx_fmt_dup(origs[i]))}</td></tr>"
+          end
+          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><th>#{to_xml(dt.children)}</th>" \
+                          "<td>#{to_xml(dd.children)}</td></tr>")
+          end
+          out
         end
-        out
       end
     end
   end
-end

data/lib/metanorma/modspec/reqt_label.rb

@@ -162,7 +162,8 @@ module Metanorma
       end
 
       def recommendation_id(ident)
-        test = @reqt_ids[ident&.strip] or return ident&.strip
+        id = to_xml(ident.children)
+        test = @reqt_ids[id&.strip] or return to_xml(ident)
         #require "debug"; binding.b if test.include?("<xref")
         #"<xref target='#{test[:id]}'>#{test[:lbl]}</xref>"
         test[:lbl]
@@ -189,11 +190,33 @@ module Metanorma
         (docxml.xpath(ns("//xref[@style = 'id']")) - docxml
           .xpath(ns("//requirement//xref | //permission//xref | " \
                     "//recommendation//xref"))).each do |x|
-          @reqt_id_base[x["target"]] or next # is a modspec requirement
-          x.children = to_xml(x.children).delete_prefix(@modspecidentifierbase)
+                      @reqt_id_base[x["target"]] or next # is a modspec requirement
+                      truncate_id_base_outside_reqts1(x, @modspecidentifierbase)
         end
       end
 
+      def truncate_id_base_fmtxreflabel(node)
+        f = node.at(ns("./fmt-xref-label")) or return
+        x = f.at(ns(".//xref[@style = 'id']")) or return
+        if @reqt_id_base[x["target"]] && @modspecidentifierbase
+          f.next = f.dup
+          x = f.next_element.at(ns(".//xref[@style = 'id']"))
+          f.next_element["container"] = 'modspec-provision'
+          truncate_id_base_outside_reqts1(x, @modspecidentifierbase)
+        end
+        if base = @reqt_id_base[node["original-id"] || node["id"]]
+          f.next = f.dup
+          x = f.next_element.at(ns(".//xref[@style = 'id']"))
+          f["container"] = node["original-id"] || node["id"]
+          truncate_id_base_outside_reqts1(x, base)
+        end
+      end
+
+      def truncate_id_base_outside_reqts1(xref, base)
+        xref = xref.at(ns("./semx")) || xref
+        xref.children = to_xml(xref.children).delete_prefix(base)
+      end
+
       def rec_subj(node)
         case node["type"]
         when "class" then @labels["modspec"]["targettype"]

data/lib/metanorma/modspec/table_cleanup.rb

@@ -3,20 +3,24 @@ require "uri"
 module Metanorma
   class Requirements
     class Modspec < Default
-      def requirement_table_cleanup(node, table)
-        table = requirement_table_nested_cleanup(node, table)
+      def requirement_table_cleanup(node, out)
+        table = out.at(ns("./fmt-provision/table"))
+        table = requirement_table_nested_cleanup(node, out, table)
         requirement_table_consec_rows_cleanup(node, table)
         node.ancestors("requirement, recommendation, permission").empty? and
           truncate_id_base_in_reqt(table)
         cell2link(table)
-        table
+        table["class"] = "modspec" # deferred; node["class"] is labelling class
+        out.xpath(ns("./fmt-name | ./fmt-identifier")).each(&:remove)
+        out
       end
 
       def cell2link(table)
         table.xpath(ns(".//td")).each do |td|
-          td.elements.empty? or next
+          td.elements.empty? ||
+            (td.elements.size == 1 && td.elements.first.name == "semx") or next
           uri?(td.text.strip) or next
-          td.children = "<link target='#{td.text.strip}'/>"
+          td.children = "<link target='#{td.text.strip}'>#{to_xml(td.children)}</link>"
         end
       end
 
@@ -43,24 +47,35 @@ module Metanorma
 
       def conflate_table_rows(trow)
         th = trow.at(ns("./th"))
-        hdr = th.text
-        th.children = @i18n.inflect(hdr, number: "pl")
+        hdr = plural_table_row_hdr(th)
         td = th.next_element
-        res = [to_xml(td.children)]
+        id = td["id"] ? "<bookmark id='#{td['id']}'/>" : ""
+        td.delete("id")
+        res = [id + to_xml(td.children).strip]
         res += gather_consec_table_rows(trow, hdr)
         td.children = res.join("<br/>")
       end
 
+      def plural_table_row_hdr(thdr)
+        th1 = thdr.at(ns("./semx")) || thdr
+        hdr = th1.text
+        th1.children = @i18n.inflect(hdr, number: "pl")
+        hdr
+      end
+
       def gather_consec_table_rows(trow, hdr)
         ret = []
         trow.xpath("./following-sibling::xmlns:tr").each do |r|
-          r.at(ns("./th[text() = '#{hdr}']")) or break
-          ret << to_xml(r.remove.at(ns("./td")).children)
+          r.at(ns("./th"))&.text&.strip == hdr or break
+          td = r.remove.at(ns("./td"))
+          id = td["id"] ? "<bookmark id='#{td['id']}'/>" : ""
+          ret << id + to_xml(td.children).strip
         end
         ret
       end
 
-      def requirement_table_nested_cleanup(node, table)
+      # KILL
+      def requirement_table_nested_cleanup(node, out, table)
         table.xpath(ns("./tbody/tr/td/table")).each do |t|
           x = t.at(ns("./thead/tr")) or next
           x.at(ns("./th")).children =
@@ -72,6 +87,25 @@ module Metanorma
         table
       end
 
+      def requirement_table_nested_cleanup(node, out, table)
+        table.xpath(ns("./tbody/tr/td/*/fmt-provision/table")).each do |t|
+          x = t.at(ns("./thead/tr")) or next
+          x.at(ns("./th")).children =
+            requirement_table_nested_cleanup_hdr(node)
+          f = x.at(ns("./td/fmt-name")) and
+            f.parent.children = to_xml(f.children).strip
+          td = x.at(ns("./td"))
+          td["id"] = t["original-id"] || t["id"]
+          if desc = t.at(ns("./tbody/tr/td/semx[@element = 'description']"))
+            p = desc.at(ns("./p")) and p.replace(p.children)
+td << " #{to_xml(desc)}"
+          end
+          t.parent.parent.parent.parent.replace(x)
+        end
+        out.xpath(ns("./*/fmt-provision")).each(&:remove)
+        table
+      end
+
       def requirement_table_nested_cleanup_hdr(node)
         label = "provision"
         node["type"] == "conformanceclass" and label = "conformancetest"
@@ -86,10 +120,13 @@ module Metanorma
       def truncate_id_base_in_reqt1(table, base)
         table.xpath(ns(".//xref[@style = 'id']")).each do |x|
           @reqt_id_base[x["target"]] or next # is a modspec requirement
+          n = x.at(ns("./semx")) and x = n
           x.children = strip_id_base(x, base)
         end
         table.xpath(ns(".//modspec-ident")).each do |x|
-          x.replace(strip_id_base(x, base))
+          n = x.at(ns("./semx")) || x
+          n.children = strip_id_base(n, base)
+          n != x and x.replace(n)
         end
       end
 

data/lib/metanorma/modspec/xrefs.rb

@@ -74,7 +74,7 @@ module Metanorma
         anchor[:xref_bare] = anchor[:xref]
         l = block.at(ns("./identifier")) and
           anchor[:xref] += l10n(": ") +
-            "<tt><xref style='id' target='#{block['id']}'>#{l.text}</xref></tt>"
+            "<tt><xref style='id' target='#{block['id']}'>#{to_xml semx_fmt_dup(l)}</xref></tt>"
         anchor[:modspec] = anchor[:xref]
         anchor
       end

data/lib/metanorma/requirements/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mn-requirements
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.5.1
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-01-06 00:00:00.000000000 Z
+date: 2025-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: isodoc-i18n