isodoc 1.0.27 → 1.1.2

data/lib/isodoc/function/blocks.rb

@@ -1,48 +1,12 @@
-require_relative "blocks_example"
+require_relative "blocks_example_note"
 
 module IsoDoc::Function
   module Blocks
     @annotation = false
 
-    def note_label(node)
-      n = get_anchors[node["id"]]
-      return @note_lbl if n.nil? || n[:label].nil? || n[:label].empty?
-      l10n("#{@note_lbl} #{n[:label]}")
-    end
-
-    def note_p_parse(node, div)
-      div.p do |p|
-        p.span **{ class: "note_label" } do |s|
-          s << note_label(node)
-        end
-        insert_tab(p, 1)
-        node.first_element_child.children.each { |n| parse(n, p) }
-      end
-      node.element_children[1..-1].each { |n| parse(n, div) }
-    end
-
-    def note_parse1(node, div)
-      div.p do |p|
-        p.span **{ class: "note_label" } do |s|
-          s << note_label(node)
-        end
-        insert_tab(p, 1)
-      end
-      node.children.each { |n| parse(n, div) }
-    end
-
-    def note_parse(node, out)
-      @note = true
-      out.div **{ id: node["id"], class: "Note" } do |div|
-        node.first_element_child.name == "p" ?
-          note_p_parse(node, div) : note_parse1(node, div)
-      end
-      @note = false
-    end
-
     def figure_name_parse(node, div, name)
       return if name.nil? && node.at(ns("./figure"))
-      lbl = anchor(node['id'], :label, false)
+      lbl = @xrefs.anchor(node['id'], :label, false)
       lbl = nil if labelled_ancestor(node) && node.ancestors("figure").empty?
       return if lbl.nil? && name.nil?
       div.p **{ class: "FigureTitle", style: "text-align:center;" } do |p|
@@ -58,11 +22,15 @@ module IsoDoc::Function
       end
     end
 
+    def figure_attrs(node)
+      attr_code(id: node["id"], class: "figure", style: keep_style(node))
+    end
+
     def figure_parse(node, out)
       return pseudocode_parse(node, out) if node["class"] == "pseudocode" ||
         node["type"] == "pseudocode"
       @in_figure = true
-      out.div **attr_code(id: node["id"], class: "figure") do |div|
+      out.div **figure_attrs(node) do |div|
         node.children.each do |n|
           figure_key(out) if n.name == "dl"
           parse(n, div) unless n.name == "name"
@@ -72,10 +40,14 @@ module IsoDoc::Function
       @in_figure = false
     end
 
+    def pseudocode_attrs(node)
+      attr_code(id: node["id"], class: "pseudocode", style: keep_style(node))
+    end
+
     def pseudocode_parse(node, out)
       @in_figure = true
       name = node.at(ns("./name"))
-      out.div **attr_code(id: node["id"], class: "pseudocode") do |div|
+      out.div **pseudocode_attrs(node) do |div|
         node.children.each { |n| parse(n, div) unless n.name == "name" }
         sourcecode_name_parse(node, div, name)
       end
@@ -83,7 +55,7 @@ module IsoDoc::Function
     end
 
     def sourcecode_name_parse(node, div, name)
-      lbl = anchor(node['id'], :label, false)
+      lbl = @xrefs.anchor(node['id'], :label, false)
       lbl = nil if labelled_ancestor(node)
       return if lbl.nil? && name.nil?
       div.p **{ class: "SourceTitle", style: "text-align:center;" } do |p|
@@ -101,9 +73,13 @@ module IsoDoc::Function
       end
     end
 
+    def sourcecode_attrs(node)
+      attr_code(id: node["id"], class: "Sourcecode", style: keep_style(node))
+    end
+
     def sourcecode_parse(node, out)
       name = node.at(ns("./name"))
-      out.p **attr_code(id: node["id"], class: "Sourcecode") do |div|
+      out.p **sourcecode_attrs(node) do |div|
         @sourcecode = true
         node.children.each { |n| parse(n, div) unless n.name == "name" }
         @sourcecode = false
@@ -138,10 +114,15 @@ module IsoDoc::Function
       name
     end
 
+    def admonition_attrs(node)
+      attr_code(id: node["id"], class: admonition_class(node),
+                style: keep_style(node))
+    end
+
     def admonition_parse(node, out)
       type = node["type"]
       name = admonition_name(node, type)
-      out.div **{ class: admonition_class(node) } do |t|
+      out.div **admonition_attrs(node) do |t|
         admonition_name_parse(node, t, name) if name
         node.children.each { |n| parse(n, t) unless n.name == "name" }
       end
@@ -157,10 +138,10 @@ module IsoDoc::Function
     end
 
     def formula_parse1(node, out)
-      out.div **attr_code(id: node["id"], class: "formula") do |div|
+      out.div **attr_code(class: "formula") do |div|
         div.p do |p|
           parse(node.at(ns("./stem")), div)
-          lbl = anchor(node['id'], :label, false)
+          lbl = @xrefs.anchor(node['id'], :label, false)
           unless lbl.nil?
             insert_tab(div, 1)
             div << "(#{lbl})"
@@ -169,12 +150,18 @@ module IsoDoc::Function
       end
     end
 
+    def formula_attrs(node)
+      attr_code(id: node["id"], style: keep_style(node))
+    end
+
     def formula_parse(node, out)
-      formula_parse1(node, out)
-      formula_where(node.at(ns("./dl")), out)
-      node.children.each do |n|
-        next if %w(stem dl).include? n.name
-        parse(n, out)
+      out.div **formula_attrs(node) do |div|
+        formula_parse1(node, div)
+        formula_where(node.at(ns("./dl")), div)
+        node.children.each do |n|
+          next if %w(stem dl).include? n.name
+          parse(n, div)
+        end
       end
     end
 
