metanorma-standoc 1.8.8 → 1.9.4

data/lib/asciidoctor/standoc/ref_date_id.rb

@@ -0,0 +1,62 @@
+module Asciidoctor
+  module Standoc
+    module Refs
+      def set_date_range(date, text)
+        matched = /^(?<from>[0-9]+)(-+(?<to>[0-9]+))?$/.match text
+        return unless matched[:from]
+
+        if matched[:to]
+          date.from matched[:from]
+          date.to matched[:to]
+        else
+          date.on matched[:from]
+        end
+      end
+
+      def id_and_year(id, year)
+        year ? "#{id}:#{year}" : id
+      end
+
+      def norm_year(year)
+        /^&\#821[12];$/.match(year) and return "--"
+        /^\d\d\d\d-\d\d\d\d$/.match(year) and return year
+        year&.sub(/(?<=[0-9])-.*$/, "")
+      end
+
+      def conditional_date(bib, match, noyr)
+        if match.names.include?("year") && !match[:year].nil?
+          bib.date(**{ type: "published" }) do |d|
+            noyr and d.on "--" or set_date_range(d, norm_year(match[:year]))
+          end
+        end
+      end
+
+      def use_my_anchor(ref, id)
+        ref.parent.elements.last["id"] = id
+        ref
+      end
+
+      def docid(bib, code)
+        type, code1 = if /^\[\d+\]$|^\([^)]+\).*$/.match?(code)
+                        ["metanorma", mn_code(code)]
+                      else
+                        @bibdb&.docid_type(code) || [nil, code]
+                      end
+        code1.sub!(/^nofetch\((.+)\)$/, "\\1")
+        bib.docidentifier **attr_code(type: type) do |d|
+          d << code1
+        end
+      end
+
+      def docnumber(bib, code)
+        bib.docnumber do |d|
+          d << HTMLEntities.new.decode(code).sub(/^[^\d]*/, "")
+        end
+      end
+
+      def mn_code(code)
+        code.sub(/^\(/, "[").sub(/\).*$/, "]").sub(/^nofetch\((.+)\)$/, "\\1")
+      end
+    end
+  end
+end

data/lib/asciidoctor/standoc/ref_sect.rb

@@ -10,10 +10,10 @@ module Asciidoctor
       end
 
       def reference(node)
-          noko do |xml|
-            node.items.each { |item| reference1(node, item.text, xml) }
-          end.join
-        end
+        noko do |xml|
+          node.items.each { |item| reference1(node, item.text, xml) }
+        end.join
+      end
 
       def bibliography_parse(attrs, xml, node)
         node.option? "bibitem" and return bibitem_parse(attrs, xml, node)
@@ -43,12 +43,12 @@ module Asciidoctor
         node.attr("style") == "bibliography" or
           @log.add("AsciiDoc Input", node, "Section not marked up as [bibliography]!")
         @norm_ref = true
-        xml.references **attr_code(attrs.merge(
-          normative: node.attr("normative") || true)) do |xml_section|
-            xml_section.title { |t| t << node.title }
-            xml_section << node.content
-          end
-          @norm_ref = false
+        attrs = attrs.merge(normative: node.attr("normative") || true)
+        xml.references **attr_code(attrs) do |xml_section|
+          xml_section.title { |t| t << node.title }
+          xml_section << node.content
+        end
+        @norm_ref = false
       end
 
       def global_ievcache_name
@@ -57,6 +57,7 @@ module Asciidoctor
 
       def local_ievcache_name(cachename)
         return nil if cachename.nil?
+
         cachename += "_iev" unless cachename.empty?
         cachename = "iev" if cachename.empty?
         "#{cachename}/cache"
@@ -64,10 +65,11 @@ module Asciidoctor
 
       def fetch_ref(xml, code, year, **opts)
         return nil if opts[:no_year]
+
         code = code.sub(/^\([^)]+\)/, "")
-        #require "byebug"; byebug if opts[:lang] == "fr"
         hit = @bibdb&.fetch(code, year, opts)
         return nil if hit.nil?
+
         xml.parent.add_child(smart_render_xml(hit, code, opts))
         xml
       rescue RelatonBib::RequestError
@@ -91,10 +93,9 @@ module Asciidoctor
           "<docidentifier type='metanorma'>#{mn_code(usrlbl)}</docidentifier>"
       end
 
-      def smart_render_xml(x, code, opts)
-        x.respond_to? :to_xml or return nil
-        xstr = x.to_xml(lang: opts[:lang])
-        xml = Nokogiri::XML(xstr)
+      def smart_render_xml(xml, code, opts)
+        xml.respond_to? :to_xml or return nil
+        xml = Nokogiri::XML(xml.to_xml(lang: opts[:lang]))
         emend_biblio(xml, code, opts[:title], opts[:usrlbl])
         xml.xpath("//date").each { |d| Metanorma::Utils::endash_date(d) }
         xml.traverse do |n|
