metanorma-standoc 1.11.3 → 2.0.2

data/lib/metanorma/standoc/front_contributor.rb

@@ -0,0 +1,192 @@
+require "date"
+require "nokogiri"
+require "htmlentities"
+require "pathname"
+require "csv"
+
+module Metanorma
+  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/metanorma/standoc/inline.rb

@@ -0,0 +1,232 @@
+require "asciidoctor/extensions"
+require "htmlentities"
+require "unicode2latex"
+require "mime/types"
+require "base64"
+require "English"
+require "latexmath"
+
+module Metanorma
+  module Standoc
+    module Inline
+      def refid?(ref)
+        @refids.include? ref
+      end
+
+      def inline_anchor(node)
+        case node.type
+        when :ref then inline_anchor_ref node
+        when :xref then inline_anchor_xref node
+        when :link then inline_anchor_link node
+        when :bibref then 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 = if %i[case fn drop drop2].any? do |x|
+                 !m[x].nil?
+               end
+              m[:text]
+            else node.text
+            end
+        { 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"),
+                       "update-type": node.attr("updatetype") ||
+                         node.attr("update-type") }
+        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

data/lib/{asciidoctor → metanorma}/standoc/isodoc.rng

@@ -32,6 +32,56 @@
         <ref name="DocumentType"/>
       </element>
     </define>
+    <define name="index">
+      <element name="index">
+        <optional>
+          <attribute name="to">
+            <data type="IDREF"/>
+          </attribute>
+        </optional>
+        <element name="primary">
+          <oneOrMore>
+            <choice>
+              <ref name="PureTextElement"/>
+              <ref name="stem"/>
+            </choice>
+          </oneOrMore>
+        </element>
+        <optional>
+          <element name="secondary">
+            <oneOrMore>
+              <choice>
+                <ref name="PureTextElement"/>
+                <ref name="stem"/>
+              </choice>
+            </oneOrMore>
+          </element>
+        </optional>
+        <optional>
+          <element name="tertiary">
+            <oneOrMore>
+              <choice>
+                <ref name="PureTextElement"/>
+                <ref name="stem"/>
+              </choice>
+            </oneOrMore>
+          </element>
+        </optional>
+      </element>
+    </define>
+    <define name="bibitem">
+      <element name="bibitem">
+        <attribute name="id">
+          <data type="ID"/>
+        </attribute>
+        <optional>
+          <attribute name="hidden">
+            <data type="boolean"/>
+          </attribute>
+        </optional>
+        <ref name="BibliographicItem"/>
+      </element>
+    </define>
     <define name="section-title">
       <element name="title">
         <zeroOrMore>
@@ -690,6 +740,7 @@
             <ref name="terms"/>
             <ref name="term-clause"/>
             <ref name="definitions"/>
+            <ref name="floating-title"/>
           </choice>
         </oneOrMore>
       </element>
@@ -1013,6 +1064,26 @@
         </zeroOrMore>
       </element>
     </define>
+    <define name="sub">
+      <element name="sub">
+        <zeroOrMore>
+          <choice>
+            <ref name="PureTextElement"/>
+            <ref name="stem"/>
+          </choice>
+        </zeroOrMore>
+      </element>
+    </define>
+    <define name="sup">
+      <element name="sup">
+        <zeroOrMore>
+          <choice>
+            <ref name="PureTextElement"/>
+            <ref name="stem"/>
+          </choice>
+        </zeroOrMore>
+      </element>
+    </define>
     <define name="pagebreak">
       <element name="pagebreak">
         <optional>
@@ -1680,6 +1751,7 @@
           <ref name="clause-subsection"/>
           <ref name="terms"/>
           <ref name="definitions"/>
+          <ref name="floating-title"/>
         </choice>
       </oneOrMore>
     </choice>
@@ -1722,6 +1794,7 @@
           <ref name="terms"/>
           <ref name="definitions"/>
           <ref name="references"/>
+          <ref name="floating-title"/>
         </choice>
       </zeroOrMore>
     </group>
@@ -1973,7 +2046,11 @@
       </optional>
       <element name="name">
         <zeroOrMore>
-          <ref name="PureTextElement"/>
+          <choice>
+            <ref name="PureTextElement"/>
+            <ref name="stem"/>
+            <ref name="index"/>
+          </choice>
         </zeroOrMore>
       </element>
       <optional>
@@ -1987,7 +2064,7 @@
         </element>
       </optional>
       <optional>
-        <element name="grammar-info">
+        <element name="grammar">
           <ref name="Grammar"/>
         </element>
       </optional>
@@ -2196,7 +2273,18 @@
           <ref name="MultilingualRenderingType"/>
         </attribute>
       </optional>
-      <ref name="paragraph"/>
+      <oneOrMore>
+        <choice>
+          <ref name="formula"/>
+          <ref name="ul"/>
+          <ref name="ol"/>
+          <ref name="dl"/>
+          <ref name="quote"/>
+          <ref name="sourcecode"/>
+          <ref name="paragraph"/>
+          <ref name="figure"/>
+        </choice>
+      </oneOrMore>
     </element>
   </define>
   <define name="termsource">
@@ -2530,4 +2618,17 @@
       </oneOrMore>
     </element>
   </define>
+  <define name="floating-title">
+    <element name="floating-title">
+      <attribute name="id">
+        <data type="ID"/>
+      </attribute>
+      <attribute name="depth">
+        <data type="int"/>
+      </attribute>
+      <zeroOrMore>
+        <ref name="TextElement"/>
+      </zeroOrMore>
+    </element>
+  </define>
 </grammar>