isodoc 1.6.7.1 → 1.7.3

data/lib/isodoc/html_convert.rb

@@ -2,7 +2,6 @@ require_relative "html_function/comments"
 require_relative "html_function/footnotes"
 require_relative "html_function/html"
 require_relative "html_function/postprocess"
-require_relative "html_function/sectionsplit"
 require_relative "html_function/form"
 
 module IsoDoc
@@ -24,9 +23,6 @@ module IsoDoc
     end
 
     def convert(filename, file = nil, debug = false, output_filename = nil)
-      @sectionsplit and
-        return sectionsplit_convert(filename, file, debug, output_filename)
-
       ret = super
       Dir.exists?(tmpimagedir) and Dir["#{tmpimagedir}/*"].empty? and
         FileUtils.rm_r tmpimagedir

data/lib/isodoc/html_function/form.rb

@@ -1,61 +1,64 @@
-module IsoDoc::HtmlFunction
-  module Form
-    def form_parse(node, out)
-      out.form **attr_code(id: node["id"], name: node["name"],
-                           action: node["action"]) do |div|
-        node.children.each do |n|
-          parse(n, div)
+module IsoDoc
+  module HtmlFunction
+    module Form
+      def form_parse(node, out)
+        out.form **attr_code(id: node["id"], name: node["name"],
+                             class: node["class"],
+                             action: node["action"]) do |div|
+          node.children.each do |n|
+            parse(n, div)
+          end
         end
       end
-    end
 
-    def input_parse(node, out)
-      out.input nil, **attr_code(
-        id: node["id"], name: node["name"], type: node["type"],
-        value: node["value"], disabled: node["disabled"],
-        readonly: node["readonly"], checked: node["checked"],
-        maxlength: node["maxlength"], minlength: node["minlength"]
-      )
-    end
+      def input_parse(node, out)
+        out.input nil, **attr_code(
+          id: node["id"], name: node["name"], type: node["type"],
+          value: node["value"], disabled: node["disabled"],
+          readonly: node["readonly"], checked: node["checked"],
+          maxlength: node["maxlength"], minlength: node["minlength"]
+        )
+      end
 
-    def select_parse(node, out)
-      selected = node.at(ns("./option[@value = '#{node['value']}']"))
-      selected and selected["selected"] = true
-      out.select **attr_code(
-        id: node["id"], name: node["name"], size: node["size"],
-        disabled: node["disabled"], multiple: node["multiple"]
-      ) do |div|
-        node.children.each do |n|
-          parse(n, div)
+      def select_parse(node, out)
+        selected = node.at(ns("./option[@value = '#{node['value']}']"))
+        selected and selected["selected"] = true
+        out.select **attr_code(
+          id: node["id"], name: node["name"], size: node["size"],
+          disabled: node["disabled"], multiple: node["multiple"]
+        ) do |div|
+          node.children.each do |n|
+            parse(n, div)
+          end
         end
       end
-    end
 
-    def label_parse(node, out)
-      out.label **attr_code(for: node["for"]) do |div|
-        node.children.each do |n|
-          parse(n, div)
+      def label_parse(node, out)
+        out.label **attr_code(for: node["for"]) do |div|
+          node.children.each do |n|
+            parse(n, div)
+          end
         end
       end
-    end
 
-    def option_parse(node, out)
-      out.option **attr_code(
-        disabled: node["disabled"], selected: node["selected"],
-        value: node["value"]
-      ) do |o|
-        node.children.each do |n|
-          parse(n, o)
+      def option_parse(node, out)
+        out.option **attr_code(
+          disabled: node["disabled"], selected: node["selected"],
+          value: node["value"]
+        ) do |o|
+          node.children.each do |n|
+            parse(n, o)
+          end
         end
       end
-    end
 
-    def textarea_parse(node, out)
-      out.textarea **attr_code(
-        id: node["id"], name: node["name"], rows: node["rows"],
-        cols: node["cols"]
-      ) do |div|
-        node["value"] and div << node["value"]
+      def textarea_parse(node, out)
+        out.textarea **attr_code(
+          id: node["id"], name: node["name"], rows: node["rows"],
+          cols: node["cols"]
+        ) do |div|
+          node["value"] and div << node["value"]
+        end
       end
     end
   end

data/lib/isodoc/html_function/html.rb

@@ -74,6 +74,8 @@ module IsoDoc::HtmlFunction
     end
 
     def html_button
+      return "" if @bare
+
       '<button onclick="topFunction()" id="myBtn" '\
         'title="Go to top">Top</button>'.freeze
     end

data/lib/isodoc/html_function/postprocess.rb

