asciimath2unitsml 0.3.3 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 829d573c90a88f5d26b2310d69f5ea575084df208cd3f441342435b0a6a3d353
-  data.tar.gz: 534c2ea7485b1de1c126de112a1ad8c9b10683797034e99313fda199c5f7e572
+  metadata.gz: b4d619489e5063d9e3616163d69c6c1f4796615412ee40f0a92f356603f0e366
+  data.tar.gz: 0465ac8a99f8929d1d4f8f2db152821e4d1fae7ac66af1a8a3e2feb6092e0c3a
 SHA512:
-  metadata.gz: c6eec2cb24fff7931d236a9a14a6d4ae1a938fe348d1e1d02a4d2f9be8e7f72e124e633ef0ef4b0f1e476ee8a2dee900210e60010600e0b082eb95237d2c70d2
-  data.tar.gz: e6943596be90a3bd1e6336b7bfa395cee4aa41e88ab6e5b2d003216a2271fc72249a018218d65c4ef446f4d246412e2b9fa0ac0d9721095abd4d9baa95515389
+  metadata.gz: 3de256a40d7eb24439409664a8b7bb14f1893403a4cfc762b70bd9693a15c0304766a7d20491de4094571fd5b117695350a5ad56100cf67bde1e7c61c4e99004
+  data.tar.gz: 4f053e85ff192f040856d0f63ff2d1ffb7a49eb72735f668785a3396e82ff145b8d678d754b8a26b26deee4c3072de4f8af8686f7ee60cb9e339dfe3f7be08c3

data/.github/workflows/rake.yml

@@ -16,7 +16,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: [ '3.0', '2.7', '2.6', '2.5', '2.4' ]
+        ruby: [ '3.0', '2.7', '2.6', '2.5' ]
         os: [ ubuntu-latest, windows-latest, macos-latest ]
         experimental: [ false ]
     steps:

data/.rubocop.yml

@@ -7,4 +7,4 @@ inherit_from:
 # ...
 
 AllCops:
-  TargetRubyVersion: 2.4
+  TargetRubyVersion: 2.5

data/README.adoc

