metanorma-ietf 2.4.1 → 2.5.0

data/lib/isodoc/ietf/inline.rb

@@ -1,167 +1,170 @@
 require "mathml2asciimath"
 
-module IsoDoc::Ietf
-  class RfcConvert < ::IsoDoc::Convert
-    def em_parse(node, out)
-      out.em do |e|
-        node.children.each { |n| parse(n, e) }
+module IsoDoc
+  module Ietf
+    class RfcConvert < ::IsoDoc::Convert
+      def em_parse(node, out)
+        out.em do |e|
+          node.children.each { |n| parse(n, e) }
+        end
       end
-    end
 
-    def sup_parse(node, out)
-      out.sup do |e|
-        node.children.each { |n| parse(n, e) }
+      def sup_parse(node, out)
+        out.sup do |e|
+          node.children.each { |n| parse(n, e) }
+        end
       end
-    end
 
-    def sub_parse(node, out)
-      out.sub do |e|
-        node.children.each { |n| parse(n, e) }
+      def sub_parse(node, out)
+        out.sub do |e|
+          node.children.each { |n| parse(n, e) }
+        end
       end
-    end
 
-    def tt_parse(node, out)
-      out.tt do |e|
-        node.children.each { |n| parse(n, e) }
+      def tt_parse(node, out)
+        out.tt do |e|
+          node.children.each { |n| parse(n, e) }
+        end
       end
-    end
 
-    def strong_parse(node, out)
-      out.strong do |e|
-        node.children.each { |n| parse(n, e) }
+      def strong_parse(node, out)
+        out.strong do |e|
+          node.children.each { |n| parse(n, e) }
+        end
       end
-    end
 
-    def bcp14_parse(node, out)
-      out.bcp14 do |e|
-        node.children.each { |n| parse(n, e) }
+      def bcp14_parse(node, out)
+        out.bcp14 do |e|
+          node.children.each { |n| parse(n, e) }
+        end
       end
-    end
 
-    def strike_parse(node, out)
-      node.children.each { |n| parse(n, out) }
-    end
+      def strike_parse(node, out)
+        node.children.each { |n| parse(n, out) }
+      end
 
-    def smallcap_parse(node, out)
-      node.children.each { |n| parse(n, out) }
-    end
+      def smallcap_parse(node, out)
+        node.children.each { |n| parse(n, out) }
+      end
 
-    def keyword_parse(node, out)
-      node.children.each { |n| parse(n, out) }
-    end
+      def keyword_parse(node, out)
+        node.children.each { |n| parse(n, out) }
+      end
 
-    def text_parse(node, out)
-      return if node.nil? || node.text.nil?
-      text = node.to_s
-      out << text
-    end
+      def text_parse(node, out)
+        return if node.nil? || node.text.nil?
 
-    def stem_parse(node, out)
-      stem = case node["type"]
-             when "MathML" then MathML2AsciiMath.m2a(node.children.to_xml)
-             else
-               HTMLEntities.new.encode(node.text)
-             end
-      out << "#{@openmathdelim} #{stem} #{@closemathdelim}"
-    end
+        text = node.to_s
+        out << text
+      end
 
-    def page_break(_out)
-    end
+      def stem_parse(node, out)
+        stem = case node["type"]
+               when "MathML" then MathML2AsciiMath.m2a(node.children.to_xml)
+               else HTMLEntities.new.encode(node.text)
+               end
+        out << "#{@openmathdelim} #{stem} #{@closemathdelim}"
+      end
 
-    def pagebreak_parse(_node, _out)
-    end
+      def page_break(_out); end
 
-    def br_parse(node, out)
-      if @sourcecode
+      def pagebreak_parse(_node, _out); end
+
+      def br_parse(_node, out)
         out.br
       end
-    end
 
-    def hr_parse(node, out)
-    end
+      def hr_parse(node, out); end
 
-    def link_parse(node, out)
-      out.eref **attr_code(target: node["target"]) do |l|
-        node.children.each { |n| parse(n, l) }
+      def link_parse(node, out)
+        out.eref **attr_code(target: node["target"]) do |l|
+          node.children.each { |n| parse(n, l) }
+        end
       end
-    end
 
