isodoc 1.5.5 → 1.6.4

data/lib/isodoc/xref/xref_counter.rb

@@ -2,16 +2,17 @@ require "roman-numerals"
 
 module IsoDoc::XrefGen
   class Counter
-    def initialize(num = 0, opts = {numerals: :arabic})
+    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)
+        if /^\d+$/.match?(num)
           @num = num.to_i
         else
           @num = nil
@@ -34,7 +35,7 @@ module IsoDoc::XrefGen
           @base = b
         else
           @letter_override = node["number"]
-          @letter = @letter_override if /^[a-zA-Z]$/.match(@letter_override)
+          @letter = @letter_override if /^[a-zA-Z]$/.match?(@letter_override)
         end
       end
     end
@@ -48,8 +49,7 @@ module IsoDoc::XrefGen
           @base = node["number"][0..-2]
           @letter = @letter_override = node["number"][-1]
         else
-          @number_override = node["number"]
-          @num = n.to_i
+          @number_override = @num = n.to_i
           @base = b
           @letter = ""
         end
@@ -64,7 +64,7 @@ module IsoDoc::XrefGen
         @letter_override = node["number"]
         /^(?<b>.*?)(?<n>\d*)(?<a>[a-zA-Z])$/ =~ node["number"]
         if blank?(a)
-          if /^\d+$/.match(node["number"])
+          if /^\d+$/.match?(node["number"])
             @letter_override = @letter = ""
             @number_override = @num = node["number"].to_i
           else
@@ -80,32 +80,46 @@ module IsoDoc::XrefGen
           @number_override = @num = n.to_i unless n.empty?
         end
       else
-        @letter = (@letter.ord + 1).chr.to_s
+        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
       end
+      @letter = (@letter.ord + 1).chr.to_s
+      @skip_i && %w(i I).include?(@letter) and
+        @letter = (@letter.ord + 1).chr.to_s
     end
 
-    def blank?(x)
-      x.nil? || x.empty?
+    def blank?(str)
+      str.nil? || str.empty?
     end
 
     def increment(node)
       return self if node["unnumbered"]
+
       @letter_override = nil
       @number_override = nil
-      if node["subsequence"] != @subseq && !(blank?(node["subsequence"]) && blank?(@subseq))
+      if node["subsequence"] != @subseq &&
+          !(blank?(node["subsequence"]) && blank?(@subseq))
         new_subseq_increment(node)
-      elsif @letter.empty?
-        sequence_increment(node)
-      else
-        subsequence_increment(node)
+      elsif @letter.empty? then sequence_increment(node)
+      else subsequence_increment(node)
       end
       self
     end
 
     def print
       num = @number_override || @num
-      num_out = @style == :roman && !num.nil? ? RomanNumerals.to_roman(num) : num
-      "#{@base}#{num_out}#{@letter_override || @letter}"
+      out = @style == :roman && !num.nil? ? RomanNumerals.to_roman(num) : num
+      "#{@base}#{out}#{@letter_override || @letter}"
     end
 
     def ol_type(list, depth)
@@ -115,7 +129,8 @@ module IsoDoc::XrefGen
       return :alphabet_upper if [4, 9].include? depth
       return :roman if [3, 8].include? depth
       return :roman_upper if [5, 10].include? depth
-      return :arabic
+
+      :arabic
     end
 
     def listlabel(list, depth)

data/lib/isodoc/xref/xref_gen.rb

@@ -1,4 +1,4 @@
-require_relative "xref_gen_seq.rb"
+require_relative "xref_gen_seq"
 
 module IsoDoc::XrefGen
   module Blocks
@@ -10,35 +10,43 @@ module IsoDoc::XrefGen
         autonum = amend_autonums(a)
         NUMBERED_BLOCKS.each do |b|
           a.xpath(ns("./newcontent//#{b}")).each_with_index do |e, i|
-            autonum[b] and i == 0 and e["number"] = autonum[b]
+            autonum[b] && i.zero? and e["number"] = autonum[b]
             !autonum[b] and e["unnumbered"] = "true"
           end
         end
       end
     end
 
-    def amend_autonums(a)
+    def amend_autonums(amend)
       autonum = {}
