metanorma-standoc 2.3.3 → 2.3.5

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,10 +42,11 @@ module Metanorma
       end
 
       def content_validate(doc)
-        xref_validate(doc)
+        repeat_id_validate(doc.root) # feeds xref_validate
+        xref_validate(doc) # feeds nested_asset_validate
+        nested_asset_validate(doc)
         section_validate(doc)
         norm_ref_validate(doc)
-        repeat_id_validate(doc.root)
         iev_validate(doc.root)
         concept_validate(doc, "concept", "refterm")
         concept_validate(doc, "related", "preferred//name")
@@ -57,12 +57,46 @@ module Metanorma
           clean_abort(@fatalerror.join("\n"), doc)
       end
 
+      def nested_asset_validate(doc)
+        nested_asset_validate_basic(doc)
+        nested_note_validate(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)
+        i = @doc_xrefs[inner["id"]] or return
+        err2 = "There is a crossreference to an instance of #{inner.name} " \
+               "nested within #{outer.name}: #{i.to_xml}"
+        @log.add("Style", i, err2)
+        @fatalerror << err2
+      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
@@ -78,8 +112,8 @@ module Metanorma
           @log.add("Anchors", x, concept_validate_msg(doc, tag, refterm, x))
           found = true
         end
-        found and
-          @fatalerror << "#{tag.capitalize} not cross-referencing term or symbol"
+        found and @fatalerror << "#{tag.capitalize} not cross-referencing " \
+                                 "term or symbol"
       end
 
       def concept_validate_ids(doc)
@@ -101,21 +135,19 @@ module Metanorma
         ret
       end
 
-      def repeat_id_validate1(ids, elem)
-        if ids[elem["id"]]
+      def repeat_id_validate1(elem)
+        if @doc_ids[elem["id"]]
           @log.add("Anchors", elem, "Anchor #{elem['id']} has already been " \
-                                    "used at line #{ids[elem['id']]}")
+                                    "used at line #{@doc_ids[elem['id']]}")
           @fatalerror << "Multiple instances of same ID: #{elem['id']}"
-        else
-          ids[elem["id"]] = elem.line
         end
-        ids
+        @doc_ids[elem["id"]] = elem.line
       end
 
       def repeat_id_validate(doc)
-        ids = {}
+        @doc_ids = {}
         doc.xpath("//*[@id]").each do |x|
-          ids = repeat_id_validate1(ids, x)
+          repeat_id_validate1(x)
         end
       end
 
@@ -164,12 +196,12 @@ module Metanorma
 
       # manually check for xref/@target, xref/@to integrity
       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]
-
+        @doc_xrefs = doc.xpath("//xref/@target | //xref/@to")
+          .each_with_object({}) do |x, m|
+          m[x.text] = x
+          @doc_ids[x] and next
           @log.add("Anchors", x.parent,
-                   "Crossreference target #{x.text} is undefined")
+                   "Crossreference target #{x} is undefined")
         end
       end
 

data/lib/metanorma/standoc/version.rb

@@ -19,6 +19,6 @@ module Metanorma
   end
 
   module Standoc
-    VERSION = "2.3.3".freeze
+    VERSION = "2.3.5".freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: metanorma-standoc
 version: !ruby/object:Gem::Version
-  version: 2.3.3
+  version: 2.3.5
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-12-22 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