metanorma-standoc 1.7.3 → 1.8.1

data/lib/asciidoctor/standoc/cleanup_ref.rb

@@ -120,91 +120,6 @@ module Asciidoctor
         end
       end
 
-      def ref_dl_cleanup(xmldoc)
-        xmldoc.xpath("//clause[@bibitem = 'true']").each do |c|
-          bib = dl_bib_extract(c) or next
-          validate_ref_dl(bib, c)
-          bibitemxml = RelatonBib::BibliographicItem.new(RelatonBib::HashConverter::hash_to_bib(bib)).to_xml or next
-          bibitem = Nokogiri::XML(bibitemxml)
-          bibitem.root["id"] = c["id"] if c["id"] && !/^_/.match(c["id"])
-          c.replace(bibitem.root)
-        end
-      end
-
-      def validate_ref_dl(bib, c)
-        id = bib["id"]
-        id ||= c["id"] unless /^_/.match(c["id"]) # do not accept implicit id
-        unless id
-          @log.add("Anchors", c, "The following reference is missing an anchor:\n" + c.to_xml)
-          return
-        end
-        bib["title"] or @log.add("Bibliography", c, "Reference #{id} is missing a title")
-        bib["docid"] or @log.add("Bibliography", c, "Reference #{id} is missing a document identifier (docid)")
-      end
-
-      def extract_from_p(tag, bib, key)
-        return unless bib[tag]
-        "<#{key}>#{bib[tag].at('p').children}</#{key}>"
-      end
-
-      # if the content is a single paragraph, replace it with its children
-      # single links replaced with uri
-      def p_unwrap(p)
-        elems = p.elements
-        if elems.size == 1 && elems[0].name == "p"
-          link_unwrap(elems[0]).children.to_xml.strip
-        else
-          p.to_xml.strip
-        end
-      end
-
-      def link_unwrap(p)
-        elems = p.elements
-        if elems.size == 1 && elems[0].name == "link"
-          p.at("./link").replace(elems[0]["target"].strip)
-        end
-        p
-      end
-
-      def dd_bib_extract(dtd)
-        return nil if dtd.children.empty?
-        dtd.at("./dl") and return dl_bib_extract(dtd)
-        elems = dtd.remove.elements
-        return p_unwrap(dtd) unless elems.size == 1 && %w(ol ul).include?(elems[0].name)
-        ret = []
-        elems[0].xpath("./li").each do |li|
-          ret << p_unwrap(li)
-        end
-        ret
-      end
-
-      def add_to_hash(bib, key, val)
-        Utils::set_nested_value(bib, key.split(/\./), val)
-      end
-
-      # definition list, with at most one level of unordered lists
-      def dl_bib_extract(c, nested = false)
-        dl = c.at("./dl") or return
-        bib = {}
-        key = ""
-        dl.xpath("./dt | ./dd").each do |dtd|
-          dtd.name == "dt" and key = dtd.text.sub(/:+$/, "") or add_to_hash(bib, key, dd_bib_extract(dtd))
-        end
-        c.xpath("./clause").each do |c1|
-          key = c1&.at("./title")&.text&.downcase&.strip
-          next unless %w(contributor relation series).include? key
-          add_to_hash(bib, key, dl_bib_extract(c1, true))
-        end
-        if !nested and c.at("./title")
-          title = c.at("./title").remove.children.to_xml
-          bib["title"] = [bib["title"]] if bib["title"].is_a? Hash
-          bib["title"] = [bib["title"]] if bib["title"].is_a? String
-          bib["title"] = [] unless bib["title"]
-          bib["title"] << title if !title.empty?
-        end
-        bib
-      end
-
       def fetch_termbase(termbase, id)
         ""
       end

data/lib/asciidoctor/standoc/cleanup_ref_dl.rb

