metanorma-standoc 1.9.4 → 1.10.3

data/lib/asciidoctor/standoc/macros_plantuml.rb

@@ -4,18 +4,17 @@ module Asciidoctor
       # https://stackoverflow.com/questions/2108727/which-in-ruby-checking-if-program-exists-in-path-from-ruby
       def self.plantuml_installed?
         cmd = "plantuml"
-        exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
-        ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+        exts = ENV["PATHEXT"] ? ENV["PATHEXT"].split(";") : [""]
+        ENV["PATH"].split(File::PATH_SEPARATOR).each do |path|
           exts.each do |ext|
             exe = File.join(path, "#{cmd}#{ext}")
             return exe if File.executable?(exe) && !File.directory?(exe)
           end
         end
         raise "PlantUML not installed"
-        nil
       end
 
-      def self.run umlfile, outfile
+      def self.run(umlfile, outfile)
         system "plantuml #{umlfile.path}" or (warn $? and return false)
         i = 0
         until !Gem.win_platform? || File.exist?(outfile) || i == 15
@@ -29,9 +28,9 @@ module Asciidoctor
       # sleep need for windows because dot works in separate process and
       # plantuml process may finish earlier then dot, as result png file
       # maybe not created yet after plantuml finish
-      def self.generate_file parent, reader
+      def self.generate_file(parent, reader)
         localdir = Metanorma::Utils::localdir(parent.document)
-        imagesdir = parent.document.attr('imagesdir')
+        imagesdir = parent.document.attr("imagesdir")
         umlfile, outfile = save_plantuml parent, reader, localdir
         run(umlfile, outfile) or raise "No image output from PlantUML (#{umlfile}, #{outfile})!"
         umlfile.unlink
@@ -40,7 +39,7 @@ module Asciidoctor
         File.writable?(localdir) or raise "Destination path #{path} not writable for PlantUML!"
         path.mkpath
         File.writable?(path) or raise "Destination path #{path} not writable for PlantUML!"
-        #File.exist?(path) or raise "Destination path #{path} already exists for PlantUML!"
+        # File.exist?(path) or raise "Destination path #{path} already exists for PlantUML!"
 
         # Warning: metanorma/metanorma-standoc#187
         # Windows Ruby 2.4 will crash if a Tempfile is "mv"ed.
@@ -51,21 +50,21 @@ module Asciidoctor
         imagesdir ? filename : File.join(path, filename)
       end
 
-      def self.save_plantuml parent, reader, localdir
+      def self.save_plantuml(_parent, reader, _localdir)
         src = reader.source
         reader.lines.first.sub(/\s+$/, "").match /^@startuml($| )/ or
           src = "@startuml\n#{src}\n@enduml\n"
         /^@startuml (?<fn>[^\n]+)\n/ =~ src
-        Tempfile.open(["plantuml", ".pml"], :encoding => "utf-8") do |f|
+        Tempfile.open(["plantuml", ".pml"], encoding: "utf-8") do |f|
           f.write(src)
           [f, File.join(File.dirname(f.path),
-                        (fn || File.basename(f.path, ".pml")) + ".png")]
+                        "#{fn || File.basename(f.path, '.pml')}.png")]
         end
       end
 
-      def self.generate_attrs attrs
-        through_attrs = %w(id align float title role width height alt).
-          inject({}) do |memo, key|
+      def self.generate_attrs(attrs)
+        %w(id align float title role width height alt)
+          .inject({}) do |memo, key|
           memo[key] = attrs[key] if attrs.has_key? key
           memo
         end
@@ -81,19 +80,18 @@ module Asciidoctor
       def abort(parent, reader, attrs, msg)
         warn msg
         attrs["language"] = "plantuml"
-        create_listing_block parent, reader.source, attrs.reject { |k, v| k == 1 }
+        create_listing_block parent, reader.source,
+                             (attrs.reject { |k, _v| k == 1 })
       end
 
       def process(parent, reader, attrs)
