isodoc 2.0.3 → 2.0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 645650786b21ed611b894e1e0f2be09efbb300f62997e021d331168b32488699
-  data.tar.gz: 9dc2ae2007b764bf33f2d406c55a666533f411e057a22eb58bb9b90cb279fe09
+  metadata.gz: 7eac37329d91f52ffb48b04b35a58e9d5966ba1ef79492c7e1fd14f77490b81a
+  data.tar.gz: e4e1fffbadb350529b5b8bcc4e3f8b13604fd9ceb982d935da33f61722ab1984
 SHA512:
-  metadata.gz: f70dccf7ad11c7563a0ed9dad4d7c90b9ca104ca3c46ffbd290544cc31206a9dce2597acafd01a4a5f8ff84c433d430d06c27b96b5b961a76cbe22d204fbc629
-  data.tar.gz: e000fe9d824d2e8825d1656d52395120373a6e6d40386ca67802337174e3dfaa762d8a3573b21f3418efeaecc81cc9350e0f6ac84024e6b235a8aebb4324f3d5
+  metadata.gz: 7f64dbf601952d1e7141ddca015d6fe61e989efd1d751ee9e42575a78e818a3551c4cbb26f5890dc53a1a50c1e75c02deca03e26c64b3568e1f49b76985027c0
+  data.tar.gz: fe336da69b2efe89d21299708b62f968109f4ff7be2973cdd6d4f92e56616ff79ee71c024a222794dfdabb7d67b8b50b7d7065f448704d6383f93639846fea20

data/lib/isodoc/convert.rb

@@ -40,6 +40,9 @@ module IsoDoc
     #   every 40-odd chars
     # sectionsplit: split up HTML output on sections
     # bare: do not insert any prefatory material (coverpage, boilerplate)
+    # tocfigures: add ToC for figures
+    # toctables: add ToC for tables
+    # tocrecommendations: add ToC for rcommendations
     def initialize(options)
       @libdir ||= File.dirname(__FILE__) # rubocop:disable Lint/DisjunctiveAssignmentInConstructor
       options.merge!(default_fonts(options)) do |_, old, new|
@@ -50,25 +53,14 @@ module IsoDoc
       @options = options
       @files_to_delete = []
       @tempfile_cache = []
-      @htmlstylesheet_name = options[:htmlstylesheet]
-      @wordstylesheet_name = options[:wordstylesheet]
-      @htmlstylesheet_override_name = options[:htmlstylesheet_override]
-      @wordstylesheet_override_name = options[:wordstylesheet_override]
-      @standardstylesheet_name = options[:standardstylesheet]
       @sourcefilename = options[:sourcefilename]
-      @header = options[:header]
-      @htmlcoverpage = options[:htmlcoverpage]
-      @wordcoverpage = options[:wordcoverpage]
-      @htmlintropage = options[:htmlintropage]
-      @wordintropage = options[:wordintropage]
+      init_stylesheets(options)
+      init_covers(options)
+      init_toc(options)
       @normalfontsize = options[:normalfontsize]
       @smallerfontsize = options[:smallerfontsize]
       @monospacefontsize = options[:monospacefontsize]
       @footnotefontsize = options[:footnotefontsize]
-      @scripts = options[:scripts] ||
-        File.join(File.dirname(__FILE__), "base_style", "scripts.html")
-      @scripts_pdf = options[:scripts_pdf]
-      @scripts_override = options[:scripts_override]
       @i18nyaml = options[:i18nyaml]
       @ulstyle = options[:ulstyle]
       @olstyle = options[:olstyle]
@@ -96,10 +88,6 @@ module IsoDoc
       @script = options[:script] || "Latn"
       @maxwidth = 1200
       @maxheight = 800
-      @wordToClevels = options[:doctoclevels].to_i
-      @wordToClevels = 2 if @wordToClevels.zero?
-      @htmlToClevels = options[:htmltoclevels].to_i
-      @htmlToClevels = 2 if @htmlToClevels.zero?
       @bookmarks_allocated = { "X" => true }
       @fn_bookmarks = {}
       @baseassetpath = options[:baseassetpath]