@@ -0,0 +1,94 @@
+require "set"
+require "relaton_bib"
+
+module Asciidoctor
+  module Standoc
+    module Cleanup
+      def ref_dl_cleanup(xmldoc)
+        xmldoc.xpath("//clause[@bibitem = 'true']").each do |c|
+          bib = dl_bib_extract(c) or next
+          validate_ref_dl(bib, c)
+          bibitemxml = RelatonBib::BibliographicItem.new(RelatonBib::HashConverter::hash_to_bib(bib)).to_xml or next
+          bibitem = Nokogiri::XML(bibitemxml)
+          bibitem.root["id"] = c["id"] if c["id"] && !/^_/.match(c["id"])
+          c.replace(bibitem.root)
+        end
+      end
+
+      def validate_ref_dl(bib, c)
+        id = bib["id"]
+        id ||= c["id"] unless /^_/.match(c["id"]) # do not accept implicit id
+        unless id
+          @log.add("Anchors", c, "The following reference is missing an anchor:\n" + c.to_xml)
+          return
+        end
+        @refids << id
+        bib["title"] or @log.add("Bibliography", c, "Reference #{id} is missing a title")
+        bib["docid"] or @log.add("Bibliography", c, "Reference #{id} is missing a document identifier (docid)")
+      end
+
+      def extract_from_p(tag, bib, key)
+        return unless bib[tag]
+        "<#{key}>#{bib[tag].at('p').children}</#{key}>"
+      end
+
+      # if the content is a single paragraph, replace it with its children
+      # single links replaced with uri
+      def p_unwrap(p)
+        elems = p.elements
+        if elems.size == 1 && elems[0].name == "p"
+          link_unwrap(elems[0]).children.to_xml.strip
+        else
+          p.to_xml.strip
+        end
+      end
+
+      def link_unwrap(p)
+        elems = p.elements
+        if elems.size == 1 && elems[0].name == "link"
+          p.at("./link").replace(elems[0]["target"].strip)
+        end
+        p
+      end
+
+      def dd_bib_extract(dtd)
+        return nil if dtd.children.empty?
+        dtd.at("./dl") and return dl_bib_extract(dtd)
+        elems = dtd.remove.elements
+        return p_unwrap(dtd) unless elems.size == 1 && %w(ol ul).include?(elems[0].name)
+        ret = []
+        elems[0].xpath("./li").each do |li|
+          ret << p_unwrap(li)
+        end
+        ret
+      end
+
+      def add_to_hash(bib, key, val)
+        Metanorma::Utils::set_nested_value(bib, key.split(/\./), val)
+      end
+
+      # definition list, with at most one level of unordered lists
+      def dl_bib_extract(c, nested = false)
+        dl = c.at("./dl") or return
+        bib = {}
+        key = ""
+        dl.xpath("./dt | ./dd").each do |dtd|
+          dtd.name == "dt" and key = dtd.text.sub(/:+$/, "") or add_to_hash(bib, key, dd_bib_extract(dtd))
+        end
+        c.xpath("./clause").each do |c1|
+          key = c1&.at("./title")&.text&.downcase&.strip
+          next unless %w(contributor relation series).include? key
+          add_to_hash(bib, key, dl_bib_extract(c1, true))
+        end
+        if !nested and c.at("./title")
+          title = c.at("./title").remove.children.to_xml
+          bib["title"] = [bib["title"]] if bib["title"].is_a? Hash
+          bib["title"] = [bib["title"]] if bib["title"].is_a? String
+          bib["title"] = [] unless bib["title"]
+          bib["title"] << title if !title.empty?
+        end
+        bib
+      end
+    end
+  end
+end

data/lib/asciidoctor/standoc/converter.rb

@@ -14,7 +14,6 @@ require "asciidoctor/standoc/utils"
 require "asciidoctor/standoc/cleanup"
 require "asciidoctor/standoc/reqt"
 require_relative "./macros.rb"
-require_relative "./log.rb"
 
 module Asciidoctor
   module Standoc

data/lib/asciidoctor/standoc/front.rb

@@ -93,7 +93,7 @@ module Asciidoctor
       end
 
       def metadata_script(node, xml)
-        xml.script (node.attr("script") || "Latn")
+        xml.script (node.attr("script") || default_script(node.attr("language")))
       end
 
       def relaton_relations
@@ -186,7 +186,7 @@ module Asciidoctor
         ["en"].each do |lang|
           at = { language: lang, format: "text/plain" }
           xml.title **attr_code(at) do |t|
