asciimath2unitsml 0.3.0 → 0.4.0

data/lib/asciimath2unitsml/dimensions.rb

@@ -0,0 +1,117 @@
+module Asciimath2UnitsML
+  class Conv
+    def dimension_components(dims)
+      return if dims.nil? || dims.empty?
+
+      <<~XML
+        <Dimension xmlns='#{UNITSML_NS}' xml:id="#{dim_id(dims)}">
+        #{dims.map { |u| dimension1(u) }.join("\n")}
+        </Dimension>
+      XML
+    end
+
+    U2D = {
+      "m" => { dimension: "Length", order: 1, symbol: "L" },
+      "g" => { dimension: "Mass", order: 2, symbol: "M" },
+      "kg" => { dimension: "Mass", order: 2, symbol: "M" },
+      "s" => { dimension: "Time", order: 3, symbol: "T" },
+      "A" => { dimension: "ElectricCurrent", order: 4, symbol: "I" },
+      "K" => { dimension: "ThermodynamicTemperature", order: 5,
+               symbol: "Theta" },
+      "degK" => { dimension: "ThermodynamicTemperature", order: 5,
+                  symbol: "Theta" },
+      "mol" => { dimension: "AmountOfSubstance", order: 6, symbol: "N" },
+      "cd" => { dimension: "LuminousIntensity", order: 7, symbol: "J" },
+      "deg" => { dimension: "PlaneAngle", order: 8, symbol: "phi" },
+    }.freeze
+
+    Dim2D = {
+      "dim_L" => U2D["m"],
+      "dim_M" => U2D["g"],
+      "dim_T" => U2D["s"],
+      "dim_I" => U2D["A"],
+      "dim_Theta" => U2D["K"],
+      "dim_N" => U2D["mol"],
+      "dim_J" => U2D["cd"],
+      "dim_phi" => U2D["deg"],
+    }.freeze
+
+    def units2dimensions(units)
+      norm = decompose_units(units)
+      return units2dimensions_dim_input(norm) if norm[0][:dim]
+      return if norm.any? do |u|
+        u[:unit] == "unknown" || u[:prefix] == "unknown" || u[:unit].nil?
+      end
+
+      norm.map do |u|
+        { dimension: U2D[u[:unit]][:dimension],
+          unit: u[:unit],
+          exponent: u[:exponent] || 1,
+          symbol: U2D[u[:unit]][:symbol] }
+      end.sort { |a, b| U2D[a[:unit]][:order] <=> U2D[b[:unit]][:order] }
+    end
+
+    def units2dimensions_dim_input(norm)
+      norm.map do |u|
+        { dimension: Dim2D[u[:dim]][:dimension],
+          exponent: u[:exponent] || 1,
+          id: u[:dim],
+          symbol: Dim2D[u[:dim]][:symbol] }
+      end.sort { |a, b| Dim2D[a[:id]][:order] <=> Dim2D[b[:id]][:order] }
+    end
+
+    def dimension1(dim)
+      %(<#{dim[:dimension]} symbol="#{dim[:symbol]}"
+      powerNumerator="#{float_to_display(dim[:exponent])}"/>)
+    end
+
+    def dim_id(dims)
+      return nil if dims.nil? || dims.empty?
+
+      dimhash = dims.each_with_object({}) { |h, m| m[h[:dimension]] = h }
+      dimsvector = %w(Length Mass Time ElectricCurrent ThermodynamicTemperature
+                      AmountOfSubstance LuminousIntensity PlaneAngle)
+        .map { |h| dimhash.dig(h, :exponent) }.join(":")
+      id = @dimensions_id&.values&.select { |d| d.vector == dimsvector }
+        &.first&.id and return id.to_s
+      "D_" + dims.map do |d|
+        (U2D.dig(d[:unit], :symbol) || Dim2D.dig(d[:id], :symbol)) +
+          (d[:exponent] == 1 ? "" : float_to_display(d[:exponent]))
+      end.join("")
+    end
+
+    def decompose_units(units)
+      gather_units(units_only(units).map { |u| decompose_unit(u) }.flatten)
+    end
+
+    def dimid2dimensions(normtext)
+      @dimensions_id[normtext].keys.map do |k|
+        { dimension: k,
+          symbol: U2D.values.select { |v| v[:dimension] == k }.first[:symbol],
+          exponent: @dimensions_id[normtext].exponent(k) }
+      end
+    end
+
+    def dimension(normtext)
+      return unless @units[normtext]&.dimension
+
+      dims = dimid2dimensions(@units[normtext]&.dimension)
+      <<~XML
+        <Dimension xmlns='#{UNITSML_NS}' xml:id="#{@units[normtext]&.dimension}">
+        #{dims.map { |u| dimension1(u) }.join("\n")}
+        </Dimension>
+      XML
+    end
+
+    def unitsml(units, origtext, normtext, quantity, name)
+      dims = units2dimensions(units)
+      <<~XML
+        #{unit(units, origtext, normtext, dims, name)}
+        #{prefix(units)}
+        #{dimension(normtext)}
+        #{dimension_components(dims)}
+        #{quantity(normtext, quantity)}
+      XML
+    end
+  end
+end

data/lib/asciimath2unitsml/parse.rb

@@ -1,143 +1,111 @@
 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