-      a.xpath(ns("./autonumber")).each do |n|
+      amend.xpath(ns("./autonumber")).each do |n|
         autonum[n["type"]] = n.text
       end
       autonum
     end
 
-    def termnote_label(n)
-      @labels["termnote"].gsub(/%/, n.to_s)
+    def termnote_label(note)
+      @labels["termnote"].gsub(/%/, note.to_s)
+    end
+
+    def increment_label(elems, node, counter, increment = true)
+      return "" if elems.size == 1 && !node["number"]
+
+      counter.increment(node) if increment
+      " #{counter.print}"
     end
 
     def termnote_anchor_names(docxml)
       docxml.xpath(ns("//term[descendant::termnote]")).each do |t|
         c = Counter.new
         t.xpath(ns(".//termnote")).each do |n|
-          return if n["id"].nil? || n["id"].empty?
+          next if n["id"].nil? || n["id"].empty?
+
           c.increment(n)
           @anchors[n["id"]] =
             { label: termnote_label(c.print), type: "termnote", value: c.print,
               xref: l10n("#{anchor(t['id'], :xref)}, "\
-                         "#{@labels["note_xref"]} #{c.print}") }
+                         "#{@labels['note_xref']} #{c.print}") }
         end
       end
     end
@@ -48,13 +56,14 @@ module IsoDoc::XrefGen
         examples = t.xpath(ns(".//termexample"))
         c = Counter.new
         examples.each do |n|
-          return if n["id"].nil? || n["id"].empty?
+          next if n["id"].nil? || n["id"].empty?
+
           c.increment(n)
-          idx = examples.size == 1 && !n["number"] ? "" : c.print
+          idx = increment_label(examples, n, c, false)
           @anchors[n["id"]] = {
             type: "termexample", label: idx, value: c.print,
             xref: l10n("#{anchor(t['id'], :xref)}, "\
-                       "#{@labels["example_xref"]} #{c.print}") }
+                       "#{@labels['example_xref']} #{c.print}") }
         end
       end
     end
@@ -81,9 +90,10 @@ module IsoDoc::XrefGen
         c = Counter.new
         notes.each do |n|
           next if @anchors[n["id"]] || n["id"].nil? || n["id"].empty?
-          idx = notes.size == 1 && !n["number"] ? "" : " #{c.increment(n).print}"
-          @anchors[n["id"]] = anchor_struct(idx, n, @labels["note_xref"], 
-                                            "note", false)
+
+          @anchors[n["id"]] =
+            anchor_struct(increment_label(notes, n, c), n,
+                          @labels["note_xref"], "note", false)
         end
         note_anchor_names(s.xpath(ns(CHILD_SECTIONS)))
       end
@@ -103,10 +113,10 @@ module IsoDoc::XrefGen
         c = Counter.new
         notes.each do |n|
           next if @anchors[n["id"]] || n["id"].nil? || n["id"].empty?
-          idx = notes.size == 1 && !n["number"]  ? "" :
-            " #{c.increment(n).print}"
-          @anchors[n["id"]] = anchor_struct(idx, n, @labels["example_xref"],
-                                            "example", n["unnumbered"])
+
+          @anchors[n["id"]] =
+            anchor_struct(increment_label(notes, n, c), n,
+                          @labels["example_xref"], "example", n["unnumbered"])
         end
         example_anchor_names(s.xpath(ns(CHILD_SECTIONS)))
       end
@@ -119,9 +129,9 @@ module IsoDoc::XrefGen
         c = Counter.new
         notes.each do |n|
           next if n["id"].nil? || n["id"].empty?
-          idx = notes.size == 1 && !n["number"] ? "" : " #{c.increment(n).print}"
-          @anchors[n["id"]] = anchor_struct(idx, n, @labels["list"], "list",
-                                            false)
+
+          @anchors[n["id"]] = anchor_struct(increment_label(notes, n, c), n,
+                                            @labels["list"], "list", false)
           list_item_anchor_names(n, @anchors[n["id"]], 1, "", notes.size != 1)
         end
         list_anchor_names(s.xpath(ns(CHILD_SECTIONS)))
@@ -146,9 +156,11 @@ module IsoDoc::XrefGen
     def bookmark_anchor_names(docxml)
       docxml.xpath(ns(".//bookmark")).each do |n|
         next if n["id"].nil? || n["id"].empty?