-        begin
-          PlantUMLBlockMacroBackend.plantuml_installed?
-          filename = PlantUMLBlockMacroBackend.generate_file(parent, reader)
-          through_attrs = PlantUMLBlockMacroBackend.generate_attrs attrs
-          through_attrs["target"] = filename
-          create_image_block parent, through_attrs
-        rescue StandardError => e
-          abort(parent, reader, attrs, e.message)
-        end
+        PlantUMLBlockMacroBackend.plantuml_installed?
+        filename = PlantUMLBlockMacroBackend.generate_file(parent, reader)
+        through_attrs = PlantUMLBlockMacroBackend.generate_attrs attrs
+        through_attrs["target"] = filename
+        create_image_block parent, through_attrs
+      rescue StandardError => e
+        abort(parent, reader, attrs, e.message)
       end
     end
   end

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,81 @@ 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"]
+        "<concept type='term'><termxref>#{attrs['name']}</termxref>"\
+          "<renderterm>#{termref}</renderterm><xrefrender/></concept>"
+      end
+    end
+
+    class SymbolRefInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :symbol
+      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 type='symbol'><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;$/, "") }
+        if m2 = /^(?<rest>.*?)(?<opt>,option=.+)$/.match(m[:rest].sub(/^,/, ""))
+          ret[:opt] = CSV.parse_line(m2[:opt].sub(/^,option=/, "")
+            .sub(/^"(.+)"$/, "\\1").sub(/^'(.+)'$/, "\\1"))
+          attrs = CSV.parse_line(m2[:rest]) || []
+        else
+          attrs = CSV.parse_line(m[:rest].sub(/^,/, "")) || []
+        end
+        ret.merge(term: attrs[0], word: attrs[1] || attrs[0],
+                  xrefrender: attrs[2])
+      end
+
+      def generate_attrs(opts)
+        ret = ""
+        opts.include?("noital") and ret += " ital='false'"
+        opts.include?("noref") and ret += " ref='false'"
+        opts.include?("ital") and ret += " ital='true'"
+        opts.include?("ref") and ret += " ref='true'"
+        ret
       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
+        optout = generate_attrs(attrs[:opt] || [])
+        attrs[:id] and return "<concept#{optout} key='#{attrs[:id]}'><refterm>"\
+          "#{termout}</refterm><renderterm>#{wordout}</renderterm>"\
+          "<xrefrender>#{xrefout}</xrefrender></concept>"
+        "<concept#{optout}><termxref>#{termout}</termxref><renderterm>"\
+          "#{wordout}</renderterm><xrefrender>#{xrefout}</xrefrender></concept>"
       end
     end
   end

data/lib/asciidoctor/standoc/ref.rb

@@ -4,7 +4,7 @@ module Asciidoctor
   module Standoc
     module Refs
       def iso_publisher(bib, code)
