metanorma-standoc 1.11.1 → 2.0.0

data/lib/asciidoctor/standoc/deprecated.rb

@@ -0,0 +1,5 @@
+warn "Please replace your references to Asciidoctor::Standoc with Metanorma::Standoc and your instances of require 'asciidoctor/standoc' with require 'metanorma/standoc'"
+
+exit 127 if ENV['METANORMA_DEPRECATION_FAIL']
+
+Asciidoctor::Standoc = Metanorma::Standoc unless defined? Asciidoctor::Standoc

data/lib/asciidoctor/standoc/front.rb

@@ -1,220 +1,3 @@
-require "date"
-require "nokogiri"
-require "htmlentities"
-require "pathname"
-require_relative "./front_contributor"
+require "asciidoctor/standoc/deprecated"
+require "metanorma/standoc/front"
 
-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_other_id(node, xml)
-        a = node.attr("isbn") and xml.docidentifier a, type: "ISBN"
-        a = node.attr("isbn10") and xml.docidentifier a, type: "ISBN10"
-      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_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&.split(/,\s*/)&.each do |i|
-          xml.ics { |elem| elem.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 announced }
-      end
-
-      def metadata_date(node, xml)
-        datetypes.each { |t| metadata_date1(node, xml, t) }
-        node.attributes.each_key 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") ||
-                    default_script(node.attr("language")))
-      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] || "--"
-              b.docidentifier id[0]
-            end
-          end
-        end
-      end
-
-      def metadata_keywords(node, xml)
-        return unless node.attr("keywords")
-
-        node.attr("keywords").split(/,\s*/).each do |kw|
-          xml.keyword kw
-        end
-      end
-
-      def metadata_classifications(node, xml)
-        csv_split(node.attr("classification"), ",")&.each do |c|
-          vals = c.split(/:/, 2)
-          vals.size == 1 and vals = ["default", vals[0]]
-          xml.classification vals[1], type: vals[0]
-        end
-      end
-
-      def metadata(node, xml)
-        title node, xml
-        metadata_source(node, xml)
-        metadata_id(node, xml)
-        metadata_other_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_classifications(node, xml)
-        metadata_keywords(node, xml)
-        xml.ext do
-          metadata_ext(node, xml)
-        end
-      end
-
-      def metadata_ext(node, ext)
-        metadata_doctype(node, ext)
-        metadata_subdoctype(node, ext)
-        metadata_committee(node, ext)
-        metadata_ics(node, ext)
-      end
-
-      def metadata_doctype(node, xml)
-        xml.doctype doctype(node)
-      end
-
-      def metadata_subdoctype(node, xml)
-        s = node.attr("docsubtype") and xml.subdoctype s
-      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 << (Metanorma::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/lib/asciidoctor/standoc/front_contributor.rb

@@ -1,192 +1,3 @@
-require "date"
-require "nokogiri"
-require "htmlentities"
-require "pathname"
-require "csv"
+require "asciidoctor/standoc/deprecated"
+require "metanorma/standoc/front_contributor"
 
-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}")
-          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, is_pub, node = nil, default_org = nil)
-        abbrevs = org_abbrev
-        n = abbrevs.invert[orgname] and orgname = n
-        org.name orgname
-        default_org and a = node.attr("subdivision") and org.subdivision a
-        abbr = org_abbrev[orgname]
-        default_org && b = node.attr("subdivision-abbr") and abbr = b
-        abbr and org.abbreviation abbr
-        is_pub && node and org_address(node, org)
-      end
-
-      def org_address(node, person)
-        node.attr("pub-address") and person.address do |ad|
-          ad.formattedAddress do |f|
-            f << node.attr("pub-address").gsub(/ \+\n/, "<br/>")
-          end
-        end
-        node.attr("pub-phone") and person.phone node.attr("pub-phone")
-        node.attr("pub-fax") and
-          person.phone node.attr("pub-fax"), **{ type: "fax" }
-        node.attr("pub-email") and person.email node.attr("pub-email")
-        node.attr("pub-uri") and person.uri node.attr("pub-uri")
-      end
-
-      # , " => ," : CSV definition does not deal with space followed by quote
-      # at start of field
-      def csv_split(text, delim = ";")
-        return if text.nil?
-
-        CSV.parse_line(text&.gsub(/#{delim} "(?!")/, "#{delim}\""),
-                       liberal_parsing: true,
-                       col_sep: delim)&.compact&.map(&:strip)
-      end
-
-      def metadata_author(node, xml)
-        csv_split(node.attr("publisher") || default_publisher || "")
-          &.each do |p|
-          xml.contributor do |c|
-            c.role **{ type: "author" }
-            c.organization do |a|
-              organization(a, p, false, node, !node.attr("publisher"))
-            end
-          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_role(node, contrib, suffix)
-        type = node.attr("role#{suffix}")&.downcase || "author"
-        contrib.role **{ type: type }
-      end
-
-      def personal_contact(node, suffix, person)
-        node.attr("phone#{suffix}") and person.phone node.attr("phone#{suffix}")
-        node.attr("fax#{suffix}") and
-          person.phone node.attr("fax#{suffix}"), **{ type: "fax" }
-        node.attr("email#{suffix}") and person.email node.attr("email#{suffix}")
-        node.attr("contributor-uri#{suffix}") and
-          person.uri node.attr("contributor-uri#{suffix}")
-      end
-
-      def personal_author1(node, xml, suffix)
-        xml.contributor do |c|
-          personal_role(node, c, suffix)
-          c.person do |p|
-            person_name(node, xml, suffix, p)
-            person_affiliation(node, xml, suffix, p)
-            personal_contact(node, suffix, p)
-          end
-        end
-      end
-
-      def person_name(node, _xml, suffix, person)
-        person.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, person)
-        node.attr("affiliation#{suffix}") and person.affiliation do |a|
-          a.organization do |o|
-            person_organization(node, suffix, o)
-          end
-        end
-      end
-
-      def person_organization(node, suffix, xml)
-        xml.name node.attr("affiliation#{suffix}")
-        abbr = node.attr("affiliation_abbrev#{suffix}") and
-          xml.abbreviation abbr
-        csv_split(node.attr("affiliation_subdiv#{suffix}"))&.each do |s|
-          xml.subdivision s
-        end
-        person_address(node, suffix, xml)
-      end
-
-      def person_address(node, suffix, xml)
-        if node.attr("address#{suffix}")
-          xml.address do |ad|
-            ad.formattedAddress do |f|
-              f << node.attr("address#{suffix}").gsub(/ \+\n/, "<br/>")
-            end
-          end
-        elsif node.attr("country#{suffix}") || node.attr("city#{suffix}")
-          person_address_components(node, suffix, xml)
-        end
-      end
-
-      def person_address_components(node, suffix, xml)
-        xml.address do |ad|
-          s = node.attr("street#{suffix}") and ad.street s
-          s = node.attr("city#{suffix}") and ad.city s
-          s = node.attr("state#{suffix}") and ad.state s
-          s = node.attr("country#{suffix}") and ad.country s
-          s = node.attr("postcode#{suffix}") and ad.postcode s
-        end
-      end
-
-      def default_publisher
-        nil
-      end
-
-      def org_abbrev
-        {}
-      end
-
-      def metadata_publisher(node, xml)
-        publishers = node.attr("publisher") || default_publisher || return
-        csv_split(publishers)&.each do |p|
-          xml.contributor do |c|
-            c.role **{ type: "publisher" }
-            c.organization do |a|
-              organization(a, p, true, node, !node.attr("publisher"))
-            end
-          end
-        end
-      end
-
-      def metadata_copyright(node, xml)
-        pub = node.attr("copyright-holder") || node.attr("publisher")
-        csv_split(pub || default_publisher || "-")&.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 do |a|
-                organization(a, p, true, node, !pub)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/asciidoctor/standoc/inline.rb