@@ -105,17 +106,19 @@ module Asciidoctor
 
       def init_bib_caches(node)
         return if @no_isobib
+
         global = !@no_isobib_cache && !node.attr("local-cache-only")
         local = node.attr("local-cache") || node.attr("local-cache-only")
         local = nil if @no_isobib_cache
         @bibdb = Relaton::DbCache.init_bib_caches(
           local_cache: local,
           flush_caches: node.attr("flush-caches"),
-          global_cache: global)
+          global_cache: global
+        )
       end
 
       def init_iev_caches(node)
-        unless (@no_isobib_cache || @no_isobib)
+        unless @no_isobib_cache || @no_isobib
           node.attr("local-cache-only") or
             @iev_globalname = global_ievcache_name
           @iev_localname = local_ievcache_name(node.attr("local-cache") ||

data/lib/asciidoctor/standoc/section.rb

@@ -10,7 +10,9 @@ module Asciidoctor
       @norm_ref = false
 
       def sectiontype1(node)
-        node&.attr("heading")&.downcase || node.title.gsub(/<[^>]+>/, "").downcase
+        node&.attr("heading")&.downcase ||
+          node.title.gsub(%r{<index>.*?</index>}m, "").gsub(/<[^>]+>/, "")
+          .strip.downcase
       end
 
       def sectiontype(node, level = true)

data/lib/asciidoctor/standoc/term_lookup_cleanup.rb

@@ -6,8 +6,8 @@ module Asciidoctor
     # Lookup all `term` and `calause` tags and replace `termxref` tags with
     # `xref`:target tag
     class TermLookupCleanup
-      AUTOMATIC_GENERATED_ID_REGEXP = /\A_/
-      EXISTING_TERM_REGEXP = /\Aterm-/
+      AUTOMATIC_GENERATED_ID_REGEXP = /\A_/.freeze
+      EXISTING_TERM_REGEXP = /\Aterm-/.freeze
 
       attr_reader :xmldoc, :termlookup, :log
 
@@ -15,17 +15,27 @@ module Asciidoctor
         @xmldoc = xmldoc
         @log = log
         @termlookup = {}
+        @idhash = {}
       end
 
       def call
+        @idhash = populate_idhash
         @termlookup = replace_automatic_generated_ids_terms
         set_termxref_tags_target
       end
 
       private
 
+      def populate_idhash
+        xmldoc.xpath("//*[@id]").each_with_object({}) do |n, mem|
+          next unless /^term-/.match?(n["id"])
+
+          mem[n["id"]] = true
+        end
+      end
+
       def set_termxref_tags_target
-        xmldoc.xpath('//termxref').each do |node|
+        xmldoc.xpath("//termxref").each do |node|
           target = normalize_ref_id(node.text)
           if termlookup[target].nil?
             remove_missing_ref(node, target)
@@ -36,7 +46,7 @@ module Asciidoctor
       end
 
       def remove_missing_ref(node, target)
-        log.add('AsciiDoc Input', node,
+        log.add("AsciiDoc Input", node,
                 %(Error: Term reference in `term[#{target}]` missing: \
                 "#{target}" is not defined in document))
         term_name_node = node.previous.previous
@@ -49,34 +59,39 @@ module Asciidoctor
       end
 
       def modify_ref_node(node, target)
-        node.name = 'xref'
-        node['target'] = termlookup[target]
+        node.name = "xref"
+        node["target"] = termlookup[target]
         node.children.remove
-        node.remove_attribute('defaultref')
+        node.remove_attribute("defaultref")
       end
 
       def replace_automatic_generated_ids_terms
-        xmldoc.xpath('//term').each.with_object({}) do |term_node, res|
-          normalize_id_and_memorize(term_node, res, './preferred')
+        xmldoc.xpath("//term").each.with_object({}) do |term_node, res|
+          normalize_id_and_memorize(term_node, res, "./preferred")
         end
       end
 
       def normalize_id_and_memorize(term_node, res_table, text_selector)
         term_text = normalize_ref_id(term_node.at(text_selector).text)
-                  unless AUTOMATIC_GENERATED_ID_REGEXP.match(term_node['id']).nil?
-        term_node['id'] = unique_text_id(term_text)
-                  end
-        res_table[term_text] = term_node['id']
+        unless AUTOMATIC_GENERATED_ID_REGEXP.match(term_node["id"]).nil?
+          id = unique_text_id(term_text)
+          term_node["id"] = id
+          @idhash[id] = true
+        end
+        res_table[term_text] = term_node["id"]
       end
 
       def normalize_ref_id(text)
-        text.downcase.gsub(/[[:space:]]/, '-')
+        text.downcase.gsub(/[[:space:]]/, "-")
       end
 
       def unique_text_id(text)
-        return "term-#{text}" if xmldoc.at("//*[@id = 'term-#{text}']").nil?
+        unless @idhash["term-#{text}"]
+          return "term-#{text}"
+        end
+
         (1..Float::INFINITY).lazy.each do |index|
-          if xmldoc.at("//*[@id = 'term-#{text}-#{index}']").nil?
+          unless @idhash["term-#{text}-#{index}"]
             break("term-#{text}-#{index}")
           end
         end

data/lib/asciidoctor/standoc/terms.rb

@@ -12,12 +12,13 @@ module Asciidoctor
         @definitions = defs
       end
 
-      def symbols_attrs(node, a)
+      def symbols_attrs(node, attr)
         case sectiontype1(node)
-        when "symbols" then a.merge(type: "symbols")
-        when "abbreviated terms", "abbreviations" then a.merge(type: "abbreviated_terms")
+        when "symbols" then attr.merge(type: "symbols")
+        when "abbreviated terms", "abbreviations"
+          attr.merge(type: "abbreviated_terms")
         else
-          a
+          attr
         end
       end
 
@@ -51,13 +52,17 @@ module Asciidoctor
 
       # 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)
+        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 == "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
@@ -69,7 +74,7 @@ module Asciidoctor
         end
       end
 
-      def term_def_parse(attrs, xml, node, toplevel)
+      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|
@@ -79,19 +84,23 @@ module Asciidoctor
         end
       end
 
-      def term_source_attrs(seen_xref)
-        { bibitemid: seen_xref.children[0]["target"],
+      def term_source_attrs(_node, seen_xref)
+        { case: seen_xref.children[0]["case"],
+          droploc: seen_xref.children[0]["droploc"],
+          bibitemid: seen_xref.children[0]["target"],
           format: seen_xref.children[0]["format"], type: "inline" }
       end
 
-      def add_term_source(xml_t, seen_xref, m)
+      def add_term_source(node, xml_t, seen_xref, match)
         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))
+          attrs = term_source_attrs(node, seen_xref)
+          attrs.delete(:text)
+          xml_t.origin seen_xref.children[0].content, **attr_code(attrs)
         end
-        m[:text] && xml_t.modification do |mod|
-          mod.p { |p| p << m[:text].sub(/^\s+/, "") }
+        match[:text] && xml_t.modification do |mod|
+          mod.p { |p| p << match[:text].sub(/^\s+/, "") }
         end
       end
 
@@ -106,7 +115,9 @@ module Asciidoctor
 
       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.nil? and @log.add("AsciiDoc Input", node,
+                                  "term reference not in expected format:"\
+                                  "#{text}")
         matched
       end
 
@@ -116,7 +127,7 @@ module Asciidoctor
           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)
