metanorma-standoc 2.3.2 → 2.3.4

data/lib/metanorma/standoc/section.rb

@@ -53,7 +53,8 @@ module Metanorma
       end
 
       PREFACE_CLAUSE_NAMES =
-        %w(abstract foreword introduction misc-container acknowledgements).freeze
+        %w(abstract foreword introduction misc-container
+           acknowledgements).freeze
 
       MAIN_CLAUSE_NAMES =
         ["normative references", "terms and definitions", "scope",

data/lib/metanorma/standoc/spans_to_bibitem.rb

@@ -0,0 +1,261 @@
+module Metanorma
+  module Standoc
+    module Cleanup
+      class SpansToBibitem
+        include ::Metanorma::Standoc::Utils
+
+        attr_reader :err, :out
+
+        def initialize(bib)
+          @bib = bib
+          @err = []
+          @spans = spans_preprocess(extract_content(bib))
+        end
+
+        def extract_content(bib)
+          extract_docid(bib) + extract_spans(bib)
+        end
+
+        def extract_spans(bib)
+          bib.xpath("./formattedref//span").each_with_object([]) do |s, m|
+            s.at("./ancestor::span") and next
+            extract_spans1(s, m)
+          end
+        end
+
+        def extract_spans1(span, acc)
+          keys = span["class"].split(".", 2)
+          acc << { key: keys[0], type: keys[1],
+                   val: span.children.to_xml }
+          (span["class"] == "type" and span.remove) or
+            span.replace(span.children)
+        end
+
+        def extract_docid(bib)
+          bib.xpath("./docidentifier").each_with_object([]) do |d, m|
+            m << { key: "docid", type: d["type"], val: d.text }
+            d.remove unless bib.at("./title")
+          end
+        end
+
+        def empty_span_hash
+          { contrib: [], docid: [], uri: [], date: [], extent: {}, in: {} }
+        end
+
+        def spans_preprocess(spans)
+          ret = empty_span_hash
+          spans.each { |s| span_preprocess1(s, ret) }
+          host_rearrange(ret)
+        end
+
+        def span_preprocess1(span, ret)
+          case span[:key]
+          when "uri", "docid"
+            val = link_unwrap(Nokogiri::XML.fragment(span[:val])).to_xml
+            ret[span[:key].to_sym] << { type: span[:type], val: val }
+          when "date"
+            ret[span[:key].to_sym] << { type: span[:type] || "published",
+                                        val: span[:val] }
+          when "pages", "volume", "issue"
+            ret[:extent][span[:key].to_sym] ||= []
+            ret[:extent][span[:key].to_sym] << span[:val]
+          when "pubplace", "title", "type", "series"
+            ret[span[:key].to_sym] = span[:val]
+          when "in_title"
+            ret[:in][:title] = span[:val]
+          when "publisher"
+            ret[:contrib] << { role: "publisher", entity: "organization",
+                               name: span[:val] }
+          when "surname", "initials", "givenname", "formatted-initials"
+            ret[:contrib] = spans_preprocess_contrib(span, ret[:contrib])
+          when "fullname"
+            ret[:contrib] = spans_preprocess_fullname(span, ret[:contrib])
+          when "organization"
+            ret[:contrib] = spans_preprocess_org(span, ret[:contrib])
+          when "in_surname", "in_initials", "in_givenname",
+            "in_formatted-initials"
+            ret[:in][:contrib] ||= []
+            span[:key].sub!(/^in_/, "")
+            ret[:in][:contrib] =
+              spans_preprocess_contrib(span, ret[:in][:contrib])
+          when "in_fullname"
+            ret[:in][:contrib] ||= []
+            span[:key].sub!(/^in_/, "")
+            ret[:in][:contrib] =
+              spans_preprocess_fullname(span, ret[:in][:contrib])
+          when "in_organization"
+            ret[:in][:contrib] ||= []
+            span[:key].sub!(/^in_/, "")
+            ret[:in][:contrib] =
+              spans_preprocess_org(span, ret[:in][:contrib])
+          else
+            msg = "unrecognised key '#{span[:key]}' in " \
+                  "`span:#{span[:key]}[#{span[:val]}]`"
+            @err << { msg: msg }
+          end
+        end
+
+        def host_rearrange(ret)
+          ret[:in][:title] or return ret
+          ret[:in].merge!(empty_span_hash, { type: "misc" }) do |_, old, _|
+            old
+          end
+          %i(series).each do |k|
+            ret[:in][k] = ret[k]
+            ret.delete(k)
+          end
+          /^in/.match?(ret[:type]) and ret[:in][:type] =
+                                         ret[:type].sub(/^in/, "")
+          ret
+        end
+
+        def spans_preprocess_contrib(span, contrib)
+          span[:key] == "initials" and span[:key] = "formatted-initials"
+          spans_preprocess_new_contrib?(span, contrib) and
+            contrib << { role: span[:type] || "author", entity: "person" }
+          if multiple_givennames?(span, contrib)
+            contrib[-1][:givenname] = [contrib[-1][:givenname],
+                                       span[:val]].flatten
+          else contrib[-1][span[:key].to_sym] = span[:val]
+          end
+          contrib
+        end
+
+        def spans_preprocess_new_contrib?(span, contrib)
+          contrib.empty? ||
+            (span[:key] == "surname" && contrib[-1][:surname]) ||
+            contrib[-1][:role] != (span[:type] || "author")
+        end
+
+        def multiple_givennames?(span, contrib)
+          (%w(formatted-initials givenname).include?(span[:key]) &&
+            (contrib[-1][:"formatted-initials"] || contrib[-1][:givenname])) or
+            return false
+          if contrib[-1][:"formatted-initials"]
+            contrib[-1][:givenname] = contrib[-1][:"formatted-initials"]
+            contrib[-1].delete(:"formatted-initials")
+          end
+          true
+        end
+
+        def spans_preprocess_fullname(span, contrib)
+          name = span[:val].gsub(/\.(?=\p{Alpha})/, ". ").split(/ /)
+          out = { role: span[:type] || "author", entity: "person",
+                  surname: name[-1] }
+          if name.size > 1 && name[0..-2].all? { |x| /\.$/.match?(x) }
+            out[:"formatted-initials"] = name[0..-2].join(" ")
+          else out[:givenname] = name[0..-2]
+          end
+          contrib << out
+          contrib
+        end
+
+        def spans_preprocess_org(span, contrib)
+          contrib << { role: span[:type] || "author", entity: "organization",
+                       name: span[:val] }
+          contrib
+        end
+
+        def convert
+          ret = spans_to_bibitem(@spans)
+          @out = Nokogiri::XML("<bibitem>#{ret}</bibitem>").root
+          @spans[:type] and @out["type"] = @spans[:type]
+          self
+        end
+
+        def spans_to_bibitem(spans)
+          ret = ""
+          spans[:title] and ret += "<title>#{spans[:title]}</title>"
+          ret += spans_to_bibitem_docid(spans)
+          spans[:contrib].each do |s|
+            ret += span_to_contrib(s, spans[:title])
+          end
+          spans[:series] and
+            ret += "<series><title>#{spans[:series]}</title></series>"
+          spans[:pubplace] and ret += "<place>#{spans[:pubplace]}</place>"
+          ret += spans_to_bibitem_host(spans)
+          ret += spans_to_bibitem_extent(spans[:extent])
+          ret
+        end
+
+        def spans_to_bibitem_host(spans)
+          spans[:in].empty? and return ""
+          ret =
+            "<relation type='includedIn'><bibitem type='#{spans[:in][:type]}'>"
+          spans[:in].delete(:type)
+          ret + "#{spans_to_bibitem(spans[:in])}</bibitem></relation>"
+        end
+
+        def spans_to_bibitem_docid(spans)
+          ret = ""
+          spans[:uri].each { |s| ret += span_to_docid(s, "uri") }
+          spans[:docid].each { |s| ret += span_to_docid(s, "docidentifier") }
+          spans[:date].each { |s| ret += span_to_date(s) }
+          ret
+        end
+
+        def spans_to_bibitem_extent(spans)
+          ret = ""
+          { volume: "volume", issue: "issue", pages: "page" }.each do |k, v|
+            spans[k]&.each { |s| ret += span_to_extent(s, v) }
+          end
+          ret.empty? and return ""
+          "<extent>#{ret}</extent>"
+        end
+
+        def span_to_extent(span, key)
+          values = span.split(/[-–]/)
+          ret = "<locality type='#{key}'>" \
+                "<referenceFrom>#{values[0]}</referenceFrom>"
+          values[1] and
+            ret += "<referenceTo>#{values[1]}</referenceTo>"
+          "#{ret}</locality>"
+        end
+
+        def span_to_docid(span, key)
+          if span[:type]
+            "<#{key} type='#{span[:type]}'>#{span[:val]}</#{key}>"
+          else "<#{key}>#{span[:val]}</#{key}>"
+          end
+        end
+
+        def span_to_date(span)
+          val = if /[-–](?=\d{4})/.match?(span[:val])
+                  from, to = span[:val].split(/[-–](?=\d{4})/, 2)
+                  "<from>#{from}</from><to>#{to}</to>"
+                else "<on>#{span[:val]}</on>"
+                end
+          type = span[:type] ? " type='#{span[:type]}'" : ""
+          "<date#{type}>#{val}</date>"
+        end
+
+        def span_to_contrib(span, title)
+          e = if span[:entity] == "organization"
+                "<organization><name>#{span[:name]}</name></organization>"
+              else span_to_person(span, title)
+              end
+          "<contributor><role type='#{span[:role]}'/>#{e}</contributor>"
+        end
+
+        def validate_span_to_person(span, title)
+          span[:surname] and return
+          msg = "Missing surname: issue with bibliographic markup " \
+                "in \"#{title}\": #{span}"
+          @err << { msg: msg, fatal: true }
+        end
+
+        def span_to_person(span, title)
+          validate_span_to_person(span, title)
+          pre = (span[:"formatted-initials"] and
+                       "<formatted-initials>" \
+                       "#{span[:"formatted-initials"]}</formatted-initials>") ||
+            Array(span[:givenname]).map do |x|
+              "<forename>#{x}</forename>"
+            end.join
+          "<person><name>#{pre}<surname>#{span[:surname]}</surname></name>" \
+            "</person>"
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/standoc/utils.rb

@@ -60,6 +60,14 @@ module Metanorma
         "<expression><name>#{elem}</name></expression>"
       end
 
+      def link_unwrap(para)
+        elems = para.elements
+        if elems.size == 1 && elems[0].name == "link"
+          para.at("./link").replace(elems[0]["target"].strip)
+        end
+        para
+      end
+
       class EmptyAttr
         def attr(_any_attribute)
           nil

data/lib/metanorma/standoc/validate.rb

@@ -13,9 +13,8 @@ module Metanorma
                        "referenceFrom".freeze
 
       def init_iev
-        return nil if @no_isobib
-        return @iev if @iev
-
+        @no_isobib and return nil
+        @iev and return @iev
         @iev = Iev::Db.new(@iev_globalname, @iev_localname) unless @no_isobib
         @iev
       end
@@ -43,6 +42,8 @@ module Metanorma
       end
 
       def content_validate(doc)
+        nested_asset_validate_basic(doc)
+        nested_note_validate(doc)
         xref_validate(doc)
         section_validate(doc)
         norm_ref_validate(doc)
@@ -57,12 +58,36 @@ module Metanorma
           clean_abort(@fatalerror.join("\n"), doc)
       end
 
+      def nested_asset_validate_basic(doc)
+        a = "//formula | //example | //figure | //termnote | //termexample | " \
+            "//table"
+        doc.xpath("#{a} | //note").each do |m|
+          m.xpath(a.gsub(%r{//}, ".//")).each do |n|
+            nested_asset_report(m, n, doc)
+          end
+        end
+      end
+
+      def nested_note_validate(doc)
+        doc.xpath("//termnote | //note").each do |m|
+          m.xpath(".//note").each do |n|
+            nested_asset_report(m, n, doc)
+          end
+        end
+      end
+
+      def nested_asset_report(outer, inner, _doc)
+        outer.name == "figure" && inner.name == "figure" and return
+        err = "There is an instance of #{inner.name} nested within #{outer.name}"
+        @log.add("Syntax", inner, err)
+        @fatalerror << "#{err}:\n#{inner.to_xml}"
+      end
+
       def norm_ref_validate(doc)
         found = false
         doc.xpath("//references[@normative = 'true']/bibitem").each do |b|
-          next unless docid = b.at("./docidentifier[@type = 'metanorma']")
-          next unless /^\[\d+\]$/.match?(docid.text)
-
+          docid = b.at("./docidentifier[@type = 'metanorma']") or next
+          /^\[\d+\]$/.match?(docid.text) or next
           @log.add("Bibliography", b,
                    "Numeric reference in normative references")
           found = true
@@ -106,8 +131,7 @@ module Metanorma
           @log.add("Anchors", elem, "Anchor #{elem['id']} has already been " \
                                     "used at line #{ids[elem['id']]}")
           @fatalerror << "Multiple instances of same ID: #{elem['id']}"
-        else
-          ids[elem["id"]] = elem.line
+        else ids[elem["id"]] = elem.line
         end
         ids
       end
@@ -166,8 +190,7 @@ module Metanorma
       def xref_validate(doc)
         ids = doc.xpath("//*/@id").each_with_object({}) { |x, m| m[x.text] = 1 }
         doc.xpath("//xref/@target | //xref/@to").each do |x|
-          next if ids[x.text]
-
+          ids[x.text] and next
           @log.add("Anchors", x.parent,
                    "Crossreference target #{x.text} is undefined")
         end

data/lib/metanorma/standoc/version.rb

@@ -19,6 +19,6 @@ module Metanorma
   end
 
   module Standoc
-    VERSION = "2.3.2".freeze
+    VERSION = "2.3.4".freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: metanorma-standoc
 version: !ruby/object:Gem::Version
-  version: 2.3.2
+  version: 2.3.4
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-12-19 00:00:00.000000000 Z
+date: 2022-12-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: asciidoctor
@@ -475,7 +475,6 @@ files:
 - lib/metanorma/standoc/cleanup.rb
 - lib/metanorma/standoc/cleanup_amend.rb
 - lib/metanorma/standoc/cleanup_asciibib.rb
-- lib/metanorma/standoc/cleanup_biblio.rb
 - lib/metanorma/standoc/cleanup_block.rb
 - lib/metanorma/standoc/cleanup_boilerplate.rb
 - lib/metanorma/standoc/cleanup_footnotes.rb
@@ -511,6 +510,7 @@ files:
 - lib/metanorma/standoc/macros_note.rb
 - lib/metanorma/standoc/macros_plantuml.rb
 - lib/metanorma/standoc/macros_terms.rb
+- lib/metanorma/standoc/merge_bibitems.rb
 - lib/metanorma/standoc/processor.rb
 - lib/metanorma/standoc/ref.rb
 - lib/metanorma/standoc/ref_sect.rb
@@ -519,6 +519,7 @@ files:
 - lib/metanorma/standoc/reqt.rb
 - lib/metanorma/standoc/reqt.rng
 - lib/metanorma/standoc/section.rb
+- lib/metanorma/standoc/spans_to_bibitem.rb
 - lib/metanorma/standoc/table.rb
 - lib/metanorma/standoc/term_lookup_cleanup.rb
 - lib/metanorma/standoc/terms.rb

data/lib/metanorma/standoc/cleanup_biblio.rb

@@ -1,242 +0,0 @@
-module Metanorma
-  module Standoc
-    module Cleanup
-      def formattedref_spans(xmldoc)
-        xmldoc.xpath("//bibitem[formattedref//span]").each do |b|
-          spans = spans_preprocess(extract_content(b))
-          ret = spans_to_bibitem(spans)
-          spans[:type] and b["type"] = spans[:type]
-          b << ret
-        end
-      end
-
-      def extract_content(bib)
-        extract_docid(bib) + extract_spans(bib)
-      end
-
-      def extract_spans(bib)
-        bib.xpath("./formattedref//span").each_with_object([]) do |s, m|
-          next if s.at("./ancestor::span")
-
-          extract_spans1(s, m)
-        end
-      end
-
-      def extract_spans1(span, acc)
-        keys = span["class"].split(".", 2)
-        acc << { key: keys[0], type: keys[1],
-                 val: span.children.to_xml }
-        (span["class"] == "type" and span.remove) or span.replace(span.children)
-      end
-
-      def extract_docid(bib)
-        bib.xpath("./docidentifier").each_with_object([]) do |d, m|
-          m << { key: "docid", type: d["type"], val: d.text }
-          d.remove
-        end
-      end
-
-      def empty_span_hash
-        { contrib: [], docid: [], uri: [], date: [], extent: {}, in: {} }
-      end
-
-      def spans_preprocess(spans)
-        ret = empty_span_hash
-        spans.each { |s| span_preprocess1(s, ret) }
-        host_rearrange(ret)
-      end
-
-      def span_preprocess1(span, ret)
-        case span[:key]
-        when "uri", "docid"
-          val = link_unwrap(Nokogiri::XML.fragment(span[:val])).to_xml
-          ret[span[:key].to_sym] << { type: span[:type], val: val }
-        when "date"
-          ret[span[:key].to_sym] << { type: span[:type] || "published",
-                                      val: span[:val] }
-        when "pages", "volume", "issue"
-          ret[:extent][span[:key].to_sym] ||= []
-          ret[:extent][span[:key].to_sym] << span[:val]
-        when "pubplace", "title", "type", "series"
-          ret[span[:key].to_sym] = span[:val]
-        when "in_title"
-          ret[:in][:title] = span[:val]
-        when "publisher"
-          ret[:contrib] << { role: "publisher", entity: "organization",
-                             name: span[:val] }
-        when "surname", "initials", "givenname", "formatted-initials"
-          ret[:contrib] = spans_preprocess_contrib(span, ret[:contrib])
-        when "fullname"
-          ret[:contrib] = spans_preprocess_fullname(span, ret[:contrib])
-        when "organization"
-          ret[:contrib] = spans_preprocess_org(span, ret[:contrib])
-        when "in_surname", "in_initials", "in_givenname",
-          "in_formatted-initials"
-          ret[:in][:contrib] ||= []
-          span[:key].sub!(/^in_/, "")
-          ret[:in][:contrib] =
-            spans_preprocess_contrib(span, ret[:in][:contrib])
-        when "in_fullname"
-          ret[:in][:contrib] ||= []
-          span[:key].sub!(/^in_/, "")
-          ret[:in][:contrib] =
-            spans_preprocess_fullname(span, ret[:in][:contrib])
-        when "in_organization"
-          ret[:in][:contrib] ||= []
-          span[:key].sub!(/^in_/, "")
-          ret[:in][:contrib] =
-            spans_preprocess_org(span, ret[:in][:contrib])
-        else
-          warn "unrecognised `span:#{span['key']}`"
-        end
-      end
-
-      def host_rearrange(ret)
-        ret[:in][:title] or return ret
-        ret[:in].merge!(empty_span_hash, { type: "misc" }) { |_, old, _| old }
-
-        %i(series).each do |k|
-          ret[:in][k] = ret[k]
-          ret.delete(k)
-        end
-        /^in/.match?(ret[:type]) and ret[:in][:type] =
-                                       ret[:type].sub(/^in/, "")
-        ret
-      end
-
-      def spans_preprocess_contrib(span, contrib)
-        span[:key] = "formatted-initials" if span[:key] == "initials"
-
-        spans_preprocess_new_contrib?(span, contrib) and
-          contrib << { role: span[:type] || "author", entity: "person" }
-        if span[:key] == "givenname" && contrib[-1][span[:key].to_sym]
-          contrib[-1][span[:key].to_sym] =
-            Array(contrib[-1][span[:key].to_sym]) + span[:val]
-        else
-          contrib[-1][span[:key].to_sym] = span[:val]
-        end
-        contrib
-      end
-
-      def spans_preprocess_new_contrib?(span, contrib)
-        contrib.empty? ||
-          (if span[:key] == "surname" then contrib[-1][:surname]
-           else (contrib[-1][:"formatted-initials"] || contrib[-1][:givenname])
-           end) ||
-          contrib[-1][:role] != (span[:type] || "author")
-      end
-
-      def spans_preprocess_fullname(span, contrib)
-        name = span[:val].gsub(/\.(?=\p{Alpha})/, ". ").split(/ /)
-        out = { role: span[:type] || "author", entity: "person",
-                surname: name[-1] }
-        if name.size > 1 && name[0..-2].all? { |x| /\.$/.match?(x) }
-          out[:"formatted-initials"] = name[0..-2].join(" ")
-        else
-          out[:givenname] = name[0..-2]
-        end
-        contrib << out
-        contrib
-      end
-
-      def spans_preprocess_org(span, contrib)
-        contrib << { role: span[:type] || "author", entity: "organization",
-                     name: span[:val] }
-        contrib
-      end
-
-      def spans_to_bibitem(spans)
-        ret = ""
-        spans[:title] and ret += "<title>#{spans[:title]}</title>"
-        ret += spans_to_bibitem_docid(spans)
-        spans[:contrib].each { |s| ret += span_to_contrib(s, spans[:title]) }
-        spans[:series] and
-          ret += "<series><title>#{spans[:series]}</title></series>"
-        spans[:pubplace] and ret += "<place>#{spans[:pubplace]}</place>"
-        ret += spans_to_bibitem_host(spans)
-        ret + spans_to_bibitem_extent(spans[:extent])
-      end
-
-      def spans_to_bibitem_host(spans)
-        return "" if spans[:in].empty?
-
-        ret =
-          "<relation type='includedIn'><bibitem type='#{spans[:in][:type]}'>"
-        spans[:in].delete(:type)
-        ret + "#{spans_to_bibitem(spans[:in])}</bibitem></relation>"
-      end
-
-      def spans_to_bibitem_docid(spans)
-        ret = ""
-        spans[:uri].each { |s| ret += span_to_docid(s, "uri") }
-        spans[:docid].each { |s| ret += span_to_docid(s, "docidentifier") }
-        spans[:date].each { |s| ret += span_to_date(s) }
-        ret
-      end
-
-      def spans_to_bibitem_extent(spans)
-        ret = ""
-        { volume: "volume", issue: "issue", pages: "page" }.each do |k, v|
-          spans[k]&.each { |s| ret += span_to_extent(s, v) }
-        end
-        return "" if ret.empty?
-
-        "<extent>#{ret}</extent>"
-      end
-
-      def span_to_extent(span, key)
-        values = span.split(/[-–]/)
-        ret = "<locality type='#{key}'>" \
-              "<referenceFrom>#{values[0]}</referenceFrom>"
-        values[1] and
-          ret += "<referenceTo>#{values[1]}</referenceTo>"
-        "#{ret}</locality>"
-      end
-
-      def span_to_docid(span, key)
-        if span[:type]
-          "<#{key} type='#{span[:type]}'>#{span[:val]}</#{key}>"
-        else
-          "<#{key}>#{span[:val]}</#{key}>"
-        end
-      end
-
-      def span_to_date(span)
-        val = if /[-–](?=\d{4})/.match?(span[:val])
-                from, to = span[:val].split(/[-–](?=\d{4})/, 2)
-                "<from>#{from}</from><to>#{to}</to>"
-              else
-                "<on>#{span[:val]}</on>"
-              end
-        type = span[:type] ? " type='#{span[:type]}'" : ""
-        "<date#{type}>#{val}</date>"
-      end
-
-      def span_to_contrib(span, title)
-        e = if span[:entity] == "organization"
-              "<organization><name>#{span[:name]}</name></organization>"
-            else span_to_person(span, title)
-            end
-        "<contributor><role type='#{span[:role]}'/>#{e}</contributor>"
-      end
-
-      def validate_span_to_person(span, title)
-        span[:surname] and return
-        msg = "Missing surname: issue with bibliographic markup " \
-              "in \"#{title}\": #{span}"
-        @log.add("Bibliography", nil, msg)
-        @fatalerror << msg
-      end
-
-      def span_to_person(span, title)
-        validate_span_to_person(span, title)
-        pre = (span[:"formatted-initials"] and
-                     "<formatted-initials>" \
-                     "#{span[:"formatted-initials"]}</formatted-initials>") ||
-          Array(span[:givenname]).map { |x| "<forename>#{x}</forename>" }.join
-        "<person><name>#{pre}<surname>#{span[:surname]}</surname></name>" \
-          "</person>"
-      end
-    end
-  end
-end