metanorma-standoc 1.4.0 → 1.5.0

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_yaml2text.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'ostruct'
 
 module Asciidoctor
@@ -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)
@@ -112,19 +129,19 @@ module Asciidoctor
         result = []
         loop do
           line = lines.next
-          if line.match(BLOCK_START_REGEXP)
+          if line.match?(BLOCK_START_REGEXP)
             line.gsub!(BLOCK_START_REGEXP,
                        '<% \1.each&.with_index do |\2,index| %>')
           end
 
-          if line.strip.match(BLOCK_END_REGEXP)
+          if line.strip.match?(BLOCK_END_REGEXP)
             line.gsub!(BLOCK_END_REGEXP, '<% end %>')
           end
           line.gsub!(/{\s*if\s*([^}]+)}/, '<% if \1 %>')
           line.gsub!(/{\s*?end\s*?}/, '<% end %>')
           line = line
-                   .gsub(/{(.+?[^}]*)}/, '<%= \1 %>')
-                   .gsub(/[a-z\.]+\#/, 'index')
+                 .gsub(/{(.+?[^}]*)}/, '<%= \1 %>')
+                 .gsub(/[a-z\.]+\#/, 'index')
           result.push(line)
         end
         result = parse_context_block(context_lines: result,
@@ -137,10 +154,10 @@ module Asciidoctor
                               context_items:,
                               context_name:)
         renderer = YamlContextRenderer
-                     .new(
-                       context_object: context_items,
-                       context_name: context_name
-                     )
+                   .new(
+                     context_object: context_items,
+                     context_name: context_name
+                   )
         renderer.render(context_lines.join("\n")).split("\n")
       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)
@@ -58,8 +57,14 @@ module Asciidoctor
       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)
@@ -67,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))
-          docnumber(t, m[:code])
+          isorefrender1(t, m, yr)
           yr and t.date **{ type: "published" } do |d|
             set_date_range(d, yr)
           end
@@ -82,61 +84,65 @@ 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], "--"))
-          docnumber(t, m[:code])
+          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
 
       def isorefmatches3(xml, m)
         yr = norm_year(m[:year])
-        hasyr =  m.names.include?("year") && yr != "--"
-        noyr =  m.names.include?("year") && yr == "--"
-        ref = fetch_ref xml, m[:code], hasyr ? yr : nil,
-          all_parts: true, no_year: noyr, text: m[:text], usrlbl: m[:usrlbl]
+        #hasyr =  m.names.include?("year") && yr != "--"
+        hasyr = !yr.nil? && yr != "--"
+        #noyr =  m.names.include?("year") && yr == "--"
+        ref = fetch_ref xml, m[:code], hasyr ? yr : nil, all_parts: true, 
+          no_year: yr == "--", text: 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) + " (all parts)")
-          docnumber(t, m[:code])
-          conditional_date(t, m, noyr)
+          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) { |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 refitem_render(xml, m)
+      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, 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])
-          docnumber(t, m[:code]) unless /^\d+$|^\(.+\)$/.match(m[:code])
+          refitem_render1(m, code, t)
+          docnumber(t, code[:id]) unless /^\d+$|^\(.+\)$/.match(code[:id])
         end
       end
 
@@ -144,19 +150,54 @@ 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)
+        return ret unless m = /^nofetch\((?<id>.+)\)$/.match(ret[:id])
+        ret[:id] = m[:id]
+        ret[:nofetch] = true
+        ret
+      end
+
+      def analyse_ref_repo_path(ret)
+        return ret unless m =
+          /^(?<type>repo|path):\((?<key>[^,]+),(?<id>.+)\)$/.match(ret[:id])
+        ret[:id] = m[:id]
+        ret[:type] = m[:type]
+        ret[:key] = m[:key]
+        ret[:nofetch] = true
+        ret
+      end
+
+      def analyse_ref_numeric(ret)
+        return ret unless /^\d+$/.match(ret[:id])
+        ret[:numeric] = true
+        ret
+      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 = 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)

