isodoc 1.6.4 → 1.7.0

data/lib/isodoc/presentation_function/bibdata.rb

@@ -1,6 +1,7 @@
 module IsoDoc
   class PresentationXMLConvert < ::IsoDoc::Convert
     def bibdata(docxml)
+      docid_prefixes(docxml)
       a = bibdata_current(docxml) or return
       address_precompose(a)
       bibdata_i18n(a)
@@ -9,6 +10,12 @@ module IsoDoc
         "</localized-strings>"
     end
 
+     def docid_prefixes(docxml)
+      docxml.xpath(ns("//references/bibitem/docidentifier")).each do |i|
+        i.children = @xrefs.klass.docid_prefix(i["type"], i.text)
+      end
+    end
+
     def address_precompose(bib)
       bib.xpath(ns("//bibdata//address")).each do |b|
         next if b.at(ns("./formattedAddress"))

data/lib/isodoc/presentation_function/block.rb

@@ -19,12 +19,15 @@ module IsoDoc
       end
     end
 
-    def svg_extract(f)
-      return unless %r{^data:image/svg\+xml;base64,}.match?(f["src"])
+    def svg_extract(elem)
+      return unless %r{^data:image/svg\+xml;base64,}.match?(elem["src"])
 
-      svg = Base64.strict_decode64(f["src"]
+      svg = Base64.strict_decode64(elem["src"]
         .sub(%r{^data:image/svg\+xml;base64,}, ""))
-      f.replace(svg.sub(/<\?xml[^>]*>/, ""))
+      x = Nokogiri::XML.fragment(svg.sub(/<\?xml[^>]*>/, "")) do |config|
+        config.huge
+      end
+      elem.replace(x)
     end
 
     def figure1(f)

data/lib/isodoc/presentation_function/inline.rb

@@ -129,10 +129,8 @@ module IsoDoc
 
       loc = @i18n.locality[type] || type.sub(/^locality:/, "")
       loc = case node["case"]
-            when "capital" then loc.capitalize
             when "lowercase" then loc.downcase
-            else
-              loc.capitalize
+            else loc.capitalize
             end
       " #{loc}"
     end
@@ -162,15 +160,12 @@ module IsoDoc
     end
 
     def concept1(node)
-      content = node.first_element_child.children.reject do |c|
-        %w{locality localityStack}.include? c.name
-      end.select { |c| !c.text? || /\S/.match(c) }
-      n = if content.empty?
-            @i18n.term_defined_in.sub(/%/, node.first_element_child.to_xml)
-          else
-            "<em>#{node.children.to_xml}</em>"
-          end
-      node.replace(n)
+      node&.at(ns("./refterm"))&.remove
+      d = node&.at(ns("./renderterm"))
+      d&.name = "em"
+      r = node.at(ns("./xref | ./eref | ./termref"))
+      r.replace(@i18n.term_defined_in.sub(/%/, r.to_xml))
+      node.replace(node.children)
     end
 
     def variant(docxml)

data/lib/isodoc/presentation_function/section.rb

@@ -44,10 +44,47 @@ module IsoDoc
       prefix_name(elem, "", "#{lbl}#{clausedelim}", "name")
     end
 
-    def references(docxml); end
+    def references(docxml)
+    end
+
+    def docid_prefixes(docxml)
+      docxml.xpath(ns("//references/bibitem/docidentifier")).each do |i|
+        i.children = @xrefs.klass.docid_prefix(i["type"], i.text)
+      end
+    end
 
     def index(docxml)
       docxml.xpath(ns("//index | //index-xref | //indexsect")).each(&:remove)
     end
+
+    def display_order_at(docxml, xpath, idx)
+      return idx unless c = docxml.at(ns(xpath))
+
+      idx += 1
+      c["displayorder"] = idx
+      idx
+    end
+
+    def display_order_xpath(docxml, xpath, idx)
+      docxml.xpath(ns(xpath)).each do |c|
+        idx += 1
+        c["displayorder"] = idx
+      end
+      idx
+    end
+
+    def display_order(docxml)
+      i = 0
+      i = display_order_xpath(docxml, "//preface/*", i)
+      i = display_order_at(docxml, "//clause[@type = 'scope']", i)
+      i = display_order_at(docxml, @xrefs.klass.norm_ref_xpath, i)
+      i = display_order_at(docxml, "//sections/terms | "\
+                           "//sections/clause[descendant::terms]", i)
+      i = display_order_at(docxml, "//sections/definitions", i)
+      i = display_order_xpath(docxml, @xrefs.klass.middle_clause(docxml), i)
+      i = display_order_xpath(docxml, "//annex", i)
+      i = display_order_xpath(docxml, @xrefs.klass.bibliography_xpath, i)
+      display_order_xpath(docxml, "//indexsect", i)
+    end
   end
 end

data/lib/isodoc/presentation_xml_convert.rb

@@ -22,6 +22,7 @@ module IsoDoc
 
     def conversions(docxml)
       bibdata docxml
+      @xrefs.parse docxml
       section docxml
       block docxml
       inline docxml
@@ -33,6 +34,7 @@ module IsoDoc
       term docxml
       references docxml
       index docxml
+      display_order docxml
     end
 
     def block(docxml)

data/lib/isodoc/version.rb

@@ -1,3 +1,3 @@
 module IsoDoc
-  VERSION = "1.6.4".freeze
+  VERSION = "1.7.0".freeze
 end

data/lib/isodoc/xref.rb

@@ -11,6 +11,8 @@ module IsoDoc
     include XrefGen::Blocks
     include XrefGen::Sections
 
+    attr_reader :klass
+
     def initialize(lang, script, klass, i18n, options = {})
       @anchors = {}
       @lang = lang
@@ -26,16 +28,16 @@ module IsoDoc
       @anchors
     end
 
-    def anchor(id, lbl, warning = true)
-      return nil if id.nil? || id.empty?
+    def anchor(ident, lbl, warning = true)
+      return nil if ident.nil? || ident.empty?
 
-      if warning && !@anchors[id]
+      if warning && !@anchors[ident]
         @seen ||= Seen_Anchor.instance
-        @seen.seen(id) or warn "No label has been processed for ID #{id}"
-        @seen.add(id)
-        return "[#{id}]"
+        @seen.seen(ident) or warn "No label has been processed for ID #{ident}"
+        @seen.add(ident)
+        return "[#{ident}]"
       end
-      @anchors.dig(id, lbl)
+      @anchors.dig(ident, lbl)
     end
 
     # extract names for all anchors, xref and label
@@ -48,6 +50,7 @@ module IsoDoc
       note_anchor_names(docxml.xpath(ns(SECTIONS_XPATH)))
       example_anchor_names(docxml.xpath(ns(SECTIONS_XPATH)))
       list_anchor_names(docxml.xpath(ns(SECTIONS_XPATH)))
+      deflist_anchor_names(docxml.xpath(ns(SECTIONS_XPATH)))
       bookmark_anchor_names(docxml)
     end
 

data/lib/isodoc/xref/xref_anchor.rb

@@ -1,61 +1,62 @@
 require "singleton"
 
-module IsoDoc::XrefGen
-  module Anchor
-    class Seen_Anchor
-      include Singleton
+module IsoDoc
+  module XrefGen
+    module Anchor
+      class Seen_Anchor
+        include Singleton
+
+        def initialize
+          @seen = {}
+        end
+
+        def seen(elem)
+          @seen.has_key?(elem)
+        end
+
+        def add(elem)
+          @seen[elem] = true
+        end
+      end
 
       def initialize
-        @seen = {}
+        @anchors = {}
       end
 
-      def seen(x)
-        @seen.has_key?(x)
+      def get_anchors
+        @anchors
       end
 
-      def add(x)
-        @seen[x] = true
+      def anchor_struct_label(lbl, elem)
+        case elem
+        when @labels["appendix"] then l10n("#{elem} #{lbl}")
+        else
+          lbl.to_s
+        end
       end
-    end
-
-    def initialize()
-      @anchors = {}
-    end
-
-    def get_anchors
-      @anchors
-    end
 
-    def anchor_struct_label(lbl, elem)
-      case elem
-      when @labels["appendix"] then l10n("#{elem} #{lbl}")
-      else
-        lbl.to_s
+      def anchor_struct_xref(lbl, elem)
+        l10n("#{elem} #{anchor_struct_value(lbl, elem)}")
       end
-    end
-
-    def anchor_struct_xref(lbl, elem)
-      l10n("#{elem} #{anchor_struct_value(lbl, elem)}")
-    end
 
-    def anchor_struct_value(lbl, elem)
-      case elem
-      when @labels["formula"] then "(#{lbl})"
-      when @labels["inequality"] then "(#{lbl})"
-      else
-        lbl
+      def anchor_struct_value(lbl, elem)
+        case elem
+        when @labels["formula"], @labels["inequality"] then "(#{lbl})"
+        else
+          lbl
+        end
       end
-    end
 
-    def anchor_struct(lbl, container, elem, type, unnumbered = false)
-      ret = {}
-      ret[:label] = unnumbered == "true" ? nil : anchor_struct_label(lbl, elem)
-      ret[:xref] = anchor_struct_xref(unnumbered == "true" ? "(??)" : lbl, elem)
-      ret[:xref].gsub!(/ $/, "")
-      ret[:container] = @klass.get_clause_id(container) unless container.nil?
-      ret[:type] = type
-      ret[:value] = anchor_struct_value(lbl, elem)
-      ret
+      def anchor_struct(lbl, container, elem, type, unnumb = false)
+        ret = {}
+        ret[:label] = unnumb == "true" ? nil : anchor_struct_label(lbl, elem)
+        ret[:xref] = anchor_struct_xref(unnumb == "true" ? "(??)" : lbl, elem)
+        ret[:xref].gsub!(/ $/, "")
+        ret[:container] = @klass.get_clause_id(container) unless container.nil?
+        ret[:type] = type
+        ret[:value] = anchor_struct_value(lbl, elem)
+        ret
+      end
     end
   end
 end

data/lib/isodoc/xref/xref_counter.rb

@@ -1,33 +1,37 @@
 require "roman-numerals"
 
-module IsoDoc::XrefGen
-  class Counter
-    def initialize(num = 0, opts = { numerals: :arabic })
-      @num = num
-      @letter = ""
-      @subseq = ""
-      @letter_override = nil
-      @number_override = nil
-      @style = opts[:numerals]
-      @skip_i = opts[:skip_i]
-      @base = ""
-      if num.is_a? String
-        if /^\d+$/.match?(num)
-          @num = num.to_i
-        else
-          @num = nil
-          @base = num[0..-2]
-          @letter = num[-1]
+module IsoDoc
+  module XrefGen
+    class Counter
+      def initialize(num = 0, opts = { numerals: :arabic })
+        @num = num
+        @letter = ""
+        @subseq = ""
+        @letter_override = nil
+        @number_override = nil
+        @style = opts[:numerals]
+        @skip_i = opts[:skip_i]
+        @base = ""
+        if num.is_a? String
+          if /^\d+$/.match?(num)
+            @num = num.to_i
+          else
+            @num = nil
+            @base = num[0..-2]
+            @letter = num[-1]
+          end
         end
       end
-    end
 
-    def new_subseq_increment(node)
-      @subseq = node["subsequence"]
-      @num += 1 unless @num.nil?
-      @letter = node["subsequence"] ? "a" : ""
-      @base = ""
-      if node["number"]
+      def new_subseq_increment(node)
+        @subseq = node["subsequence"]
+        @num += 1 unless @num.nil?
+        @letter = node["subsequence"] ? "a" : ""
+        @base = ""
+        new_subseq_increment1(node) if node["number"]
+      end
+
+      def new_subseq_increment1(node)
         /^(?<b>.*?)(?<n>\d*)(?<a>[a-zA-Z]*)$/ =~ node["number"]
         if !n.empty? || !a.empty?
           @letter_override = @letter = a unless a.empty?
@@ -38,108 +42,114 @@ module IsoDoc::XrefGen
           @letter = @letter_override if /^[a-zA-Z]$/.match?(@letter_override)
         end
       end
-    end
 
-    def sequence_increment(node)
-      if node["number"]
-        @base = @letter_override = @number_override = ""
-        /^(?<b>.*?)(?<n>\d+)$/ =~ node["number"]
-        if blank?(n)
-          @num = nil
-          @base = node["number"][0..-2]
-          @letter = @letter_override = node["number"][-1]
-        else
-          @number_override = @num = n.to_i
-          @base = b
-          @letter = ""
+      def sequence_increment(node)
+        if node["number"]
+          @base = @letter_override = @number_override = ""
+          /^(?<b>.*?)(?<n>\d+)$/ =~ node["number"]
+          if blank?(n)
+            @num = nil
+            @base = node["number"][0..-2]
+            @letter = @letter_override = node["number"][-1]
+          else
+            @number_override = @num = n.to_i
+            @base = b
+            @letter = ""
+          end
+        else @num += 1
         end
-      else
-        @num += 1
       end
-    end
 
-    def subsequence_increment(node)
-      if node["number"]
+      def subsequence_increment(node)
+        return increment_letter unless node["number"]
+
         @base = ""
         @letter_override = node["number"]
         /^(?<b>.*?)(?<n>\d*)(?<a>[a-zA-Z])$/ =~ node["number"]
-        if blank?(a)
-          if /^\d+$/.match?(node["number"])
-            @letter_override = @letter = ""
-            @number_override = @num = node["number"].to_i
-          else
-            /^(?<b>.*)(?<a>[a-zA-Z])$/ =~ node["number"]
-            unless blank?(a)
-              @letter = @letter_override = a
-              @base = b
-            end
-          end
+        if blank?(a) then subsequence_increment_no_letter(node)
         else
           @letter_override = @letter = a
           @base = b
           @number_override = @num = n.to_i unless n.empty?
         end
-      else
-        increment_letter
       end
-    end
 
-    def increment_letter
-      case @letter
-      when "Z"
-        @letter = "@"
-        @base = @base.empty? ? "A" : @base[0..-2] + (@base[-1].ord + 1).chr.to_s
-      when "z"
-        @letter = "`"
-        @base = @base.empty? ? "a" : @base[0..-2] + (@base[-1].ord + 1).chr.to_s
+      def subsequence_increment_no_letter(node)
+        if /^\d+$/.match?(node["number"])
+          @letter_override = @letter = ""
+          @number_override = @num = node["number"].to_i
+        else
+          /^(?<b>.*)(?<a>[a-zA-Z])$/ =~ node["number"]
+          unless blank?(a)
+            @letter = @letter_override = a
+            @base = b
+          end
+        end
+      end
+
+      def string_inc(str, start)
+        return start if str.empty?
+
+        str[0..-2] + (str[-1].ord + 1).chr.to_s
       end
-      @letter = (@letter.ord + 1).chr.to_s
-      @skip_i && %w(i I).include?(@letter) and
+
+      def increment_letter
+        case @letter
+        when "Z"
+          @letter = "@"
+          @base = string_inc(@base, "A")
+        when "z"
+          @letter = "`"
+          @base = string_inc(@base, "a")
+        end
         @letter = (@letter.ord + 1).chr.to_s
-    end
+        @skip_i && %w(i I).include?(@letter) and
+          @letter = (@letter.ord + 1).chr.to_s
+      end
 
-    def blank?(str)
-      str.nil? || str.empty?
-    end
+      def blank?(str)
+        str.nil? || str.empty?
+      end
 
-    def increment(node)
-      return self if node["unnumbered"]
+      def increment(node)
+        return self if node["unnumbered"]
 
-      @letter_override = nil
-      @number_override = nil
-      if node["subsequence"] != @subseq &&
-          !(blank?(node["subsequence"]) && blank?(@subseq))
-        new_subseq_increment(node)
-      elsif @letter.empty? then sequence_increment(node)
-      else subsequence_increment(node)
+        @letter_override = nil
+        @number_override = nil
+        if node["subsequence"] != @subseq &&
+            !(blank?(node["subsequence"]) && blank?(@subseq))
+          new_subseq_increment(node)
+        elsif @letter.empty? then sequence_increment(node)
+        else subsequence_increment(node)
+        end
+        self
       end
-      self
-    end
 
-    def print
-      num = @number_override || @num
-      out = @style == :roman && !num.nil? ? RomanNumerals.to_roman(num) : num
-      "#{@base}#{out}#{@letter_override || @letter}"
-    end
+      def print
+        num = @number_override || @num
+        out = @style == :roman && !num.nil? ? RomanNumerals.to_roman(num) : num
+        "#{@base}#{out}#{@letter_override || @letter}"
+      end
 
-    def ol_type(list, depth)
-      return list["type"].to_sym if list["type"]
-      return :arabic if [2, 7].include? depth
-      return :alphabet if [1, 6].include? depth
-      return :alphabet_upper if [4, 9].include? depth
-      return :roman if [3, 8].include? depth
-      return :roman_upper if [5, 10].include? depth
+      def ol_type(list, depth)
+        return list["type"].to_sym if list["type"]
+        return :arabic if [2, 7].include? depth
+        return :alphabet if [1, 6].include? depth
+        return :alphabet_upper if [4, 9].include? depth
+        return :roman if [3, 8].include? depth
+        return :roman_upper if [5, 10].include? depth
 
-      :arabic
-    end
+        :arabic
+      end
 
-    def listlabel(list, depth)
-      case ol_type(list, depth)
-      when :arabic then @num.to_s
-      when :alphabet then (96 + @num).chr.to_s
-      when :alphabet_upper then (64 + @num).chr.to_s
-      when :roman then RomanNumerals.to_roman(@num).downcase
-      when :roman_upper then RomanNumerals.to_roman(@num).upcase
+      def listlabel(list, depth)
+        case ol_type(list, depth)
+        when :arabic then @num.to_s
+        when :alphabet then (96 + @num).chr.to_s
+        when :alphabet_upper then (64 + @num).chr.to_s
+        when :roman then RomanNumerals.to_roman(@num).downcase
+        when :roman_upper then RomanNumerals.to_roman(@num).upcase
+        end
       end
     end
   end