-    def image_parse(node, out, caption)
-      attrs = { src: node["src"], title: node["title"],
-                align: node["align"], name: node["filename"],
-                anchor: node["id"], type: "svg",
-                alt: node["alt"] }
-      out.artwork **attr_code(attrs)
-      image_title_parse(out, caption)
-    end
+      def image_parse(node, out, caption)
+        attrs = { src: node["src"], title: node["title"],
+                  align: node["align"], name: node["filename"],
+                  anchor: node["id"], type: "svg",
+                  alt: node["alt"] }
+        out.artwork **attr_code(attrs)
+        image_title_parse(out, caption)
+      end
 
-    def image_title_parse(out, caption)
-      unless caption.nil?
-        out.t **{ align: "center", keepWithPrevious: "true" } do |p|
-          p << caption.to_s
+      def image_title_parse(out, caption)
+        unless caption.nil?
+          out.t **{ align: "center", keepWithPrevious: "true" } do |p|
+            p << caption.to_s
+          end
         end
       end
-    end
 
-    def xref_parse(node, out)
-      out.xref **attr_code(target: node["target"], format: node["format"],
-                           relative: node["relative"]) do |l|
-                             l << get_linkend(node)
-                           end
-    end
+      def xref_parse(node, out)
+        out.xref **attr_code(target: node["target"], format: node["format"],
+                             relative: node["relative"]) do |l|
+                               l << get_linkend(node)
+                             end
+      end
 
-    def get_linkend(node)
-      contents = node.children.select { |c| !%w{locality localityStack}.include? c.name }.
-        select { |c| !c.text? || /\S/.match(c) }
-      !contents.empty? and
-        return Nokogiri::XML::NodeSet.new(node.document, contents).to_xml
-      ""
-    end
+      def get_linkend(node)
+        contents = node.children.reject do |c|
+                     %w{locality localityStack}.include? c.name
+                   end
+          .select { |c| !c.text? || /\S/.match(c) }
+        !contents.empty? and
+          return Nokogiri::XML::NodeSet.new(node.document, contents).to_xml
+        ""
+      end
 
-    def eref_parse(node, out)
-      linkend = node.children.reject { |c| %w{locality localityStack}.include? c.name }
-      relative = node["relative"] ||
-        node.at(ns(".//locality[@type = 'anchor']/referenceFrom"))&.text || ""
-      section = eref_clause(node.xpath(ns("./locality | ./localityStack")), nil) || ""
-      section = "" if relative.empty?
-      out.relref **attr_code(target: node["bibitemid"], section: section,
-                             relative: relative,
-                             displayFormat: node["displayFormat"]) do |l|
-                               linkend.each { |n| parse(n, l) }
-                             end
-    end
+      def eref_parse(node, out)
+        linkend = node.children.reject do |c|
+          %w{locality localityStack}.include? c.name
+        end
+        relative = node["relative"] ||
+          node.at(ns(".//locality[@type = 'anchor']/referenceFrom"))&.text || ""
+        section = eref_clause(node.xpath(ns("./locality | ./localityStack")),
+                              nil) || ""
+        #section = "" unless relative.empty?
+        out.relref **attr_code(target: node["bibitemid"], section: section,
+                               relative: relative,
+                               displayFormat: node["displayFormat"]) do |l|
+                                 linkend.each { |n| parse(n, l) }
+                               end
+      end
 
-    def eref_clause(refs, target)
-      ret = []
-      ret1 = ""
-      refs.each do |l|
-        if l.name == "localityStack"
-          ret << ret1
-          ret1 = ""
-          ret << eref_clause1(l.elements, target)
-        else
-          ret1 += eref_clause1([l], target)
+      def eref_clause(refs, target)
+        ret = []
+        ret1 = ""
+        refs.each do |l|
+          if l.name == "localityStack"
+            ret << ret1
+            ret1 = ""
+            ret << eref_clause1(l.elements, target)
+          else ret1 += eref_clause1([l], target)
+          end
         end
+        ret << ret1
+        ret.reject { |c| c.nil? || c.empty? }.join("; ")
       end
-      ret << ret1
-      ret.reject { |c| c.nil? || c.empty? }.join("; ")
-    end
 
-    def eref_clause1(refs, target)
-      refs.each do |l|
-        next unless %w(clause section).include? l["type"]
-        return l&.at(ns("./referenceFrom"))&.text
+      def eref_clause1(refs, _target)
+        refs.each do |l|
+          next unless %w(clause section).include? l["type"]
+
+          return l&.at(ns("./referenceFrom"))&.text
+        end
+        ""
       end
