metanorma-standoc 1.8.7 → 1.9.3

data/lib/asciidoctor/standoc/macros_form.rb

@@ -0,0 +1,63 @@
+module Asciidoctor
+  module Standoc
+    class FormInputMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :input
+
+      def process(_parent, target, attr)
+        m = %w(id name value disabled readonly checked maxlength minlength)
+          .map { |a| attr[a] ? " #{a}='#{attr[a]}'" : nil }.compact
+        %{<input type='#{target}' #{m.join}/>}
+      end
+    end
+
+    class FormLabelMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :label
+      parse_content_as :text
+
+      def process(parent, target, attr)
+        out = Asciidoctor::Inline.new(parent, :quoted, attr["text"]).convert
+        %{<label for="#{target}">#{out}</label>}
+      end
+    end
+
+    class FormTextareaMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :textarea
+      using_format :short
+
+      def process(_parent, _target, attr)
+        m = %w(id name rows cols value)
+          .map { |a| attr[a] ? " #{a}='#{attr[a]}'" : nil }.compact
+        %{<textarea #{m.join}/>}
+      end
+    end
+
+    class FormSelectMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :select
+      using_format :short
+
+      def process(parent, _target, attr)
+        m = %w(id name size disabled multiple value)
+          .map { |a| attr[a] ? " #{a}='#{attr[a]}'" : nil }.compact
+        out = Asciidoctor::Inline.new(parent, :quoted, attr["text"]).convert
+        %{<select #{m.join}>#{out}</select>}
+      end
+    end
+
+    class FormOptionMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :option
+      using_format :short
+
+      def process(parent, _target, attr)
+        m = %w(disabled value)
+          .map { |a| attr[a] ? " #{a}='#{attr[a]}'" : nil }.compact
+        out = Asciidoctor::Inline.new(parent, :quoted, attr["text"]).convert
+        %{<option #{m.join}">#{out}</option>}
+      end
+    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

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") ||