metanorma-standoc 1.7.3 → 1.8.5

data/lib/asciidoctor/standoc/lists.rb

@@ -54,7 +54,7 @@ module Asciidoctor
       end
 
       def ol_attrs(node)
-        attr_code(keep_attrs(node).merge(id: Utils::anchor_or_uuid(node),
+        attr_code(keep_attrs(node).merge(id: Metanorma::Utils::anchor_or_uuid(node),
                                          type: olist_style(node.style)))
       end
 
@@ -88,7 +88,7 @@ module Asciidoctor
 
       def dl_attrs(node)
         attr_code(keep_attrs(node).
-                  merge(id: Utils::anchor_or_uuid(node),
+                  merge(id: Metanorma::Utils::anchor_or_uuid(node),
                         key: node.option?("key") ? "true" : nil))
       end
 

data/lib/asciidoctor/standoc/macros_plantuml.rb

@@ -30,7 +30,7 @@ module Asciidoctor
       # plantuml process may finish earlier then dot, as result png file
       # maybe not created yet after plantuml finish
       def self.generate_file parent, reader
-        localdir = Utils::localdir(parent.document)
+        localdir = Metanorma::Utils::localdir(parent.document)
         imagesdir = parent.document.attr('imagesdir')
         umlfile, outfile = save_plantuml parent, reader, localdir
         run(umlfile, outfile) or raise "No image output from PlantUML (#{umlfile}, #{outfile})!"

data/lib/asciidoctor/standoc/ref_sect.rb

@@ -96,9 +96,9 @@ module Asciidoctor
         xstr = x.to_xml(lang: opts[:lang])
         xml = Nokogiri::XML(xstr)
         emend_biblio(xml, code, opts[:title], opts[:usrlbl])
-        xml.xpath("//date").each { |d| Utils::endash_date(d) }
+        xml.xpath("//date").each { |d| Metanorma::Utils::endash_date(d) }
         xml.traverse do |n|
-          n.text? and n.replace(Utils::smartformat(n.text))
+          n.text? and n.replace(Metanorma::Utils::smartformat(n.text))
         end
         xml.to_xml.sub(/<\?[^>]+>/, "")
       end

data/lib/asciidoctor/standoc/reqt.rb

@@ -6,6 +6,11 @@ require "base64"
 module Asciidoctor
   module Standoc
     module Blocks
+      def reqt_subpart(x)
+        %w(specification measurement-target verification import label
+             subject inherit classification title).include? x
+      end
+
       def reqt_subpart_attrs(node)
         attr_code(keep_attrs(node).merge(exclude: node.option?("exclude"),
                                      type: node.attr("type")))
@@ -41,7 +46,7 @@ module Asciidoctor
 
       def reqt_attrs(node)
         attr_code(keep_attrs(node).merge(id_unnum_attrs(node)).merge(
-          id: Utils::anchor_or_uuid(node),
+          id: Metanorma::Utils::anchor_or_uuid(node),
           unnumbered: node.option?("unnumbered") ? "true" : nil,
           number: node.attr("number"),
           subsequence: node.attr("subsequence"),

data/lib/asciidoctor/standoc/section.rb

@@ -1,6 +1,6 @@
-require "htmlentities"
 require "uri"
 require_relative "ref_sect"
+require_relative "terms"
 
 module Asciidoctor
   module Standoc
@@ -9,10 +9,6 @@ module Asciidoctor
       @term_def = false
       @norm_ref = false
 
-      def in_terms?
-        @term_def
-      end
-
       def sectiontype1(node)
         node&.attr("heading")&.downcase || node.title.gsub(/<[^>]+>/, "").downcase
       end
@@ -45,10 +41,11 @@ module Asciidoctor
       end
 
       def section_attributes(node)
-        ret = { id: Utils::anchor_or_uuid(node),
+        ret = { id: Metanorma::Utils::anchor_or_uuid(node),
                 language: node.attributes["language"],
                 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: (
@@ -91,6 +88,8 @@ module Asciidoctor
               bibliography_parse(a, xml, node)
             elsif node.attr("style") == "abstract" 
               abstract_parse(a, xml, node)
+            elsif node.attr("style") == "index" 
+              indexsect_parse(a, xml, node)
             elsif node.attr("style") == "appendix" && node.level == 1
               annex_parse(a, xml, node)
             else
@@ -117,6 +116,13 @@ module Asciidoctor
         end.join("\n")
       end
 
+      def indexsect_parse(attrs, xml, node)
+        xml.indexsect **attr_code(attrs) do |xml_section|
+          xml_section.title { |name| name << node.title }
+          xml_section << node.content
+        end
+      end
+
       def abstract_parse(attrs, xml, node)
         xml.abstract **attr_code(attrs) do |xml_section|
           xml_section << node.content
@@ -147,80 +153,6 @@ module Asciidoctor
         end
       end
 
-      def nonterm_symbols_parse(attrs, xml, node)
-        defs = @definitions
-        @definitions = false
-        clause_parse(attrs, xml, node)
-        @definitions = defs
-      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|
-          xml_section.title { |t| t << node.title }
-          defs = @definitions
-          termdefs = @term_def
-          @definitions = true
-          @term_def = false
-          xml_section << node.content
-          @definitions = defs
-          @term_def = termdefs
-        end
-      end
-
-      def nonterm_term_def_subclause_parse(attrs, xml, node)
-        defs = @term_def
-        @term_def = false
-        clause_parse(attrs, xml, node)
-        @term_def = defs
-      end
-
-      def terms_boilerplate_parse(attrs, xml, node)
-        defs = @term_def
-        @term_def = false
-        clause_parse(attrs.merge(type: "boilerplate"), xml, node)
-        @term_def = defs
-      end
-
-      # subclause contains subclauses
-      def term_def_subclause_parse(attrs, xml, node)
-        node.role == "nonterm"  and return nonterm_term_def_subclause_parse(attrs, xml, node)
-        node.role == "boilerplate"  and return terms_boilerplate_parse(attrs, xml, node)
-        st = sectiontype(node, false)
-        return symbols_parse(attrs, xml, node) if @definitions
-        sub = node.find_by(context: :section) { |s| s.level == node.level + 1 }
-        sub.empty? || (return term_def_parse(attrs, xml, node, false))
-        st == "symbols and abbreviated terms" and (return symbols_parse(attrs, xml, node))
-        st == "terms and definitions" and return clause_parse(attrs, xml, node)
-        term_def_subclause_parse1(attrs, xml, node)
-      end
-
-      def term_def_subclause_parse1(attrs, xml, node)
-        xml.term **attr_code(attrs) do |xml_section|
-          xml_section.preferred { |name| name << node.title }
-          xml_section << node.content
-        end
-      end
-
-      def term_def_parse(attrs, xml, node, toplevel)
-        xml.terms **attr_code(attrs) do |section|
-          section.title { |t| t << node.title }
-          (s = node.attr("source")) && s.split(/,/).each do |s1|
-            section.termdocsource(nil, **attr_code(bibitemid: s1))
-          end
-          section << node.content
-        end
-      end
-
       def introduction_parse(attrs, xml, node)
         xml.introduction **attr_code(attrs) do |xml_section|
           xml_section.title { |t| t << @i18n.introduction }

data/lib/asciidoctor/standoc/table.rb

@@ -2,7 +2,7 @@ module Asciidoctor
   module Standoc
     module Table
       def table_attrs(node)
-        keep_attrs(node).merge( id: Utils::anchor_or_uuid(node),
+        keep_attrs(node).merge( id: Metanorma::Utils::anchor_or_uuid(node),
           headerrows: node.attr("headerrows"),
           unnumbered: node.option?("unnumbered") ? "true" : nil,
           number: node.attr("number"),

data/lib/asciidoctor/standoc/terms.rb

@@ -0,0 +1,125 @@
+module Asciidoctor
+  module Standoc
+    module Section
+      def in_terms?
+        @term_def
+      end
+
+      def nonterm_symbols_parse(attrs, xml, node)
+        defs = @definitions
+        @definitions = false
+        clause_parse(attrs, xml, node)
+        @definitions = defs
+      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|
+          xml_section.title { |t| t << node.title }
+          defs = @definitions
+          termdefs = @term_def
+          @definitions = true
+          @term_def = false
+          xml_section << node.content
+          @definitions = defs
+          @term_def = termdefs
+        end
+      end
+
+      def nonterm_term_def_subclause_parse(attrs, xml, node)
+        defs = @term_def
+        @term_def = false
+        clause_parse(attrs, xml, node)
+        @term_def = defs
+      end
+
+      def terms_boilerplate_parse(attrs, xml, node)
+        defs = @term_def
+        @term_def = false
+        clause_parse(attrs.merge(type: "boilerplate"), xml, node)
+        @term_def = defs
+      end
+
+      # subclause contains subclauses
+      def term_def_subclause_parse(attrs, xml, node)
+        node.role == "nonterm"  and return nonterm_term_def_subclause_parse(attrs, xml, node)
+        node.role == "boilerplate"  and return terms_boilerplate_parse(attrs, xml, node)
+        st = sectiontype(node, false)
+        return symbols_parse(attrs, xml, node) if @definitions
+        sub = node.find_by(context: :section) { |s| s.level == node.level + 1 }
+        sub.empty? || (return term_def_parse(attrs, xml, node, false))
+        st == "symbols and abbreviated terms" and (return symbols_parse(attrs, xml, node))
+        st == "terms and definitions" and return clause_parse(attrs, xml, node)
+        term_def_subclause_parse1(attrs, xml, node)
+      end
+
+      def term_def_subclause_parse1(attrs, xml, node)
+        xml.term **attr_code(attrs) do |xml_section|
+          xml_section.preferred { |name| name << node.title }
+          xml_section << node.content
+        end
+      end
+
+      def term_def_parse(attrs, xml, node, toplevel)
+        xml.terms **attr_code(attrs) do |section|
+          section.title { |t| t << node.title }
+          (s = node.attr("source")) && s.split(/,/).each do |s1|
+            section.termdocsource(nil, **attr_code(bibitemid: s1))
+          end
+          section << node.content
+        end
+      end
+
+      def term_source_attrs(seen_xref)
+        { bibitemid: seen_xref.children[0]["target"],
+          format: seen_xref.children[0]["format"], type: "inline" }
+      end
+
+      def add_term_source(xml_t, seen_xref, m)
+        if seen_xref.children[0].name == "concept"
+          xml_t.origin { |o| o << seen_xref.children[0].to_xml }
+        else
+          xml_t.origin seen_xref.children[0].content, **attr_code(term_source_attrs(seen_xref))
+        end
+        m[:text] && xml_t.modification do |mod|
+          mod.p { |p| p << m[:text].sub(/^\s+/, "") }
+        end
+      end
+
+      TERM_REFERENCE_RE_STR = <<~REGEXP.freeze
+        ^(?<xref><(xref|concept)[^>]+>([^<]*</(xref|concept)>)?)
+               (,\s(?<text>.*))?
+        $
+      REGEXP
+      TERM_REFERENCE_RE =
+        Regexp.new(TERM_REFERENCE_RE_STR.gsub(/\s/, "").gsub(/_/, "\\s"),
+                   Regexp::IGNORECASE | Regexp::MULTILINE)
+
+      def extract_termsource_refs(text, node)
+        matched = TERM_REFERENCE_RE.match text
+        matched.nil? and @log.add("AsciiDoc Input", node, "term reference not in expected format: #{text}")
+        matched
+      end
+
+      def termsource(node)
+        matched = extract_termsource_refs(node.content, node) || return
+        noko do |xml|
+          attrs = { status: matched[:text] ? "modified" : "identical" }
+          xml.termsource **attrs do |xml_t|
+            seen_xref = Nokogiri::XML.fragment(matched[:xref])
+            add_term_source(xml_t, seen_xref, matched)
+          end
+        end.join("\n")
+      end
+    end
+  end
+end

data/lib/asciidoctor/standoc/utils.rb

@@ -5,105 +5,10 @@ require "json"
 require "pathname"
 require "open-uri"
 require "uuidtools"
-require "sterile"
-require "mimemagic"
 
 module Asciidoctor
   module Standoc
     module Utils
-      class << self
-        def anchor_or_uuid(node = nil)
-          uuid = UUIDTools::UUID.random_create
-          node.nil? || node.id.nil? || node.id.empty? ? "_" + uuid : node.id
-        end
-
-        def asciidoc_sub(x)
-          return nil if x.nil?
-          return "" if x.empty?
-          d = Asciidoctor::Document.new(x.lines.entries, { header_footer: false,
-                                                           backend: :standoc })
-          b = d.parse.blocks.first
-          b.apply_subs(b.source)
-        end
-
-        def localdir(node)
-          docfile = node.attr("docfile")
-          docfile.nil? ? './' : Pathname.new(docfile).parent.to_s + '/'
-        end
-
-        # TODO needs internationalisation
-        def smartformat(n)
-          n.gsub(/ --? /, "&#8201;&#8212;&#8201;").
-            gsub(/\'(\d\d)(?=[^\u2019\'\s<]+[’\'][\p{P}\p{Z}])([\p{P}\p{Z}])/, "\u2018\\1\\2").
-            gsub(/--/, "&#8212;").smart_format.gsub(/</, "&lt;").gsub(/>/, "&gt;")
-        end
-
-        def endash_date(elem)
-          elem.traverse do |n|
-            n.text? and n.replace(n.text.gsub(/\s+--?\s+/, "&#8211;").gsub(/--/, "&#8211;"))
-          end
-        end
-
-        # Set hash value using keys path
-        # mod from https://stackoverflow.com/a/42425884
-        def set_nested_value(hash, keys, new_val)
-          key = keys[0]
-          if keys.length == 1
-            hash[key] = hash[key].is_a?(Array) ?  (hash[key] << new_val) :
-              hash[key].nil? ?  new_val : [hash[key], new_val]
-            return hash
-          end
-          if hash[key].is_a?(Array)
-            hash[key][-1] = {} if hash[key][-1].nil?
-            set_nested_value(hash[key][-1], keys[1..-1], new_val)
-          elsif hash[key].nil? || hash[key].empty?
-            hash[key] = {}
-            set_nested_value(hash[key], keys[1..-1], new_val)
-          elsif hash[key].is_a?(Hash) && !hash[key][keys[1]]
-            set_nested_value(hash[key], keys[1..-1], new_val)
-          elsif !hash[key][keys[1]]
-            hash[key] = [hash[key], {}]
-            set_nested_value(hash[key][-1], keys[1..-1], new_val)
-          else
-            set_nested_value(hash[key], keys[1..-1], new_val)
-          end
-        end
-
-        def flatten_rawtext_lines(node, result)
-          node.lines.each do |x|
-            if node.respond_to?(:context) && (node.context == :literal ||
-                node.context == :listing)
-              result << x.gsub(/</, "&lt;").gsub(/>/, "&gt;")
-            else
-              # strip not only HTML <tag>, and Asciidoc xrefs <<xref>>
-              result << x.gsub(/<[^>]*>+/, "")
-            end
-          end
-          result
-        end
-
-        # if node contains blocks, flatten them into a single line;
-        # and extract only raw text
-        def flatten_rawtext(node)
-          result = []
-          if node.respond_to?(:blocks) && node.blocks?
-            node.blocks.each { |b| result << flatten_rawtext(b) }
-          elsif node.respond_to?(:lines)
-            result = flatten_rawtext_lines(node, result)
-          elsif node.respond_to?(:text)
-            result << node.text.gsub(/<[^>]*>+/, "")
-          else
-            result << node.content.gsub(/<[^>]*>+/, "")
-          end
-          result.reject(&:empty?)
-        end
-
-        def reqt_subpart(x)
-          %w(specification measurement-target verification import label
-             subject inherit classification title).include? x
-        end
-      end
-
       def convert(node, transform = nil, opts = {})
         transform ||= node.node_name
         opts.empty? ? (send transform, node) : (send transform, node, opts)
@@ -151,40 +56,17 @@ module Asciidoctor
         end
       end
 
-      def datauri2mime(uri)
-        %r{^data:image/(?<imgtype>[^;]+);base64,(?<imgdata>.+)$} =~ uri
-        type = nil
-        imgtype = "png" unless /^[a-z0-9]+$/.match imgtype
-        Tempfile.open(["imageuri", ".#{imgtype}"]) do |file|
-          type = datauri2mime1(file, imgdata)
-        end
-        [type]
-      end
-
-      def datauri2mime1(file, imgdata)
-        type = nil
-        begin
-          file.binmode
-          file.write(Base64.strict_decode64(imgdata))
-          file.rewind
-          type = MimeMagic.by_magic(file)
-        ensure
-          file.close!
-        end
-        type
-      end
-
       SUBCLAUSE_XPATH = "//clause[not(parent::sections)]"\
         "[not(ancestor::boilerplate)]".freeze
 
-       def isodoc(lang, script, i18nyaml = nil)
+      def isodoc(lang, script, i18nyaml = nil)
         conv = html_converter(EmptyAttr.new)
         i18n = conv.i18n_init(lang, script, i18nyaml)
         conv.metadata_init(lang, script, i18n)
         conv
       end
 
-       class EmptyAttr
+      class EmptyAttr
         def attr(_x)
           nil
         end