isodoc 1.0.28 → 1.1.3.pre.alpha

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 **{ id: node["id"], 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/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

@@ -17,17 +17,17 @@ 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
@@ -90,21 +90,38 @@ module IsoDoc::Function
     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
 

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

@@ -6,6 +6,7 @@ module IsoDoc::Function
     def docid_l10n(x)
       return x if x.nil?
       x.gsub(/All Parts/i, @all_parts_lbl.downcase) if @all_parts_lbl
+      x
     end
 
     # TODO generate formatted ref if not present
@@ -15,22 +16,24 @@ module IsoDoc::Function
         identifiers = render_identifier(ids)
         if biblio then ref_entry_code(ref, ordinal, identifiers, ids)
         else
-          ref << "#{identifiers[0] || identifiers[1]}, "
-          ref << "#{identifiers[1]}, " if identifiers[0] && identifiers[1]
+          ref << "#{identifiers[0] || identifiers[1]}"
+          ref << ", #{identifiers[1]}" if identifiers[0] && identifiers[1]
         end
+        ref << ", " unless biblio && !identifiers[1]
         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|
-        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]
+        identifiers = render_identifier(bibitem_ref_code(b))
+        if biblio then ref_entry_code(ref, ordinal, identifiers, nil)
+        else
+          ref << "#{identifiers[0] || identifiers[1]}"
+          ref << ", #{identifiers[1]}" if identifiers[0] && identifiers[1]
+        end
         date_note_process(b, ref)
-        ref << ", "
+        ref << ", " unless biblio && !identifiers[1]
         reference_format(b, ref)
       end
     end
@@ -39,9 +42,7 @@ module IsoDoc::Function
     # else, use both ordinal, as prefix, and t
     def ref_entry_code(r, ordinal, t, id)
       prefix_bracketed_ref(r, t[0] || "[#{ordinal}]")
-      if t[1]
-        r << "#{t[1]}, "
-      end
+      t[1] and r << "#{t[1]}"
     end
 
     def pref_ref_code(b)
@@ -88,9 +89,8 @@ module IsoDoc::Function
     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
@@ -129,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|
@@ -159,22 +153,33 @@ module IsoDoc::Function
       end
     end
 
+    def norm_ref_xpath
+      "//bibliography/references[@normative = 'true'] | "\
+      "//bibliography/clause[.//references[@normative = 'true']]"
+    end
+
     def norm_ref(isoxml, out, num)
-      q = "//bibliography/references[@normative = 'true']"
-      f = isoxml.at(ns(q)) or return num
+      f = isoxml.at(ns(norm_ref_xpath)) or return num
       out.div do |div|
         num = num + 1
         clause_name(num, @normref_lbl, div, nil)
-        biblio_list(f, div, false)
+        if f.name == "clause"
+          f.elements.each { |e| parse(e, div) unless e.name == "title" }
+        else
+          biblio_list(f, div, false)
+        end
       end
       num
     end
 
-    BIBLIOGRAPHY_XPATH = "//bibliography/clause[.//references[@normative = 'false']] | "\
-      "//bibliography/references[@normative = 'false']".freeze
+    def bibliography_xpath 
+      "//bibliography/clause[.//references]"\
+      "[not(.//references[@normative = 'true'])] | "\
+      "//bibliography/references[@normative = 'false']"
+    end
 
     def bibliography(isoxml, out)
-      f = isoxml.at(ns(BIBLIOGRAPHY_XPATH)) || return
+      f = isoxml.at(ns(bibliography_xpath)) || return
       page_break(out)
       out.div do |div|
         div.h1 @bibliography_lbl, **{ class: "Section3" }
@@ -185,7 +190,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)
@@ -199,16 +204,6 @@ module IsoDoc::Function
         ref
     end
 
-    def reference_names(ref)
-      isopub = ref.at(ns(ISO_PUBLISHER_XPATH))
-      ids = bibitem_ref_code(ref)
-      identifiers = render_identifier(ids)
-      date = ref.at(ns("./date[@type = 'published']"))
-      allparts = ref.at(ns("./extent[@type='part'][referenceFrom='all']"))
-      reference = docid_l10n(identifiers[0] || identifiers[1])
-      @anchors[ref["id"]] = { xref: reference }
-    end
-
     # def ref_names(ref)
     #  linkend = ref.text
     # linkend.gsub!(/[\[\]]/, "") unless /^\[\d+\]$/.match linkend