isodoc 1.0.25 → 1.1.0

data/lib/isodoc/function/cleanup.rb

@@ -1,13 +1,25 @@
 module IsoDoc::Function
   module Cleanup
     def textcleanup(docxml)
+      docxml = termref_cleanup(passthrough_cleanup(docxml))
+    end
+
+    def termref_cleanup(docxml)
       docxml.
+        gsub(%r{\s*\[/TERMREF\]\s*</p>\s*<p>\s*\[TERMREF\]}, "; ").
         gsub(/\[TERMREF\]\s*/, l10n("[#{@source_lbl}: ")).
         gsub(/\s*\[MODIFICATION\]\s*\[\/TERMREF\]/, l10n(", #{@modified_lbl} [/TERMREF]")).
-        gsub(/\s*\[\/TERMREF\]\s*/, l10n("]")).
+        gsub(%r{\s*\[\/TERMREF\]\s*}, l10n("]")).
         gsub(/\s*\[MODIFICATION\]/, l10n(", #{@modified_lbl} &mdash; "))
     end
 
+    def passthrough_cleanup(docxml)
+      docxml.split(%r{(<passthrough>|</passthrough>)}).each_slice(4).map do |a|
+        a.size > 2 and a[2] = HTMLEntities.new.decode(a[2])
+        [a[0], a[2]]
+      end.join
+    end
+
     def cleanup(docxml)
       comment_cleanup(docxml)
       footnote_cleanup(docxml)
@@ -118,7 +130,7 @@ module IsoDoc::Function
     end
 
     def footnote_cleanup(docxml)
-      docxml.xpath('//a[@epub:type = "footnote"]/sup').each_with_index do |x, i|
+      docxml.xpath('//a[@class = "FootnoteRef"]/sup').each_with_index do |x, i|
         x.content = (i + 1).to_s
       end
       docxml

data/lib/isodoc/function/i18n.rb

@@ -87,6 +87,7 @@ module IsoDoc::Function
 
     # TODO: move to localization file
     def eref_localities1(target, type, from, to, delim, lang = "en")
+      return "" if type == "anchor"
       return l10n(eref_localities1_zh(target, type, from, to, delim)) if lang == "zh"
       ret = delim
       loc = @locality[type] || type.sub(/^locality:/, "").capitalize

data/lib/isodoc/function/inline.rb

@@ -1,28 +1,7 @@
+require_relative "inline_simple"
+
 module IsoDoc::Function
   module Inline
-    def section_break(body)
-      body.br
-    end
-
-    def page_break(out)
-      out.br
-    end
-
-    def pagebreak_parse(_node, out)
-      out.br
-    end
-
-    def hr_parse(node, out)
-      out.hr
-    end
-
-    def br_parse(node, out)
-      out.br
-    end
-
-    def index_parse(node, out)
-    end
-
     def link_parse(node, out)
       out.a **attr_code(href: node["target"], title: node["alt"]) do |l|
         if node.text.empty?
@@ -38,29 +17,51 @@ module IsoDoc::Function
     end
 
     def prefix_container(container, linkend, _target)
-      l10n(anchor(container, :xref) + ", " + linkend)
+      l10n(@xrefs.anchor(container, :xref) + ", " + linkend)
     end
 
     def anchor_linkend(node, linkend)
       if node["citeas"].nil? && node["bibitemid"] 
-        return anchor(node["bibitemid"] ,:xref) || "???"
+        return @xrefs.anchor(node["bibitemid"] ,:xref) || "???"
       elsif node["target"] && !/.#./.match(node["target"])
-        linkend = anchor(node["target"], :xref)
-        container = anchor(node["target"], :container, false)
+        linkend = @xrefs.anchor(node["target"], :xref)
+        container = @xrefs.anchor(node["target"], :container, false)
         (container && get_note_container_id(node) != container &&
-         @anchors[node["target"]]) &&
+         @xrefs.get[node["target"]]) &&
         linkend = prefix_container(container, linkend, node["target"])
+        linkend = capitalise_xref(node, linkend)
       end
       linkend || "???"
     end
 
+    def capitalise_xref(node, linkend)
+      return linkend unless %w(Latn Cyrl Grek).include? @script
+      return linkend&.capitalize if node["case"] == "capital"
+      return linkend&.downcase if node["case"] == "lowercase"
+      return linkend if linkend[0,1].match(/\p{Upper}/)
+      prec = nearest_block_parent(node).xpath("./descendant-or-self::text()") &
+        node.xpath("./preceding::text()")
+      (prec.empty? || /(?!<[^.].)\.\s+$/.match(prec.map { |p| p.text }.join)) ?
+        linkend&.capitalize : linkend
+    end
+
+    def nearest_block_parent(node)
+      until %w(p title td th name formula 
+        li dt dd sourcecode pre).include?(node.name)
+        node = node.parent
+      end
+      node
+    end
+
     def get_linkend(node)