+            add_term_source(node, xml_t, seen_xref, matched)
           end
         end.join("\n")
       end

data/lib/asciidoctor/standoc/utils.rb

@@ -19,11 +19,11 @@ module Asciidoctor
       end
 
       NOKOHEAD = <<~HERE.freeze
-          <!DOCTYPE html SYSTEM
-          "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-          <html xmlns="http://www.w3.org/1999/xhtml">
-          <head> <title></title> <meta charset="UTF-8" /> </head>
-          <body> </body> </html>
+        <!DOCTYPE html SYSTEM
+        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+        <html xmlns="http://www.w3.org/1999/xhtml">
+        <head> <title></title> <meta charset="UTF-8" /> </head>
+        <body> </body> </html>
       HERE
 
       # block for processing XML document fragments as XHTML,
@@ -34,9 +34,9 @@ module Asciidoctor
         fragment = doc.fragment("")
         ::Nokogiri::XML::Builder.with fragment, &block
         fragment.to_xml(encoding: "US-ASCII", indent: 0).lines.map do |l|
-          l.gsub(/>\n$/, ">").gsub(/\s*\n$/m, " ").gsub("&#150;", "\u0096").
-            gsub("&#151;", "\u0097").gsub("&#x96;", "\u0096").
-            gsub("&#x97;", "\u0097")
+          l.gsub(/>\n$/, ">").gsub(/\s*\n$/m, " ").gsub("&#150;", "\u0096")
+            .gsub("&#151;", "\u0097").gsub("&#x96;", "\u0096")
+            .gsub("&#x97;", "\u0097")
         end
       end
 
@@ -66,10 +66,36 @@ module Asciidoctor
         conv
       end
 