@@ -108,6 +96,36 @@ module IsoDoc
       @tmpfilesdir_suffix = tmpfilesdir_suffix
     end
 
+    def init_covers(options)
+      @header = options[:header]
+      @htmlcoverpage = options[:htmlcoverpage]
+      @wordcoverpage = options[:wordcoverpage]
+      @htmlintropage = options[:htmlintropage]
+      @wordintropage = options[:wordintropage]
+      @scripts = options[:scripts] ||
+        File.join(File.dirname(__FILE__), "base_style", "scripts.html")
+      @scripts_pdf = options[:scripts_pdf]
+      @scripts_override = options[:scripts_override]
+    end
+
+    def init_stylesheets(options)
+      @htmlstylesheet_name = options[:htmlstylesheet]
+      @wordstylesheet_name = options[:wordstylesheet]
+      @htmlstylesheet_override_name = options[:htmlstylesheet_override]
+      @wordstylesheet_override_name = options[:wordstylesheet_override]
+      @standardstylesheet_name = options[:standardstylesheet]
+    end
+
+    def init_toc(options)
+      @wordToClevels = options[:doctoclevels].to_i
+      @wordToClevels = 2 if @wordToClevels.zero?
+      @htmlToClevels = options[:htmltoclevels].to_i
+      @htmlToClevels = 2 if @htmlToClevels.zero?
+      @tocfigures = options[:tocfigures]
+      @toctables = options[:toctables]
+      @tocrecommendations = options[:tocrecommendations]
+    end
+
     def tmpimagedir_suffix
       "_#{SecureRandom.hex(8)}_images"
     end

data/lib/isodoc/function/inline.rb

@@ -34,30 +34,41 @@ module IsoDoc
       end
 
       def suffix_url(url)
