metanorma-standoc 2.1.4 → 2.2.0.1

data/lib/metanorma/standoc/front.rb

@@ -121,7 +121,7 @@ module Metanorma
 
       def metadata_getrelation(node, xml, type, desc = nil)
         docs = node.attr(desc || type) or return
-        HTMLEntities.new.decode(docs).split(/;\s*/).each do |d|
+        @c.decode(docs).split(/;\s*/).each do |d|
           metadata_getrelation1(d, xml, type, desc)
         end
       end

data/lib/metanorma/standoc/inline.rb

@@ -79,8 +79,8 @@ module Metanorma
       end
 
       def inline_anchor_bibref(node)
-        eref_contents = HTMLEntities.new
-          .decode(node.text || node.target || node.id)
+        eref_contents =
+          @c.decode(node.text || node.target || node.id)
           &.sub(/^\[?([^\[\]]+?)\]?$/, "[\\1]")
         @refids << (node.target || node.id)
         noko do |xml|
@@ -125,14 +125,14 @@ module Metanorma
       end
 
       def xml_encode(text)
-        HTMLEntities.new.encode(text, :basic, :hexadecimal)
+        @c.encode(text, :basic, :hexadecimal)
           .gsub(/&amp;gt;/, ">").gsub(/&amp;lt;/, "<").gsub(/&amp;amp;/, "&")
           .gsub(/&gt;/, ">").gsub(/&lt;/, "<").gsub(/&amp;/, "&")
           .gsub(/&quot;/, '"').gsub(/&#xa;/, "\n").gsub(/&amp;#/, "&#")
       end
 
       def latex_parse1(text)
-        lxm_input = Unicode2LaTeX.unicode2latex(HTMLEntities.new.decode(text))
+        lxm_input = Unicode2LaTeX.unicode2latex(@c.decode(text))
         results = Latexmath.parse(lxm_input).to_mathml
         results.nil? and
           @log.add("Math", nil,
@@ -191,6 +191,10 @@ module Metanorma
             when "underline" then xml.underline { |s| s << node.text }
             when "smallcap" then xml.smallcap { |s| s << node.text }
             when "keyword" then xml.keyword { |s| s << node.text }
+            when /^css /
+              xml.span **{ style: node.role.sub(/^css /, "") } do |s|
+                s << node.text
+              end
             else
               xml << node.text
             end

data/lib/metanorma/standoc/isodoc.rng

@@ -1285,7 +1285,12 @@
   </define>
   <define name="span">
     <element name="span">
-      <attribute name="class"/>
+      <optional>
+        <attribute name="class"/>
+      </optional>
+      <optional>
+        <attribute name="style"/>
+      </optional>
       <oneOrMore>
         <ref name="TextElement"/>
       </oneOrMore>
@@ -2504,6 +2509,16 @@
           <text/>
         </element>
       </optional>
+      <optional>
+        <element name="amendment">
+          <text/>
+        </element>
+      </optional>
+      <optional>
+        <element name="corrigendum">
+          <text/>
+        </element>
+      </optional>
       <optional>
         <element name="language">
           <text/>

data/lib/metanorma/standoc/macros.rb

@@ -3,6 +3,7 @@ require "fileutils"
 require "uuidtools"
 require "yaml"
 require "csv"
+require_relative "./macros_inline"
 require_relative "./macros_plantuml"
 require_relative "./macros_terms"
 require_relative "./macros_form"
@@ -15,54 +16,6 @@ require "metanorma-plugin-lutaml"
 
 module Metanorma
   module Standoc
-    class InheritInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
-      use_dsl
-      named :inherit
-      parse_content_as :text
-      using_format :short
-
-      def process(parent, _target, attrs)
-        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
-        %{<inherit>#{out}</inherit>}
-      end
-    end
-
-    class IndexXrefInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
-      use_dsl
-      named :index
-
-      def preprocess_attrs(attrs)
-        return unless attrs.size > 1 && attrs.size < 5
-
-        ret = { primary: attrs[1], target: attrs[attrs.size] }
-        ret[:secondary] = attrs[2] if attrs.size > 2
-        ret[:tertiary] = attrs[3] if attrs.size > 3
-        ret
-      end
-
-      def process(_parent, target, attr)
-        args = preprocess_attrs(attr) or return
-        ret = "<index-xref also='#{target == 'also'}'>"\
-              "<primary>#{args[:primary]}</primary>"
-        ret += "<secondary>#{args[:secondary]}</secondary>" if args[:secondary]
-        ret += "<tertiary>#{args[:tertiary]}</tertiary>" if args[:tertiary]
-        ret + "<target>#{args[:target]}</target></index-xref>"
-      end
-    end
-
-    class IndexRangeInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
-      use_dsl
-      named :"index-range"
-      parse_content_as :text
-
-      def process(parent, target, attr)
-        text = attr["text"]
-        text = "((#{text}))" unless /^\(\(.+\)\)$/.match?(text)
-        out = parent.sub_macros(text)
-        out.sub(/<index>/, "<index to='#{target}'>")
-      end
-    end
-
     class PseudocodeBlockMacro < Asciidoctor::Extensions::BlockProcessor
       use_dsl
       named :pseudocode
@@ -97,138 +50,6 @@ module Metanorma
       end
     end
 
-    class HTML5RubyMacro < Asciidoctor::Extensions::InlineMacroProcessor
-      use_dsl
-      named :ruby
-      parse_content_as :text
-      option :pos_attrs, %w(rpbegin rt rpend)
-
-      # for example, html5ruby:楽聖少女[がくせいしょうじょ]
-      def process(_parent, target, attributes)
-        rpbegin = "("
-        rpend = ")"
-        if (attributes.size == 1) && attributes.key?("text")
-          rt = attributes["text"]
-        elsif (attributes.size == 2) && attributes.key?(1) &&
-            attributes.key?("rpbegin")
-          rt = attributes[1] || ""
-        else
-          rpbegin = attributes["rpbegin"]
-          rt = attributes["rt"]
-          rpend = attributes["rpend"]
-        end
-
-        "<ruby>#{target}<rp>#{rpbegin}</rp><rt>#{rt}</rt>"\
-          "<rp>#{rpend}</rp></ruby>"
-      end
-    end
-
-    class AutonumberInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
-      use_dsl
-      named :autonumber
-      parse_content_as :text
-
-      def process(parent, target, attrs)
-        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
-        %{<autonumber type='#{target}'>#{out}</autonumber>}
-      end
-    end
-
-    class VariantInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
-      use_dsl
-      named :lang
-      parse_content_as :text
-
-      def process(parent, target, attrs)
-        /^(?<lang>[^-]*)(?:-(?<script>.*))?$/ =~ target
-        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
-        if script
-          %{<variant lang='#{lang}' script='#{script}'>#{out}</variant>}
-        else
-          %{<variant lang='#{lang}'>#{out}</variant>}
-        end
-      end
-    end
-
-    class AddMacro < Asciidoctor::Extensions::InlineMacroProcessor
-      use_dsl
-      named :add
-      parse_content_as :text
-      using_format :short
-
-      def process(parent, _target, attrs)
-        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
-        %{<add>#{out}</add>}
-      end
-    end
-
-    class DelMacro < Asciidoctor::Extensions::InlineMacroProcessor
-      use_dsl
-      named :del
-      parse_content_as :text
-      using_format :short
-
-      def process(parent, _target, attrs)
-        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
-        %{<del>#{out}</del>}
-      end
-    end
-
-    class ToCInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
-      use_dsl
-      named :toc
-      parse_content_as :text
-      using_format :short
-
-      def process(parent, _target, attrs)
-        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
-        content = CSV.parse_line(out).map do |x|
-          x.sub!(/^(["'])(.+)\1/, "\\2")
-          m = /^(.*?)(:\d+)?$/.match(x)
-          %{<toc-xpath depth='#{m[2]&.sub(/:/, '') || 1}'>#{m[1]}</toc-xpath>}
-        end.join
-        "<toc>#{content}</toc>"
-      end
-    end
-
-    # inject ZWNJ to prevent Asciidoctor from attempting regex substitutions
-    class PassInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
-      use_dsl
-      named :"pass-format"
-
-      def process(parent, target, attrs)
-        format = target || "metanorma"
-        out = Asciidoctor::Inline.new(parent, :quoted, attrs[1]).convert
-          .gsub(/((?![<>&])[[:punct:]])/, "\\1&#x200c;")
-        %{<passthrough-inline formats="#{format}">#{out}</passthrough-inline>}
-      end
-    end
-
-    class IdentifierInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
-      use_dsl
-      named :identifier
-      parse_content_as :raw
-      using_format :short
-
-      def process(parent, _target, attrs)
-        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
-          .gsub(/((?![<>&])[[:punct:]])/, "\\1&#x200c;")
-        %{<identifier>#{out}</identifier>}
-      end
-    end
-
-    class StdLinkInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
-      use_dsl
-      named :"std-link"
-      parse_content_as :text
-      using_format :short
-
-      def process(parent, _target, attrs)
-        create_anchor(parent, "hidden%#{attrs['text']}",
-                      type: :xref, target: "_#{UUIDTools::UUID.random_create}")
-      end
-    end
-
     class NamedEscapePreprocessor < Asciidoctor::Extensions::Preprocessor
       def process(_document, reader)
         c = HTMLEntities.new

data/lib/metanorma/standoc/macros_inline.rb

@@ -0,0 +1,194 @@
+module Metanorma
+  module Standoc
+    class InheritInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :inherit
+      parse_content_as :text
+      using_format :short
+
+      def process(parent, _target, attrs)
+        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
+        %{<inherit>#{out}</inherit>}
+      end
+    end
+
+    class IndexXrefInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :index
+
+      def preprocess_attrs(attrs)
+        return unless attrs.size > 1 && attrs.size < 5
+
+        ret = { primary: attrs[1], target: attrs[attrs.size] }
+        ret[:secondary] = attrs[2] if attrs.size > 2
+        ret[:tertiary] = attrs[3] if attrs.size > 3
+        ret
+      end
+
+      def process(_parent, target, attr)
+        args = preprocess_attrs(attr) or return
+        ret = "<index-xref also='#{target == 'also'}'>"\
+              "<primary>#{args[:primary]}</primary>"
+        ret += "<secondary>#{args[:secondary]}</secondary>" if args[:secondary]
+        ret += "<tertiary>#{args[:tertiary]}</tertiary>" if args[:tertiary]
+        ret + "<target>#{args[:target]}</target></index-xref>"
+      end
+    end
+
+    class IndexRangeInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :"index-range"
+      parse_content_as :text
+
+      def process(parent, target, attr)
+        text = attr["text"]
+        text = "((#{text}))" unless /^\(\(.+\)\)$/.match?(text)
+        out = parent.sub_macros(text)
+        out.sub(/<index>/, "<index to='#{target}'>")
+      end
+    end
+
+    class HTML5RubyMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :ruby
+      parse_content_as :text
+      option :pos_attrs, %w(rpbegin rt rpend)
+
+      # for example, html5ruby:楽聖少女[がくせいしょうじょ]
+      def process(_parent, target, attributes)
+        rpbegin = "("
+        rpend = ")"
+        if (attributes.size == 1) && attributes.key?("text")
+          rt = attributes["text"]
+        elsif (attributes.size == 2) && attributes.key?(1) &&
+            attributes.key?("rpbegin")
+          rt = attributes[1] || ""
+        else
+          rpbegin = attributes["rpbegin"]
+          rt = attributes["rt"]
+          rpend = attributes["rpend"]
+        end
+
+        "<ruby>#{target}<rp>#{rpbegin}</rp><rt>#{rt}</rt>"\
+          "<rp>#{rpend}</rp></ruby>"
+      end
+    end
+
+    class AutonumberInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :autonumber
+      parse_content_as :text
+
+      def process(parent, target, attrs)
+        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
+        %{<autonumber type='#{target}'>#{out}</autonumber>}
+      end
+    end
+
+    class VariantInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :lang
+      parse_content_as :text
+
+      def process(parent, target, attrs)
+        /^(?<lang>[^-]*)(?:-(?<script>.*))?$/ =~ target
+        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
+        if script
+          %{<variant lang='#{lang}' script='#{script}'>#{out}</variant>}
+        else
+          %{<variant lang='#{lang}'>#{out}</variant>}
+        end
+      end
+    end
+
+    class AddMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :add
+      parse_content_as :text
+      using_format :short
+
+      def process(parent, _target, attrs)
+        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
+        %{<add>#{out}</add>}
+      end
+    end
+
+    class DelMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :del
+      parse_content_as :text
+      using_format :short
+
+      def process(parent, _target, attrs)
+        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
+        %{<del>#{out}</del>}
+      end
+    end
+
+    class ToCInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :toc
+      parse_content_as :text
+      using_format :short
+
+      def process(parent, _target, attrs)
+        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
+        content = CSV.parse_line(out).map do |x|
+          x.sub!(/^(["'])(.+)\1/, "\\2")
+          m = /^(.*?)(:\d+)?$/.match(x)
+          %{<toc-xpath depth='#{m[2]&.sub(/:/, '') || 1}'>#{m[1]}</toc-xpath>}
+        end.join
+        "<toc>#{content}</toc>"
+      end
+    end
+
+    # inject ZWNJ to prevent Asciidoctor from attempting regex substitutions
+    class PassInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :"pass-format"
+
+      def process(parent, target, attrs)
+        format = target || "metanorma"
+        out = Asciidoctor::Inline.new(parent, :quoted, attrs[1]).convert
+          .gsub(/((?![<>&])[[:punct:]])/, "\\1&#x200c;")
+        %{<passthrough-inline formats="#{format}">#{out}</passthrough-inline>}
+      end
+    end
+
+    class IdentifierInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :identifier
+      parse_content_as :raw
+      using_format :short
+
+      def process(parent, _target, attrs)
+        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
+          .gsub(/((?![<>&])[[:punct:]])/, "\\1&#x200c;")
+        %{<identifier>#{out}</identifier>}
+      end
+    end
+
+    class StdLinkInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :"std-link"
+      parse_content_as :text
+      using_format :short
+
+      def process(parent, _target, attrs)
+        create_anchor(parent, "hidden%#{attrs['text']}",
+                      type: :xref, target: "_#{UUIDTools::UUID.random_create}")
+      end
+    end
+
+    class SpanInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :span
+      parse_content_as :text
+
+      def process(parent, target, attrs)
+        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
+        %{<span class="#{target}">#{out}</span>}
+      end
+    end
+  end
+end

data/lib/metanorma/standoc/ref_sect.rb

@@ -84,7 +84,7 @@ module Metanorma
         if ref[:code].nil? || ref[:no_year] || @bibdb.nil?
           res << [ref, idx, nil]
         else
-          @bibdb.fetch_async(HTMLEntities.new.decode(ref[:code]),
+          @bibdb.fetch_async(@c.decode(ref[:code]),
                              ref[:year], ref) do |doc|
             res << [ref, idx, doc]
           end
@@ -131,7 +131,7 @@ module Metanorma
         global = !@no_isobib_cache && !node.attr("local-cache-only")
         local = node.attr("local-cache") || node.attr("local-cache-only")
         local = nil if @no_isobib_cache
-        @bibdb = Relaton::DbCache.init_bib_caches(
+        @bibdb = Relaton::Db.init_bib_caches(
           local_cache: local,
           flush_caches: node.attr("flush-caches"),
           global_cache: global,

data/lib/metanorma/standoc/ref_utility.rb

@@ -53,7 +53,7 @@ module Metanorma
 
       def docnumber(bib, code)
         bib.docnumber do |d|
-          d << HTMLEntities.new.decode(code).sub(/^[^\d]*/, "")
+          d << @c.decode(code).sub(/^[^\d]*/, "")
         end
       end
 
@@ -104,9 +104,9 @@ module Metanorma
         ret = { id: code }
         return ret if code.blank?
 
-        analyse_ref_nofetch(
-          analyse_ref_hidden(
-            analyse_ref_dropid(analyse_ref_repo_path(analyse_ref_numeric(ret))),
+        analyse_ref_numeric(
+          analyse_ref_repo_path(
+            analyse_ref_dropid(analyse_ref_hidden(analyse_ref_nofetch(ret))),
           ),
         )
       end
@@ -121,8 +121,7 @@ module Metanorma
       end
 
       def ref_attributes(match)
-
-code = analyse_ref_code(match[:code])
+        code = analyse_ref_code(match[:code])
 
         { id: match[:anchor], type: "standard",
           suppress_identifier: code[:dropid] || nil }

data/lib/metanorma/standoc/reqt.rb

@@ -7,7 +7,7 @@ module Metanorma
   module Standoc
     module Blocks
       def reqt_subpart(name)
-        %w(specification measurement-target verification import label title
+        %w(specification measurement-target verification import identifier title
            description component subject inherit classification).include? name
       end
 
@@ -30,7 +30,7 @@ module Metanorma
 
       def req_classif_parse(classif)
         ret = []
-        HTMLEntities.new.decode(classif).split(/;\s*/).each do |c|
+        @c.decode(classif).split(/;\s*/).each do |c|
           c1 = c.split(/:\s*/)
           next unless c1.size == 2
 
@@ -63,16 +63,16 @@ module Metanorma
 
       def requirement_elems(node, out)
         node.title and out.title { |t| t << node.title }
-        a = node.attr("label") and out.label do |l|
+        a = node.attr("identifier") and out.identifier do |l|
           l << out.text(a)
         end
         a = node.attr("subject") and csv_split(a)&.each do |subj|
           out.subject { |s| s << out.text(subj) }
         end
-        a = HTMLEntities.new.decode(node.attr("inherit")) and
+        a = @c.decode(node.attr("inherit")) and
           csv_split(a)&.each do |i|
             out.inherit do |inh|
-              inh << HTMLEntities.new.encode(i, :hexadecimal)
+              inh << @c.encode(i, :hexadecimal)
             end
           end
         classif = node.attr("classification") and

data/lib/metanorma/standoc/reqt.rng

@@ -108,7 +108,7 @@
     </element>
   </define>
   <define name="label">
-    <element name="label">
+    <element name="identifier">
       <oneOrMore>
         <ref name="TextElement"/>
       </oneOrMore>

data/lib/metanorma/standoc/section.rb

@@ -38,6 +38,8 @@ module Metanorma
         when "symbols and abbreviated terms",
           "symbols", "abbreviated terms", "abbreviations"
           "symbols and abbreviated terms"
+        when "acknowledgements", "acknowledgments"
+          "acknowledgements"
         else
           ret
         end

data/lib/metanorma/standoc/term_lookup_cleanup.rb

@@ -68,7 +68,7 @@ module Metanorma
       end
 
       def remove_missing_ref(node, target)
-        if node.at("../concept[@type = 'symbol']")
+        if node.at("./parent::concept[@type = 'symbol']")
           remove_missing_ref_symbol(node, target)
         else
           remove_missing_ref_term(node, target)

data/lib/metanorma/standoc/utils.rb

@@ -60,7 +60,7 @@ module Metanorma
                         "[not(ancestor::boilerplate)]".freeze
 
       def isodoc(lang, script, i18nyaml = nil)
-        conv = html_converter(EmptyAttr.new)
+        conv = presentation_xml_converter(EmptyAttr.new)
         i18n = conv.i18n_init(lang, script, i18nyaml)
         conv.metadata_init(lang, script, i18n)
         conv

data/lib/metanorma/standoc/validate.rb

@@ -1,5 +1,6 @@
 require "metanorma/standoc/utils"
 require_relative "./validate_section"
+require_relative "./validate_table"
 require "nokogiri"
 require "jing"
 require "iev"
@@ -53,75 +54,6 @@ module Metanorma
         @fatalerror.empty? or clean_abort(@fatalerror.join("\n"), doc.to_xml)
       end
 
-      def table_validate(doc)
-        doc.xpath("//table[colgroup]").each do |t|
-          maxrowcols_validate(t, t.xpath("./colgroup/col").size)
-        end
-        doc.xpath("//table[.//*[@colspan] | .//*[@rowspan]]").each do |t|
-          maxrowcols_validate(t, max_td_count(t))
-        end
-      end
-
-      def max_td_count(table)
-        max = 0
-        table.xpath("./tr").each do |tr|
-          n = tr.xpath("./td | ./th").size
-          max < n and max = n
-        end
-        max
-      end
-
-      def maxrowcols_validate(table, maxcols)
-        cells2d = table.xpath("./*/tr").each_with_object([]) { |_r, m| m << {} }
-        table.xpath("./*/tr").each_with_index do |tr, r|
-          curr = 0
-          tr.xpath("./td | ./th").each do |td|
-            curr = maxcols_validate1(td, r, curr, cells2d, maxcols)
-          end
-        end
-        maxrows_validate(table, cells2d)
-      end
-
-      # code doesn't actually do anything, since Asciidoctor refuses to generate
-      # table with inconsistent column count
-      def maxcols_validate1(tcell, row, curr, cells2d, maxcols)
-        rs = tcell&.attr("rowspan")&.to_i || 1
-        cs = tcell&.attr("colspan")&.to_i || 1
-        curr = table_tracker_update(cells2d, row, curr, rs, cs)
-        maxcols_check(curr + cs - 1, maxcols, tcell)
-        curr + cs
-      end
-
-      def table_tracker_update(cells2d, row, curr, rowspan, colspan)
-        cells2d[row] ||= {}
-        while cells2d[row][curr]
-          curr += 1
-        end
-        (row..(row + rowspan - 1)).each do |y2|
-          cells2d[y2] ||= {}
-          (curr..(curr + colspan - 1)).each { |x2| cells2d[y2][x2] = 1 }
-        end
-        curr
-      end
-
-      def maxrows_validate(table, cells2d)
-        if cells2d.any? { |x| x.size != cells2d.first.size }
-          @log.add("Table", table,
-                   "Table rows in table are inconsistent: check rowspan")
-          @fatalerror << "Table rows in table are inconsistent: check rowspan"
-        end
-      end
-
-      # if maxcols or maxrows negative, do not check them
-      def maxcols_check(col, maxcols, tcell)
-        if maxcols.positive? && col > maxcols
-          @log.add("Table", tcell, "Table exceeds maximum number of columns "\
-                                   "defined (#{maxcols})")
-          @fatalerror << "Table exceeds maximum number of columns defined "\
-                         "(#{maxcols})"
-        end
-      end
-
       def norm_ref_validate(doc)
         found = false
         doc.xpath("//references[@normative = 'true']/bibitem").each do |b|