+
         parent = nil
         n.ancestors.each do |a|
           next unless a["id"] && parent = @anchors.dig(a["id"], :xref)
+
           break
         end
         @anchors[n["id"]] = { type: "bookmark", label: nil, value: nil,

data/lib/isodoc/xref/xref_gen_seq.rb

@@ -8,25 +8,27 @@ module IsoDoc::XrefGen
       "-"
     end
 
-    def subfigure_increment(j, c, t)
-      if t.parent.name == "figure" then j += 1
+    def subfigure_increment(idx, counter, elem)
+      if elem.parent.name == "figure" then idx += 1
       else
-        j = 0
-        c.increment(t)
+        idx = 0
+        counter.increment(elem)
       end
-      j
+      idx
     end
 
     def sequential_figure_names(clause)
       c = Counter.new
       j = 0
-      clause.xpath(ns(".//figure | .//sourcecode[not(ancestor::example)]")).
-        each do |t|
+      clause.xpath(ns(".//figure | .//sourcecode[not(ancestor::example)]"))
+        .each do |t|
         j = subfigure_increment(j, c, t)
         label = c.print + (j.zero? ? "" : "-#{j}")
         next if t["id"].nil? || t["id"].empty?
-        @anchors[t["id"]] =
-          anchor_struct(label, nil, @labels["figure"], "figure", t["unnumbered"])
+
+        @anchors[t["id"]] = anchor_struct(
+          label, nil, @labels["figure"], "figure", t["unnumbered"]
+        )
       end
     end
 
@@ -34,8 +36,11 @@ module IsoDoc::XrefGen
       c = Counter.new
       clause.xpath(ns(".//table")).each do |t|
         next if t["id"].nil? || t["id"].empty?
-        @anchors[t["id"]] = anchor_struct(c.increment(t).print, nil, 
-                                          @labels["table"], "table", t["unnumbered"])
+
+        @anchors[t["id"]] = anchor_struct(
+          c.increment(t).print, nil,
+          @labels["table"], "table", t["unnumbered"]
+        )
       end
     end
 
@@ -43,10 +48,12 @@ module IsoDoc::XrefGen
       c = Counter.new
       clause.xpath(ns(".//formula")).each do |t|
         next if t["id"].nil? || t["id"].empty?
-        @anchors[t["id"]] =
-          anchor_struct(c.increment(t).print, t, 
-                        t["inequality"] ? @labels["inequality"] : @labels["formula"],
-                        "formula", t["unnumbered"])
+
+        @anchors[t["id"]] = anchor_struct(
+          c.increment(t).print, t,
+          t["inequality"] ? @labels["inequality"] : @labels["formula"],
+          "formula", t["unnumbered"]
+        )
       end
     end
 
@@ -57,22 +64,27 @@ module IsoDoc::XrefGen
       c = Counter.new
       clause.xpath(ns(".//#{klass}#{FIRST_LVL_REQ}")).each do |t|
         next if t["id"].nil? || t["id"].empty?
+
         id = c.increment(t).print
         @anchors[t["id"]] = anchor_struct(id, t, label, klass, t["unnumbered"])
         sequential_permission_names2(t, id)
       end
     end
 
-    def sequential_permission_names2(t, id)
-      sequential_permission_names1(t, id, "permission", @labels["permission"])
-      sequential_permission_names1(t, id, "requirement", @labels["requirement"])
-      sequential_permission_names1(t, id, "recommendation", @labels["recommendation"])
+    def sequential_permission_names2(elem, ident)
+      sequential_permission_names1(elem, ident, "permission",
+                                   @labels["permission"])
+      sequential_permission_names1(elem, ident, "requirement",
+                                   @labels["requirement"])
+      sequential_permission_names1(elem, ident, "recommendation",
+                                   @labels["recommendation"])
     end
 
     def sequential_permission_names1(block, lbl, klass, label)
       c = Counter.new
       block.xpath(ns("./#{klass}")).each do |t|
         next if t["id"].nil? || t["id"].empty?
+
         id = "#{lbl}#{hierfigsep}#{c.increment(t).print}"
         @anchors[t["id"]] = anchor_struct(id, t, label, klass, t["unnumbered"])
         sequential_permission_names2(t, id)
@@ -85,20 +97,22 @@ module IsoDoc::XrefGen
       sequential_formula_names(clause)
       sequential_permission_names(clause, "permission", @labels["permission"])
       sequential_permission_names(clause, "requirement", @labels["requirement"])
-      sequential_permission_names(clause, "recommendation", @labels["recommendation"])
+      sequential_permission_names(clause, "recommendation",
+                                  @labels["recommendation"])
     end
 
     def hierarchical_figure_names(clause, num)
       c = Counter.new
       j = 0
-      clause.xpath(ns(".//figure |  .//sourcecode[not(ancestor::example)]")).
-        each do |t|
+      clause.xpath(ns(".//figure |  .//sourcecode[not(ancestor::example)]"))
+        .each do |t|
         j = subfigure_increment(j, c, t)
         label = "#{num}#{hiersep}#{c.print}" +
           (j.zero? ? "" : "#{hierfigsep}#{j}")
         next if t["id"].nil? || t["id"].empty?
-        @anchors[t["id"]] = anchor_struct(label, nil, @labels["figure"], "figure",
-                                          t["unnumbered"])
+
+        @anchors[t["id"]] = anchor_struct(label, nil, @labels["figure"],
+                                          "figure", t["unnumbered"])
       end
     end
 
@@ -106,6 +120,7 @@ module IsoDoc::XrefGen
       c = Counter.new
       clause.xpath(ns(".//table")).each do |t|
         next if t["id"].nil? || t["id"].empty?
+
         @anchors[t["id"]] =
           anchor_struct("#{num}#{hiersep}#{c.increment(t).print}",
                         nil, @labels["table"], "table", t["unnumbered"])
@@ -116,7 +131,8 @@ module IsoDoc::XrefGen
       hierarchical_table_names(clause, num)
       hierarchical_figure_names(clause, num)
       hierarchical_formula_names(clause, num)
-      hierarchical_permission_names(clause, num, "permission", @labels["permission"])
+      hierarchical_permission_names(clause, num, "permission",
+                                    @labels["permission"])
       hierarchical_permission_names(clause, num, "requirement",
                                     @labels["requirement"])
       hierarchical_permission_names(clause, num, "recommendation",
@@ -127,10 +143,12 @@ module IsoDoc::XrefGen
       c = Counter.new
       clause.xpath(ns(".//formula")).each do |t|
         next if t["id"].nil? || t["id"].empty?
-        @anchors[t["id"]] =
-          anchor_struct("#{num}#{hiersep}#{c.increment(t).print}", nil,
-                        t["inequality"] ? @labels["inequality"] : @labels["formula"],
-                        "formula", t["unnumbered"])
+
+        @anchors[t["id"]] = anchor_struct(
+          "#{num}#{hiersep}#{c.increment(t).print}", nil,
+          t["inequality"] ? @labels["inequality"] : @labels["formula"],
+          "formula", t["unnumbered"]
+        )
       end
     end
 
@@ -138,24 +156,31 @@ module IsoDoc::XrefGen
       c = Counter.new
       clause.xpath(ns(".//#{klass}#{FIRST_LVL_REQ}")).each do |t|
         next if t["id"].nil? || t["id"].empty?
+
         id = "#{num}#{hiersep}#{c.increment(t).print}"
-        @anchors[t["id"]] = anchor_struct(id, nil, label, klass, t["unnumbered"])
+        @anchors[t["id"]] =
+          anchor_struct(id, nil, label, klass, t["unnumbered"])
         hierarchical_permission_names2(t, id)
       end
     end
 
-    def hierarchical_permission_names2(t, id)
-      hierarchical_permission_names1(t, id, "permission", @labels["permission"])
-      hierarchical_permission_names1(t, id, "requirement", @labels["requirement"])
-      hierarchical_permission_names1(t, id, "recommendation", @labels["recommendation"])
+    def hierarchical_permission_names2(elem, ident)
+      hierarchical_permission_names1(elem, ident, "permission",
+                                     @labels["permission"])
+      hierarchical_permission_names1(elem, ident, "requirement",
+                                     @labels["requirement"])
+      hierarchical_permission_names1(elem, ident, "recommendation",
+                                     @labels["recommendation"])
     end
 
     def hierarchical_permission_names1(block, lbl, klass, label)
       c = Counter.new
       block.xpath(ns("./#{klass}")).each do |t|
         next if t["id"].nil? || t["id"].empty?
+
         id = "#{lbl}#{hierfigsep}#{c.increment(t).print}"
-        @anchors[t["id"]] = anchor_struct(id, nil, label, klass, t["unnumbered"])
+        @anchors[t["id"]] =
+          anchor_struct(id, nil, label, klass, t["unnumbered"])
         hierarchical_permission_names2(t, id)
       end
     end

data/lib/isodoc/xref/xref_sect_gen.rb

@@ -14,25 +14,24 @@ module IsoDoc::XrefGen
       end
     end
 
-    def initial_anchor_names(d)
-      d.xpath(ns("//preface/*")).each { |c| c.element? and preface_names(c) }
+    def initial_anchor_names(doc)
+      doc.xpath(ns("//preface/*")).each { |c| c.element? and preface_names(c) }
       # potentially overridden in middle_section_asset_names()
-      sequential_asset_names(d.xpath(ns("//preface/*")))
+      sequential_asset_names(doc.xpath(ns("//preface/*")))
       n = Counter.new
-      n = section_names(d.at(ns("//clause[@type = 'scope']")), n, 1)
-      n = section_names(d.at(ns(@klass.norm_ref_xpath)), n, 1)
-      n = section_names(d.at(ns("//sections/terms | "\
+      n = section_names(doc.at(ns("//clause[@type = 'scope']")), n, 1)
+      n = section_names(doc.at(ns(@klass.norm_ref_xpath)), n, 1)
+      n = section_names(doc.at(ns("//sections/terms | "\
                                 "//sections/clause[descendant::terms]")), n, 1)
-      n = section_names(d.at(ns("//sections/definitions")), n, 1)
-      clause_names(d, n)
-      middle_section_asset_names(d)
-      termnote_anchor_names(d)
-      termexample_anchor_names(d)
+      n = section_names(doc.at(ns("//sections/definitions")), n, 1)
+      clause_names(doc, n)
+      middle_section_asset_names(doc)
+      termnote_anchor_names(doc)
+      termexample_anchor_names(doc)
     end
 
-    def preface_clause_name(c)
-      ret = c.at(ns("./title"))&.text || c.name.capitalize
-      ret
+    def preface_clause_name(clause)
+      clause.at(ns("./title"))&.text || clause.name.capitalize
     end
 
     SUBCLAUSES =
@@ -41,12 +40,13 @@ module IsoDoc::XrefGen
     # in StanDoc, prefaces have no numbering; they are referenced only by title
     def preface_names(clause)
       return if clause.nil?
+
       @anchors[clause["id"]] =
         { label: nil, level: 1, xref: preface_clause_name(clause),
           type: "clause" }
       clause.xpath(ns(SUBCLAUSES)).each_with_index do |c, i|
         preface_names1(c, c.at(ns("./title"))&.text,
-                       "#{preface_clause_name(clause)}, #{i+1}", 2)
+                       "#{preface_clause_name(clause)}, #{i + 1}", 2)
       end
     end
 
@@ -55,31 +55,32 @@ module IsoDoc::XrefGen
       @anchors[clause["id"]] =
         { label: nil, level: level, xref: label, type: "clause" }
       clause.xpath(ns(SUBCLAUSES)).each_with_index do |c, i|
-        preface_names1(c, c.at(ns("./title"))&.text, "#{label} #{i+1}",
+        preface_names1(c, c.at(ns("./title"))&.text, "#{label} #{i + 1}",
                        level + 1)
       end
     end
 
-    def middle_section_asset_names(d)
+    def middle_section_asset_names(doc)
       middle_sections = "//clause[@type = 'scope'] | "\
         "#{@klass.norm_ref_xpath} | "\
         "//sections/terms | //preface/* | "\
         "//sections/definitions | //clause[parent::sections]"
-      sequential_asset_names(d.xpath(ns(middle_sections)))
+      sequential_asset_names(doc.xpath(ns(middle_sections)))
     end
 
-    def clause_names(docxml, n)
-      docxml.xpath(ns(@klass.middle_clause(docxml))).each_with_index do |c, i|
-        section_names(c, n, 1)
+    def clause_names(docxml, num)
+      docxml.xpath(ns(@klass.middle_clause(docxml))).each_with_index do |c, _i|
+        section_names(c, num, 1)
       end
     end
 
     def section_names(clause, num, lvl)
       return num if clause.nil?
+
       num.increment(clause)
       @anchors[clause["id"]] =
-        { label: num.print, xref: l10n("#{@labels["clause"]} #{num.print}"), level: lvl,
-          type: "clause" }
+        { label: num.print, xref: l10n("#{@labels['clause']} #{num.print}"),
+          level: lvl, type: "clause" }
       i = Counter.new
       clause.xpath(ns(SUBCLAUSES)).each do |c|
         i.increment(c)
@@ -90,7 +91,7 @@ module IsoDoc::XrefGen
 
     def section_names1(clause, num, level)
       @anchors[clause["id"]] =
-        { label: num, level: level, xref: l10n("#{@labels["clause"]} #{num}"),
+        { label: num, level: level, xref: l10n("#{@labels['clause']} #{num}"),
           type: "clause" }
       i = Counter.new
       clause.xpath(ns(SUBCLAUSES)).each do |c|
@@ -100,26 +101,27 @@ module IsoDoc::XrefGen
     end
 
     def annex_name_lbl(clause, num)
-      obl = l10n("(#{@labels["inform_annex"]})")
-      obl = l10n("(#{@labels["norm_annex"]})") if clause["obligation"] == "normative"
-      l10n("<strong>#{@labels["annex"]} #{num}</strong><br/>#{obl}")
+      obl = l10n("(#{@labels['inform_annex']})")
+      clause["obligation"] == "normative" and
+        obl = l10n("(#{@labels['norm_annex']})")
+      l10n("<strong>#{@labels['annex']} #{num}</strong><br/>#{obl}")
     end
 
     def single_annex_special_section(clause)
       a = clause.xpath(ns("./references | ./terms | ./definitions"))
       a.size == 1 or return nil
       clause.xpath(ns("./clause | ./p | ./table | ./ol | ./ul | ./dl | "\
-                      "./note | ./admonition | ./figure")).size == 0 or
-                     return nil
+                      "./note | ./admonition | ./figure")).empty? or
+        return nil
       a[0]
     end
 
     def annex_names(clause, num)
       @anchors[clause["id"]] = { label: annex_name_lbl(clause, num),
                                  type: "clause", value: num.to_s,
-                                 xref: "#{@labels["annex"]} #{num}", level: 1 }
+                                 xref: "#{@labels['annex']} #{num}", level: 1 }
       if a = single_annex_special_section(clause)
-        annex_names1(a, "#{num}", 1)
+        annex_names1(a, num.to_s, 1)
       else
         i = Counter.new
         clause.xpath(ns(SUBCLAUSES)).each do |c|
@@ -131,10 +133,10 @@ module IsoDoc::XrefGen
     end
 
     def annex_names1(clause, num, level)
-      @anchors[clause["id"]] = { label: num, xref: "#{@labels["annex"]} #{num}",
+      @anchors[clause["id"]] = { label: num, xref: "#{@labels['annex']} #{num}",
                                  level: level, type: "clause" }
       i = Counter.new
-      clause.xpath(ns(SUBCLAUSES)).each_with_index do |c|
+      clause.xpath(ns(SUBCLAUSES)).each do |c|
         i.increment(c)
         annex_names1(c, "#{num}.#{i.print}", level + 1)
       end
@@ -147,10 +149,10 @@ module IsoDoc::XrefGen
       "xmlns:name = 'International Electrotechnical Commission']".freeze
 
     def reference_names(ref)
-      isopub = ref.at(ns(ISO_PUBLISHER_XPATH))
+      # isopub = ref.at(ns(ISO_PUBLISHER_XPATH))
       ids = @klass.bibitem_ref_code(ref)
       identifiers = @klass.render_identifier(ids)
-      date = ref.at(ns("./date[@type = 'published']"))
+      # date = ref.at(ns("./date[@type = 'published']"))
       reference = @klass.docid_l10n(identifiers[0] || identifiers[1])
       @anchors[ref["id"]] = { xref: reference }
     end