-    end
-
-    def validate_yaml(hash, path)
-      return hash if path == "../unitsdb/quantities.yaml"
-      return hash if path == "../unitsdb/dimensions.yaml"
-      hash.each_with_object({}) do |(k, v), m|
-        path == "../unitsdb/units.yaml" and validate_unit(v)
-        m = validate_symbols(m, v)
-        v[:unit_symbols]&.each { |s| validate_unit_symbol_cardinality(s, k) }
-      end
-      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}"
-      end
-      if v[:unit_name]
-        v[:unit_name].is_a?(Array) or raise StandardError.new "No unit_name array provided for unit: #{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 validate_symbols(m, v)
-      symbol = symbol_key(v)
-      !symbol.nil? or raise StandardError.new "No symbol provided for unit: #{v}"
-      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
-      end
-      m 
-    end
-
-    def validate_unit_symbol_cardinality(us, k)
-      return true if us.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}"
-    end
-
-    def symbol_key(v)
-      symbol = v[:unit_symbols]&.each_with_object([]) { |s, m| m << (s["id"] || s[:id]) } || 
-        v.dig(:symbol, :ascii) || v[:symbol] #|| v[:short]
-      symbol = [symbol] if !symbol.nil? && v[:unit_symbols] && !symbol.is_a?(Array)
-      symbol
-    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) { |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] ) } } |
-        "1".r.map { |_| { prefix: nil, unit: "1", display_exponent: nil } } 
-      units = seq(prefix2, "-") { |x| [{ prefix: x[0], unit: nil, display_exponent: nil }] } |
+        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]) } } |
+        "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 }] } | # rubocop:disable Style/RedundantAssignment
         seq(prefix1, "-") { |x| [{ prefix: x[0], unit: nil, display_exponent: nil }] } |
-        unit.join(multiplier)
-      parser = units.eof
+        units1.join(multiplier)
+      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, 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)
-    end
-
-    def postprocess(units, text)
-      units = postprocess1(units)
-      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}"
+      postprocess(units, text, false)
+    end
+
+    def postprocess(units, text, is_units)
+      units = postprocess1(units.flatten)
+      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)
       inverse = false
-      units.each_with_object([]) do |u, m| 
+      units.each_with_object([]) do |u, m|
         if u[:multiplier]
-          inverse = (u[:multiplier] == "/")
+          inverse = !inverse if u[:multiplier] == "/"
         else
-          u[:exponent] = inverse ? "-#{u[:display_exponent] || '1'}" : u[:display_exponent]
+          u[:exponent] =
+            inverse ? "-#{u[:display_exponent] || '1'}" : u[:display_exponent]
           u[:exponent] = u[:exponent]&.sub(/^--+/, "")
         end
         m << u
@@ -149,36 +117,53 @@ 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)
-        x.replace("#{delimspace(rendering, x)}<mrow xref='#{unit_id(origtext)}'>#{rendering}</mrow>\n"\
+        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)}")
       end
       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
-      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>"
+      prec_text_elem =
+        elem.xpath("./preceding-sibling::*[namespace-uri() = '#{MATHML_NS}']/"\
+                   "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)
+      if /\p{L}|\p{N}/.match?(text)
+        "<mo rspace='thickmathspace'>&#x2062;</mo>"
+      else "<mo>&#x2062;</mo>"
+      end
     end
 
     def dedup_ids(xml)
       %w(Unit Dimension Prefix Quantity).each do |t|
-        xml.xpath(".//m:#{t}/@xml:id", "m" => UNITSML_NS).map { |a| a.text }.uniq.each do |v|
+        xml.xpath(".//m:#{t}/@xml:id", "m" => UNITSML_NS).map(&:text)
+          .uniq.each do |v|
           xml.xpath(".//*[@xml:id = '#{v}']").each_with_index do |n, i|
-            next if i == 0
+            next if i.zero?
+
             n.remove
           end
         end
@@ -187,45 +172,50 @@ 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)
       x = Nokogiri::XML(mathml)
-      x.xpath(".//m:mi", "m" => MATHML_NS).each { |mi| mi["mathvariant"] = "normal" }
+      x.xpath(".//m:mi", "m" => MATHML_NS)
+        .each { |mi| mi["mathvariant"] = "normal" }
       x.children.to_xml
     end
 
     def ambig_units
-      u = @units_id.each_with_object({}) do |(k, v), m|
+      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]] ||= []
           m[v.symbols_hash[x][:html]] << x
         end
       end
-      u.keys.each { |k| u[k] = u[k].unshift(k) if @symbols.dig(k, :html) == k }
+      u.each_key { |k| u[k] = u[k].unshift(k) if @symbols.dig(k, :html) == k }
       render_ambig_units(u)
     end
 
     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 { |v1| v1.size }.each { |v1| print "| #{@units[v1].name}: `#{v1}` " }
-        puts "#{"| " * (maxcols - u[k].size) }\n"
+        u[k].sort_by(&:size).each { |v1| print "| #{@units[v1].name}: `#{v1}` " }
+        puts "#{'| ' * (maxcols - u[k].size)}\n"
       end
       puts "|===\n"
     end
 
-    def html2adoc(k)
-      k.gsub(%r{<i>}, "__").gsub(%r{</i>}, "__")
+    def html2adoc(elem)
+      elem.gsub(%r{<i>}, "__").gsub(%r{</i>}, "__")
         .gsub(%r{<sup>}, "^").gsub(%r{</sup>}, "^")
         .gsub(%r{<sub>}, "~").gsub(%r{</sub>}, "~")
     end