+      def default_script(lang)
+        case lang
+        when "ar", "fa"
+          "Arab"
+        when "ur"
+          "Aran"
+        when "ru", "bg"
+          "Cyrl"
+        when "hi"
+          "Deva"
+        when "el"
+          "Grek"
+        when "zh"
+          "Hans"
+        when "ko"
+          "Kore"
+        when "he"
+          "Hebr"
+        when "ja"
+          "Jpan"
+        else
+          "Latn"
+        end
+      end
+
       class EmptyAttr
-        def attr(_x)
+        def attr(_any_attribute)
           nil
         end
+
         def attributes
           {}
         end

data/lib/asciidoctor/standoc/validate.rb

@@ -1,5 +1,5 @@
 require "asciidoctor/standoc/utils"
-require_relative "./validate_section.rb"
+require_relative "./validate_section"
 require "nokogiri"
 require "jing"
 require "iev"
@@ -7,13 +7,13 @@ require "iev"
 module Asciidoctor
   module Standoc
     module Validate
-
       SOURCELOCALITY = "./termsource/origin//locality[@type = 'clause']/"\
         "referenceFrom".freeze
 
       def init_iev
         return nil if @no_isobib
         return @iev if @iev
+
         @iev = Iev::Db.new(@iev_globalname, @iev_localname) unless @no_isobib
         @iev
       end
@@ -44,23 +44,23 @@ module Asciidoctor
         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)
-          @log.add("Bibliography", b, "Numeric reference in normative references")
+          next unless /^\[\d+\]$/.match?(docid.text)
+
+          @log.add("Bibliography", b,
+                   "Numeric reference in normative references")
           found = true
         end
-        if found
-          clean_exit
-          abort("Numeric reference in normative references")
-        end
+        found and
+          clean_abort("Numeric reference in normative references", doc.to_xml)
       end
 
-      def repeat_id_validate1(ids, x)
-        if ids[x["id"]]
-          @log.add("Anchors", x, "Anchor #{x['id']} has already been used "\
-                   "at line #{ids[x['id']]}")
+      def repeat_id_validate1(ids, elem)
+        if ids[elem["id"]]
+          @log.add("Anchors", elem, "Anchor #{elem['id']} has already been "\
+                   "used at line #{ids[elem['id']]}")
           raise StandardError.new "Error: multiple instances of same ID"
         else
-          ids[x["id"]] = x.line
+          ids[elem["id"]] = elem.line
         end
         ids
       end
@@ -72,39 +72,41 @@ module Asciidoctor
             ids = repeat_id_validate1(ids, x)
           end
         rescue StandardError => e
-          clean_exit
-          abort(e.message)
+          clean_abort(e.message, doc.to_xml)
         end
       end
 
       def schema_validate(doc, schema)
-        Tempfile.open(["tmp", ".xml"], :encoding => 'UTF-8') do |f|
+        Tempfile.open(["tmp", ".xml"], encoding: "UTF-8") do |f|
           begin
-            f.write(doc.to_xml) 
-            f.close
-            errors = Jing.new(schema).validate(f.path)
-            warn "Syntax Valid!" if errors.none?
-            errors.each do |e|
-              @log.add("Metanorma XML Syntax",
-                       "XML Line #{"%06d" % e[:line]}:#{e[:column]}",
-                       e[:message])
-            end
+            schema_validate1(f, doc, schema)
           rescue Jing::Error => e
-            clean_exit
-            abort "Jing failed with error: #{e}"
+            clean_abort("Jing failed with error: #{e}", doc.to_xml)
           ensure
             f.close!
           end
         end
       end
 
+      def schema_validate1(file, doc, schema)
+        file.write(doc.to_xml)
+        file.close
+        errors = Jing.new(schema).validate(file.path)
+        warn "Syntax Valid!" if errors.none?
+        errors.each do |e|
+          @log.add("Metanorma XML Syntax",
+                   "XML Line #{'%06d' % e[:line]}:#{e[:column]}", e[:message])
+        end
+      end
+
       # RelaxNG cannot cope well with wildcard attributes. So we strip
       # any attributes from FormattedString instances (which can contain
       # xs:any markup, and are signalled with @format) before validation.
       def formattedstr_strip(doc)
         doc.xpath("//*[@format] | //stem | //bibdata//description | "\
                   "//formattedref | //bibdata//note | //bibdata/abstract | "\
-                  "//bibitem/abstract | //bibitem/note | //misc-container").each do |n|
+                  "//bibitem/abstract | //bibitem/note | //misc-container")
+          .each do |n|
           n.elements.each do |e|
             e.traverse do |e1|
               e1.element? and e1.each { |k, _v| e1.delete(k) }