metanorma-standoc 1.9.0 → 1.10.0

data/lib/asciidoctor/standoc/macros_terms.rb

@@ -1,3 +1,5 @@
+require "csv"
+
 module Asciidoctor
   module Standoc
     class AltTermInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
@@ -36,46 +38,54 @@ module Asciidoctor
       end
     end
 
-     # Macro to transform `term[X,Y]` into em, termxref xml
     class TermRefInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
       use_dsl
       named :term
-      name_positional_attributes 'name', 'termxref'
+      name_positional_attributes "name", "termxref"
       using_format :short
 
       def process(_parent, _target, attrs)
-        termref = attrs['termxref'] || attrs['name']
-        "<em>#{attrs['name']}</em> (<termxref>#{termref}</termxref>)"
+        termref = attrs["termxref"] || attrs["name"]
+        "<concept><termxref>#{attrs['name']}</termxref>"\
+          "<renderterm>#{termref}</renderterm><xrefrender/></concept>"
       end
     end
 
+    # Possibilities:
+    # {{<<id>>, term}}
+    # {{<<id>>, term, text}}
+    # {{<<termbase:id>>, term}}
+    # {{<<termbase:id>>, term, text}}
+    # {{term}} equivalent to term:[term]
+    # {{term, text}} equivalent to term:[term, text]
+    # text may optionally be followed by crossreference-rendering, options=""
     class ConceptInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
       use_dsl
       named :concept
-      name_positional_attributes "id", "word", "term"
-      # match %r{concept:(?<target>[^\[]*)\[(?<content>|.*?[^\\])\]$}
       match /\{\{(?<content>|.*?[^\\])\}\}/
       using_format :short
 
-      # deal with locality attrs and their disruption of positional attrs
-      def preprocess_attrs(attrs)
-        attrs.delete("term") if attrs["term"] && !attrs["word"]
-        attrs.delete(3) if attrs[3] == attrs["term"]
-        a = attrs.keys.reject { |k| k.is_a?(String) || [1, 2].include?(k) }
-        attrs["word"] ||= attrs[a[0]] if !a.empty?
-        attrs["term"] ||= attrs[a[1]] if a.length > 1
-        attrs
+      def preprocess_attrs(target)
+        m = /^(?<id>&lt;&lt;.+?&gt;&gt;)?(?<rest>.*)$/.match(target)
+        ret = { id: m[:id]&.sub(/^&lt;&lt;/, "")&.sub(/&gt;&gt;$/, "") }
+        m2 = /^(?<rest>.*)(?<opt>,option=.+)?$/.match(m[:rest].sub(/^,/, ""))
+        ret[:opt] = m2[:opt]&.sub(/^,option=/, "")
+        attrs = CSV.parse_line(m2[:rest]) || []
+        ret.merge(term: attrs[0], word: attrs[1] || attrs[0],
+                  xrefrender: attrs[2])
       end
 
