asciimath2unitsml 0.3.2 → 0.4.2

data/lib/asciimath2unitsml/parse.rb

@@ -1,94 +1,101 @@
 module Asciimath2UnitsML
   class Conv
     include Rsec::Helpers
-
-    def read_yaml(path)
-      validate_yaml(symbolize_keys(YAML
-        .load_file(File.join(File.join(File.dirname(__FILE__), path)))), path)
-    end
-
-    def flip_name_and_symbol(hash)
-      hash.each_with_object({}) do |(_k, v), m|
-        next if v.name.nil? || v.name.empty?
-
-        m[v.symbolid] = v
-      end
-    end
-
-    def flip_name_and_symbols(hash)
-      hash.each_with_object({}) do |(_k, v), m|
-        next if v.name.nil? || v.name.empty?
-
-        v.symbolids.each { |s| m[s] = v }
-      end
+    def parsers
+      exponent = /\^\(-?\d+\)/.r.map { |m| m.sub(/\^/, "").gsub(/[()]/, "") } |
+        /\^-?\d+/.r.map { |m| m.sub(/\^/, "") }
+      multiplier = %r{\*|//|/}.r.map { |x| { multiplier: x[0] } }
+      units = units_parse(exponent, multiplier)
+      dimensions = dimensions_parser(exponent, multiplier)
+      [units.eof, dimensions.eof]
     end
 
-    def symbolize_keys(hash)
-      return hash if hash.is_a? String
-
-      hash.inject({}) do |result, (key, value)|
-        new_key = case key
-                  when String then key.to_sym
-                  else key
-                  end
-        new_value = case value
-                    when Hash then symbolize_keys(value)
-                    when Array then value.map { |m| symbolize_keys(m) }
-                    else value
-                    end
-        result[new_key] = new_value
-        result
-      end
+    def dimensions_parser(exponent, multiplier)
+      dim1 = /#{@dimensions.keys.sort_by(&:length).reverse.join("|")}/.r
+      dimension =
+        seq("sqrt(", dim1, ")") { |x| { dim: x[1], display_exponent: "0.5" } } |
+        seq(dim1, exponent._? & (multiplier | ")".r)) { |x| { dim: x[0], display_exponent: (x[1][0]) } } |
+        seq(dim1, exponent._?).eof { |x| { dim: x[0], display_exponent: (x[1][0]) } }
+      dimensions1 = "(".r >> lazy { dimensions } << ")" | dimension
+      dimensions = dimensions1.join(multiplier) # rubocop:disable Style/RedundantAssignment
+      dimensions
     end
 
-    def parser
+    def units_parse(exponent, multiplier)
       prefix2 = /#{@prefixes.keys.select { |x| x.size == 2 }.join("|")}/.r
       prefix1 = /#{@prefixes.keys.select { |x| x.size == 1 }.join("|")}/.r
       unit_keys = @units.keys.reject do |k|
         /\*|\^|\/|^1$/.match(k) || @units[k].prefixed
       end.map { |k| Regexp.escape(k) }
       unit1 = /#{unit_keys.sort_by(&:length).reverse.join("|")}/.r
-      exponent = /\^\(-?\d+\)/.r.map { |m| m.sub(/\^/, "").gsub(/[()]/, "") } |
-        /\^-?\d+/.r.map { |m| m.sub(/\^/, "") }
-      multiplier = %r{\*|//|/}.r.map { |x| { multiplier: x[0] } }
-      unit = 
+
+      unit =
         seq("sqrt(", unit1, ")") { |x| { prefix: nil, unit: x[1], display_exponent: "0.5" } } |
         seq("sqrt(", prefix1, unit1, ")") { |x| { prefix: x[1], unit: x[2], display_exponent: "0.5" } } |
         seq("sqrt(", prefix2, unit1, ")") { |x| { prefix: x[1], unit: x[2], display_exponent: "0.5" } } |
         seq(unit1, exponent._? & (multiplier | ")".r)) { |x| { prefix: nil, unit: x[0], display_exponent: (x[1][0]) } } |
         seq(unit1, exponent._?).eof { |x| { prefix: nil, unit: x[0], display_exponent: (x[1][0]) } } |
-        seq(prefix1, unit1, exponent._? ) { |x| { prefix: x[0], unit: x[1], display_exponent: (x[2][0]) } } |
-        seq(prefix2, unit1, exponent._? ) { |x| { prefix: x[0], unit: x[1], display_exponent: (x[2][0]) } } |
+        seq(prefix1, unit1, exponent._?) { |x| { prefix: x[0], unit: x[1], display_exponent: (x[2][0]) } } |
+        seq(prefix2, unit1, exponent._?) { |x| { prefix: x[0], unit: x[1], display_exponent: (x[2][0]) } } |
         "1".r.map { |_| { prefix: nil, unit: "1", display_exponent: nil } }
-      units1 = "(".r >> lazy{units} << ")" | unit
-      units = seq(prefix2, "-") { |x| [{ prefix: x[0], unit: nil, display_exponent: nil }] } |
+      units1 = "(".r >> lazy { units } << ")" | unit
+      units = seq(prefix2, "-") { |x| [{ prefix: x[0], unit: nil, display_exponent: nil }] } | # rubocop:disable Style/RedundantAssignment
         seq(prefix1, "-") { |x| [{ prefix: x[0], unit: nil, display_exponent: nil }] } |
         units1.join(multiplier)
-      parser = units.eof
+      units
     end
 
-    def parse(x)
-      text = Array(x.split(/,\s*/))
+    def parse(expr)
+      text = Array(expr.split(/,\s*/))
+      if /dim_/.match?(text[0]) then parse_dimensions(text)
+      else parse_units(text)
+      end
+    end
+
+    def parse_units(text)
       units = @parser.parse!(text[0])
       if !units || Rsec::INVALID[units]
         raise Rsec::SyntaxError.new "error parsing UnitsML expression", x, 1, 0
       end
 
       Rsec::Fail.reset
-      postprocess(units, text)
+      postprocess(units, text, true)
+    end
+
+    def parse_dimensions(text)
+      units = @dim_parser.parse!(text[0])
+      if !units || Rsec::INVALID[units]
+        raise Rsec::SyntaxError.new "error parsing UnitsML expression", x, 1, 0
+      end
+
+      Rsec::Fail.reset
+      postprocess(units, text, false)
     end
 
-    def postprocess(units, text)
+    def postprocess(units, text, is_units)
       units = postprocess1(units.flatten)
-      quantity = text[1..-1]&.select { |x| /^quantity:/.match(x) }&.first&.sub(/^quantity:\s*/, "")
-      name = text[1..-1]&.select { |x| /^name:/.match(x) }&.first&.sub(/^name:\s*/, "")
-      symbol = text[1..-1]&.select { |x| /^symbol:/.match(x) }&.first&.sub(/^symbol:\s*/, "")
-      multiplier = text[1..-1]&.select { |x| /^multiplier:/.match(x) }&.first&.sub(/^multiplier:\s*/, "")
-      normtext = units_only(units).each.map do |u|
-        exp = u[:exponent] && u[:exponent] != "1" ? "^#{u[:exponent]}" : ""
-        "#{u[:prefix]}#{u[:unit]}#{exp}"
+      normtext = postprocess_normtext(units, is_units)
+      [units, text[0], normtext, postprocess_extr(text, "quantity"),
+       postprocess_extr(text, "name"), postprocess_extr(text, "symbol"),
+       postprocess_extr(text, "multiplier")]
+    end
+
+    def postprocess_normtext(units, is_units)
+      units_only(units).each.map do |u|
+        if is_units then "#{u[:prefix]}#{u[:unit]}#{display_exp(u)}"
+        else "#{u[:dim]}#{display_exp(u)}"
+        end
       end.join("*")
-      [units, text[0], normtext, quantity, name, symbol, multiplier]
+    end
+
+    def postprocess_extr(text, name)
+      text[1..-1]&.select do |x|
+        /^#{name}:/.match(x)
+      end&.first&.sub(/^#{name}:\s*/, "")
+    end
+
+    def display_exp(unit)
+      unit[:exponent] && unit[:exponent] != "1" ? "^#{unit[:exponent]}" : ""
     end
 
     def postprocess1(units)
@@ -110,16 +117,21 @@ module Asciimath2UnitsML
       MathML2UnitsML(xml).to_xml
     end
 
-    # https://www.w3.org/TR/mathml-units/ section 2: delimit number Invisible-Times unit
+    # https://www.w3.org/TR/mathml-units/ section 2:
+    # delimit number Invisible-Times unit
     def MathML2UnitsML(xml)
       xml.is_a? String and xml = Nokogiri::XML(xml)
       xml.xpath(".//m:mtext", "m" => MATHML_NS).each do |x|
-        next unless %r{^unitsml\(.+\)$}.match(x.text)
+        next unless %r{^unitsml\(.+\)$}.match?(x.text)
 
         text = x.text.sub(%r{^unitsml\((.+)\)$}m, "\\1")
-        units, origtext, normtext, quantity, name, symbol, multiplier = parse(text)
-        rendering = symbol ? embeddedmathml(asciimath2mathml(symbol)) :
-          mathmlsymbol(units, false, multiplier)
+        units, origtext, normtext, quantity, name, symbol, multiplier =
+          parse(text)
+        rendering = if symbol
+                      embeddedmathml(asciimath2mathml(symbol))
+                    else
+                      mathmlsymbol(units, false, multiplier)
+                    end
         x.replace("#{delimspace(rendering, x)}"\
                   "<mrow xref='#{unit_id(origtext)}'>#{rendering}</mrow>\n"\
                   "#{unitsml(units, origtext, normtext, quantity, name)}")
@@ -127,18 +139,22 @@ module Asciimath2UnitsML
       dedup_ids(xml)
     end
 
-    # if previous sibling's last descendent non-whitespace is MathML and mn or mi, no space
+    # if previous sibling's last descendent non-whitespace is MathML and
+    # mn or mi, no space
     def delimspace(rendering, elem)
       prec_text_elem =
         elem.xpath("./preceding-sibling::*[namespace-uri() = '#{MATHML_NS}']/"\
-                   "descendant::text()[normalize-space()!=''][last()]/parent::*").last
+                   "descendant::text()[normalize-space()!='']"\
+                   "[last()]/parent::*").last
       return "" if prec_text_elem.nil? ||
         !%w(mn mi).include?(prec_text_elem&.name)
 
       text = HTMLEntities.new.encode(Nokogiri::XML("<mrow>#{rendering}</mrow>")
         .text.strip)
-      /\p{L}|\p{N}/.match(text) ?
-        "<mo rspace='thickmathspace'>&#x2062;</mo>" : "<mo>&#x2062;</mo>"
+      if /\p{L}|\p{N}/.match?(text)
+        "<mo rspace='thickmathspace'>&#x2062;</mo>"
+      else "<mo>&#x2062;</mo>"
+      end
     end
 
     def dedup_ids(xml)
@@ -156,9 +172,9 @@ module Asciimath2UnitsML
     end
 
     def asciimath2mathml(expression)
-      AsciiMath::MathMLBuilder.new(:msword => true).append_expression(
-        AsciiMath.parse(HTMLEntities.new.decode(expression)).ast).to_s
-        .gsub(/<math>/, "<math xmlns='#{MATHML_NS}'>")
+      AsciiMath::MathMLBuilder.new(msword: true).append_expression(
+        AsciiMath.parse(HTMLEntities.new.decode(expression)).ast,
+      ).to_s.gsub(/<math>/, "<math xmlns='#{MATHML_NS}'>")
     end
 
     def embeddedmathml(mathml)
@@ -171,7 +187,7 @@ module Asciimath2UnitsML
     def ambig_units
       u = @units_id.each_with_object({}) do |(_k, v), m|
         v.symbolids.each do |x|
-          next if %r{[*/^]}.match(x)
+          next if %r{[*/^]}.match?(x)
           next unless v.symbols_hash[x][:html] != x
 
           m[v.symbols_hash[x][:html]] ||= []
@@ -185,13 +201,15 @@ module Asciimath2UnitsML
     def render_ambig_units(u)
       maxcols = 0
       u.each { |_, v| maxcols = v.size if maxcols < v.size }
-      puts %([cols="#{maxcols + 1}*"]\n|===\n|Symbol | Unit + ID #{"| " * (maxcols - 1)}\n)
+      puts %([cols="#{maxcols + 1}*"]\n|===\n|Symbol | Unit + ID #{'| ' * (maxcols - 1)}\n)
       puts "\n\n"
-      u.keys.sort_by { |a| [-u[a].size, a.gsub(%r{\&[^;]+;}, "")
-        .gsub(/[^A-Za-z]/, "").downcase] }.each do |k|
+      u.keys.sort_by do |a|
+        [-u[a].size, a.gsub(%r{&[^;]+;}, "")
+          .gsub(/[^A-Za-z]/, "").downcase]
+      end.each do |k|
         print "| #{html2adoc(k)} "
         u[k].sort_by(&:size).each { |v1| print "| #{@units[v1].name}: `#{v1}` " }
-        puts "#{'| ' * (maxcols - u[k].size) }\n"
+        puts "#{'| ' * (maxcols - u[k].size)}\n"
       end
       puts "|===\n"
     end

data/lib/asciimath2unitsml/read.rb

@@ -0,0 +1,42 @@
+module Asciimath2UnitsML
+  class Conv
+    def read_yaml(path)
+      validate_yaml(symbolize_keys(YAML
+        .load_file(File.join(File.join(File.dirname(__FILE__), path)))), path)
+    end
+
+    def symbolize_keys(hash)
+      return hash if hash.is_a? String
+
+      hash.inject({}) do |result, (key, value)|
+        new_key = case key
+                  when String then key.to_sym
+                  else key
+                  end
+        new_value = case value
+                    when Hash then symbolize_keys(value)
+                    when Array then value.map { |m| symbolize_keys(m) }
+                    else value
+                    end
+        result[new_key] = new_value
+        result
+      end
+    end
+
+    def flip_name_and_symbol(hash)
+      hash.each_with_object({}) do |(_k, v), m|
+        next if v.name.nil? || v.name.empty?
+
+        m[v.symbolid] = v
+      end
+    end
+
+    def flip_name_and_symbols(hash)
+      hash.each_with_object({}) do |(_k, v), m|
+        next if v.name.nil? || v.name.empty?
+
+        v.symbolids.each { |s| m[s] = v }
+      end
+    end
+  end
+end

data/lib/asciimath2unitsml/render.rb

@@ -1,13 +1,14 @@
 module Asciimath2UnitsML
   class Conv
-    def multiplier(x)
-      case x
+    def multiplier(val)
+      case val
       when :space
         { html: "&#xA0;", mathml: "<mo rspace='thickmathspace'>&#x2062;</mo>" }
       when :nospace
         { html: "", mathml: "<mo>&#x2062;</mo>" }
       else
-        { html: HTMLEntities.new.encode(x), mathml: "<mo>#{HTMLEntities.new.encode(x)}</mo>" }
+        { html: HTMLEntities.new.encode(val),
+          mathml: "<mo>#{HTMLEntities.new.encode(val)}</mo>" }
       end
     end
 
@@ -15,28 +16,31 @@ module Asciimath2UnitsML
       @symbols[unit][style] || unit
     end
 
-    def htmlent(x)
-      HTMLEntities.new.decode(x).split(/([<>&])/)
-        .map { |c| /[<>'"]/.match(c) ? c : HTMLEntities.new.encode(c, :hexadecimal) }.join
+    def htmlent(xml)
+      HTMLEntities.new.decode(xml).split(/([<>&])/).map do |c|
+        /[<>'"]/.match?(c) ? c : HTMLEntities.new.encode(c, :hexadecimal)
+      end.join
     end
 
     def htmlsymbol(units, normalise)
       units.map do |u|
-        if u[:multiplier] then u[:multiplier] == "*" ? @multiplier[:html] : u[:multiplier]
+        if u[:multiplier]
+          u[:multiplier] == "*" ? @multiplier[:html] : u[:multiplier]
         elsif u[:unit].nil? && u[:prefix]
           @prefixes[u[:prefix]].html
         else
-          base = (u[:prefix] || "") + render(normalise ? @units[u[:unit]].symbolid : u[:unit], :html)
+          base = (u[:prefix] || "") +
+            render(normalise ? @units[u[:unit]].symbolid : u[:unit], :html)
           htmlsymbol_exponent(u, base)
         end
-      end.join("")
+      end.join
     end
 
-    def htmlsymbol_exponent(u, base)
-      if u[:display_exponent] == "0.5"
+    def htmlsymbol_exponent(unit, base)
+      if unit[:display_exponent] == "0.5"
         base = "&#x221a;#{base}"
-      elsif u[:display_exponent]
-        exp = "<sup>#{u[:display_exponent].sub(/-/, "&#x2212;")}</sup>"
+      elsif unit[:display_exponent]
+        exp = "<sup>#{unit[:display_exponent].sub(/-/, '&#x2212;')}</sup>"
         base += exp
       end
       base
@@ -44,41 +48,54 @@ module Asciimath2UnitsML
 
     def mathmlsymbol(units, normalise, multiplier = nil)
       multiplier = multiplier ? "<mo>#{multiplier}</mo>" : @multiplier[:mathml]
-      exp = units.map do |u|
-        if u[:multiplier] then u[:multiplier] == "*" ? multiplier : "<mo>#{u[:multiplier]}</mo>"
+      units.map do |u|
+        if u[:multiplier]
+          u[:multiplier] == "*" ? multiplier : "<mo>#{u[:multiplier]}</mo>"
         elsif u[:unit].nil? && u[:prefix]
           %(<mi mathvariant='normal'>#{htmlent(@prefixes[u[:prefix]].html)}</mi>)
         else
           mathmlsymbol1(u, normalise)
         end
-      end.join("")
+      end.join
+    end
+
+    def mathmlsymbol1(unit, normalise)
+      base = if unit[:dim]
+               render(normalise ? @dimensions[unit[:dim]].symbolid : unit[:dim],
+                      :mathml)
+             else
+               render(normalise ? @units[unit[:unit]].symbolid : unit[:unit],
+                      :mathml)
+             end
+      unit[:prefix] and base = mathmlsymbol1_prefixed(unit, base)
+      mathmlsymbol_exponent(unit, base)
     end
 
-    def mathmlsymbol1(u, normalise)
-      base = render(normalise ? @units[u[:unit]].symbolid : u[:unit], :mathml)
-      if u[:prefix]
-        prefix = htmlent(@prefixes[u[:prefix]].html)
-        base = base.match(/<mi mathvariant='normal'>/) ?
-          base.sub(/<mi mathvariant='normal'>/, "<mi mathvariant='normal'>#{prefix}") :
-          "<mrow><mi mathvariant='normal'>#{prefix}#{base}</mrow>"
+    def mathmlsymbol1_prefixed(unit, base)
+      prefix = htmlent(@prefixes[unit[:prefix]].html)
+      if /<mi mathvariant='normal'>/.match?(base)
+        base.sub(/<mi mathvariant='normal'>/,
+                 "<mi mathvariant='normal'>#{prefix}")
+      else
+        "<mrow><mi mathvariant='normal'>#{prefix}#{base}</mrow>"
       end
-      mathmlsymbol_exponent(u, base)
     end
 
-    def mathmlsymbol_exponent(u, base)
-      if u[:display_exponent] == "0.5"
+    def mathmlsymbol_exponent(unit, base)
+      if unit[:display_exponent] == "0.5"
         base = "<msqrt>#{base}</msqrt>"
-      elsif u[:display_exponent]
-        exp = "<mn>#{u[:display_exponent]}</mn>".sub(/<mn>-/, "<mo>&#x2212;</mo><mn>")
+      elsif unit[:display_exponent]
+        exp = "<mn>#{unit[:display_exponent]}</mn>"
+          .sub(/<mn>-/, "<mo>&#x2212;</mo><mn>")
         base = "<msup><mrow>#{base}</mrow><mrow>#{exp}</mrow></msup>"
       end
       base
     end
 
     def mathmlsymbolwrap(units, normalise)
-      <<~END
-      <math xmlns='#{MATHML_NS}'><mrow>#{mathmlsymbol(units, normalise)}</mrow></math>
-      END
+      <<~XML
+        <math xmlns='#{MATHML_NS}'><mrow>#{mathmlsymbol(units, normalise)}</mrow></math>
+      XML
     end
   end
 end

data/lib/asciimath2unitsml/unit.rb

@@ -7,21 +7,22 @@ module Asciimath2UnitsML
     def unit_id(text)
       text = text.gsub(/[()]/, "")
       /-$/.match(text) and return @prefixes[text.sub(/-$/, "")].id
-      "U_" + (@units[text] ? @units[text].id.gsub(/'/, "_") : text.gsub(/\*/, ".").gsub(/\^/, ""))
+      "U_#{@units[text] ? @units[text].id.gsub(/'/, '_') : text.gsub(/\*/, '.').gsub(/\^/, '')}"
     end
 
-    def unit(units, origtext, normtext, dims, name)
+    def unit(units, _origtext, normtext, dims, name)
       return if units_only(units).any? { |x| x[:unit].nil? }
+
       dimid = dim_id(dims)
       norm_units = normalise_units(units)
-      <<~END
-      <Unit xmlns='#{UNITSML_NS}' xml:id='#{unit_id(normtext)}'#{dimid ? " dimensionURL='##{dimid}'" : ""}>
-      #{unitsystem(units)}
-      #{unitname(norm_units, normtext, name)}
-      #{unitsymbol(norm_units)}
-      #{rootunits(units)}
-      </Unit>
-      END
+      <<~XML
+        <Unit xmlns='#{UNITSML_NS}' xml:id='#{unit_id(normtext)}'#{dimid ? " dimensionURL='##{dimid}'" : ''}>
+        #{unitsystem(units)}
+        #{unitname(norm_units, normtext, name)}
+        #{unitsymbol(norm_units)}
+        #{rootunits(units)}
+        </Unit>
+      XML
     end
 
     def normalise_units(units)
@@ -36,14 +37,17 @@ module Asciimath2UnitsML
     # kg exception
     def unitsystem(units)
       return if units_only(units).any? { |x| x[:unit].nil? }
+
       ret = []
       units = units_only(units)
       units.any? { |x| @units[x[:unit]].system_name != "SI" } and
         ret << "<UnitSystem name='not_SI' type='not_SI' xml:lang='en-US'/>"
       if units.any? { |x| @units[x[:unit]].system_name == "SI" }
-        base = units.size == 1 && @units[units[0][:unit]].system_type == "SI-base"
-        base = true if units.size == 1 && units[0][:unit] == "g" && units[0][:prefix] == "k"
-        ret << "<UnitSystem name='SI' type='#{base ? "SI_base" : "SI_derived"}' xml:lang='en-US'/>"
+        base = units.size == 1 &&
+          @units[units[0][:unit]].system_type == "SI-base"
+        base = true if units.size == 1 && units[0][:unit] == "g" &&
+          units[0][:prefix] == "k"
+        ret << "<UnitSystem name='SI' type='#{base ? 'SI_base' : 'SI_derived'}' xml:lang='en-US'/>"
       end
       ret.join("\n")
     end
@@ -54,28 +58,30 @@ module Asciimath2UnitsML
     end
 
     # TODO: compose name from the component units
-    def compose_name(units, text)
+    def compose_name(_units, text)
       text
     end
 
     def unitsymbol(units)
-      <<~END
-      <UnitSymbol type="HTML">#{htmlsymbol(units, true)}</UnitSymbol>
-      <UnitSymbol type="MathML">#{mathmlsymbolwrap(units, true)}</UnitSymbol>
-      END
+      <<~XML
+        <UnitSymbol type="HTML">#{htmlsymbol(units, true)}</UnitSymbol>
+        <UnitSymbol type="MathML">#{mathmlsymbolwrap(units, true)}</UnitSymbol>
+      XML
     end
 
     def rootunits(units)
       return if units_only(units).any? { |x| x[:unit].nil? }
       return if units.size == 1 && !units[0][:prefix]
+
       exp = units_only(units).map do |u|
         prefix = " prefix='#{u[:prefix]}'" if u[:prefix]
-        exponent = " powerNumerator='#{u[:exponent]}'" if u[:exponent] && u[:exponent] != "1"
-        "<EnumeratedRootUnit unit='#{@units[u[:unit]].name}'#{prefix}#{exponent}/>"
+        u[:exponent] && u[:exponent] != "1" and
+          arg = " powerNumerator='#{u[:exponent]}'"
+        "<EnumeratedRootUnit unit='#{@units[u[:unit]].name}'#{prefix}#{arg}/>"
       end.join("\n")
-      <<~END
-      <RootUnits>#{exp}</RootUnits>
-      END
+      <<~XML
+        <RootUnits>#{exp}</RootUnits>
+      XML
     end
   end
 end

data/lib/asciimath2unitsml/validate.rb

@@ -12,44 +12,46 @@ module Asciimath2UnitsML
       hash
     end
 
-    def validate_unit(v)
-      if v[:quantity_reference]
-        v[:quantity_reference].is_a?(Array) or
-          raise StandardError.new "No quantity_reference array provided for unit: #{v}"
+    def validate_unit(unit)
+      if unit[:quantity_reference]
+        unit[:quantity_reference].is_a?(Array) or
+          raise StandardError
+            .new "No quantity_reference array provided for unit: #{unit}"
       end
-      if v[:unit_name]
-        v[:unit_name].is_a?(Array) or
-          raise StandardError.new "No unit_name array provided for unit: #{v}"
+      if unit[:unit_name]
+        unit[:unit_name].is_a?(Array) or
+          raise StandardError
+            .new "No unit_name array provided for unit: #{unit}"
       end
     end
 
-    def validate_symbols(m, v)
-      symbol = symbol_key(v)
+    def validate_symbols(acc, val)
+      symbol = symbol_key(val)
       !symbol.nil? or
-        raise StandardError.new "No symbol provided for unit: #{v}"
+        raise StandardError.new "No symbol provided for unit: #{val}"
       Array(symbol)&.each do |s|
-        m[s] && s != "1" and
-          raise StandardError.new "symbol #{s} is not unique in #{v}: "\
-          "already used for #{m[s]}"
-        m[s] = v
+        acc[s] && s != "1" and
+          raise StandardError.new "symbol #{s} is not unique in #{val}: "\
+          "already used for #{acc[s]}"
+        acc[s] = val
       end
-      m 
+      acc
     end
 
-    def validate_unit_symbol_cardinality(us, k)
-      return true if us.nil?
+    def validate_unit_symbol_cardinality(sym, key)
+      return true if sym.nil?
 
-      !us[:id].nil? && !us[:ascii].nil? && !us[:html].nil? &&
-        !us[:mathml].nil? && !us[:latex].nil? &&
-        !us[:unicode].nil? and return true
-      raise StandardError.new "malformed unit_symbol for #{k}: #{us}"
+      !sym[:id].nil? && !sym[:ascii].nil? && !sym[:html].nil? &&
+        !sym[:mathml].nil? && !sym[:latex].nil? &&
+        !sym[:unicode].nil? and return true
+      raise StandardError.new "malformed unit_symbol for #{key}: #{sym}"
     end
 
-    def symbol_key(v)
-      symbol = v[:unit_symbols]&.each_with_object([]) do |s, m|
+    def symbol_key(val)
+      symbol = val[:unit_symbols]&.each_with_object([]) do |s, m|
         m << (s["id"] || s[:id])
-      end || v.dig(:symbol, :ascii) || v[:symbol] #|| v[:short]
-      !symbol.nil? && v[:unit_symbols] && !symbol.is_a?(Array) and
+      end || val.dig(:symbol, :ascii) || val[:symbol] # || val[:short]
+      !symbol.nil? && val[:unit_symbols] && !symbol.is_a?(Array) and
         symbol = [symbol]
       symbol
     end

data/lib/asciimath2unitsml/version.rb

@@ -1,3 +1,3 @@
 module Asciimath2UnitsML
-  VERSION = '0.3.2'.freeze
+  VERSION = "0.4.2".freeze
 end

data/lib/asciimath2unitsml.rb

@@ -1,4 +1,3 @@
 require_relative "asciimath2unitsml/version"
 require_relative "asciimath2unitsml/conv"
 require_relative "unitsdb_ruby/unitsdb"
-