metanorma-cli 1.3.3.1 → 1.3.4

data/gems/ruby/2.6.0/gems/metanorma-standoc-1.5.0/lib/asciidoctor/standoc/ref.rb

@@ -0,0 +1,257 @@
+module Asciidoctor
+  module Standoc
+    module Lists
+      def iso_publisher(t, code)
+        code.sub(/ .*$/, "").split(/\//).each do |abbrev|
+          t.contributor do |c|
+            c.role **{ type: "publisher" }
+            c.organization do |org|
+              organization(org, abbrev)
+            end
+          end
+        end
+      end
+
+      def plaintxt
+        { format: "text/plain" }
+      end
+
+      def ref_attributes(m)
+        { 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) ? "--" : 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)
+        yr = norm_year(m[:year])
+        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|
+          isorefrender1(t, m, yr)
+          yr and t.date **{ type: "published" } do |d|
+            set_date_range(d, yr)
+          end
+          iso_publisher(t, m[: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]
+        return use_my_anchor(ref, m[:anchor]) if ref
+        xml.bibitem **attr_code(ref_attributes(m)) do |t|
+          isorefrender1(t, m, "--")
+          t.date **{ type: "published" } do |d|
+            d.on "--"
+          end
+          iso_publisher(t, m[:code])
+          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|
+          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 =  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|
+          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: "ISO DATE")) { |p| p << "#{m[:fn]}" }
+          t.extent **{ type: 'part' } do |e|
+            e.referenceFrom "all"
+          end
+        end
+      end
+
+      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
+          refitem_render1(m, code, t)
+          docnumber(t, code[:id]) unless /^\d+$|^\(.+\)$/.match(code[:id])
+        end
+      end
+
+      MALFORMED_REF = "no anchor on reference, markup may be malformed: see "\
+        "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
+        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, code)
+      end
+
+      def ref_normalise(ref)
+        ref.gsub(/&amp;amp;/, "&amp;").gsub(%r{^<em>(.*)</em>}, "\\1")
+      end
+
+      def ref_normalise_no_format(ref)
+        ref.gsub(/&amp;amp;/, "&amp;")
+      end
+
+      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
+
+        ISO_REF_NO_YEAR = %r{^<ref\sid="(?<anchor>[^"]+)">
+      \[(?<usrlbl>\([^)]+\))?(?<code>(ISO|IEC)[^0-9]*\s[0-9-]+):(--|\&\#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]))?\]</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?
+            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 reference(node)
+          noko do |xml|
+            node.items.each { |item| reference1(node, item.text, xml) }
+          end.join
+        end
+
+        def mn_code(code)
+          code.sub(/^\(/, "[").sub(/\).*$/, "]").sub(/^nofetch\((.+)\)$/, "\\1")
+        end
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/metanorma-standoc-1.5.0/lib/asciidoctor/standoc/ref_sect.rb

@@ -0,0 +1,124 @@
+module Asciidoctor
+  module Standoc
+    module Section
+      def in_biblio?
+        @biblio
+      end
+
+      def in_norm_ref?
+        @norm_ref
+      end
+
+      def bibliography_parse(attrs, xml, node)
+        node.option? "bibitem" and return bibitem_parse(attrs, xml, node)
+        node.attr("style") == "bibliography" or
+          @log.add("AsciiDoc Input", node, "Section not marked up as [bibliography]!")
+        @biblio = true
+        xml.references **attr_code(attrs.merge(normative: false)) do |xml_section|
+          title = node.level == 1 ? "Bibliography" : node.title
+          xml_section.title { |t| t << title }
+          xml_section << node.content
+        end
+        @biblio = false
+      end
+
+      def bibitem_parse(attrs, xml, node)
+        norm_ref = @norm_ref
+        biblio = @biblio
+        @biblio = false
+        @norm_ref = false
+        clause_parse(attrs, xml, node)
+        @biblio = biblio
+        @norm_ref = norm_ref
+      end
+
+      def norm_ref_parse(attrs, xml, node)
+        node.option? "bibitem" and return bibitem_parse(attrs, xml, node)
+        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: true)) do |xml_section|
+          xml_section.title { |t| t << "Normative References" }
+          xml_section << node.content
+        end
+        @norm_ref = false
+      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 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
+      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
+
+      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)
+      end
+
+      def init_iev_caches(node)
+        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") ||
+                                               node.attr("local-cache-only"))
+          if node.attr("flush-caches")
+            FileUtils.rm_f @iev_globalname unless @iev_globalname.nil?
+            FileUtils.rm_f @iev_localname unless @iev_localname.nil?
+          end
+        end
+        #@iev = Iev::Db.new(globalname, localname) unless @no_isobib
+      end
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/metanorma-standoc-1.5.0/lib/asciidoctor/standoc/reqt.rb

@@ -0,0 +1,73 @@
+require "htmlentities"
+require "uri"
+require "mime/types"
+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, **reqt_subpart_attrs(node) do |o|
+            o << node.content
+          end
+        end
+      end
+
+      def req_classif_parse(classif)
+        ret = []
+        HTMLEntities.new.decode(classif).split(/;\s*/).each do |c|
+          c1 = c.split(/:\s*/)
+          next unless c1.size == 2
+          c1[1].split(/,\s*/).each { |v| ret << [ c1[0], v ] }
+        end
+        ret
+      end
+
+      def requirement_classification(classif, ex)
+        req_classif_parse(classif).each do |r|
+          ex.classification do |c|
+            c.tag { |t| t << r[0] }
+            c.value { |v| v << r[1] }
+          end
+        end
+      end
+
+      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, **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") }
+            i = HTMLEntities.new.decode(node.attr("inherit"))
+            i&.split(/;\s*/)&.each do |i|
+              ex.inherit { |inh| inh << i }
+            end
+            requirement_classification(classif, ex) if classif
+            wrap_in_para(node, ex)
+          end
+        end.join("\n")
+      end
+    end
+  end
+end