-      return ""
-    end
 
-    def index_parse(node, out)
-      out.iref nil, **attr_code(item: node.at(ns("./primary")).text, primary: node["primary"],
-                                subitem: node&.at(ns("./secondary"))&.text)
-    end
+      def index_parse(node, out)
+        out.iref nil, **attr_code(item: node.at(ns("./primary")).text,
+                                  primary: node["primary"],
+                                  subitem: node&.at(ns("./secondary"))&.text)
+      end
 
-    def bookmark_parse(node, out)
-      out.bookmark nil, **attr_code(anchor: node["id"])
+      def bookmark_parse(node, out)
+        out.bookmark nil, **attr_code(anchor: node["id"])
+      end
     end
   end
 end

data/lib/isodoc/ietf/references.rb

@@ -55,15 +55,29 @@ module IsoDoc
           uris&.each do |u|
             r.format nil, **attr_code(target: u.text, type: u["type"])
           end
-          docidentifiers = bib.xpath(ns("./docidentifier"))
-          id = render_identifier(bibitem_ref_code(bib))
-          !id[1].nil? && id[1] != "(NO ID)" and r.refcontent id[1]
-          docidentifiers&.each do |u|
-            if %w(DOI IETF).include? u["type"]
-              r.seriesInfo nil, **attr_code(value: u.text.sub(/^DOI /, ""),
-                                            name: u["type"])
-            end
-          end
+          docidentifier_render(bib, r)
+        end
+      end
+
+      def docidentifier_render(bib, out)
+        docidentifiers = bib.xpath(ns("./docidentifier"))
+        id = render_identifier(bibitem_ref_code(bib))
+        !id[1].nil? && id[1] != "(NO ID)" and out.refcontent id[1]
+        docidentifiers&.each do |u|
+          u["type"] == "DOI" and
+            out.seriesInfo nil, **attr_code(value: u.text.sub(/^DOI /, ""),
+                                            name: "DOI")
+          u["type"] == "IETF" and docidentifier_ietf(u, out)
+        end
+      end
+
+      def docidentifier_ietf(ident, out)
+        if /^RFC /.match?(ident.text)
+          out.seriesInfo nil, **attr_code(value: ident.text.sub(/^RFC 0*/, ""),
+                                          name: "RFC")
+        elsif /^I-D\./.match?(ident.text)
+          out.seriesInfo nil, **attr_code(value: ident.text.sub(/^I-D\./, ""),
+                                          name: "Internet-Draft")
         end
       end
 

data/lib/isodoc/ietf/reqt.rb

@@ -1,79 +1,83 @@
-module IsoDoc::Ietf
-  class RfcConvert < ::IsoDoc::Convert
-    def recommendation_labels(node)
-      [node.at(ns("./label")), node.at(ns("./title")), 
-       @xrefs.anchor(node['id'], :label, false)]
-    end
-
-    def recommendation_name(node, out, type)
-      label, title, lbl = recommendation_labels(node)
-      out.t **{ keepWithNext: "true" }  do |b|
-        b << (lbl.nil? ? l10n("#{type}:") : l10n("#{type} #{lbl}:"))
+module IsoDoc
+  module Ietf
+    class RfcConvert < ::IsoDoc::Convert
+      def recommendation_labels(node)
+        [node.at(ns("./label")), node.at(ns("./title")),
+         @xrefs.anchor(node["id"], :label, false)]
       end
-      if label || title
-        out.t **{ keepWithNext: "true" }  do |b|
-          label and label.children.each { |n| parse(n,b) }
-          b << "#{clausedelim} " if label && title
-          title and title.children.each { |n| parse(n,b) }
+
+      def recommendation_name(node, out, type)
+        label, title, lbl = recommendation_labels(node)
+        out.t **{ keepWithNext: "true" } do |b|
+          b << (lbl.nil? ? l10n("#{type}:") : l10n("#{type} #{lbl}:"))
+        end
+        if label || title
+          out.t **{ keepWithNext: "true" }  do |b|
+            label and label.children.each { |n| parse(n, b) }
+            b << "#{clausedelim} " if label && title
+            title and title.children.each { |n| parse(n, b) }
+          end
         end
       end
-    end
 