@@ -19,7 +19,6 @@ module IsoDoc
 
       def toHTML(result, filename)
         result = from_xhtml(html_cleanup(to_xhtml(result)))
-        # result = populate_template(result, :html)
         result = from_xhtml(move_images(to_xhtml(result)))
         result = html5(script_cdata(inject_script(result)))
         File.open(filename, "w:UTF-8") { |f| f.write(result) }
@@ -33,7 +32,14 @@ module IsoDoc
       def html_cleanup(html)
         html = term_header(html_footnote_filter(html_preface(htmlstyle(html))))
         html = footnote_format(footnote_backlinks(html_toc(html)))
-        mathml(html_list_clean(html))
+        mathml(html_list_clean(remove_placeholder_paras(html)))
+      end
+
+      def remove_placeholder_paras(html)
+        %w(title-section prefatory-section).each do |s|
+          html&.at("//div[@class = '#{s}']/p[last()]")&.remove
+        end
+        html
       end
 
       def html_list_clean(html)
@@ -68,6 +74,7 @@ module IsoDoc
         head = docxml.at("//*[local-name() = 'head']")
         head << htmlstylesheet(@htmlstylesheet)
         s = htmlstylesheet(@htmlstylesheet_override) and head << s
+        @bare and head << "<style>body {margin-left: 2em; margin-right: 2em;}</style>"
         docxml
       end
 
@@ -99,7 +106,6 @@ module IsoDoc
       def html_cover(docxml)
         doc = to_xhtml_fragment(File.read(@htmlcoverpage, encoding: "UTF-8"))
         d = docxml.at('//div[@class="title-section"]')
-        # d.children.first.add_previous_sibling doc.to_xml(encoding: "US-ASCII")
         d.children.first.add_previous_sibling(
           populate_template(doc.to_xml(encoding: "US-ASCII"), :html),
         )
@@ -108,7 +114,6 @@ module IsoDoc
       def html_intro(docxml)
         doc = to_xhtml_fragment(File.read(@htmlintropage, encoding: "UTF-8"))
         d = docxml.at('//div[@class="prefatory-section"]')
-        # d.children.first.add_previous_sibling doc.to_xml(encoding: "US-ASCII")
         d.children.first.add_previous_sibling(
           populate_template(doc.to_xml(encoding: "US-ASCII"), :html),
         )

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,34 @@ 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)
+      xref = node&.at(ns("./xref/@target"))&.text or
+        return concept_render(node, node["ital"] || "true",
+                              node["ref"] || "true")
+      if node.at(ns("//definitions//dt[@id = '#{xref}']"))
+        concept_render(node, node["ital"] || "false", node["ref"] || "false")
+      else concept_render(node, node["ital"] || "true", node["ref"] || "true")
+      end
+    end
+
+    def concept_render(node, ital, ref)
+      node&.at(ns("./refterm"))&.remove
+      r = node.at(ns("./renderterm"))
+      r&.next = " " if node.at(ns("./xref | ./eref | ./termref")) && ref != "false"
+      if ital == "true" then r&.name = "em"
+      else r&.replace(r&.children)
+      end
+      concept1_ref(node, ref)
+      node.replace(node.children)
+    end
+
+    def concept1_ref(node, ref)
+      r = node.at(ns("./xref | ./eref | ./termref")) or return
+      return r.remove if ref == "false"
+
+      if non_locality_elems(r).select { |c| !c.text? || /\S/.match(c) }.empty?
+        r.replace(@i18n.term_defined_in.sub(/%/, r.to_xml))
+      else r.replace("[#{r.to_xml}]")
+      end
     end
 
     def variant(docxml)

data/lib/isodoc/presentation_function/section.rb

@@ -44,8 +44,7 @@ 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|

data/lib/isodoc/presentation_xml_convert.rb

@@ -29,12 +29,12 @@ module IsoDoc
     end
 
     def section(docxml)
-      display_order docxml
       clause docxml
       annex docxml
       term docxml
       references docxml
       index docxml
+      display_order docxml
     end
 
     def block(docxml)
@@ -53,10 +53,10 @@ module IsoDoc
     end
 
     def inline(docxml)
+      concept docxml
       xref docxml
       eref docxml
       origin docxml
-      concept docxml
       quotesource docxml
       mathml docxml
       variant docxml

data/lib/isodoc/version.rb

@@ -1,3 +1,3 @@
 module IsoDoc
-  VERSION = "1.6.7.1".freeze
+  VERSION = "1.7.3".freeze
 end

data/lib/isodoc/xref.rb

@@ -28,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
@@ -50,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