-      contents = node.children.select { |c| !%w{locality localityStack}.include? c.name }.
-        select { |c| !c.text? || /\S/.match(c) }
+      contents = node.children.select do |c|
+        !%w{locality localityStack}.include? c.name 
+      end.select { |c| !c.text? || /\S/.match(c) }
       !contents.empty? and
         return Nokogiri::XML::NodeSet.new(node.document, contents).to_xml
       link = anchor_linkend(node, docid_l10n(node["target"] || node["citeas"]))
-      link + eref_localities(node.xpath(ns("./locality | ./localityStack")), link)
+      link + eref_localities(node.xpath(ns("./locality | ./localityStack")),
+                             link)
       # so not <origin bibitemid="ISO7301" citeas="ISO 7301">
       # <locality type="section"><reference>3.1</reference></locality></origin>
     end
@@ -83,27 +84,44 @@ module IsoDoc::Function
           end
         else
           ret += eref_localities0(r, i, target, delim)
-          end
+        end
       end
       ret
     end
 
     def eref_localities0(r, i, target, delim)
-      if r["type"] == "whole" then l10n("#{delim} #{@whole_of_text}")
+      if r["type"] == "whole" then l10n("#{delim} #{@wholeoftext_lbl}")
       else
         eref_localities1(target, r["type"], r.at(ns("./referenceFrom")),
                          r.at(ns("./referenceTo")), delim, @lang)
       end
     end
 