@@ -187,8 +174,9 @@ module IsoDoc::Function
 
     def para_attrs(node)
       attrs = { class: para_class(node), id: node["id"] }
-      node["align"].nil? or
-        attrs[:style] = "text-align:#{node['align']};"
+      s = node["align"].nil? ? "" : "text-align:#{node['align']};"
+      s = "#{s}#{keep_style(node)}"
+      attrs[:style] = s unless s.empty?
       attrs
     end
 
@@ -224,7 +212,8 @@ module IsoDoc::Function
     end
 
     def passthrough_parse(node, out)
-      return if node["format"] and !(node["format"].split(/,/).include? @format.to_s)
+      return if node["format"] and
+        !(node["format"].split(/,/).include? @format.to_s)
       out.passthrough node.text
     end
   end

data/lib/isodoc/function/blocks_example_note.rb

@@ -0,0 +1,108 @@
+module IsoDoc::Function
+  module Blocks
+    def example_label(node, div, name)
+      n = @xrefs.get[node["id"]]
+      div.p **{ class: "example-title" } do |p|
+        lbl = (n.nil? || n[:label].nil? || n[:label].empty?) ? @example_lbl :
+          l10n("#{@example_lbl} #{n[:label]}")
+        p << lbl
+        name and !lbl.nil? and p << "&nbsp;&mdash; "
+        name and name.children.each { |n| parse(n, div) }
+      end
+    end
+
+    EXAMPLE_TBL_ATTR =
+      { class: "example_label", style: "width:82.8pt;padding:0 0 0 0;\
+        margin-left:0pt;vertical-align:top;" }.freeze
+
+    def example_div_attr(node)
+      attr_code(id: node["id"], class: "example", style: keep_style(node))
+    end
+
+    # used if we are boxing examples
+    def example_div_parse(node, out)
+      out.div **example_div_attr(node) do |div|
+        example_label(node, div, node.at(ns("./name")))
+        node.children.each do |n|
+          parse(n, div) unless n.name == "name"
+        end
+      end
+    end
+
+    def example_table_attr(node)
+      attr_code(id: node["id"], class: "example",
+                style: "border-collapse:collapse;border-spacing:0;"\
+                "#{keep_style(node)}" )
+    end
+
+    EXAMPLE_TD_ATTR =
+      { style: "vertical-align:top;padding:0;", class: "example" }.freeze
+
+    def example_table_parse(node, out)
+      out.table **example_table_attr(node) do |t|
+        t.tr do |tr|
+          tr.td **EXAMPLE_TBL_ATTR do |td|
+            example_label(node, td, node.at(ns("./name")))
+          end
+          tr.td **EXAMPLE_TD_ATTR do |td|
+            node.children.each { |n| parse(n, td) unless n.name == "name" }
+          end
+        end
+      end
+    end
+
+    def example_parse(node, out)
+      example_div_parse(node, out)
+    end
+
+    def note_label(node)
+      n = @xrefs.get[node["id"]]
+      return @note_lbl if n.nil? || n[:label].nil? || n[:label].empty?
+      l10n("#{@note_lbl} #{n[:label]}")
+    end
+
+    def note_p_parse(node, div)
+      div.p do |p|
+        p.span **{ class: "note_label" } do |s|
+          s << note_label(node)
+        end
+        insert_tab(p, 1)
+        node.first_element_child.children.each { |n| parse(n, p) }
+      end
+      node.element_children[1..-1].each { |n| parse(n, div) }
+    end
+
+    def note_parse1(node, div)
+      div.p do |p|
+        p.span **{ class: "note_label" } do |s|
+          s << note_label(node)
+        end
+        insert_tab(p, 1)
+      end
+      node.children.each { |n| parse(n, div) }
+    end
+
+    def keep_style(node)
+      ret = ""
+      node["keep-with-next"] == "true" and
+        ret += "page-break-after: avoid;"
+      node["keep-lines-together"] == "true" and
+        ret += "page-break-inside: avoid;"
+      return nil if ret.empty?
+      ret
+    end
+
+    def note_attrs(node)
+      attr_code(id: node["id"], class: "Note", style: keep_style(node))
+    end
+
+    def note_parse(node, out)
+      @note = true
+      out.div **note_attrs(node) do |div|
+        node.first_element_child.name == "p" ?
+          note_p_parse(node, div) : note_parse1(node, div)
+      end
+      @note = false
+    end
+  end
+end

data/lib/isodoc/function/cleanup.rb

@@ -1,16 +1,20 @@
 module IsoDoc::Function
   module Cleanup
     def textcleanup(docxml)
-      docxml = passthrough_cleanup(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 = docxml.split(%r{(<passthrough>|</passthrough>)}).each_slice(4).map do |a|
+      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
@@ -126,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,52 +195,6 @@ 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) }
-      end
-    end
-
-    def strike_parse(node, out)
-      out.s do |e|
-        node.children.each { |n| parse(n, e) }
-      end
-    end
-
     def error_parse(node, out)
       text = node.to_xml.gsub(/</, "&lt;").gsub(/>/, "&gt;")
       out.para do |p|
@@ -232,14 +206,20 @@ module IsoDoc::Function
       if node["lang"] == @lang && node["script"] == @script
         node.children.each { |n| parse(n, out) }
       else
-        prev = node.xpath("./preceding-sibling::xmlns:variant")
-        foll = node.xpath("./following-sibling::xmlns:variant")
-        found = false
-        (prev + foll).each { |n| found = true if n["lang"] == @lang && n["script"] == @script }
-        return if found
-        return unless prev.empty?
+        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 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