data/lib/asciidoctor/standoc/reqt.rb

@@ -6,11 +6,15 @@ require "base64"
 module Asciidoctor
   module Standoc
     module Blocks
+      def reqt_subpart_attrs(node)
+        attr_code(keep_attrs(node).merge(exclude: node.option?("exclude"),
+                                     type: node.attr("type")))
+      end
+
       def requirement_subpart(node)
         name = node.role || node.attr("style")
         noko do |xml|
-          xml.send name, **attr_code(exclude: node.option?("exclude"),
-                                     type: node.attr("type")) do |o|
+          xml.send name, **reqt_subpart_attrs(node) do |o|
             o << node.content
           end
         end
@@ -35,22 +39,23 @@ module Asciidoctor
         end
       end
 
-      def reqt_attributes(node)
-        {
+      def reqt_attrs(node)
+        attr_code(keep_attrs(node).merge(id_unnum_attrs(node)).merge(
           id: Utils::anchor_or_uuid(node),
           unnumbered: node.option?("unnumbered") ? "true" : nil,
+          number: node.attr("number"),
           subsequence: node.attr("subsequence"),
           obligation: node.attr("obligation"),
           filename: node.attr("filename"),
           type: node.attr("type"),
           model: node.attr("model"),
-        }
+        ))
       end
 
       def requirement(node, obligation)
         classif = node.attr("classification")
         noko do |xml|
-          xml.send obligation, **attr_code(reqt_attributes(node)) do |ex|
+          xml.send obligation, **reqt_attrs(node) do |ex|
             node.title and ex.title { |t| t << node.title }
             node.attr("label") and ex.label { |l| l << node.attr("label") }
             node.attr("subject") and ex.subject { |s| s << node.attr("subject") }

data/lib/asciidoctor/standoc/reqt.rng

@@ -30,9 +30,22 @@
         <data type="boolean"/>
       </attribute>
     </optional>
+    <optional>
+      <attribute name="number"/>
+    </optional>
     <optional>
       <attribute name="subsequence"/>
     </optional>
+    <optional>
+      <attribute name="keep-with-next">
+        <data type="boolean"/>
+      </attribute>
+    </optional>
+    <optional>
+      <attribute name="keep-lines-together">
+        <data type="boolean"/>
+      </attribute>
+    </optional>
     <attribute name="id">
       <data type="ID"/>
     </attribute>
@@ -141,6 +154,16 @@
         <data type="boolean"/>
       </attribute>
     </optional>
+    <optional>
+      <attribute name="keep-with-next">
+        <data type="boolean"/>
+      </attribute>
+    </optional>
+    <optional>
+      <attribute name="keep-lines-together">
+        <data type="boolean"/>
+      </attribute>
+    </optional>
     <oneOrMore>
       <ref name="BasicBlock"/>
     </oneOrMore>

data/lib/asciidoctor/standoc/section.rb

@@ -13,9 +13,13 @@ module Asciidoctor
         @term_def
       end
 
-      def sectiontype(node, level = true)
-        ret = node&.attr("heading")&.downcase ||
+      def sectiontype1(node)
+        node&.attr("heading")&.downcase ||
           node.title.gsub(/<[^>]+>/, "").downcase
+      end
+
+      def sectiontype(node, level = true)
+        ret = sectiontype1(node)
         ret1 = sectiontype_streamline(ret)
         return ret1 if "symbols and abbreviated terms" == ret1
         return nil unless !level || node.level == 1
@@ -61,16 +65,18 @@ module Asciidoctor
           case sectiontype(node)
           when "introduction" then introduction_parse(a, xml, node)
           when "foreword" then foreword_parse(a, xml, node)
+          when "scope" then scope_parse(a, xml, node)
           when "normative references" then norm_ref_parse(a, xml, node)
           when "terms and definitions"
             @term_def = true
             term_def_parse(a, xml, node, true)
             @term_def = false
           when "symbols and abbreviated terms"