-      def process(parent, _target, attr)
-        attr = preprocess_attrs(attr)
-        localities = attr.keys.reject { |k| %w(id word term).include? k }.
-          reject { |k| k.is_a? Numeric }.
-          map { |k| "#{k}=#{attr[k]}" }.join(",")
-        text = [localities, attr["word"]].reject{ |k| k.nil? || k.empty? }.
-          join(",")
-        out = Asciidoctor::Inline.new(parent, :quoted, text).convert
-        %{<concept key="#{attr['id']}" term="#{attr['term']}">#{out}</concept>}
+      def process(parent, target, _attrs)
+        attrs = preprocess_attrs(target)
+        termout = Asciidoctor::Inline.new(parent, :quoted, attrs[:term]).convert
+        wordout = Asciidoctor::Inline.new(parent, :quoted, attrs[:word]).convert
+        xrefout = Asciidoctor::Inline.new(parent, :quoted,
+                                          attrs[:xrefrender]).convert
+        attrs[:id] and return "<concept key='#{attrs[:id]}'><refterm>"\
+          "#{termout}</refterm><renderterm>#{wordout}</renderterm>"\
+          "<xrefrender>#{xrefout}</xrefrender></concept>"
+        "<concept><termxref>#{termout}</termxref><renderterm>#{wordout}"\
+          "</renderterm><xrefrender>#{xrefout}</xrefrender></concept>"
       end
     end
   end

data/lib/asciidoctor/standoc/ref.rb

@@ -1,12 +1,14 @@
+require_relative "ref_date_id"
+
 module Asciidoctor
   module Standoc
     module Refs
-      def iso_publisher(t, code)
+      def iso_publisher(bib, code)
         code.sub(/ .*$/, "").split(/\//).each do |abbrev|
-          t.contributor do |c|
+          bib.contributor do |c|
             c.role **{ type: "publisher" }
             c.organization do |org|
-              organization(org, abbrev)
+              organization(org, abbrev, true)
             end
           end
         end
@@ -20,58 +22,19 @@ module Asciidoctor
         { id: m[:anchor], type: "standard" }
       end
 
-      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 use_my_anchor(ref, id)
-        ref.parent.elements.last["id"] = id
-        ref
-      end
-
-      def id_and_year(id, year)
-        year ? "#{id}:#{year}" : id
-      end
-
-      def docid(t, code)
-        type, code1 = /^\[\d+\]$|^\([^)]+\).*$/.match(code) ?
-          ["metanorma", mn_code(code)] : @bibdb&.docid_type(code) || [nil, code]
-        code1.sub!(/^nofetch\((.+)\)$/, "\\1")
-        t.docidentifier **attr_code(type: type) do |d|
-          d << code1
-        end
-      end
-
-      def docnumber(t, code)
-        t.docnumber do |d|
-          d << HTMLEntities.new.decode(code).sub(/^[^\d]*/, "")
-        end
-      end
-
-      def norm_year(yr)
-        /^\&\#821[12];$/.match(yr) and return "--" 
-        /^\d\d\d\d-\d\d\d\d$/.match(yr) and return yr
-        yr&.sub(/(?<=[0-9])-.*$/, "")
-      end
-
-      def isorefrender1(t, m, yr, allp = "")
-        t.title(**plaintxt) { |i| i << ref_normalise(m[:text]) }
-        docid(t, m[:usrlbl]) if m[:usrlbl]
-        docid(t, id_and_year(m[:code], yr) + allp)
-        docnumber(t, m[:code])
+      def isorefrender1(bib, m, yr, allp = "")
+        bib.title(**plaintxt) { |i| i << ref_normalise(m[:text]) }
+        docid(bib, m[:usrlbl]) if m[:usrlbl]
+        docid(bib, id_and_year(m[:code], yr) + allp)
+        docnumber(bib, m[:code])
       end
 
       def isorefmatches(xml, m)
         yr = norm_year(m[:year])
-        ref = fetch_ref xml, m[:code], yr, title: m[:text], usrlbl: m[:usrlbl], lang: (@lang || :all)
+        ref = fetch_ref xml, m[:code], yr, title: m[:text], usrlbl: m[:usrlbl],
+          lang: (@lang || :all)
         return use_my_anchor(ref, m[:anchor]) if ref
+
         xml.bibitem **attr_code(ref_attributes(m)) do |t|
           isorefrender1(t, m, yr)
           yr and t.date **{ type: "published" } do |d|
@@ -85,6 +48,7 @@ module Asciidoctor
         ref = fetch_ref xml, m[:code], nil, no_year: true, note: m[:fn],
           title: m[:text], usrlbl: m[:usrlbl], lang: (@lang || :all)
         return use_my_anchor(ref, m[:anchor]) if ref
+
         isorefmatches2_1(xml, m)
       end
 
@@ -95,49 +59,51 @@ module Asciidoctor
             d.on "--"
           end
           iso_publisher(t, m[:code])
-          m[:fn].nil? or t.note(**plaintxt.merge(type: "Unpublished-Status")) do |p|
-            p << "#{m[:fn]}"
+          unless m[:fn].nil?
+            t.note(**plaintxt.merge(type: "Unpublished-Status")) do |p|
+            p << (m[:fn]).to_s
+            end
           end
         end
       end
 
-      def conditional_date(t, m, noyr)
-        m.names.include?("year") and !m[:year].nil? and
-          t.date(**{ type: "published" }) do |d|
-          noyr and d.on "--" or set_date_range(d, norm_year(m[:year]))
-        end
-      end
-
       def isorefmatches3(xml, m)
         yr = norm_year(m[:year])
         hasyr = !yr.nil? && yr != "--"
-        ref = fetch_ref xml, m[:code], hasyr ? yr : nil, all_parts: true, 
-          no_year: yr == "--", text: m[:text], usrlbl: m[:usrlbl], lang: (@lang || :all)
+        ref = fetch_ref(xml, m[:code], hasyr ? yr : nil,
+                        all_parts: true,
+                        no_year: yr == "--", text: m[:text], usrlbl: m[:usrlbl],
+                        lang: (@lang || :all))
         return use_my_anchor(ref, m[:anchor]) if ref
+
         isorefmatches3_1(xml, m, yr, hasyr, ref)
       end
 
-      def isorefmatches3_1(xml, m, yr, hasyr, ref)
+      def isorefmatches3_1(xml, m, yr, _hasyr, _ref)
         xml.bibitem(**attr_code(ref_attributes(m))) do |t|
           isorefrender1(t, m, yr, " (all parts)")
           conditional_date(t, m, yr == "--")
           iso_publisher(t, m[:code])
-          m.names.include?("fn") && m[:fn] and
-            t.note(**plaintxt.merge(type: "Unpublished-Status")) { |p| p << "#{m[:fn]}" }
-          t.extent **{ type: 'part' } do |e|
+          if m.names.include?("fn") && m[:fn]
+            t.note(**plaintxt.merge(type: "Unpublished-Status")) do |p|
+              p << (m[:fn]).to_s
+            end
+          end
+          t.extent **{ type: "part" } do |e|
             e.referenceFrom "all"
           end
         end
       end
 
-      def refitem_render1(m, code, t)
+      def refitem_render1(m, code, bib)
         if code[:type] == "path"
-          t.uri code[:key].sub(/\.[a-zA-Z0-9]+$/, ""), **{ type: "URI" }
-          t.uri code[:key].sub(/\.[a-zA-Z0-9]+$/, ""), **{ type: "citation" }
+          bib.uri code[:key].sub(/\.[a-zA-Z0-9]+$/, ""), **{ type: "URI" }
+          bib.uri code[:key].sub(/\.[a-zA-Z0-9]+$/, ""), **{ type: "citation" }
         end
-        docid(t, m[:usrlbl]) if m[:usrlbl]
-        docid(t, /^\d+$/.match(code[:id]) ? "[#{code[:id]}]" : code[:id])
-        code[:type] == "repo" and t.docidentifier code[:key], **{ type: "repository" }
+        docid(bib, m[:usrlbl]) if m[:usrlbl]
+        docid(bib, /^\d+$/.match?(code[:id]) ? "[#{code[:id]}]" : code[:id])
+        code[:type] == "repo" and
+          bib.docidentifier code[:key], **{ type: "repository" }
       end
 
       def refitem_render(xml, m, code)
@@ -146,7 +112,7 @@ module Asciidoctor
             i << ref_normalise_no_format(m[:text])
           end
           refitem_render1(m, code, t)
-          docnumber(t, code[:id]) unless /^\d+$|^\(.+\)$/.match(code[:id])
+          docnumber(t, code[:id]) unless /^\d+$|^\(.+\)$/.match?(code[:id])
         end
       end
 
@@ -156,25 +122,30 @@ module Asciidoctor
 
       def analyse_ref_nofetch(ret)
         return ret unless m = /^nofetch\((?<id>.+)\)$/.match(ret[:id])
+
         ret.merge(id: m[:id], nofetch: true)
       end
 
       def analyse_ref_repo_path(ret)
-        return ret unless m = /^(?<type>repo|path):\((?<key>[^,]+),?(?<id>.*)\)$/.match(ret[:id])
+        return ret unless m =
+          /^(?<type>repo|path):\((?<key>[^,]+),?(?<id>.*)\)$/.match(ret[:id])
+
         id = m[:id].empty? ? m[:key].sub(%r{^[^/]+/}, "") : m[:id]
         ret.merge(id: id, type: m[:type], key: m[:key], nofetch: true)
       end
 
       def analyse_ref_numeric(ret)
-        return ret unless /^\d+$/.match(ret[:id])
+        return ret unless /^\d+$/.match?(ret[:id])
+
         ret.merge(numeric: true)
       end
 
       # ref id = (usrlbl)code[:-]year
       # code = nofetch(code) | (repo|path):(key,code) | \[? number \]? | ident
       def analyse_ref_code(code)
-        ret = {id: code}
-        return ret if code.nil? || code.empty?
+        ret = { id: code }
+        return ret if code.blank?
+
         analyse_ref_nofetch(analyse_ref_repo_path(analyse_ref_numeric(ret)))
       end
 
@@ -185,11 +156,13 @@ module Asciidoctor
         nil
       end
 
-      def refitem1(xml, item, m)
+      def refitem1(xml, _item, m)
         code = analyse_ref_code(m[:code])
         unless code[:id] && code[:numeric] || code[:nofetch]
-          ref = fetch_ref xml, code[:id], m.names.include?("year") ? m[:year] : nil, title: m[:text],
-            usrlbl: m[:usrlbl], lang: (@lang || :all)
+          ref = fetch_ref(xml, code[:id],
+                          m.names.include?("year") ? m[:year] : nil,
+                          title: m[:text],
+                          usrlbl: m[:usrlbl], lang: (@lang || :all))
           return use_my_anchor(ref, m[:anchor]) if ref
         end
         refitem_render(xml, m, code)
@@ -203,44 +176,46 @@ module Asciidoctor
         ref.gsub(/&amp;amp;/, "&amp;")
       end
 
-      ISO_REF = %r{^<ref\sid="(?<anchor>[^"]+)">
+      ISO_REF =
+        %r{^<ref\sid="(?<anchor>[^"]+)">
       \[(?<usrlbl>\([^)]+\))?(?<code>(ISO|IEC)[^0-9]*\s[0-9-]+|IEV)
