isodoc 1.5.4 → 1.6.3

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
@@ -94,18 +104,19 @@ module IsoDoc::XrefGen
       "not(self::xmlns:terms) and not(self::xmlns:definitions)]//"\
       "xmlns:example | ./xmlns:example".freeze
 
-    CHILD_SECTIONS = "./clause | ./appendix | ./terms | ./definitions | ./references"
+    CHILD_SECTIONS = "./clause | ./appendix | ./terms | ./definitions | "\
+      "./references"
 
     def example_anchor_names(sections)
       sections.each do |s|
         notes = s.xpath(CHILD_EXAMPLES_XPATH)
         c = Counter.new
         notes.each do |n|
-          next if @anchors[n["id"]]
-          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["example_xref"],
-                                            "example", n["unnumbered"])
+          next if @anchors[n["id"]] || n["id"].nil? || n["id"].empty?
+
+          @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
@@ -118,8 +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)))
@@ -141,17 +153,18 @@ module IsoDoc::XrefGen
       end
     end
 
-    def bookmark_anchor_names(sections)
-      sections.each do |s|
-        notes = s.xpath(ns(".//bookmark")) - s.xpath(ns(".//clause//bookmark")) -
-          s.xpath(ns(".//appendix//bookmark"))
-        notes.each do |n|
-          next if n["id"].nil? || n["id"].empty?
-          @anchors[n["id"]] = {
-            type: "bookmark", label: nil, value: nil,
-            xref: @anchors[s["id"]][:xref] }
+    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
-        bookmark_anchor_names(s.xpath(ns(CHILD_SECTIONS)))
+        @anchors[n["id"]] = { type: "bookmark", label: nil, value: nil,
+                              xref: parent || "???" }
       end
     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,7 +55,7 @@ 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
@@ -69,17 +69,18 @@ module IsoDoc::XrefGen
     end
 
     def clause_names(docxml, n)
-      docxml.xpath(ns(@klass.middle_clause(docxml))).each_with_index do |c, i|
+      docxml.xpath(ns(@klass.middle_clause(docxml))).each_with_index do |c, _i|
         section_names(c, n, 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

data/lib/isodoc/xslfo_convert.rb

@@ -2,50 +2,61 @@ require "metanorma"
 
 module IsoDoc
   class XslfoPdfConvert < ::IsoDoc::Convert
+    MN2PDF_OPTIONS = :mn2pdf
+    MN2PDF_FONT_MANIFEST = :font_manifest_file
 
     def initialize(options)
+      @format = :pdf
+      @suffix = "pdf"
       super
-      @maxwidth = 500
-      @maxheight = 800
     end
 
     def tmpimagedir_suffix
       "_pdfimages"
     end
 
-    def initialize(options)
-      @format = :pdf
-      @suffix = "pdf"
-      super
-    end
-
-    def pdf_stylesheet(docxml)
+    def pdf_stylesheet(_docxml)
       nil
     end
 
-    def pdf_options(docxml)
-      ""
+    def pdf_options(_docxml)
+      if font_manifest_file = @options.dig(MN2PDF_OPTIONS,
+                                           MN2PDF_FONT_MANIFEST)
+        "--font-manifest #{font_manifest_file}"
+      else
+        ""
+      end
     end
 
-    def convert(input_filename, file = nil, debug = false, output_filename = nil)
+    def convert(input_filename, file = nil, debug = false,
+                output_filename = nil)
       file = File.read(input_filename, encoding: "utf-8") if file.nil?
-      docxml, filename, dir = convert_init(file, input_filename, debug)
-      /\.xml$/.match(input_filename) or
-          input_filename = Tempfile.open([filename, ".xml"], encoding: "utf-8") do |f|
-          f.write file
+      input_filename, docxml, filename = input_xml_path(input_filename,
+                                                        file, debug)
+      ::Metanorma::Output::XslfoPdf.new.convert(
+        input_filename,
+        output_filename || "#{filename}.#{@suffix}",
+        File.join(@libdir, pdf_stylesheet(docxml)),
+        pdf_options(docxml)
+      )
+    end
+
+    def xref_parse(node, out)
+      out.a(**{ "href": target_pdf(node) }) { |l| l << get_linkend(node) }
+    end
+
+    def input_xml_path(input_filename, xml_file, debug)
+      docxml, filename, dir = convert_init(xml_file, input_filename, debug)
+      unless /\.xml$/.match?(input_filename)
+        input_filename = Tempfile.open([filename, ".xml"],
+                                       encoding: "utf-8") do |f|
+          f.write xml_file
           f.path
         end
+      end
       FileUtils.rm_rf dir
-      ::Metanorma::Output::XslfoPdf.new.convert(input_filename,
-                                                output_filename || "#{filename}.#{@suffix}", 
-                                               File.join(@libdir, pdf_stylesheet(docxml)),
-                                               pdf_options(docxml))
-    end
 
-    def xref_parse(node, out)
-      target = /#/.match(node["target"]) ? node["target"].sub(/#/, ".pdf#") :
-        "##{node["target"]}"
-      out.a(**{ "href": target }) { |l| l << get_linkend(node) }
+      [input_filename, docxml, filename]
     end
   end
 end