-        code.sub(/ .*$/, "").split(/\//).each do |abbrev|
+        code.sub(/ .*$/, "").split("/").each do |abbrev|
           bib.contributor do |c|
             c.role **{ type: "publisher" }
             c.organization do |org|
@@ -18,75 +18,78 @@ module Asciidoctor
         { format: "text/plain" }
       end
 
-      def ref_attributes(m)
-        { id: m[:anchor], type: "standard" }
+      def ref_attributes(match)
+        { id: match[:anchor], type: "standard" }
       end
 
-      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])
+      def isorefrender1(bib, match, yr, allp = "")
+        bib.title(**plaintxt) { |i| i << ref_normalise(match[:text]) }
+        docid(bib, match[:usrlbl]) if match[:usrlbl]
+        docid(bib, id_and_year(match[:code], yr) + allp)
+        docnumber(bib, match[: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)
-        return use_my_anchor(ref, m[:anchor]) if ref
+      def isorefmatches(xml, match)
+        yr = norm_year(match[:year])
+        ref = fetch_ref xml, match[:code], yr,
+                        title: match[:text], usrlbl: match[:usrlbl],
+                        lang: (@lang || :all)
+        return use_my_anchor(ref, match[:anchor]) if ref
 
-        xml.bibitem **attr_code(ref_attributes(m)) do |t|
-          isorefrender1(t, m, yr)
+        xml.bibitem **attr_code(ref_attributes(match)) do |t|
+          isorefrender1(t, match, yr)
           yr and t.date **{ type: "published" } do |d|
             set_date_range(d, yr)
           end
-          iso_publisher(t, m[:code])
+          iso_publisher(t, match[:code])
         end
       end
 
-      def isorefmatches2(xml, m)
-        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
+      def isorefmatches2(xml, match)
+        ref = fetch_ref xml, match[:code], nil,
+                        no_year: true, note: match[:fn],
+                        title: match[:text], usrlbl: match[:usrlbl],
+                        lang: (@lang || :all)
+        return use_my_anchor(ref, match[:anchor]) if ref
 
-        isorefmatches2_1(xml, m)
+        isorefmatches2_1(xml, match)
       end
 
-      def isorefmatches2_1(xml, m)
-        xml.bibitem **attr_code(ref_attributes(m)) do |t|
-          isorefrender1(t, m, "--")
+      def isorefmatches2_1(xml, match)
+        xml.bibitem **attr_code(ref_attributes(match)) do |t|
+          isorefrender1(t, match, "--")
           t.date **{ type: "published" } do |d|
             d.on "--"
           end
-          iso_publisher(t, m[:code])
-          unless m[:fn].nil?
+          iso_publisher(t, match[:code])
+          unless match[:fn].nil?
             t.note(**plaintxt.merge(type: "Unpublished-Status")) do |p|
-            p << (m[:fn]).to_s
+              p << (match[:fn]).to_s
             end
           end
         end
       end
 
-      def isorefmatches3(xml, m)
-        yr = norm_year(m[:year])
+      def isorefmatches3(xml, match)
+        yr = norm_year(match[: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],
+        ref = fetch_ref(xml, match[:code], hasyr ? yr : nil,
+                        all_parts: true, no_year: yr == "--",
+                        text: match[:text], usrlbl: match[:usrlbl],
                         lang: (@lang || :all))
-        return use_my_anchor(ref, m[:anchor]) if ref
+        return use_my_anchor(ref, match[:anchor]) if ref
 
-        isorefmatches3_1(xml, m, yr, hasyr, ref)
+        isorefmatches3_1(xml, match, yr, hasyr, ref)
       end
 
-      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])
-          if m.names.include?("fn") && m[:fn]
+      def isorefmatches3_1(xml, match, yr, _hasyr, _ref)
+        xml.bibitem(**attr_code(ref_attributes(match))) do |t|
+          isorefrender1(t, match, yr, " (all parts)")
+          conditional_date(t, match, yr == "--")
+          iso_publisher(t, match[:code])
+          if match.names.include?("fn") && match[:fn]
             t.note(**plaintxt.merge(type: "Unpublished-Status")) do |p|
-              p << (m[:fn]).to_s
+              p << (match[:fn]).to_s
             end
           end
           t.extent **{ type: "part" } do |e|
@@ -95,23 +98,23 @@ module Asciidoctor
         end
       end
 
-      def refitem_render1(m, code, bib)
+      def refitem_render1(match, code, bib)
         if code[:type] == "path"
           bib.uri code[:key].sub(/\.[a-zA-Z0-9]+$/, ""), **{ type: "URI" }
           bib.uri code[:key].sub(/\.[a-zA-Z0-9]+$/, ""), **{ type: "citation" }
         end
-        docid(bib, m[:usrlbl]) if m[:usrlbl]
+        docid(bib, match[:usrlbl]) if match[: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)
-        xml.bibitem **attr_code(id: m[:anchor]) do |t|
+      def refitem_render(xml, match, code)
+        xml.bibitem **attr_code(id: match[:anchor]) do |t|
           t.formattedref **{ format: "application/x-isodoc+xml" } do |i|
-            i << ref_normalise_no_format(m[:text])
+            i << ref_normalise_no_format(match[:text])
           end
-          refitem_render1(m, code, t)
+          refitem_render1(match, code, t)
           docnumber(t, code[:id]) unless /^\d+$|^\(.+\)$/.match?(code[:id])
         end
       end
@@ -128,7 +131,7 @@ module Asciidoctor
 
       def analyse_ref_repo_path(ret)
         return ret unless m =