@@ -1,230 +1,3 @@
-require "asciidoctor/extensions"
-require "htmlentities"
-require "unicode2latex"
-require "mime/types"
-require "base64"
-require "English"
-require "latexmath"
+require "asciidoctor/standoc/deprecated"
+require "metanorma/standoc/inline"
 
-module Asciidoctor
-  module Standoc
-    module Inline
-      def refid?(ref)
-        @refids.include? ref
-      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)
-        noko do |xml|
-          attrs = inline_anchor_xref_attrs(node)
-          c = attrs[:text]
-          attrs.delete(:text) unless c.nil?
-          xml.xref **attr_code(attrs) do |x|
-            x << c
-          end
-        end.join
-      end
-
-      def inline_anchor_xref_attrs(node)
-        m = /^(?<drop>droploc%)?(?<case>capital%|lowercase%)?(?<drop2>droploc%)?
-          (?<fn>fn:?\s*)?(?<text>.*)$/x.match node.text
-        t = node.target.gsub(/^#/, "").gsub(%r{(\.xml|\.adoc)(#.*$)}, "\\2")
-        m.nil? and return { target: t, type: "inline", text: node.text }
-        droploc = m[:drop].nil? && m[:drop2].nil? ? nil : true
-        f = m[:fn].nil? ? "inline" : "footnote"
-        c = %i[case fn drop drop2].any? { |x| !m[x].nil? } ? m[:text] : node.text
-        { target: t, type: f, case: m[:case]&.sub(/%$/, ""), droploc: droploc,
-          text: c }
-      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"),
-                       "updatetype": node.attr("updatetype") }
-        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").gsub(/&amp;#/, "&#")
-      end
-
-      def latex_parse1(text)
-        lxm_input = Unicode2LaTeX.unicode2latex(HTMLEntities.new.decode(text))
-        results = Latexmath.parse(lxm_input).to_mathml
-        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 then latex_parse(text, xml)
-        else
-          xml.stem text&.gsub(/&amp;#/, "&#"), **{ type: "AsciiMath" }
-        end
-      end
-
-      def latex_parse(text, xml)
-        latex = latex_parse1(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
-      end
-
-      def highlight_parse(text, xml)
-        xml << text
-      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)
-          when :mark then highlight_parse(node.text, xml)
-          else
-            case node.role
-              # the following three are legacy, they are now handled by macros
-            when "alt"
-              term_designation(xml, node, "admitted", node.text)
-            when "deprecated"
-              term_designation(xml, node, "deprecates", node.text)
-            when "domain" then xml.domain { |a| a << node.text }
-
-            when "strike" then xml.strike { |s| s << node.text }
-            when "underline" then xml.underline { |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 image_attributes(node)
-        uri = node.image_uri (node.attr("target") || node.target)
-        types = if /^data:/.match?(uri) then Metanorma::Utils::datauri2mime(uri)
-                else MIME::Types.type_for(uri)
-                end
-        type = types.first.to_s
-        uri = uri.sub(%r{^data:image/\*;}, "data:#{type};")
-        image_attributes1(node, uri, type)
-      end
-
-      def image_attributes1(node, uri, type)
-        attr_code(src: uri,
-                  id: Metanorma::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") || [node.text]).map { |x| xml_encode(x) }
-          xml.index do |i|
-            i.primary { |x| x << terms[0] }
-            a = terms[1] and i.secondary { |x| x << a }
-            a = terms[2] and i.tertiary { |x| x << a }
-          end
-        end.join
-      end
-    end
-  end
-end