+    def suffix_url(url)
+      return url if %r{^http[s]?://}.match(url)
+      url.sub(/#{File.extname(url)}$/, ".html")
+    end
+
+    def eref_target(node)
+      href = "#" + node["bibitemid"]
+      url = node.at(ns("//bibitem[@id = '#{node['bibitemid']}']/"\
+                       "uri[@type = 'citation']"))
+      return href unless url
+      href = suffix_url(url.text)
+      anchor = node&.at(ns(".//locality[@type = 'anchor']"))&.text
+      anchor and href += "##{anchor}"
+      href
+    end
+
     def eref_parse(node, out)
       linkend = get_linkend(node)
+      href = eref_target(node)
       if node["type"] == "footnote"
         out.sup do |s|
-          s.a(**{ "href": "#" + node["bibitemid"] }) { |l| l << linkend }
+          s.a(**{ "href": href }) { |l| l << linkend }
         end
       else
-        out.a(**{ "href": "#" + node["bibitemid"] }) { |l| l << linkend }
+        out.a(**{ "href": href }) { |l| l << linkend }
       end
     end
 
@@ -120,8 +138,9 @@ module IsoDoc::Function
     end
 
     def concept_parse(node, out)
-      content = node.first_element_child.children.select { |c| !%w{locality localityStack}.include? c.name }.
-        select { |c| !c.text? || /\S/.match(c) }
+      content = node.first_element_child.children.select do |c|
+        !%w{locality localityStack}.include? c.name 
+      end.select { |c| !c.text? || /\S/.match(c) }
       if content.empty?
         out << "[Term defined in "
         parse(node.first_element_child, out)
@@ -133,7 +152,8 @@ module IsoDoc::Function
 
     def stem_parse(node, out)
       ooml = if node["type"] == "AsciiMath"
-               "#{@openmathdelim}#{HTMLEntities.new.encode(node.text)}#{@closemathdelim}"
+               "#{@openmathdelim}#{HTMLEntities.new.encode(node.text)}"\
+                 "#{@closemathdelim}"
              elsif node["type"] == "MathML" then node.first_element_child.to_s
              else
                HTMLEntities.new.encode(node.text)
@@ -175,57 +195,31 @@ module IsoDoc::Function
       out << text
     end
 
-    def bookmark_parse(node, out)
-      out.a **attr_code(id: node["id"])
-    end
-
-    def keyword_parse(node, out)
-      out.span **{ class: "keyword" } do |s|
-        node.children.each { |n| parse(n, s) }
-      end
-    end
-
-    def em_parse(node, out)
-      out.i do |e|
-        node.children.each { |n| parse(n, e) }
-      end
-    end
-
-    def strong_parse(node, out)
-      out.b do |e|
-        node.children.each { |n| parse(n, e) }
-      end
-    end
-
-    def sup_parse(node, out)
-      out.sup do |e|
-        node.children.each { |n| parse(n, e) }
-      end
-    end
-
-    def sub_parse(node, out)
-      out.sub do |e|
-        node.children.each { |n| parse(n, e) }
-      end
-    end
-
-    def tt_parse(node, out)
-      out.tt do |e|
-        node.children.each { |n| parse(n, e) }
+    def error_parse(node, out)
+      text = node.to_xml.gsub(/</, "&lt;").gsub(/>/, "&gt;")
+      out.para do |p|
+        p.b(**{ role: "strong" }) { |e| e << text }
       end
     end
 
-    def strike_parse(node, out)
-      out.s do |e|
-        node.children.each { |n| parse(n, e) }
+    def variant_parse(node, out)
+      if node["lang"] == @lang && node["script"] == @script
+        node.children.each { |n| parse(n, out) }
+      else
+        return if found_matching_variant_sibling(node)
+        return unless !node.at("./preceding-sibling::xmlns:variant")
+        node.children.each { |n| parse(n, out) }
       end
     end
 
-    def error_parse(node, out)
-      text = node.to_xml.gsub(/</, "&lt;").gsub(/>/, "&gt;")
-      out.para do |p|
-        p.b(**{ role: "strong" }) { |e| e << text }
+    def found_matching_variant_sibling(node)
+      prev = node.xpath("./preceding-sibling::xmlns:variant")
+      foll = node.xpath("./following-sibling::xmlns:variant")
+      found = false
+      (prev + foll).each do |n|
+        found = true if n["lang"] == @lang && n["script"] == @script
       end
+      found
     end
   end
 end

data/lib/isodoc/function/inline_simple.rb

@@ -0,0 +1,72 @@
+module IsoDoc::Function
+  module Inline
+    def section_break(body)
+      body.br
+    end
+
+    def page_break(out)
+      out.br
+    end
+
+    def pagebreak_parse(_node, out)
+      out.br
+    end
+
+    def hr_parse(node, out)
+      out.hr
+    end
+
+    def br_parse(node, out)
+      out.br
+    end
+
+    def index_parse(node, out)
+    end
+
+        def bookmark_parse(node, out)
+      out.a **attr_code(id: node["id"])
+    end
+
+    def keyword_parse(node, out)
+      out.span **{ class: "keyword" } do |s|
+        node.children.each { |n| parse(n, s) }
+      end
+    end
+
+    def em_parse(node, out)
+      out.i do |e|
+        node.children.each { |n| parse(n, e) }
+      end
+    end
+
+    def strong_parse(node, out)
+      out.b do |e|
+        node.children.each { |n| parse(n, e) }
+      end
+    end
+
+    def sup_parse(node, out)
+      out.sup do |e|
+        node.children.each { |n| parse(n, e) }
+      end
+    end
+
+    def sub_parse(node, out)
+      out.sub do |e|
+        node.children.each { |n| parse(n, e) }
+      end
+    end
+
+    def tt_parse(node, out)
+      out.tt do |e|
+        node.children.each { |n| parse(n, e) }
+      end
+    end
+
+    def strike_parse(node, out)
+      out.s do |e|
+        node.children.each { |n| parse(n, e) }
+      end
+    end
+  end
+end

data/lib/isodoc/function/lists.rb

@@ -1,8 +1,11 @@
 module IsoDoc::Function
   module Lists
+    def ul_attrs(node)
+      { id: node["id"], style: keep_style(node) }
+    end
 
     def ul_parse(node, out)
-      out.ul **attr_code(id: node["id"]) do |ul|
+      out.ul **attr_code(ul_attrs(node)) do |ul|
         node.children.each { |n| parse(n, ul) }
       end
     end
@@ -34,9 +37,12 @@ module IsoDoc::Function
       ol_style(type)
     end
 
+    def ol_attrs(node)
+      { type: ol_depth(node), id: node["id"], style: keep_style(node) }
+    end
+
     def ol_parse(node, out)
-      style = ol_depth(node)
-      out.ol **attr_code(type: style, id: node["id"] ) do |ol|
+      out.ol **attr_code(ol_attrs(node)) do |ol|
         node.children.each { |n| parse(n, ol) }
       end
     end
@@ -67,12 +73,12 @@ module IsoDoc::Function
       %w{dt dd}.include? n.name
     end
 
-    def dl_attr(node)
-      attr_code(id: node["id"])
+    def dl_attrs(node)
+      attr_code(id: node["id"], style: keep_style(node))
     end
 
     def dl_parse(node, out)
-      out.dl  **dl_attr(node) do |v|
+      out.dl  **dl_attrs(node) do |v|
         node.elements.select { |n| dt_dd? n }.each_slice(2) do |dt, dd|
           v.dt **attr_code(id: dt["id"]) do |term|
             dt_parse(dt, term) 

data/lib/isodoc/function/references.rb

@@ -5,30 +5,31 @@ module IsoDoc::Function
     # references anyway; keeping here instead of in IsoDoc::Iso for now
     def docid_l10n(x)
       return x if x.nil?
-      x.gsub(/All Parts/i, @all_parts_lbl.downcase)
+      x.gsub(/All Parts/i, @all_parts_lbl.downcase) if @all_parts_lbl
+      x
     end
 
     # TODO generate formatted ref if not present
-    def nonstd_bibitem(list, b, ordinal, bibliography)
-      list.p **attr_code(iso_bibitem_entry_attrs(b, bibliography)) do |r|
-        id = bibitem_ref_code(b)
-        identifier = render_identifier(id)
-        if bibliography then ref_entry_code(r, ordinal, identifier, id)
+    def nonstd_bibitem(list, b, ordinal, biblio)
+      list.p **attr_code(iso_bibitem_entry_attrs(b, biblio)) do |ref|
+        ids = bibitem_ref_code(b)
+        identifiers = render_identifier(ids)
+        if biblio then ref_entry_code(ref, ordinal, identifiers, ids)
         else
-          identifier = "[#{identifier}]" if id["type"] == "metanorma"
-          r << "#{identifier}, "
+          ref << "#{identifiers[0] || identifiers[1]}, "
+          ref << "#{identifiers[1]}, " if identifiers[0] && identifiers[1]
         end
-        reference_format(b, r)
+        reference_format(b, ref)
       end
     end
 
     def std_bibitem_entry(list, b, ordinal, biblio)
       list.p **attr_code(iso_bibitem_entry_attrs(b, biblio)) do |ref|
-        prefix_bracketed_ref(ref, ordinal) if biblio
-        id = bibitem_ref_code(b)
-        identifier = render_identifier(id)
-        identifier = "[#{identifier}]" if id["type"] == "metanorma" && !biblio
-        ref << identifier
+        ids = bibitem_ref_code(b)
+        identifiers = render_identifier(ids)
+        prefix_bracketed_ref(ref, "[#{ordinal}]") if biblio
+        ref << "#{identifiers[0] || identifiers[1]}"
+        ref << ", #{identifiers[1]}" if identifiers[0] && identifiers[1]
         date_note_process(b, ref)
         ref << ", "
         reference_format(b, ref)
@@ -38,29 +39,43 @@ module IsoDoc::Function
     # if t is just a number, only use that ([1] Non-Standard)
     # else, use both ordinal, as prefix, and t
     def ref_entry_code(r, ordinal, t, id)
-      if id["type"] == "metanorma"
-        prefix_bracketed_ref(r, t)
-      else
-        prefix_bracketed_ref(r, ordinal)
-        if !t.empty? && !%w(DOI ISSN ISBN).include?(id["type"])
-          r << "#{t}, "
-        end
+      prefix_bracketed_ref(r, t[0] || "[#{ordinal}]")
+      if t[1]
+        r << "#{t[1]}, "
       end
     end
 
+    def pref_ref_code(b)
+      b.at(ns("./docidentifier[not(@type = 'DOI' or @type = 'metanorma' "\
+              "or @type = 'ISSN' or @type = 'ISBN' or @type = 'rfc-anchor')]"))
+    end
+
+    # returns [metanorma, non-metanorma, DOI/ISSN/ISBN] identifiers
     def bibitem_ref_code(b)
       id = b.at(ns("./docidentifier[@type = 'metanorma']"))
-      id ||= b.at(ns("./docidentifier[not(@type = 'DOI' or @type = 'metanorma' "\
-                   "or @type = 'ISSN' or @type = 'ISBN')]"))
-      id ||= b.at(ns("./docidentifier")) 
-      return id if id
+      id1 = pref_ref_code(b)
+      id2 = b.at(ns("./docidentifier[@type = 'DOI' or @type = 'ISSN' or @type = 'ISBN']")) 
+      return [id, id1, id2] if id || id1 || id2
       id = Nokogiri::XML::Node.new("docidentifier", b.document)
       id << "(NO ID)"
-      id
+      [nil, id, nil]
+    end
+
+    def bracket_if_num(x)
+      return nil if x.nil?
+      x = x.text.sub(/^\[/, "").sub(/\]$/, "")
+      return "[#{x}]" if /^\d+$/.match(x)
+      x
     end
 
     def render_identifier(id)
-      docid_prefix(id["type"], id.text.sub(/^\[/, "").sub(/\]$/, ""))
+      [
+        bracket_if_num(id[0]),
+        id[1].nil? ? nil :
+        docid_prefix(id[1]["type"], id[1].text.sub(/^\[/, "").sub(/\]$/, "")),
+        id[2].nil? ? nil :
+        docid_prefix(id[2]["type"], id[2].text.sub(/^\[/, "").sub(/\]$/, "")),
+      ]
     end
 
     def docid_prefix(prefix, docid)
@@ -70,13 +85,12 @@ module IsoDoc::Function
 
     def omit_docid_prefix(prefix)
       return true if prefix.nil? || prefix.empty?
-      return %w(ISO IEC ITU metanorma).include? prefix
+      return %w(ISO IEC ITU W3C metanorma).include? prefix
     end
 
     def date_note_process(b, ref)
-      date_note = b.at(ns("./note[text()][contains(.,'ISO DATE:')]"))
+      date_note = b.at(ns("./note[@type = 'ISO DATE']"))
       return if date_note.nil?
-      date_note.content = date_note.content.gsub(/ISO DATE: /, "")
       date_note.children.first.replace("<p>#{date_note.content}</p>")
       footnote_parse(date_note, ref)
     end
@@ -100,7 +114,7 @@ module IsoDoc::Function
     end
 
     def prefix_bracketed_ref(ref, text)
-      ref << "[#{text}]"
+      ref << text.to_s
       insert_tab(ref, 1)
     end
 
@@ -115,12 +129,6 @@ module IsoDoc::Function
       end
     end
 
-    ISO_PUBLISHER_XPATH =
-      "./contributor[xmlns:role/@type = 'publisher']/"\
-      "organization[abbreviation = 'ISO' or xmlns:abbreviation = 'IEC' or "\
-      "xmlns:name = 'International Organization for Standardization' or "\
-      "xmlns:name = 'International Electrotechnical Commission']".freeze
-
     def is_standard(b)
       ret = false
       b.xpath(ns("./docidentifier")).each do |id|
@@ -146,8 +154,7 @@ module IsoDoc::Function
     end
 
     def norm_ref(isoxml, out, num)
-      q = "//bibliography/references[title = 'Normative References' or "\
-        "title = 'Normative references']"
+      q = "//bibliography/references[@normative = 'true']"
       f = isoxml.at(ns(q)) or return num
       out.div do |div|
         num = num + 1
@@ -157,8 +164,8 @@ module IsoDoc::Function
       num
     end
 
-    BIBLIOGRAPHY_XPATH = "//bibliography/clause[title = 'Bibliography'] | "\
-      "//bibliography/references[title = 'Bibliography']".freeze
+    BIBLIOGRAPHY_XPATH = "//bibliography/clause[.//references[@normative = 'false']] | "\
+      "//bibliography/references[@normative = 'false']".freeze
 
     def bibliography(isoxml, out)
       f = isoxml.at(ns(BIBLIOGRAPHY_XPATH)) || return
@@ -172,7 +179,7 @@ module IsoDoc::Function
     def bibliography_parse(node, out)
       title = node&.at(ns("./title"))&.text || ""
       out.div do |div|
-        anchor(node['id'], :label, false) and
+        @xrefs.anchor(node['id'], :label, false) and
           clause_parse_title(node, div, node.at(ns("./title")), out) or
           div.h2 title, **{ class: "Section3" }
         biblio_list(node, div, true)
@@ -186,17 +193,6 @@ module IsoDoc::Function
         ref
     end
 
-    def reference_names(ref)
-      isopub = ref.at(ns(ISO_PUBLISHER_XPATH))
-      docid = bibitem_ref_code(ref)
-      prefix = docid["type"]
-      date = ref.at(ns("./date[@type = 'published']"))
-      allparts = ref.at(ns("./extent[@type='part'][referenceFrom='all']"))
-      reference = format_ref(docid_l10n(docid.text), prefix, isopub, date,
-                             allparts)
-      @anchors[ref["id"]] = { xref: reference }
-    end
-
     # def ref_names(ref)
     #  linkend = ref.text
     # linkend.gsub!(/[\[\]]/, "") unless /^\[\d+\]$/.match linkend