-          /^(?<type>repo|path):\((?<key>[^,]+),?(?<id>.*)\)$/.match(ret[:id])
+                            /^(?<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)
@@ -156,16 +159,17 @@ module Asciidoctor
         nil
       end
 
-      def refitem1(xml, _item, m)
-        code = analyse_ref_code(m[:code])
+      def refitem1(xml, _item, match)
+        code = analyse_ref_code(match[: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))
-          return use_my_anchor(ref, m[:anchor]) if ref
+                          match.names.include?("year") ? match[:year] : nil,
+                          title: match[:text],
+                          usrlbl: match[:usrlbl], lang: (@lang || :all)) and
+            return use_my_anchor(ref, match[:anchor])
         end
-        refitem_render(xml, m, code)
+
+        refitem_render(xml, match, code)
       end
 
       def ref_normalise(ref)
@@ -186,7 +190,7 @@ module Asciidoctor
       \[(?<usrlbl>\([^)]+\))?(?<code>(ISO|IEC)[^0-9]*\s[0-9-]+):
       (--|&\#821[12];)\]</ref>,?\s*
         (<fn[^>]*>\s*<p>(?<fn>[^\]]+)</p>\s*</fn>)?,?\s?(?<text>.*)$}xm
-        .freeze
+          .freeze
 
       ISO_REF_ALL_PARTS =
         %r{^<ref\sid="(?<anchor>[^"]+)">

data/lib/asciidoctor/standoc/section.rb

@@ -12,7 +12,7 @@ module Asciidoctor
       def sectiontype1(node)
         node&.attr("heading")&.downcase ||
           node.title.gsub(%r{<index>.*?</index>}m, "").gsub(/<[^>]+>/, "")
-          .strip.downcase
+            .strip.downcase
       end
 
       def sectiontype(node, level = true)
@@ -21,6 +21,7 @@ module Asciidoctor
         return ret1 if "symbols and abbreviated terms" == ret1
         return nil unless !level || node.level == 1
         return nil if @seen_headers.include? ret
+
         @seen_headers << ret
         ret1
       end
@@ -48,11 +49,14 @@ module Asciidoctor
                 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: (
-                           (node.role == "preface" || node.attr("style") == "preface") ?  true : nil) }
+                annex: (if (node.attr("style") == "appendix" || node.role == "appendix") &&
+                          node.level == 1
+                          true
+                        end),
+                preface: (
+                           node.role == "preface" || node.attr("style") == "preface" ? true : nil) }
         return ret unless node.attributes["change"]
+
         ret.merge(change: node.attributes["change"],
                   path: node.attributes["path"],
                   path_end: node.attributes["path_end"],
@@ -75,7 +79,7 @@ module Asciidoctor
             symbols_parse(symbols_attrs(node, a), xml, node)
           when "acknowledgements"
             acknowledgements_parse(a, xml, node)
-          when "bibliography" 
+          when "bibliography"
             bibliography_parse(a, xml, node)
           else
             if @term_def then term_def_subclause_parse(a, xml, node)
@@ -88,9 +92,9 @@ module Asciidoctor
               bibliography_parse(a, xml, node)
             elsif node.attr("style") == "bibliography"
               bibliography_parse(a, xml, node)
-            elsif node.attr("style") == "abstract" 
+            elsif node.attr("style") == "abstract"
               abstract_parse(a, xml, node)
-            elsif node.attr("style") == "index" 
+            elsif node.attr("style") == "index"
               indexsect_parse(a, xml, node)
             elsif node.attr("style") == "appendix" && node.level == 1
               annex_parse(a, xml, node)
@@ -102,10 +106,13 @@ module Asciidoctor
       end
 
       def set_obligation(attrs, node)
-        attrs[:obligation] = node.attributes.has_key?("obligation") ?
-          node.attr("obligation") :
-          node.parent.attributes.has_key?("obligation") ?
-          node.parent.attr("obligation") : "normative"
+        attrs[:obligation] = if node.attributes.has_key?("obligation")
+                               node.attr("obligation")
+                             elsif node.parent.attributes.has_key?("obligation")
+                               node.parent.attr("obligation")
+                             else
+                               "normative"
+                             end
       end
 
       def preamble(node)