-      (:(?<year>[0-9][0-9-]+))?\]</ref>,?\s*(?<text>.*)$}xm
+      (:(?<year>[0-9][0-9-]+))?\]</ref>,?\s*(?<text>.*)$}xm.freeze
 
-        ISO_REF_NO_YEAR = %r{^<ref\sid="(?<anchor>[^"]+)">
+      ISO_REF_NO_YEAR =
+        %r{^<ref\sid="(?<anchor>[^"]+)">
       \[(?<usrlbl>\([^)]+\))?(?<code>(ISO|IEC)[^0-9]*\s[0-9-]+):
-      (--|\&\#821[12]\;)\]</ref>,?\s*
+      (--|&\#821[12];)\]</ref>,?\s*
         (<fn[^>]*>\s*<p>(?<fn>[^\]]+)</p>\s*</fn>)?,?\s?(?<text>.*)$}xm
-
-        ISO_REF_ALL_PARTS = %r{^<ref\sid="(?<anchor>[^"]+)">
-        \[(?<usrlbl>\([^)]+\))?(?<code>(ISO|IEC)[^0-9]*\s[0-9]+)
-        (:(?<year>--|\&\#821[12]\;|[0-9][0-9-]+))?\s
-        \(all\sparts\)\]</ref>,?\s*
-          (<fn[^>]*>\s*<p>(?<fn>[^\]]+)</p>\s*</fn>,?\s?)?(?<text>.*)$}xm
-
-          NON_ISO_REF = %r{^<ref\sid="(?<anchor>[^"]+)">
-        \[(?<usrlbl>\([^)]+\))?(?<code>[^\]]+?)
-        ([:-](?<year>(19|20)[0-9][0-9][0-9-]*))?\]</ref>,?\s*(?<text>.*)$}xm
-
-        def reference1_matches(item)
-          matched = ISO_REF.match item
-          matched2 = ISO_REF_NO_YEAR.match item
-          matched3 = ISO_REF_ALL_PARTS.match item
-          [matched, matched2, matched3]
-        end
-
-        def reference1(node, item, xml)
-          matched, matched2, matched3 = reference1_matches(item)
-          if matched3.nil? && matched2.nil? && matched.nil? then refitem(xml, item, node)
-          elsif !matched.nil? then isorefmatches(xml, matched)
-          elsif !matched2.nil? then isorefmatches2(xml, matched2)
-          elsif !matched3.nil? then isorefmatches3(xml, matched3)
-          end
-        end
-
-        def mn_code(code)
-          code.sub(/^\(/, "[").sub(/\).*$/, "]").sub(/^nofetch\((.+)\)$/, "\\1")
+        .freeze
+
+      ISO_REF_ALL_PARTS =
+        %r{^<ref\sid="(?<anchor>[^"]+)">
+      \[(?<usrlbl>\([^)]+\))?(?<code>(ISO|IEC)[^0-9]*\s[0-9]+)
+      (:(?<year>--|&\#821[12];|[0-9][0-9-]+))?\s
+      \(all\sparts\)\]</ref>,?\s*
+        (<fn[^>]*>\s*<p>(?<fn>[^\]]+)</p>\s*</fn>,?\s?)?(?<text>.*)$}xm.freeze
+
+      NON_ISO_REF = %r{^<ref\sid="(?<anchor>[^"]+)">
+      \[(?<usrlbl>\([^)]+\))?(?<code>[^\]]+?)
+      ([:-](?<year>(19|20)[0-9][0-9][0-9-]*))?\]</ref>,?\s*(?<text>.*)$}xm
+        .freeze
+
+      def reference1_matches(item)
+        matched = ISO_REF.match item
+        matched2 = ISO_REF_NO_YEAR.match item
+        matched3 = ISO_REF_ALL_PARTS.match item
+        [matched, matched2, matched3]
+      end
+
+      def reference1(node, item, xml)
+        matched, matched2, matched3 = reference1_matches(item)
+        if matched3.nil? && matched2.nil? && matched.nil?
+          refitem(xml, item, node)
+        elsif !matched.nil? then isorefmatches(xml, matched)
+        elsif !matched2.nil? then isorefmatches2(xml, matched2)
+        elsif !matched3.nil? then isorefmatches3(xml, matched3)
         end
+      end
     end
   end
 end

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