@@ -59,6 +59,24 @@ units. The options are an XML entity, or the values `space` or `nospace` (for wh
 Standalone prefixes can be recognised by replacing the unit with hyphen; so `unitsml(p-)` corresponds
 to the standalone prefix "pico" (and is rendered as "p").
 
+The gem also supports fundamental units, e.g. `unitsml(e)` for the atomic unit of charge, _e_,
+and symbols for dimensions. The latter are entered as `dim_XXX`, where `XXX` is their established symbol:
+
+|===
+|Symbol | Dimension
+
+|dim_L | Length
+|dim_M | Mass
+|dim_T | Time
+|dim_I | Electric Current
+|dim_Theta | Thermodynamic Temperature
+|dim_N | Amount of Substance
+|dim_J | Luminous Intensity
+|dim_phi | Plane Angle (dimensionless)
+|===
+
+e.g. `unitsml(dim_I)` for the dimension of electric current, 𝖨.
+
 == Rendering
 
 The output of the gem is MathML, with MathML unit expressions (expressed as `<mi>`, 
@@ -141,7 +159,7 @@ The converter is run as:
 [source,ruby]
 ----
 c = Asciimath2UnitsML::Conv.new()
-c.Asciimath2UnitsML(1 "unitsml(mm*s^-2)") # AsciiMath string containing UnitsML
+c.Asciimath2UnitsML('1 "unitsml(mm*s^-2)"') # AsciiMath string containing UnitsML
 c.MathML2UnitsML("<math xmlns='http://www.w3.org/1998/Math/MathML'><mn>7</mn>"\
   "<mtext>unitsml(kg^-2)</mtext></math>") # AsciiMath string containing <mtext>unitsml()</mtext>
 c.MathML2UnitsML(Nokogiri::XML("<math xmlns='http://www.w3.org/1998/Math/MathML'><mn>7</mn>"\

data/asciimath2unitsml.gemspec

@@ -22,7 +22,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
   spec.files         = `git ls-files`.split("\n")
   spec.test_files    = `git ls-files -- {spec}/*`.split("\n")
-  spec.required_ruby_version = Gem::Requirement.new(">= 2.4.0")
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.5.0")
 
   # get an array of submodule dirs relatively to root repo
   `git config --file .gitmodules --get-regexp '\\.path$'`

data/lib/asciimath2unitsml/conv.rb

@@ -3,6 +3,8 @@ require "nokogiri"
 require "htmlentities"
 require "yaml"
 require "rsec"
+require_relative "read"
+require_relative "dimensions"
 require_relative "string"
 require_relative "parse"
 require_relative "render"
@@ -19,6 +21,7 @@ module Asciimath2UnitsML
         .each_with_object({}) do |(k, v), m|
         m[k.to_s] = UnitsDB::Dimension.new(k, v)
       end
+      @dimensions = flip_name_and_symbols(@dimensions_id)
       @prefixes_id = read_yaml("../unitsdb/prefixes.yaml")
         .each_with_object({}) do |(k, v), m|
         m[k] = UnitsDB::Prefix.new(k, v)
@@ -33,10 +36,10 @@ module Asciimath2UnitsML
         m[k.to_s] = UnitsDB::Unit.new(k.to_s, v)
       end
       @units = flip_name_and_symbols(@units_id)
-      @symbols = @units.each_with_object({}) do |(_k, v), m|
+      @symbols = @units.merge(@dimensions).each_with_object({}) do |(_k, v), m|
         v.symbolids.each { |x| m[x] = v.symbols_hash[x] }
       end
-      @parser = parser
+      @parser, @dim_parser = parsers
       @multiplier = multiplier(options[:multiplier] || "\u22c5")
     end
 
@@ -59,70 +62,17 @@ module Asciimath2UnitsML
       end.join("\n")
     end
 
-    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
-
-    def units2dimensions(units)
-      norm = decompose_units(units)
-      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 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[d[:unit]][: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 gather_units(units)
+      if units[0][:dim] then gather_dimensions(units)
+      else gather_units1(units)
+      end
+    end
+
+    def gather_units1(units)
       units.sort_by { |a| a[:unit] }.each_with_object([]) do |k, m|
         if m.empty? || m[-1][:unit] != k[:unit] then m << k
         else
@@ -138,12 +88,24 @@ module Asciimath2UnitsML
       end
     end
 
+    def gather_dimensions(units)
+      units.sort_by { |a| a[:dim] }.each_with_object([]) do |k, m| 
+        if m.empty? || m[-1][:dim] != k[:dim] then m << k
+        else
+          m[-1] = {
+            dim: m[-1][:dim],
+            exponent: (k[:exponent]&.to_f || 1) +
+              (m[-1][:exponent]&.to_f || 1),
+          }
+        end
+      end
+    end
+
     # treat g not kg as base unit: we have stripped the prefix k in parsing
     # reduce units down to basic units
     def decompose_unit(u)
-      if u[:unit].nil? then u
-      elsif u[:unit] == "g" then u
-      elsif @units[u[:unit]].system_type == "SI_base" then u
+      if u[:unit].nil? || u[:unit] == "g" ||
+          @units[u[:unit]].system_type == "SI_base" then u
       elsif !@units[u[:unit]].si_derived_bases
         { prefix: u[:prefix], unit: "unknown", exponent: u[:exponent] }
       else
@@ -195,25 +157,6 @@ module Asciimath2UnitsML
       XML
     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

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,102 +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(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 do |x|
-        /^quantity:/.match(x)
-      end&.first&.sub(/^quantity:\s*/, "")
-      name = text[1..-1]&.select do |x|
-        /^name:/.match(x)
-      end&.first&.sub(/^name:\s*/, "")
-      symbol = text[1..-1]&.select do |x|
-        /^symbol:/.match(x)
-      end&.first&.sub(/^symbol:\s*/, "")
-      multiplier = text[1..-1]&.select do |x|
-        /^multiplier:/.match(x)
-      end&.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)
@@ -128,8 +127,11 @@ module Asciimath2UnitsML
         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)
+        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)}")
@@ -149,8 +151,10 @@ module Asciimath2UnitsML
 
       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)
@@ -168,8 +172,8 @@ module Asciimath2UnitsML
     end
 
     def asciimath2mathml(expression)
-      AsciiMath::MathMLBuilder.new(:msword => true).append_expression(
-        AsciiMath.parse(HTMLEntities.new.decode(expression)).ast
+      AsciiMath::MathMLBuilder.new(msword: true).append_expression(
+        AsciiMath.parse(HTMLEntities.new.decode(expression)).ast,
       ).to_s.gsub(/<math>/, "<math xmlns='#{MATHML_NS}'>")
     end
 
@@ -183,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]] ||= []
@@ -199,8 +203,10 @@ module Asciimath2UnitsML
       u.each { |_, v| maxcols = v.size if maxcols < v.size }
       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"