-    def recommendation_attributes(node, out)
-      ret = recommendation_attributes1(node)
-      return if ret.empty?
-      out.ul do |p|
-        ret.each do |l|
-          p.li do |i|
-            i.em { |e| i << l }
+      def recommendation_attributes(node, out)
+        ret = recommendation_attributes1(node)
+        return if ret.empty?
+
+        out.ul do |p|
+          ret.each do |l|
+            p.li do |i|
+              i.em { |_e| i << l }
+            end
           end
         end
       end
-    end
 
-    def recommendation_parse(node, out)
-      recommendation_name(node, out, @i18n.recommendation)
-      recommendation_attributes(node, out)
-      node.children.each do |n|
-        parse(n, out) unless %w(label title).include? n.name
+      def recommendation_parse(node, out)
+        recommendation_name(node, out, @i18n.recommendation)
+        recommendation_attributes(node, out)
+        node.children.each do |n|
+          parse(n, out) unless %w(label title).include? n.name
+        end
       end
-    end
 
-    def requirement_parse(node, out)
-      recommendation_name(node, out, @i18n.requirement)
-      recommendation_attributes(node, out)
-      node.children.each do |n|
-        parse(n, out) unless %w(label title).include? n.name
+      def requirement_parse(node, out)
+        recommendation_name(node, out, @i18n.requirement)
+        recommendation_attributes(node, out)
+        node.children.each do |n|
+          parse(n, out) unless %w(label title).include? n.name
+        end
       end
-    end
 
-    def permission_parse(node, out)
-      recommendation_name(node, out, @i18n.permission)
-      recommendation_attributes(node, out)
-      node.children.each do |n|
-        parse(n, out) unless %w(label title).include? n.name
+      def permission_parse(node, out)
+        recommendation_name(node, out, @i18n.permission)
+        recommendation_attributes(node, out)
+        node.children.each do |n|
+          parse(n, out) unless %w(label title).include? n.name
+        end
       end
-    end
 
-    def inline?(node)
-      return true if node.first_element_child.nil?
-      %w(em link eref xref strong tt sup sub strike keyword smallcap
-         br hr bookmark pagebreak stem origin term preferred admitted
-         deprecates domain termsource modification).include? node.first_element_child.name
-    end
+      def inline?(node)
+        return true if node.first_element_child.nil?
 
-    def requirement_component_parse(node, out)
-      return if node["exclude"] == "true"
-      out1 = out
-      if inline?(node)
-        out.t do |p|
-          p << "INHERIT: " if node.name == "inherit"
-          node.children.each { |n| parse(n, p) }
+        %w(em link eref xref strong tt sup sub strike keyword smallcap
+           br hr bookmark pagebreak stem origin term preferred admitted
+           deprecates domain termsource modification)
+          .include? node.first_element_child.name
+      end
+
+      def requirement_component_parse(node, out)
+        return if node["exclude"] == "true"
+
+        if inline?(node)
+          out.t do |p|
+            p << "INHERIT: " if node.name == "inherit"
+            node.children.each { |n| parse(n, p) }
+          end
+        else
+          node.children.each { |n| parse(n, out) }
         end
-      else
-        node.children.each { |n| parse(n, out) }
       end
     end
   end
 end
-

data/lib/isodoc/ietf/rfc_convert.rb

@@ -52,6 +52,8 @@ module IsoDoc::Ietf
       case node.name
       when "bcp14" then bcp14_parse(node, out)
       when "concept" then concept_parse(node, out)
+      when "verbaldefinition", "nonverbalrepresentation"
+        node.elements.each { |n| parse(n, out) }
       else
         text = node.to_xml.gsub(/</, "&lt;").gsub(/>/, "&gt;")
         out.t { |p| p << text }

data/lib/isodoc/ietf/terms.rb

@@ -1,63 +1,70 @@
-module IsoDoc::Ietf
-  class RfcConvert < ::IsoDoc::Convert
-    def definition_parse(node, out)
-      node.children.each { |n| parse(n, out) }
-    end
+module IsoDoc
+  module Ietf
+    class RfcConvert < ::IsoDoc::Convert
+      def definition_parse(node, out)
+        node.children.each { |n| parse(n, out) }
+      end
 
