metanorma-cli 1.3.3.1 → 1.3.4

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

@@ -0,0 +1,210 @@
+require "date"
+require "nokogiri"
+require "htmlentities"
+require "pathname"
+require "open-uri"
+require_relative "./front_contributor.rb"
+
+module Asciidoctor
+  module Standoc
+    module Front
+      def metadata_id(node, xml)
+        part, subpart = node&.attr("partnumber")&.split(/-/)
+        id = node.attr("docnumber") || ""
+        id += "-#{part}" if part
+        id += "-#{subpart}" if subpart
+        xml.docidentifier id
+        xml.docnumber node.attr("docnumber")
+      end
+
+      def metadata_version(node, xml)
+        xml.edition node.attr("edition") if node.attr("edition")
+        xml.version do |v|
+          v.revision_date node.attr("revdate") if node.attr("revdate")
+          v.draft node.attr("draft") if node.attr("draft")
+        end
+      end
+
+      def metadata_copyright(node, xml)
+        publishers = node.attr("publisher") || " "
+        publishers.split(/,[ ]?/).each do |p|
+          xml.copyright do |c|
+            c.from (node.attr("copyright-year") || Date.today.year)
+            p.match(/[A-Za-z]/).nil? or c.owner do |owner|
+              owner.organization { |o| organization(o, p) }
+            end
+          end
+        end
+      end
+
+      def metadata_status(node, xml)
+        xml.status do |s|
+          s.stage ( node.attr("status") || node.attr("docstage") || "published" )
+          node.attr("docsubstage") and s.substage node.attr("docsubstage")
+          node.attr("iteration") and s.iteration node.attr("iteration")
+        end
+      end
+
+      def metadata_committee(node, xml)
+        return unless node.attr("technical-committee")
+        xml.editorialgroup do |a|
+          committee_component("technical-committee", node, a)
+        end
+      end
+
+      def metadata_ics(node, xml)
+        ics = node.attr("library-ics")
+        ics && ics.split(/,\s*/).each do |i|
+          xml.ics { |ics| ics.code i }
+        end
+      end
+
+      def metadata_source(node, xml)
+        node.attr("uri") && xml.uri(node.attr("uri"))
+        node.attr("xml-uri") && xml.uri(node.attr("xml-uri"), type: "xml")
+        node.attr("html-uri") && xml.uri(node.attr("html-uri"), type: "html")
+        node.attr("pdf-uri") && xml.uri(node.attr("pdf-uri"), type: "pdf")
+        node.attr("doc-uri") && xml.uri(node.attr("doc-uri"), type: "doc")
+        node.attr("relaton-uri") && xml.uri(node.attr("relaton-uri"),
+                                            type: "relaton")
+      end
+
+      def metadata_date1(node, xml, type)
+        date = node.attr("#{type}-date")
+        date and xml.date **{ type: type } do |d|
+          d.on date
+        end
+      end
+
+      def datetypes
+        %w{ published accessed created implemented obsoleted
+            confirmed updated issued circulated unchanged received 
+            vote-started vote-ended
+        }
+      end
+
+      def metadata_date(node, xml)
+        datetypes.each { |t| metadata_date1(node, xml, t) }
+        node.attributes.keys.each do |a|
+          next unless a == "date" || /^date_\d+$/.match(a)
+          type, date = node.attr(a).split(/ /, 2)
+          type or next
+          xml.date **{ type: type } do |d|
+            d.on date
+          end
+        end
+      end
+
+      def metadata_language(node, xml)
+        xml.language (node.attr("language") || "en")
+      end
+
+      def metadata_script(node, xml)
+        xml.script (node.attr("script") || "Latn")
+      end
+
+      def relaton_relations
+        %w(part-of translated-from)
+      end
+
+      def relaton_relation_descriptions
+        {}
+      end
+
+      def metadata_relations(node, xml)
+        relaton_relations.each do |t|
+          metadata_getrelation(node, xml, t)
+        end
+        relaton_relation_descriptions.each do |k, v|
+          metadata_getrelation(node, xml, v, k)
+        end
+      end
+
+      def relation_normalise(type)
+        type.sub(/-by$/, "By").sub(/-of$/, "Of").sub(/-from$/, "From").
+          sub(/-in$/, "In")
+      end
+
+      def metadata_getrelation(node, xml, type, desc = nil)
+        docs = node.attr(desc || type) || return
+        HTMLEntities.new.decode(docs).split(/;\s*/).each do |d|
+          id = d.split(/,\s*/)
+          xml.relation **{ type: relation_normalise(type) } do |r|
+            desc.nil? or r.description relation_normalise(desc)
+            fetch_ref(r, d, nil, {}) or r.bibitem do |b|
+              b.title id[1] ? id[1] : "--"
+              b.docidentifier id[0]
+            end
+          end
+        end
+      end
+
+      def metadata_keywords(node, xml)
+        return unless node.attr("keywords")
+        node.attr("keywords").split(/,[ ]*/).each do |kw|
+          xml.keyword kw
+        end
+      end
+
+      def metadata(node, xml)
+        title node, xml
+        metadata_source(node, xml)
+        metadata_id(node, xml)
+        metadata_date(node, xml)
+        metadata_author(node, xml)
+        metadata_publisher(node, xml)
+        metadata_version(node, xml)
+        metadata_note(node, xml)
+        metadata_language(node, xml)
+        metadata_script(node, xml)
+        metadata_status(node, xml)
+        metadata_copyright(node, xml)
+        metadata_relations(node, xml)
+        metadata_series(node, xml)
+        metadata_keywords(node, xml)
+        xml.ext do |ext|
+          metadata_ext(node, xml)
+        end
+      end
+
+      def metadata_ext(node, ext)
+        metadata_doctype(node, ext)
+        metadata_committee(node, ext)
+        metadata_ics(node, ext)
+      end
+
+      def metadata_doctype(node, xml)
+        xml.doctype doctype(node)
+      end
+
+      def metadata_note(node, xml)
+      end
+
+      def metadata_series(node, xml)
+      end
+
+      def title(node, xml)
+        title_english(node, xml)
+        title_otherlangs(node, xml)
+      end
+
+      def title_english(node, xml)
+        ["en"].each do |lang|
+          at = { language: lang, format: "text/plain" }
+          xml.title **attr_code(at) do |t|
+            t << (Utils::asciidoc_sub(node.attr("title") || node.attr("title-en")) ||
+                  node.title)
+          end
+        end
+      end
+
+      def title_otherlangs(node, xml)
+        node.attributes.each do |k, v|
+          next unless /^title-(?<titlelang>.+)$/ =~ k
+          next if titlelang == "en"
+          xml.title v, { language: titlelang, format: "text/plain" }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+require "date"
+require "nokogiri"
+require "htmlentities"
+require "pathname"
+require "open-uri"
+
+module Asciidoctor
+  module Standoc
+    module Front
+      def committee_component(compname, node, out)
+        out.send compname.gsub(/-/, "_"), node.attr(compname),
+          **attr_code(number: node.attr("#{compname}-number"),
+                      type: node.attr("#{compname}-type"))
+        i = 2
+        while node.attr(compname+"_#{i}") do
+          out.send compname.gsub(/-/, "_"), node.attr(compname+"_#{i}"),
+            **attr_code(number: node.attr("#{compname}-number_#{i}"),
+                        type: node.attr("#{compname}-type_#{i}"))
+          i += 1
+        end
+      end
+
+      def organization(org, orgname)
+        org.name orgname
+      end
+
+      def metadata_author(node, xml)
+        (node.attr("publisher") || "").split(/,[ ]?/).each do |p|
+          xml.contributor do |c|
+            c.role **{ type: "author" }
+            c.organization { |a| organization(a, p) }
+          end
+        end
+        personal_author(node, xml)
+      end
+
+      def personal_author(node, xml)
+        (node.attr("fullname") || node.attr("surname")) and
+          personal_author1(node, xml, "")
+        i = 2
+        while node.attr("fullname_#{i}") || node.attr("surname_#{i}")
+          personal_author1(node, xml, "_#{i}")
+          i += 1
+        end
+      end
+
+      def personal_author1(node, xml, suffix)
+        xml.contributor do |c|
+          c.role **{ type: node.attr("role#{suffix}")&.downcase || "author" }
+          c.person do |p|
+            person_name(node, xml, suffix, p)
+            person_affiliation(node, xml, suffix, p)
+            node.attr("phone#{suffix}") and p.phone node.attr("phone#{suffix}")
+            node.attr("fax#{suffix}") and
+              p.phone node.attr("fax#{suffix}"), **{type: "fax"}
+            node.attr("email#{suffix}") and p.email node.attr("email#{suffix}")
+            node.attr("contributor-uri#{suffix}") and
+              p.uri node.attr("contributor-uri#{suffix}")
+          end
+        end
+      end
+
+      def person_name(node, xml, suffix, p)
+        p.name do |n|
+          if node.attr("fullname#{suffix}")
+            n.completename node.attr("fullname#{suffix}")
+          else
+            n.forename node.attr("givenname#{suffix}")
+            n.initial node.attr("initials#{suffix}")
+            n.surname node.attr("surname#{suffix}")
+          end
+        end
+      end
+
+      def person_affiliation(node, xml, suffix, p)
+        node.attr("affiliation#{suffix}") and p.affiliation do |a|
+          a.organization do |o|
+            o.name node.attr("affiliation#{suffix}")
+            abbr = node.attr("affiliation_abbrev#{suffix}") and
+              o.abbreviation abbr
+            node.attr("address#{suffix}") and o.address do |ad|
+              ad.formattedAddress node.attr("address#{suffix}")
+            end
+          end
+        end
+      end
+
+      def metadata_publisher(node, xml)
+        publishers = node.attr("publisher") || return
+        publishers.split(/,[ ]?/).each do |p|
+          xml.contributor do |c|
+            c.role **{ type: "publisher" }
+            c.organization { |a| organization(a, p) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,233 @@
+require "asciidoctor/extensions"
+require "htmlentities"
+require "unicode2latex"
+require "mime/types"
+require "base64"
+require 'English'
+
+module Asciidoctor
+  module Standoc
+    module Inline
+      def refid?(x)
+        @refids.include? x
+      end
+
+      def inline_anchor(node)
+        case node.type
+        when :ref
+          inline_anchor_ref node
+        when :xref
+          inline_anchor_xref node
+        when :link
+          inline_anchor_link node
+        when :bibref
+          inline_anchor_bibref node
+        end
+      end
+
+      def inline_anchor_ref(node)
+        noko do |xml|
+          xml.bookmark nil, **attr_code(id: node.id)
+        end.join
+      end
+
+      def inline_anchor_xref(node)
+        m = /^(?<case>capital%|lowercase%)?(?<fn>fn(:\s*(?<text>.*))?)?$/.match node.text
+        casing = m.nil? ? nil : m[:case]&.sub(/%$/, "")
+        f = (m.nil? || m[:fn].nil?) ? "inline" : "footnote"
+        c = (!m.nil? && (!m[:fn].nil? || !m[:case].nil?)) ? m[:text] : node.text
+        t = node.target.gsub(/^#/, "").gsub(%r{(\.xml|\.adoc)(#.*$)}, "\\2")
+        noko do |xml|
+          xml.xref **attr_code(target: t, type: f, case: casing) do |x|
+            x << c
+          end
+        end.join
+      end
+
+      def inline_anchor_link(node)
+        contents = node.text
+        contents = "" if node.target.gsub(%r{^mailto:}, "") == node.text
+        attributes = { "target": node.target, "alt": node.attr("title") }
+        noko do |xml|
+          xml.link **attr_code(attributes) do |l|
+            l << contents
+          end
+        end.join
+      end
+
+      def inline_anchor_bibref(node)
+        eref_contents = (node.text || node.target || node.id)&.
+          sub(/^\[?([^\[\]]+?)\]?$/, "[\\1]")
+        eref_attributes = { id: node.target || node.id }
+        @refids << (node.target || node.id)
+        noko do |xml|
+          xml.ref **attr_code(eref_attributes) do |r|
+            r << eref_contents
+          end
+        end.join
+      end
+
+      def inline_callout(node)
+        noko do |xml|
+          xml.callout node.text
+        end.join
+      end
+
+      def inline_footnote(node)
+        @fn_number ||= 0
+        noko do |xml|
+          @fn_number += 1
+          xml.fn **{ reference: @fn_number } do |fn|
+            fn.p { |p| p << node.text }
+          end
+        end.join
+      end
+
+      def inline_break(node)
+        noko do |xml|
+          xml << node.text
+          xml.br
+        end.join
+      end
+
+      def page_break(node)
+        attrs = {}
+        node.option?("landscape") and attrs[:orientation] = "landscape"
+        node.option?("portrait") and attrs[:orientation] = "portrait"
+        noko { |xml| xml.pagebreak **attr_code(attrs)}.join
+      end
+
+      def thematic_break(_node)
+        noko { |xml| xml.hr }.join
+      end
+
+      def xml_encode(text)
+        HTMLEntities.new.encode(text, :basic, :hexadecimal).
+          gsub(/&amp;gt;/, ">").gsub(/\&amp;lt;/, "<").gsub(/&amp;amp;/, "&").
+          gsub(/&gt;/, ">").gsub(/&lt;/, "<").gsub(/&amp;/, "&").
+          gsub(/&quot;/, '"').gsub(/&#xa;/, "\n")
+      end
+
+      def latex_run1(lxm_input, cmd)
+        IO.popen(cmd, "r+", external_encoding: "UTF-8") do |io|
+          io.write(lxm_input)
+          io.close_write
+          io.read
+        end
+      end
+
+      def latex_run(lxm_input)
+        results = nil
+        Metanorma::Standoc::Requirements[:latexml].cmd.each_with_index do |cmd, i|
+          warn "Retrying with #{cmd}" if i > 0
+          results = latex_run1(lxm_input, cmd)
+          if $CHILD_STATUS.to_i.zero?
+            warn "Success!" if i > 0
+            break
+          end
+        end
+        $CHILD_STATUS.to_i.zero? ? results : nil
+      end
+
+      def latex_parse(text)
+        lxm_input = Unicode2LaTeX.unicode2latex(HTMLEntities.new.decode(text))
+        results = latex_run(lxm_input)
+        results.nil? and
+          @log.add('Math', nil,
+                   "latexmlmath failed to process equation:\n#{lxm_input}")
+        results&.sub(%r{<math ([^>]+ )?display="block"}, "<math \\1")
+      end
+
+      def stem_parse(text, xml, style)
+        if /&lt;([^:>&]+:)?math(\s+[^>&]+)?&gt; |
+          <([^:>&]+:)?math(\s+[^>&]+)?>/x.match text
+          math = xml_encode(text)
+          xml.stem math, **{ type: "MathML" }
+        elsif style == :latexmath
+          latex = latex_parse(text) or return xml.stem **{ type: "MathML" }
+          xml.stem **{ type: "MathML" } do |s|
+            math = Nokogiri::XML.fragment(latex.sub(/<\?[^>]+>/, "")).elements[0]
+            math.delete("alttext")
+            s.parent.children = math
+          end
+        else
+          xml.stem text, **{ type: "AsciiMath" }
+        end
+      end
+
+      def inline_quoted(node)
+        noko do |xml|
+          case node.type
+          when :emphasis then xml.em { |s| s << node.text }
+          when :strong then xml.strong { |s| s << node.text }
+          when :monospaced then xml.tt { |s| s << node.text }
+          when :double then xml << "\"#{node.text}\""
+          when :single then xml << "'#{node.text}'"
+          when :superscript then xml.sup { |s| s << node.text }
+          when :subscript then xml.sub { |s| s << node.text }
+          when :asciimath then stem_parse(node.text, xml, :asciimath)
+          when :latexmath then stem_parse(node.text, xml, :latexmath)
+          else
+            case node.role
+              # the following three are legacy, they are now handled by macros
+            when "alt" then xml.admitted { |a| a << node.text }
+            when "deprecated" then xml.deprecates { |a| a << node.text }
+            when "domain" then xml.domain { |a| a << node.text }
+
+            when "strike" then xml.strike { |s| s << node.text }
+            when "smallcap" then xml.smallcap { |s| s << node.text }
+            when "keyword" then xml.keyword { |s| s << node.text }
+            else
+              xml << node.text
+            end
+          end
+        end.join
+      end
+
+      def datauri(uri)
+        return uri if /^data:/.match(uri)
+        types = MIME::Types.type_for(@localdir + uri)
+        type = types ? types.first.to_s : 'text/plain; charset="utf-8"'
+        # FIXME: nested uri path error(
+        #   sources/plantuml/plantuml20200524-90467-1iqek5i.png ->
+        #   sources/sources/plantuml/plantuml20200524-90467-1iqek5i.png)
+        path = File.file?(uri) ? uri : @localdir + uri
+        bin = File.open(path, 'rb', &:read)
+        data = Base64.strict_encode64(bin)
+        "data:#{type};base64,#{data}"
+      end
+
+      def image_attributes(node)
+        uri = node.image_uri (node.attr("target") || node.target)
+        types = /^data:/.match(uri) ? datauri2mime(uri) : MIME::Types.type_for(uri)
+        type = types.first.to_s
+        uri = uri.sub(%r{^data:image/\*;}, "data:#{type};")
+        attr_code(src: uri, #@datauriimage ? datauri(uri) : uri,
+                  id: Utils::anchor_or_uuid,
+                  mimetype: type,
+                  height: node.attr("height") || "auto",
+                  width: node.attr("width") || "auto" ,
+                  filename: node.attr("filename"),
+                  title: node.attr("titleattr"),
+                  alt: node.alt == node.attr("default-alt") ? nil : node.alt)
+      end
+
+      def inline_image(node)
+        noko do |xml|
+          xml.image **(image_attributes(node))
+        end.join("")
+      end
+
+      def inline_indexterm(node)
+        noko do |xml|
+          node.type == :visible and xml << node.text
+          terms = node.attr("terms") ||
+            [Nokogiri::XML("<a>#{node.text}</a>").xpath("//text()").text]
+          xml.index nil, **attr_code(primary: terms[0],
+                                     secondary: terms.dig(1),
+                                     tertiary: terms.dig(2))
+        end.join
+      end
+    end
+  end
+end