metanorma-standoc 1.3.28 → 1.4.3

data/lib/asciidoctor/standoc/lists.rb

@@ -13,7 +13,7 @@ module Asciidoctor
       end
 
       def ul_li(xml_ul, item)
-        xml_ul.li **ul_li_attr(item) do |xml_li|
+        xml_ul.li **ul_li_attrs(item) do |xml_li|
           if item.blocks?
             xml_li.p(**id_attr(item)) { |t| t << item.text }
             xml_li << item.content
@@ -23,11 +23,11 @@ module Asciidoctor
         end
       end
 
-      def ul_attr(node)
-        attr_code(id_attr(node))
+      def ul_attrs(node)
+        attr_code(id_attr(node).merge(keep_attrs(node)))
       end
 
-      def ul_li_attr(node)
+      def ul_li_attrs(node)
         attr_code(
           uncheckedcheckbox: node.attr?("checkbox") ? !node.attr?("checked") : nil,
           checkedcheckbox: node.attr?("checkbox") ? node.attr?("checked") : nil,
@@ -37,7 +37,7 @@ module Asciidoctor
       def ulist(node)
         return reference(node) if in_norm_ref? || in_biblio?
         noko do |xml|
-          xml.ul **ul_attr(node) do |xml_ul|
+          xml.ul **ul_attrs(node) do |xml_ul|
             node.items.each do |item|
               ul_li(xml_ul, item)
             end
@@ -53,14 +53,14 @@ module Asciidoctor
         style
       end
 
-      def ol_attr(node)
-        attr_code(id: Utils::anchor_or_uuid(node),
-                  type: olist_style(node.style))
+      def ol_attrs(node)
+        attr_code(keep_attrs(node).merge(id: Utils::anchor_or_uuid(node),
+                  type: olist_style(node.style)))
       end
 
       def olist(node)
         noko do |xml|
-          xml.ol **ol_attr(node) do |xml_ol|
+          xml.ol **ol_attrs(node) do |xml_ol|
             node.items.each { |item| li(xml_ol, item) }
           end
         end.join("\n")
@@ -86,13 +86,13 @@ module Asciidoctor
         end
       end
 
-      def dl_attr(node)
-        attr_code(id_attr(node))
+      def dl_attrs(node)
+        attr_code(id_attr(node).merge(keep_attrs(node)))
       end
 
       def dlist(node)
         noko do |xml|
-          xml.dl **dl_attr(node) do |xml_dl|
+          xml.dl **dl_attrs(node) do |xml_dl|
             node.items.each do |terms, dd|
               dt(terms, xml_dl)
               dd(dd, xml_dl)

data/lib/asciidoctor/standoc/macros.rb

@@ -1,8 +1,11 @@
 require "asciidoctor/extensions"
 require "fileutils"
 require "uuidtools"
-require_relative "./macros_plantuml.rb"
-require_relative "./macros_yaml2text.rb"
+require 'yaml'
+require_relative './macros_plantuml.rb'
+require_relative './datamodel/attributes_table_preprocessor.rb'
+require_relative './datamodel/diagram_preprocessor.rb'
+require_relative './macros_yaml2text.rb'
 
 module Asciidoctor
   module Standoc
@@ -97,23 +100,25 @@ module Asciidoctor
       end
 
       def supply_br(lines)
+        ignore = false
         lines.each_with_index do |l, i|
+          /^(--+|====+|\|===|\.\.\.\.+|\*\*\*\*+|\+\+\+\++|\`\`\`\`+|____\+)$/.match(l) and
+            ignore = !ignore
           next if l.empty? || l.match(/ \+$/)
+          next if /^\[.*\]$/.match(l)
+          next if ignore
           next if i == lines.size - 1 || i < lines.size - 1 && lines[i+1].empty?
           lines[i] += " +"
         end
         lines
       end
 
-      def prevent_smart_quotes(m)
-        m.gsub(/'/, "&#x27;").gsub(/"/, "&#x22;")
-      end
-
       def process parent, reader, attrs
         attrs['role'] = 'pseudocode'
-        lines = reader.lines.map { |m| prevent_smart_quotes(init_indent(m)) }
-        create_block(parent, :example, supply_br(lines),
+        lines = reader.lines.map { |m| init_indent(m) }
+        ret = create_block(parent, :example, supply_br(lines),
                      attrs, content_model: :compound)
+        ret
       end
     end
 

data/lib/asciidoctor/standoc/macros_yaml2text.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'ostruct'
 
 module Asciidoctor
@@ -44,8 +46,8 @@ module Asciidoctor
     end
 
     class Yaml2TextPreprocessor < Asciidoctor::Extensions::Preprocessor
-      BLOCK_START_REGEXP = /\{(.+?)\.\*,(.+),(.+)\}/.freeze
-      BLOCK_END_REGEXP = /\A\{[A-Z]+\}\z/.freeze
+      BLOCK_START_REGEXP = /\{(.+?)\.\*,(.+),(.+)\}/
+      BLOCK_END_REGEXP = /\A\{[A-Z]+\}\z/
       # search document for block `yaml2text`
       #   after that take template from block and read file into this template
       #   example:
@@ -61,7 +63,7 @@ module Asciidoctor
       #     - name: spaghetti
       #       desc: wheat noodles of 9mm diameter
       #       symbol: SPAG
-      #       symbol_def: the situation is message like spaghetti at a kid's meal
+      #       symbol_def: the situation is message like spaghetti at a kid's
       #
       #   will produce:
       #     === spaghetti
@@ -77,19 +79,20 @@ module Asciidoctor
 
       def processed_lines(document, input_lines)
         result = []
+        current_macro_line_num = 0
         loop do
           line = input_lines.next
+          current_macro_line_num += 1
           if yaml_block_match = line.match(/^\[yaml2text,(.+?),(.+?)\]/)
             mark = input_lines.next
             current_yaml_block = []
             while (yaml_block_line = input_lines.next) != mark
               current_yaml_block.push(yaml_block_line)
             end
-            content = nested_open_struct_from_yaml(yaml_block_match[1], document)
-            result.push(*
-              parse_blocks_recursively(lines: current_yaml_block,
-                                       attributes: content,
-                                       context_name: yaml_block_match[2]))
+            result.push(*read_yaml_and_parse_template(current_yaml_block,
+                                                      document,
+                                                      yaml_block_match,
+                                                      current_macro_line_num))
           else
             result.push(line)
           end
@@ -97,9 +100,23 @@ module Asciidoctor
         result
       end
 
+      def read_yaml_and_parse_template(current_yaml_block, document, yaml_block_match, current_macro_line_num)
+        content = nested_open_struct_from_yaml(yaml_block_match[1], document)
+        parse_blocks_recursively(lines: current_yaml_block,
+                                 attributes: content,
+                                 context_name: yaml_block_match[2])
+      rescue StandardError => exception
+        document
+          .logger
+          .warn("Failed to parse yaml2text block on line #{current_macro_line_num}: #{exception.message}")
+        []
+      end
+
       def nested_open_struct_from_yaml(file_path, document)
         docfile_directory = File.dirname(document.attributes['docfile'] || '.')
-        yaml_file_path = document.path_resolver.system_path(file_path, docfile_directory)
+        yaml_file_path = document
+                         .path_resolver
+                         .system_path(file_path, docfile_directory)
         content = YAML.safe_load(File.read(yaml_file_path))
         # Load content as json, then parse with JSON as nested open_struct
         JSON.parse(content.to_json, object_class: YamlBlockStruct)
@@ -107,35 +124,41 @@ module Asciidoctor
 
       def parse_blocks_recursively(lines:,
                                    attributes:,
-                                   context_name:,
-                                   parent_context: nil)
+                                   context_name:)
         lines = lines.to_enum
         result = []
         loop do
           line = lines.next
-          if line.match(BLOCK_START_REGEXP)
-            line.gsub!(BLOCK_START_REGEXP, '<% \1.each.with_index do |\2,index| %>')
+          if line.match?(BLOCK_START_REGEXP)
+            line.gsub!(BLOCK_START_REGEXP,
+                       '<% \1.each&.with_index do |\2,index| %>')
           end
 
-          if line.match(BLOCK_END_REGEXP)
+          if line.strip.match?(BLOCK_END_REGEXP)
             line.gsub!(BLOCK_END_REGEXP, '<% end %>')
           end
-          line = line.gsub(/{(.+?[^}]*)}/, '<%= \1 %>').gsub(/[a-z\.]+\#/, 'index')
+          line.gsub!(/{\s*if\s*([^}]+)}/, '<% if \1 %>')
+          line.gsub!(/{\s*?end\s*?}/, '<% end %>')
+          line = line
+                 .gsub(/{(.+?[^}]*)}/, '<%= \1 %>')
+                 .gsub(/[a-z\.]+\#/, 'index')
           result.push(line)
         end
         result = parse_context_block(context_lines: result,
                                      context_items: attributes,
-                                     context_name: context_name,
-                                     parent_context: parent_context)
+                                     context_name: context_name)
         result
       end
 
       def parse_context_block(context_lines:,
                               context_items:,
-                              context_name:,
-                              parent_context: nil)
-        renderer = YamlContextRenderer.new(context_object: context_items, context_name: context_name)
-        renderer.render(context_lines.join('\n')).split('\n')
+                              context_name:)
+        renderer = YamlContextRenderer
+                   .new(
+                     context_object: context_items,
+                     context_name: context_name
+                   )
+        renderer.render(context_lines.join("\n")).split("\n")
       end
     end
   end

data/lib/asciidoctor/standoc/ref.rb

@@ -37,8 +37,7 @@ module Asciidoctor
       end
 
       def id_and_year(id, year)
-        return id unless year
-        "#{id}:#{year}"
+        year ? "#{id}:#{year}" : id
       end
 
       def docid(t, code)
@@ -46,12 +45,26 @@ module Asciidoctor
           ["metanorma", mn_code(code)] :
           @bibdb&.docid_type(code) || [nil, code]
         code1.sub!(/^nofetch\((.+)\)$/, "\\1")
-        t.docidentifier code1, **attr_code(type: type)
+        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)
-        return "--" if /^\&\#821[12];$/.match yr
-        yr
+        /^\&\#821[12];$/.match(yr) ? "--" : yr
+      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])
       end
 
       def isorefmatches(xml, m)
@@ -59,10 +72,7 @@ module Asciidoctor
         ref = fetch_ref xml, m[:code], yr, title: m[:text], usrlbl: m[:usrlbl]
         return use_my_anchor(ref, m[:anchor]) if ref
         xml.bibitem **attr_code(ref_attributes(m)) do |t|
-          t.title(**plaintxt) { |i| i << ref_normalise(m[:text]) }
-          docid(t, m[:usrlbl]) if m[:usrlbl]
-          docid(t, id_and_year(m[:code], yr))
-          t.docnumber m[:code].sub(/^[^\d]*/, "")
+          isorefrender1(t, m, yr)
           yr and t.date **{ type: "published" } do |d|
             set_date_range(d, yr)
           end
@@ -74,27 +84,23 @@ module Asciidoctor
         ref = fetch_ref xml, m[:code], nil, no_year: true, note: m[:fn],
           title: m[:text], usrlbl: m[:usrlbl]
         return use_my_anchor(ref, m[:anchor]) if ref
-
         xml.bibitem **attr_code(ref_attributes(m)) do |t|
-          t.title(**plaintxt) { |i| i << ref_normalise(m[:text]) }
-          docid(t, m[:usrlbl]) if m[:usrlbl]
-          docid(t, id_and_year(m[:code], "--"))
-          t.docnumber m[:code].sub(/^[^\d]*/, "")
+          isorefrender1(t, m, "--")
           t.date **{ type: "published" } do |d|
             d.on "--"
           end
           iso_publisher(t, m[:code])
-          m[:fn].nil? or t.note(**plaintxt) { |p| p << "ISO DATE: #{m[:fn]}" }
+          m[:fn].nil? or t.note(**plaintxt.merge(type: "ISO DATE")) do |p|
+            p << "#{m[:fn]}"
+          end
         end
       end
 
       def conditional_date(t, m, noyr)
         m.names.include?("year") and !m[:year].nil? and
           t.date(**{ type: "published" }) do |d|
-          if noyr then d.on "--"
-          else
+          noyr and d.on "--" or
             set_date_range(d, norm_year(m[:year]))
-          end
         end
       end
 
@@ -107,42 +113,35 @@ module Asciidoctor
         return use_my_anchor(ref, m[:anchor]) if ref
 
         xml.bibitem(**attr_code(ref_attributes(m))) do |t|
-          t.title(**plaintxt) { |i| i << ref_normalise(m[:text]) }
-          docid(t, m[:usrlbl]) if m[:usrlbl]
-          docid(t, id_and_year(m[:code], yr) + " (all parts)")
-          t.docnumber m[:code].sub(/^[^\d]*/, "")
+          isorefrender1(t, m, yr, " (all parts)")
           conditional_date(t, m, noyr)
           iso_publisher(t, m[:code])
           m.names.include?("fn") && m[:fn] and
-            t.note(**plaintxt) { |p| p << "ISO DATE: #{m[:fn]}" }
+            t.note(**plaintxt.merge(type: "ISO DATE")) { |p| p << "#{m[:fn]}" }
           t.extent **{ type: 'part' } do |e|
             e.referenceFrom "all"
           end
         end
       end
 
-      def fetch_ref(xml, code, year, **opts)
-        return nil if opts[:no_year]
-        code = code.sub(/^\([^)]+\)/, "")
-        hit = @bibdb&.fetch(code, year, opts)
-        return nil if hit.nil?
-        xml.parent.add_child(smart_render_xml(hit, code, opts[:title],
-                                              opts[:usrlbl]))
-        xml
-      rescue RelatonBib::RequestError
-        @log.add("Bibliography", nil, "Could not retrieve #{code}: "\
-                 "no access to online site")
-        nil
+      def refitem_render1(m, code, t)
+        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" }
+        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" }
       end
 
-      def refitem_render(xml, m)
+      def refitem_render(xml, m, code)
         xml.bibitem **attr_code(id: m[:anchor]) do |t|
           t.formattedref **{ format: "application/x-isodoc+xml" } do |i|
             i << ref_normalise_no_format(m[:text])
           end
-          docid(t, m[:usrlbl]) if m[:usrlbl]
-          docid(t, /^\d+$/.match(m[:code]) ? "[#{m[:code]}]" : m[:code])
-          t.docnumber m[:code].sub(/^[^\d]*/, "") unless /^\d+$|^\(.+\)$/.match(m[:code])
+          refitem_render1(m, code, t)
+          docnumber(t, code[:id]) unless /^\d+$|^\(.+\)$/.match(code[:id])
         end
       end
 
@@ -150,19 +149,56 @@ module Asciidoctor
         "https://www.metanorma.com/author/topics/document-format/bibliography/ , "\
         "https://www.metanorma.com/author/iso/topics/markup/#bibliographies".freeze
 
+      def analyse_ref_nofetch(ret)
+        if m = /^nofetch\((?<id>.+)\)$/.match(ret[:id])
+          ret[:id] = m[:id]
+          ret[:nofetch] = true
+        end
+        ret
+      end
+     
+      def analyse_ref_repo_path(ret)
+         if m = /^(?<type>repo|path):\((?<key>[^,]+),(?<id>.+)\)$/.match(ret[:id])
+          ret[:id] = m[:id]
+          ret[:type] = m[:type]
+          ret[:key] = m[:key]
+          ret[:nofetch] = true
+        end
+         ret
+      end
+
+      def analyse_ref_numeric(ret)
+        if /^\d+$/.match(ret[:id])
+          ret[:numeric] = true
+        end
+        ret
+      end
+
+      # ref id = (usrlbl)code[:-]year
+      # code = nofetch(code) | (repo|path):(key,code) | \[? number \]? | identifier
+      def analyse_ref_code(code)
+        ret = {id: code}
+        return ret if code.nil? || code.empty?
+        ret = analyse_ref_nofetch(ret)
+        ret = analyse_ref_repo_path(ret)
+        ret = analyse_ref_numeric(ret)
+        ret
+      end
+
       # TODO: alternative where only title is available
       def refitem(xml, item, node)
         unless m = NON_ISO_REF.match(item)
           @log.add("AsciiDoc Input", node, "#{MALFORMED_REF}: #{item}")
           return
         end
-        unless m[:code] && /^\d+$/.match(m[:code])
-          ref = fetch_ref xml, m[:code],
+        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]
           return use_my_anchor(ref, m[:anchor]) if ref
         end
-        refitem_render(xml, m)
+        refitem_render(xml, m, code)
       end
 
       def ref_normalise(ref)
@@ -214,46 +250,9 @@ module Asciidoctor
           end.join
         end
 
-        def global_ievcache_name
-          "#{Dir.home}/.iev/cache"
-        end
-
-        def local_ievcache_name(cachename)
-          return nil if cachename.nil?
-          cachename += "_iev" unless cachename.empty?
-          cachename = "iev" if cachename.empty?
-          "#{cachename}/cache"
-        end
-
         def mn_code(code)
           code.sub(/^\(/, "[").sub(/\).*$/, "]").sub(/^nofetch\((.+)\)$/, "\\1")
         end
-
-        def emend_biblio(xml, code, title, usrlbl)
-          unless xml.at("/bibitem/docidentifier[not(@type = 'DOI')][text()]")
-            @log.add("Bibliography", nil,
-                     "ERROR: No document identifier retrieved for #{code}")
-            xml.root << "<docidentifier>#{code}</docidentifier>"
-          end
-          unless xml.at("/bibitem/title[text()]")
-            @log.add("Bibliography", nil,
-                     "ERROR: No title retrieved for #{code}")
-            xml.root << "<title>#{title || "(MISSING TITLE)"}</title>"
-          end
-          usrlbl and xml.at("/bibitem/docidentifier").next =
-            "<docidentifier type='metanorma'>#{mn_code(usrlbl)}</docidentifier>"
-        end
-
-        def smart_render_xml(x, code, title, usrlbl)
-          xstr = x.to_xml if x.respond_to? :to_xml
-          xml = Nokogiri::XML(xstr)
-          emend_biblio(xml, code, title, usrlbl)
-          xml.xpath("//date").each { |d| Utils::endash_date(d) }
-          xml.traverse do |n|
-            n.text? and n.replace(Utils::smartformat(n.text))
-          end
-          xml.to_xml.sub(/<\?[^>]+>/, "")
-        end
     end
   end
 end