-            symbols_parse(a, xml, node)
+            symbols_parse(symbols_attrs(node, a), xml, node)
           when "acknowledgements"
             acknowledgements_parse(a, xml, node)
-          when "bibliography" then bibliography_parse(a, xml, node)
+          when "bibliography" 
+            bibliography_parse(a, xml, node)
           else
             if @term_def then term_def_subclause_parse(a, xml, node)
             elsif @definitions then symbols_parse(a, xml, node)
@@ -106,7 +112,7 @@ module Asciidoctor
       def preamble(node)
         noko do |xml|
           xml.foreword **attr_code(section_attributes(node)) do |xml_abstract|
-            xml_abstract.title { |t| t << (node.blocks[0].title || "Foreword") }
+            xml_abstract.title { |t| t << (node.blocks[0].title || @i18n.foreword) }
             content = node.content
             xml_abstract << content
           end
@@ -119,6 +125,10 @@ module Asciidoctor
         end
       end
 
+      def scope_parse(attrs, xml, node)
+        clause_parse(attrs.merge(type: "scope"), xml, node)
+      end
+
       def clause_parse(attrs, xml, node)
         attrs["inline-header".to_sym] = node.option? "inline-header"
         attrs[:bibitem] = true if node.option? "bibitem"
@@ -145,6 +155,15 @@ module Asciidoctor
         @definitions = true
       end
 
+      def symbols_attrs(node, a)
+        case sectiontype1(node)
+        when "symbols" then a.merge(type: "symbols")
+        when "abbreviated terms", "abbreviations" then a.merge(type: "abbreviated_terms")
+        else
+          a
+        end
+      end
+
       def symbols_parse(attr, xml, node)
         node.role == "nonterm" and return nonterm_symbols_parse(attr, xml, node)
         xml.definitions **attr_code(attr) do |xml_section|
@@ -159,9 +178,6 @@ module Asciidoctor
         end
       end
 
-      SYMBOLS_TITLES = ["symbols and abbreviated terms", "symbols",
-                        "abbreviated terms"].freeze
-
       def nonterm_term_def_subclause_parse(attrs, xml, node)
         @term_def = false
         clause_parse(attrs, xml, node)
@@ -190,23 +206,9 @@ module Asciidoctor
         end
       end
 
-      def term_def_title(toplevel, node)
-        return node.title unless toplevel
-        sub = node.find_by(context: :section) do |s|
-          SYMBOLS_TITLES.include? s.title.downcase
-        end
-        return "Terms and definitions" if sub.empty?
-        sym = /symbol/i.match(node.title)
-        abbrev = /abbreviat/i.match(node.title)
-        sym && abbrev and return "Terms, definitions, symbols and abbreviated terms"
-        sym and return "Terms, definitions and symbols"
-        abbrev and return "Terms, definitions and abbreviated terms"
-        "Terms, definitions, symbols and abbreviated terms"
-      end
-
       def term_def_parse(attrs, xml, node, toplevel)
         xml.terms **attr_code(attrs) do |section|
-          section.title { |t| t << term_def_title(toplevel, node) }
+          section.title { |t| t << node.title }
           (s = node.attr("source")) && s.split(/,/).each do |s1|
             section.termdocsource(nil, **attr_code(bibitemid: s1))
           end
@@ -216,7 +218,7 @@ module Asciidoctor
 
       def introduction_parse(attrs, xml, node)
         xml.introduction **attr_code(attrs) do |xml_section|
-          xml_section.title { |t| t << "Introduction" }
+          xml_section.title { |t| t << @i18n.introduction }
           content = node.content
           xml_section << content
         end
@@ -232,7 +234,7 @@ module Asciidoctor
 
       def acknowledgements_parse(attrs, xml, node)
         xml.acknowledgements **attr_code(attrs) do |xml_section|
-          xml_section.title { |t| t << node.title || "Acknowledgements" }
+          xml_section.title { |t| t << node.title || @i18n.acknowledgements }
           content = node.content
           xml_section << content
         end