-            t << (Utils::asciidoc_sub(node.attr("title") ||
+            t << (Metanorma::Utils::asciidoc_sub(node.attr("title") ||
                                       node.attr("title-en")) || node.title)
           end
         end

data/lib/asciidoctor/standoc/inline.rb

@@ -194,7 +194,7 @@ module Asciidoctor
         type = types.first.to_s
         uri = uri.sub(%r{^data:image/\*;}, "data:#{type};")
         attr_code(src: uri, #@datauriimage ? datauri(uri) : uri,
-                  id: Utils::anchor_or_uuid,
+                  id: Metanorma::Utils::anchor_or_uuid,
                   mimetype: type,
                   height: node.attr("height") || "auto",
                   width: node.attr("width") || "auto" ,

data/lib/asciidoctor/standoc/isodoc.rng

@@ -789,6 +789,9 @@
       <attribute name="width"/>
     </element>
   </define>
+  <define name="BibItemType" combine="choice">
+    <value>internal</value>
+  </define>
   <define name="TextElement" combine="choice">
     <ref name="concept"/>
   </define>

data/lib/asciidoctor/standoc/lists.rb

@@ -54,7 +54,7 @@ module Asciidoctor
       end
 
       def ol_attrs(node)
-        attr_code(keep_attrs(node).merge(id: Utils::anchor_or_uuid(node),
+        attr_code(keep_attrs(node).merge(id: Metanorma::Utils::anchor_or_uuid(node),
                                          type: olist_style(node.style)))
       end
 
@@ -88,7 +88,7 @@ module Asciidoctor
 
       def dl_attrs(node)
         attr_code(keep_attrs(node).
-                  merge(id: Utils::anchor_or_uuid(node),
+                  merge(id: Metanorma::Utils::anchor_or_uuid(node),
                         key: node.option?("key") ? "true" : nil))
       end
 

data/lib/asciidoctor/standoc/macros_plantuml.rb

@@ -30,7 +30,7 @@ module Asciidoctor
       # plantuml process may finish earlier then dot, as result png file
       # maybe not created yet after plantuml finish
       def self.generate_file parent, reader
-        localdir = Utils::localdir(parent.document)
+        localdir = Metanorma::Utils::localdir(parent.document)
         imagesdir = parent.document.attr('imagesdir')
         umlfile, outfile = save_plantuml parent, reader, localdir
         run(umlfile, outfile) or raise "No image output from PlantUML (#{umlfile}, #{outfile})!"

data/lib/asciidoctor/standoc/ref_sect.rb

@@ -96,9 +96,9 @@ module Asciidoctor
         xstr = x.to_xml(lang: opts[:lang])
         xml = Nokogiri::XML(xstr)
         emend_biblio(xml, code, opts[:title], opts[:usrlbl])
-        xml.xpath("//date").each { |d| Utils::endash_date(d) }
+        xml.xpath("//date").each { |d| Metanorma::Utils::endash_date(d) }
         xml.traverse do |n|
-          n.text? and n.replace(Utils::smartformat(n.text))
+          n.text? and n.replace(Metanorma::Utils::smartformat(n.text))
         end
         xml.to_xml.sub(/<\?[^>]+>/, "")
       end

data/lib/asciidoctor/standoc/reqt.rb

@@ -6,6 +6,11 @@ require "base64"
 module Asciidoctor
   module Standoc
     module Blocks
+      def reqt_subpart(x)
+        %w(specification measurement-target verification import label
+             subject inherit classification title).include? x
+      end
+
       def reqt_subpart_attrs(node)
         attr_code(keep_attrs(node).merge(exclude: node.option?("exclude"),
                                      type: node.attr("type")))
@@ -41,7 +46,7 @@ module Asciidoctor
 
       def reqt_attrs(node)
         attr_code(keep_attrs(node).merge(id_unnum_attrs(node)).merge(
-          id: Utils::anchor_or_uuid(node),
+          id: Metanorma::Utils::anchor_or_uuid(node),
           unnumbered: node.option?("unnumbered") ? "true" : nil,
           number: node.attr("number"),
           subsequence: node.attr("subsequence"),

data/lib/asciidoctor/standoc/section.rb

@@ -1,6 +1,6 @@
-require "htmlentities"
 require "uri"
 require_relative "ref_sect"
+require_relative "terms"
 
 module Asciidoctor
   module Standoc
@@ -9,10 +9,6 @@ module Asciidoctor
       @term_def = false
       @norm_ref = false
 
-      def in_terms?
-        @term_def
-      end
-
       def sectiontype1(node)
         node&.attr("heading")&.downcase || node.title.gsub(/<[^>]+>/, "").downcase
       end
@@ -45,10 +41,11 @@ module Asciidoctor
       end
 
       def section_attributes(node)
-        ret = { id: Utils::anchor_or_uuid(node),
+        ret = { id: Metanorma::Utils::anchor_or_uuid(node),
                 language: node.attributes["language"],
                 script: node.attributes["script"],
                 number: node.attributes["number"],
+                type: node.attributes["type"],
                 annex: ( ((node.attr("style") == "appendix" || node.role == "appendix") && 
                           node.level == 1) ? true : nil),
                          preface: (
@@ -147,80 +144,6 @@ module Asciidoctor
         end
       end
 
-      def nonterm_symbols_parse(attrs, xml, node)
-        defs = @definitions
-        @definitions = false
-        clause_parse(attrs, xml, node)
-        @definitions = defs
-      end
-
-      def symbols_attrs(node, a)
-        case sectiontype1(node)
-        when "symbols" then a.merge(type: "symbols")
-        when "abbreviated terms", "abbreviations" then a.merge(type: "abbreviated_terms")
-        else
-          a
-        end
-      end
-
-      def symbols_parse(attr, xml, node)
-        node.role == "nonterm" and return nonterm_symbols_parse(attr, xml, node)
-        xml.definitions **attr_code(attr) do |xml_section|
-          xml_section.title { |t| t << node.title }
-          defs = @definitions
-          termdefs = @term_def
-          @definitions = true
-          @term_def = false
-          xml_section << node.content
-          @definitions = defs
-          @term_def = termdefs
-        end
-      end
-
-      def nonterm_term_def_subclause_parse(attrs, xml, node)
-        defs = @term_def
-        @term_def = false
-        clause_parse(attrs, xml, node)
-        @term_def = defs
-      end
-
-      def terms_boilerplate_parse(attrs, xml, node)
-        defs = @term_def
-        @term_def = false
-        clause_parse(attrs.merge(type: "boilerplate"), xml, node)
-        @term_def = defs
-      end
-
-      # subclause contains subclauses
-      def term_def_subclause_parse(attrs, xml, node)
-        node.role == "nonterm"  and return nonterm_term_def_subclause_parse(attrs, xml, node)
-        node.role == "boilerplate"  and return terms_boilerplate_parse(attrs, xml, node)
-        st = sectiontype(node, false)
-        return symbols_parse(attrs, xml, node) if @definitions
-        sub = node.find_by(context: :section) { |s| s.level == node.level + 1 }
-        sub.empty? || (return term_def_parse(attrs, xml, node, false))
-        st == "symbols and abbreviated terms" and (return symbols_parse(attrs, xml, node))
-        st == "terms and definitions" and return clause_parse(attrs, xml, node)
-        term_def_subclause_parse1(attrs, xml, node)
-      end
-
-      def term_def_subclause_parse1(attrs, xml, node)
-        xml.term **attr_code(attrs) do |xml_section|
-          xml_section.preferred { |name| name << node.title }
-          xml_section << node.content
-        end
-      end
-
-      def term_def_parse(attrs, xml, node, toplevel)
-        xml.terms **attr_code(attrs) do |section|
-          section.title { |t| t << node.title }
-          (s = node.attr("source")) && s.split(/,/).each do |s1|
-            section.termdocsource(nil, **attr_code(bibitemid: s1))
-          end
-          section << node.content
-        end
-      end
-
       def introduction_parse(attrs, xml, node)
         xml.introduction **attr_code(attrs) do |xml_section|
           xml_section.title { |t| t << @i18n.introduction }

data/lib/asciidoctor/standoc/table.rb

@@ -2,7 +2,7 @@ module Asciidoctor
   module Standoc
     module Table
       def table_attrs(node)
-        keep_attrs(node).merge( id: Utils::anchor_or_uuid(node),
+        keep_attrs(node).merge( id: Metanorma::Utils::anchor_or_uuid(node),
           headerrows: node.attr("headerrows"),
           unnumbered: node.option?("unnumbered") ? "true" : nil,
           number: node.attr("number"),

data/lib/asciidoctor/standoc/terms.rb

@@ -0,0 +1,125 @@
+module Asciidoctor
+  module Standoc
+    module Section
+      def in_terms?
+        @term_def
+      end
+
+      def nonterm_symbols_parse(attrs, xml, node)
+        defs = @definitions
+        @definitions = false
+        clause_parse(attrs, xml, node)
+        @definitions = defs
+      end
+
+      def symbols_attrs(node, a)
+        case sectiontype1(node)
+        when "symbols" then a.merge(type: "symbols")
+        when "abbreviated terms", "abbreviations" then a.merge(type: "abbreviated_terms")
+        else
+          a
+        end
+      end
+
+      def symbols_parse(attr, xml, node)
+        node.role == "nonterm" and return nonterm_symbols_parse(attr, xml, node)
+        xml.definitions **attr_code(attr) do |xml_section|
+          xml_section.title { |t| t << node.title }
+          defs = @definitions
+          termdefs = @term_def
+          @definitions = true
+          @term_def = false
+          xml_section << node.content
+          @definitions = defs
+          @term_def = termdefs
+        end
+      end
+
+      def nonterm_term_def_subclause_parse(attrs, xml, node)
+        defs = @term_def
+        @term_def = false
+        clause_parse(attrs, xml, node)
+        @term_def = defs
+      end
+
+      def terms_boilerplate_parse(attrs, xml, node)
+        defs = @term_def
+        @term_def = false
+        clause_parse(attrs.merge(type: "boilerplate"), xml, node)
+        @term_def = defs
+      end
+
+      # subclause contains subclauses
+      def term_def_subclause_parse(attrs, xml, node)
+        node.role == "nonterm"  and return nonterm_term_def_subclause_parse(attrs, xml, node)
+        node.role == "boilerplate"  and return terms_boilerplate_parse(attrs, xml, node)
+        st = sectiontype(node, false)
+        return symbols_parse(attrs, xml, node) if @definitions
+        sub = node.find_by(context: :section) { |s| s.level == node.level + 1 }
+        sub.empty? || (return term_def_parse(attrs, xml, node, false))
+        st == "symbols and abbreviated terms" and (return symbols_parse(attrs, xml, node))
+        st == "terms and definitions" and return clause_parse(attrs, xml, node)
+        term_def_subclause_parse1(attrs, xml, node)
+      end
+
+      def term_def_subclause_parse1(attrs, xml, node)
+        xml.term **attr_code(attrs) do |xml_section|
+          xml_section.preferred { |name| name << node.title }
+          xml_section << node.content
+        end
+      end
+
+      def term_def_parse(attrs, xml, node, toplevel)
+        xml.terms **attr_code(attrs) do |section|
+          section.title { |t| t << node.title }
+          (s = node.attr("source")) && s.split(/,/).each do |s1|
+            section.termdocsource(nil, **attr_code(bibitemid: s1))
+          end
+          section << node.content
+        end
+      end
+
+      def term_source_attrs(seen_xref)
+        { bibitemid: seen_xref.children[0]["target"],
+          format: seen_xref.children[0]["format"], type: "inline" }
+      end
+
+      def add_term_source(xml_t, seen_xref, m)
+        if seen_xref.children[0].name == "concept"
+          xml_t.origin { |o| o << seen_xref.children[0].to_xml }
+        else
+          xml_t.origin seen_xref.children[0].content, **attr_code(term_source_attrs(seen_xref))
+        end
+        m[:text] && xml_t.modification do |mod|
+          mod.p { |p| p << m[:text].sub(/^\s+/, "") }
+        end
+      end
+
+      TERM_REFERENCE_RE_STR = <<~REGEXP.freeze
+        ^(?<xref><(xref|concept)[^>]+>([^<]*</(xref|concept)>)?)
+               (,\s(?<text>.*))?
+        $
+      REGEXP
+      TERM_REFERENCE_RE =
+        Regexp.new(TERM_REFERENCE_RE_STR.gsub(/\s/, "").gsub(/_/, "\\s"),
+                   Regexp::IGNORECASE | Regexp::MULTILINE)
+
+      def extract_termsource_refs(text, node)
+        matched = TERM_REFERENCE_RE.match text
+        matched.nil? and @log.add("AsciiDoc Input", node, "term reference not in expected format: #{text}")
+        matched
+      end
+
+      def termsource(node)
+        matched = extract_termsource_refs(node.content, node) || return
+        noko do |xml|
+          attrs = { status: matched[:text] ? "modified" : "identical" }
+          xml.termsource **attrs do |xml_t|
+            seen_xref = Nokogiri::XML.fragment(matched[:xref])
+            add_term_source(xml_t, seen_xref, matched)
+          end
+        end.join("\n")
+      end
+    end
+  end
+end