-    def modification_parse(node, out)
-      para = node.at(ns("./p"))
-      out << " -- "
-      para.children.each { |n| parse(n, out) }
-    end
+      def modification_parse(node, out)
+        para = node.at(ns("./p"))
+        out << " -- "
+        para.children.each { |n| parse(n, out) }
+      end
 
-    def deprecated_term_parse(node, out)
-      out.t do |p|
-        p << l10n("#{@i18n.deprecated}: ")
-        node.children.each { |c| parse(c, p) }
+      def deprecated_term_parse(node, out)
+        name = node.at(ns(".//name"))
+        out.t do |p|
+          p << l10n("#{@i18n.deprecated}: ")
+          name.children.each { |c| parse(c, p) }
+        end
       end
-    end
 
-    def admitted_term_parse(node, out)
-      out.t do |p|
-        node.children.each { |c| parse(c, p) }
+      def admitted_term_parse(node, out)
+        name = node.at(ns(".//name"))
+        out.t do |p|
+          name.children.each { |c| parse(c, p) }
+        end
       end
-    end
 
-    def term_parse(node, out)
-      out.name do |p|
-        node.children.each { |n| parse(n, p) }
+      def term_parse(node, out)
+        name = node.at(ns(".//name"))
+        out.name do |p|
+          name.children.each { |n| parse(n, p) }
+        end
       end
-    end
 
-    def termnote_parse(node, out)
-      note_parse(node, out)
-    end
+      def termnote_parse(node, out)
+        note_parse(node, out)
+      end
 
-    def termref_parse(node, out)
-      out.t do |p|
-        p << "SOURCE: "
-        node.children.each { |n| parse(n, p) }
+      def termref_parse(node, out)
+        out.t do |p|
+          p << "SOURCE: "
+          node.children.each { |n| parse(n, p) }
+        end
       end
-    end
 
-    def termdef_parse(node, out)
-      set_termdomain("")
-      clause_parse(node, out)
-    end
+      def termdef_parse(node, out)
+        set_termdomain("")
+        node.xpath(ns("./definition")).size > 1 and
+          IsoDoc::PresentationXMLConvert.new({}).multidef(node)
+        clause_parse(node, out)
+      end
 
-    def termdocsource_parse(_node, _out); end
+      def termdocsource_parse(_node, _out); end
 
-    def concept_parse(node, out)
-      if d = node.at(ns("./renderterm"))
-        out.em do |em|
-          d.children.each { |n| parse(n, em) }
+      def concept_parse(node, out)
+        if d = node.at(ns("./renderterm"))
+          out.em do |em|
+            d.children.each { |n| parse(n, em) }
+          end
+          out << " "
         end
-        out << " "
+        out << "[term defined in "
+        r = node.at(ns("./xref | ./eref | ./termref"))
+        parse(r, out)
+        out << "]"
       end
-      out << "[term defined in "
-      r = node.at(ns("./xref | ./eref | ./termref"))
-      parse(r, out)
-      out << "]"
     end
   end
 end

data/lib/isodoc/ietf/validation.rb

@@ -165,7 +165,7 @@ module IsoDoc
       def seriesInfo_check(xml)
         ret = []
         xml.root["ipr"] == "none" and return []
-        rfcinfo = xml.at("//seriesInfo[@name = 'RFC']")
+        rfcinfo = xml.at("//front//seriesInfo[@name = 'RFC']")
         rfcnumber = xml.root["number"]
         rfcinfo && rfcnumber && rfcnumber != rfcinfo["value"] and
           ret << "Mismatch between <rfc number='#{rfcnumber}'> "\

data/lib/metanorma/ietf/version.rb

@@ -1,5 +1,5 @@
 module Metanorma
   module Ietf
-    VERSION = "2.4.1".freeze
+    VERSION = "2.5.0".freeze
   end
 end

data/metanorma-ietf.gemspec

@@ -35,11 +35,9 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
   spec.required_ruby_version = Gem::Requirement.new(">= 2.5.0")
 
-  spec.add_dependency "isodoc", "~> 1.7.0"
   spec.add_dependency "mathml2asciimath"
-  spec.add_dependency "metanorma-standoc", "~> 1.10.0"
   spec.add_dependency "metanorma-ietf-data"
-  spec.add_dependency "nokogiri", "~> 1.11.6"
+  spec.add_dependency "metanorma-standoc", "~> 1.11.0"
   spec.add_dependency "open-uri"
 
   spec.add_development_dependency "byebug"