-        return url if %r{^https?://}.match?(url)
+        return url if url.nil? || %r{^https?://|^#}.match?(url)
         return url unless File.extname(url).empty?
 
         url.sub(/#{File.extname(url)}$/, ".html")
       end
 
       def eref_target(node)
-        return "##{node['bibitemid']}" unless (!@bibitems.nil? &&
-          url = @bibitems[node["bibitemid"]]&.at(ns("./uri[@type = 'citation']")))
+        url = suffix_url(eref_url(node["bibitemid"]))
+        anchor = node&.at(ns(".//locality[@type = 'anchor']"))
+        return url if url.nil? || /^#/.match?(url) || !anchor
 
-        href = suffix_url(url.text)
-        anchor = node&.at(ns(".//locality[@type = 'anchor']"))&.text&.strip
-        anchor and href += "##{anchor}"
-        href
+        "#{url}##{anchor.text.strip}"
+      end
+
+      def eref_url(bibitemid)
+        return nil if @bibitems.nil? || @bibitems[bibitemid].nil?
+
+        if url = @bibitems[bibitemid].at(ns("./uri[@type = 'citation']"))
+          url.text
+        elsif @bibitems[bibitemid]["hidden"] == "true"
+          @bibitems[bibitemid]&.at(ns("./uri"))&.text
+        else "##{bibitemid}"
+        end
       end
 
       def eref_parse(node, out)
-        href = eref_target(node)
-        if node["type"] == "footnote"
-          out.sup do |s|
-            s.a(**{ href: href }) { |l| no_locality_parse(node, l) }
+        if href = eref_target(node)
+          if node["type"] == "footnote"
+            out.sup do |s|
+              s.a(**{ href: href }) { |l| no_locality_parse(node, l) }
+            end
+          else
+            out.a(**{ href: href }) { |l| no_locality_parse(node, l) }
           end
-        else
-          out.a(**{ href: href }) { |l| no_locality_parse(node, l) }
+        else no_locality_parse(node, out)
         end
       end
 

data/lib/isodoc/function/references.rb

@@ -118,7 +118,7 @@ module IsoDoc
         date_note = bib.at(ns("./note[@type = 'Unpublished-Status']"))
         return if date_note.nil?
 
-        date_note.children.first.replace("<p>#{date_note.content}</p>")
+        date_note.children = "<p>#{date_note.content}</p>"
         footnote_parse(date_note, ref)
       end
 

data/lib/isodoc/i18n.rb

@@ -104,15 +104,28 @@ module IsoDoc
       xml.to_xml.gsub(/<b>/, "").gsub("</b>", "").gsub(/<\?[^>]+>/, "")
     end
 
-    def multiple_and(names, andword)
-      return "" if names.empty?
-      return names[0] if names.length == 1
-
-      (names.length == 2) &&
-        (return l10n("#{names[0]} #{andword} #{names[1]}", @lang, @script))
-      l10n(names[0..-2].join(", ") + " #{andword} #{names[-1]}", @lang, @script)
+    def boolean_conj(list, conn)
+      case list.size
+      when 0 then ""
+      when 1 then list.first
+      when 2 then @labels["binary_#{conn}"].sub(/%1/, list[0])
+        .sub(/%2/, list[1])
+      else
+        @labels["multiple_#{conn}"]
+          .sub(/%1/, l10n(list[0..-2].join(", "), @lang, @script))
+          .sub(/%2/, list[-1])
+      end
     end
 
+    #     def multiple_and(names, andword)
+    #       return "" if names.empty?
+    #       return names[0] if names.length == 1
+    #
+    #       (names.length == 2) &&
+    #         (return l10n("#{names[0]} #{andword} #{names[1]}", @lang, @script))
+    #       l10n(names[0..-2].join(", ") + " #{andword} #{names[-1]}", @lang, @script)
+    #     end
+
     include Function::Utils
     # module_function :l10n
   end

data/lib/isodoc/metadata_contributor.rb

@@ -75,7 +75,7 @@ module IsoDoc
     def agency(xml)
       agency, publisher = agency1(xml)
       set(:agency, agency.sub(%r{/$}, ""))
-      set(:publisher, @i18n.multiple_and(publisher, @labels["and"]))
+      set(:publisher, @i18n.boolean_conj(publisher, "and"))
       agency_addr(xml)
     end
 

data/lib/isodoc/presentation_function/bibdata.rb

@@ -1,15 +1,30 @@
 module IsoDoc
   class PresentationXMLConvert < ::IsoDoc::Convert
     def bibdata(docxml)
+      toc_metadata(docxml)
       docid_prefixes(docxml)
       a = bibdata_current(docxml) or return
       address_precompose(a)
       bibdata_i18n(a)
       a.next =
-        "<localized-strings>#{i8n_name(trim_hash(@i18n.get), '').join('')}"\
+        "<localized-strings>#{i8n_name(trim_hash(@i18n.get), '').join}"\
         "</localized-strings>"
     end
 
+    def toc_metadata(docxml)
+      return unless @tocfigures || @toctables || @tocrecommendations
+
+      ins = docxml.at(ns("//misc-container")) ||
+        docxml.at(ns("//bibdata")).after("<misc-container/>").next_element
+      @tocfigures and
+        ins << "<toc type='figure'><title>#{@i18n.toc_figures}</title></toc>"
+      @toctables and
+        ins << "<toc type='table'><title>#{@i18n.toc_tables}</title></toc>"
+      @tocfigures and
+        ins << "<toc type='recommendation'><title>#{@i18n.toc_recommendations}"\
+               "</title></toc>"
+    end
+
     def address_precompose(bib)
       bib.xpath(ns("//bibdata//address")).each do |b|
         next if b.at(ns("./formattedAddress"))
@@ -66,8 +81,9 @@ module IsoDoc
     end
 
     def i8n_name(hash, pref)
-      if hash.is_a? Hash then i8n_name1(hash, pref)
-      elsif hash.is_a? Array
+      case hash
+      when Hash then i8n_name1(hash, pref)
+      when Array
         hash.reject { |a| blank?(a) }.each_with_object([])
           .with_index do |(v1, g), i|
           i8n_name(v1, "#{i18n_safe(k)}.#{i}").each { |x| g << x }
@@ -78,8 +94,9 @@ module IsoDoc
 
     def i8n_name1(hash, pref)
       hash.reject { |_k, v| blank?(v) }.each_with_object([]) do |(k, v), g|
-        if v.is_a? Hash then i8n_name(v, i18n_safe(k)).each { |x| g << x }
-        elsif v.is_a? Array
+        case v
+        when Hash then i8n_name(v, i18n_safe(k)).each { |x| g << x }
+        when Array
           v.reject { |a| blank?(a) }.each_with_index do |v1, i|
             i8n_name(v1, "#{i18n_safe(k)}.#{i}").each { |x| g << x }
           end
@@ -109,11 +126,11 @@ module IsoDoc
       hash.each_with_object({}) do |(k, v), g|
         next if blank?(v)
 
-        g[k] = if v.is_a? Hash then trim_hash1(hash[k])
-               elsif v.is_a? Array
+        g[k] = case v
+               when Hash then trim_hash1(hash[k])
+               when Array
                  hash[k].map { |a| trim_hash1(a) }.reject { |a| blank?(a) }
-               else
-                 v
+               else v
                end
       end
     end

data/lib/isodoc/presentation_function/image.rb

@@ -65,15 +65,14 @@ module IsoDoc
       uri = svg_to_emf_uri(node)
       ret = svg_to_emf_filename(uri)
       File.exists?(ret) and return ret
-      exe = inkscape_installed? or return nil
+      exe = inkscape_installed? or raise "Inkscape missing in PATH, unable" \
+                                         "to convert EMF to SVG. Aborting."
       uri = Metanorma::Utils::external_path uri
       exe = Metanorma::Utils::external_path exe
       system(%(#{exe} --export-type="emf" #{uri})) and
         return Metanorma::Utils::datauri(ret)
 
-      warn %(Fail on #{exe} --export-type="emf" #{uri})
-
-      nil
+      raise %(Fail on #{exe} --export-type="emf" #{uri})
     end
 
     def svg_to_emf_uri(node)

data/lib/isodoc/presentation_function/inline.rb

@@ -1,56 +1,8 @@
 require "metanorma-utils"
+require_relative "xrefs"
 
 module IsoDoc
   class PresentationXMLConvert < ::IsoDoc::Convert
-    def prefix_container(container, linkend, _target)
-      l10n("#{@xrefs.anchor(container, :xref)}, #{linkend}")
-    end
-
-    def anchor_value(id)
-      @xrefs.anchor(id, :value) || @xrefs.anchor(id, :label) ||
-        @xrefs.anchor(id, :xref)
-    end
-
-    def anchor_linkend(node, linkend)
-      if node["citeas"].nil? && node["bibitemid"]
-        return @xrefs.anchor(node["bibitemid"], :xref) || "???"
-      elsif node["target"] && node["droploc"]
-        return anchor_value(node["target"]) || "???"
-      elsif node["target"] && !/.#./.match(node["target"])
-        linkend = anchor_linkend1(node)
-      end
-
-      linkend || "???"
-    end
-
-    def anchor_linkend1(node)
-      linkend = @xrefs.anchor(node["target"], :xref)
-      container = @xrefs.anchor(node["target"], :container, false)
-      (container && get_note_container_id(node) != container &&
-       @xrefs.get[node["target"]]) and
-        linkend = prefix_container(container, linkend, node["target"])
-      capitalise_xref(node, linkend, anchor_value(node["target"]))
-    end
-
-    def capitalise_xref(node, linkend, label)
-      linktext = linkend.gsub(/<[^>]+>/, "")
-      (label && !label.empty? && /^#{Regexp.escape(label)}/.match?(linktext)) ||
-        linktext[0, 1].match?(/\p{Upper}/) and return linkend
-      node["case"] and
-        return Common::case_with_markup(linkend, node["case"], @script)
-
-      capitalise_xref1(node, linkend)
-    end
-
-    def capitalise_xref1(node, linkend)
-      prec = nearest_block_parent(node).xpath("./descendant-or-self::text()") &
-        node.xpath("./preceding::text()")
-      if prec.empty? || /(?!<[^.].)\.\s+$/.match(prec.map(&:text).join)
-        Common::case_with_markup(linkend, "capital", @script)
-      else linkend
-      end
-    end
-
     def nearest_block_parent(node)
       until %w(p title td th name formula li dt dd sourcecode pre)
           .include?(node.name)
@@ -61,7 +13,7 @@ module IsoDoc
 
     def non_locality_elems(node)
       node.children.reject do |c|
-        %w{locality localityStack}.include? c.name
+        %w{locality localityStack location}.include? c.name
       end
     end
 
@@ -69,7 +21,8 @@ module IsoDoc
       c1 = non_locality_elems(node).select { |c| !c.text? || /\S/.match(c) }
       return unless c1.empty?
 
-      link = anchor_linkend(node, docid_l10n(node["target"] || node["citeas"]))
+      link = anchor_linkend(node, docid_l10n(node["target"] ||
+                                             expand_citeas(node["citeas"])))
       link += eref_localities(node.xpath(ns("./locality | ./localityStack")),
                               link, node)
       non_locality_elems(node).each(&:remove)
@@ -78,54 +31,144 @@ module IsoDoc
     # so not <origin bibitemid="ISO7301" citeas="ISO 7301">
     # <locality type="section"><reference>3.1</reference></locality></origin>
 
+    def expand_citeas(text)
+      text.nil? and return text
+      HTMLEntities.new.decode(text.gsub(/&amp;#x/, "&#"))
+    end
+
     def eref_localities(refs, target, node)
-      ret = ""
-      refs.each_with_index do |r, i|
-        delim = ","
-        delim = ";" if r.name == "localityStack" && i.positive?
-        ret = eref_locality_stack(r, i, target, delim, ret, node)
+      if can_conflate_eref_rendering?(refs)
+        l10n(", #{eref_localities_conflated(refs, target, node)}")
+      else
+        ret = resolve_eref_connectives(eref_locality_stacks(refs, target, node))
+        l10n(ret.join)
       end
-      ret
     end
 
-    def eref_locality_stack(ref, idx, target, delim, ret, node)
+    def eref_localities_conflated(refs, target, node)
+      droploc = node["droploc"]
+      node["droploc"] = true
+      ret = resolve_eref_connectives(eref_locality_stacks(refs, target,
+                                                          node))
+      node["droploc"] = droploc
+      eref_localities1(target,
+                       refs.first.at(ns("./locality/@type")).text,
+                       l10n(ret[1..-1].join), nil, node, @lang)
+    end
+
+    def can_conflate_eref_rendering?(refs)
+      (refs.size > 1 &&
+        refs.all? { |r| r.name == "localityStack" } &&
+        refs.all? { |r| r.xpath(ns("./locality")).size == 1 }) or return false
+
+      first = refs.first.at(ns("./locality/@type")).text
+      refs.all? do |r|
+        r.at(ns("./locality/@type")).text == first
+      end
+    end
+
+    def resolve_eref_connectives(locs)
+      locs = resolve_comma_connectives(locs)
+      locs = resolve_to_connectives(locs)
+      return locs if locs.size < 3
+
+      locs = locs.each_slice(2).with_object([]) do |a, m|
+        m << { conn: a[0], target: a[1] }
+      end
+      [", ", combine_conn(locs)]
+    end
+
+    def resolve_comma_connectives(locs)
+      locs1 = []
+      add = ""
+      until locs.empty?
+        if [", ", " "].include?(locs[1])
+          add += locs[0..2].join
+          locs.shift(3)
+        else
+          locs1 << add unless add.empty?
+          add = ""
+          locs1 << locs.shift
+        end
+      end
+      locs1 << add unless add.empty?
+      locs1
+    end
+
+    def resolve_to_connectives(locs)
+      locs1 = []
+      until locs.empty?
+        if locs[1] == "to"
+          locs1 << @i18n.chain_to.sub(/%1/, locs[0]).sub(/%2/, locs[2])
+          locs.shift(3)
+        else locs1 << locs.shift
+        end
+      end
+      locs1
+    end
+
+    def eref_locality_stacks(refs, target, node)
+      ret = refs.each_with_index.with_object([]) do |(r, i), m|
+        added = eref_locality_stack(r, i, target, node)
+        added.empty? and next
+        added.each { |a| m << a }
+        next if i == refs.size - 1
+
+        m << if r&.next_element&.name == "localityStack"
+               r.next_element["connective"]
+             else locality_delimiter(r)
+             end
+      end
+      ret.empty? ? ret : [", "] + ret
+    end
+
+    def eref_locality_stack(ref, idx, target, node)
+      ret = []
       if ref.name == "localityStack"
         ref.elements.each_with_index do |rr, j|
-          ret += eref_localities0(rr, j, target, delim, node)
-          delim = ","
+          l = eref_localities0(rr, j, target, node) or next
+
+          ret << l
+          ret << locality_delimiter(rr) unless j == ref.elements.size - 1
         end
-      else ret += eref_localities0(ref, idx, target, delim, node)
+      else
+        l = eref_localities0(ref, idx, target, node) and ret << l
       end
+      ret[-1] == ", " and ret.pop
       ret
     end
 
-    def eref_localities0(ref, _idx, target, delim, node)
-      if ref["type"] == "whole" then l10n("#{delim} #{@i18n.wholeoftext}")
+    def locality_delimiter(_loc)
+      ", "
+    end
+
+    def eref_localities0(ref, _idx, target, node)
+      if ref["type"] == "whole" then @i18n.wholeoftext
       else
-        eref_localities1(target, ref["type"], ref.at(ns("./referenceFrom")),
-                         ref.at(ns("./referenceTo")), delim, node, @lang)
+        eref_localities1(target, ref["type"],
+                         ref&.at(ns("./referenceFrom"))&.text,
+                         ref&.at(ns("./referenceTo"))&.text, node, @lang)
       end
     end
 
     # TODO: move to localization file
-    def eref_localities1_zh(_target, type, from, upto, node, delim)
-      ret = "#{delim} 第#{from.text}" if from
-      ret += "&ndash;#{upto.text}" if upto
-      loc = (@i18n.locality[type] || type.sub(/^locality:/, "").capitalize)
+    def eref_localities1_zh(_target, type, from, upto, node)
+      ret = "第#{from}" if from
+      ret += "&ndash;#{upto}" if upto
+      loc = eref_locality_populate(type, node)
       ret += " #{loc}" unless node["droploc"] == "true"
       ret
     end
 
     # TODO: move to localization file
-    def eref_localities1(target, type, from, upto, delim, node, lang = "en")
-      return "" if type == "anchor"
+    def eref_localities1(target, type, from, upto, node, lang = "en")
+      return nil if type == "anchor"
 
       lang == "zh" and
-        return l10n(eref_localities1_zh(target, type, from, upto, node, delim))
-      ret = delim
-      ret += eref_locality_populate(type, node)
-      ret += " #{from.text}" if from
-      ret += "&ndash;#{upto.text}" if upto
+        return l10n(eref_localities1_zh(target, type, from, upto, node))
+      ret = eref_locality_populate(type, node)
+      ret += " #{from}" if from
+      ret += "&ndash;#{upto}" if upto
       l10n(ret)
     end
 

data/lib/isodoc/presentation_function/math.rb

@@ -20,6 +20,7 @@ module IsoDoc
         num = BigDecimal(x.text)
         precision = /\./.match?(x.text) ? x.text.sub(/^.*\./, "").size : 0
         x.children = localized_number(num, locale, precision)
+      rescue ArgumentError => e
       end
     end
 

data/lib/isodoc/presentation_function/xrefs.rb

@@ -0,0 +1,100 @@
+module IsoDoc
+  class PresentationXMLConvert < ::IsoDoc::Convert
+    def prefix_container(container, linkend, _target)
+      l10n("#{@xrefs.anchor(container, :xref)}, #{linkend}")
+    end
+
+    def anchor_value(id)
+      @xrefs.anchor(id, :value) || @xrefs.anchor(id, :label) ||
+        @xrefs.anchor(id, :xref)
+    end
+
+    def anchor_linkend(node, linkend)
+      if node["citeas"].nil? && node["bibitemid"]
+        return @xrefs.anchor(node["bibitemid"], :xref) || "???"
+      elsif node.at(ns("./location"))
+        linkend = combine_xref_locations(node)
+      elsif node["target"] && node["droploc"]
+        return anchor_value(node["target"]) || "???"
+      elsif node["target"] && !/.#./.match(node["target"])
+        linkend = anchor_linkend1(node)
+      end
+
+      linkend || "???"
+    end
+
+    def anchor_linkend1(node)
+      linkend = @xrefs.anchor(node["target"], :xref)
+      container = @xrefs.anchor(node["target"], :container, false)
+      (container && get_note_container_id(node) != container &&
+       @xrefs.get[node["target"]]) and
+        linkend = prefix_container(container, linkend, node["target"])
+      capitalise_xref(node, linkend, anchor_value(node["target"]))
+    end
+
+    def combine_xref_locations(node)
+      locs = gather_xref_locations(node)
+      linkend = if can_conflate_xref_rendering?(locs)
+                  out = locs.each { |l| l[:target] = anchor_value(l[:target]) }
+                  l10n("#{locs.first[:elem]} #{combine_conn(out)}")
+                else
+                  out = locs.each { |l| l[:target] = anchor_linked1(l[:node]) }
+                  l10n(combine_conn(out))
+                end
+      capitalise_xref(node, linkend, anchor_value(node["target"]))
+    end
+
+    def gather_xref_locations(node)
+      node.xpath(ns("./location")).each_with_object([]) do |l, m|
+        type = @xrefs.anchor(l["target"], :type)
+        m << { conn: l["connective"], target: l["target"],
+               type: type, node: l, elem: @xrefs.anchor(l["target"], :elem),
+               container: @xrefs.anchor(node["target"], :container, false) ||
+                 %w(termnote).include?(type) }
+      end
+    end
+
+    def combine_conn(list)
+      return list.first[:target] if list.size == 1
+
+      if list[1..-1].all? { |l| l[:conn] == "and" }
+        @i18n.boolean_conj(list.map { |l| l[:target] }, "and")
+      elsif list[1..-1].all? { |l| l[:conn] == "or" }
+        @i18n.boolean_conj(list.map { |l| l[:target] }, "or")
+      else
+        ret = list[0][:target]
+        list[1..-1].each { |l| ret = i18n_chain_boolean(ret, l) }
+        ret
+      end
+    end
+
+    def i18n_chain_boolean(value, entry)
+      @i18n.send("chain_#{entry[:conn]}").sub(/%1/, value)
+        .sub(/%2/, entry[:target])
+    end
+
+    def can_conflate_xref_rendering?(locs)
+      !locs.all? { |l| l[:container].nil? } &&
+        locs.all? { |l| l[:type] == locs[0][:type] }
+    end
+
+    def capitalise_xref(node, linkend, label)
+      linktext = linkend.gsub(/<[^>]+>/, "")
+      (label && !label.empty? && /^#{Regexp.escape(label)}/.match?(linktext)) ||
+        linktext[0, 1].match?(/\p{Upper}/) and return linkend
+      node["case"] and
+        return Common::case_with_markup(linkend, node["case"], @script)
+
+      capitalise_xref1(node, linkend)
+    end
+
+    def capitalise_xref1(node, linkend)
+      prec = nearest_block_parent(node).xpath("./descendant-or-self::text()") &
+        node.xpath("./preceding::text()")
+      if prec.empty? || /(?!<[^.].)\.\s+$/.match(prec.map(&:text).join)
+        Common::case_with_markup(linkend, "capital", @script)
+      else linkend
+      end
+    end
+  end
+end

data/lib/isodoc/version.rb

@@ -1,3 +1,3 @@
 module IsoDoc
-  VERSION = "2.0.3".freeze
+  VERSION = "2.0.5.1".freeze
 end