asciimath2unitsml 0.2.3 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 161503157f4b3622c8bcae6ece418ed5f675a95f409d60017287017c923f7749
-  data.tar.gz: 48571d4a30ea4ade2f864178dcb473c9a636d71d5088b64a2356e3cbfa5f2886
+  metadata.gz: f51b82e234fddaf66252f77a276a3acf68dae4356502a3c900253f5d4d4dffcf
+  data.tar.gz: 59dd18f009952329c1c07af2132ec06123c06dd3caea4ee7f22f17c0f4ec1cbc
 SHA512:
-  metadata.gz: a50f75b036f2a19dcd1925965f192d1652ddabc242ce22c33efcfaf0d03c0ee5118c46021f22ee02237f93e5e32492c922466fd7f3206a20713c7a2bf749e6ef
-  data.tar.gz: 279f88fb13d2ed6961b42fec192312b52b82d993daf4efa2750de21b2e240b2b63702d82dac831e4dc3a0b86bd6b797cbbca057809d4c971eb27bf71548f9010
+  metadata.gz: 9a925e3db85d3086d676c07c101609e87674d620394f5fa0a536ab3652f3aa9c0cc6a74507d79264e0154bf51ea4121d47b7275a94212bc934b822b0392a9970
+  data.tar.gz: 59d98ebd629a20e8f03dc32a1870474e5808b9d38f51a87feec5eae9f0746535bed9dcf38b1faf3939319bb3989b1d926088e8d834388e48f045070e3749312a

data/.gitignore

@@ -0,0 +1 @@
+.rubocop-https--*

data/.rubocop.yml

@@ -0,0 +1,14 @@
+# This project follows the Ribose OSS style guide.
+# https://github.com/riboseinc/oss-guides
+# All project-specific additions and overrides should be specified in this file.
+inherit_from:
+  - https://raw.githubusercontent.com/riboseinc/oss-guides/master/ci/rubocop.yml
+
+# local repo-specific modifications
+
+AllCops:
+  DisplayCopNames: false
+  StyleGuideCopsOnly: false
+  TargetRubyVersion: 2.4
+Rails:
+  Enabled: true

data/README.adoc

@@ -53,6 +53,8 @@ from UnitsDB. For example, `unitsml(cal_th/cm^2, name: langley)`.
 The unit-string gives the canonical representation of the unit, but SYMBOL is what will be rendered.
 For example, `unitsml(cal_th/cm^2, name: langley, symbol: La)`, or `unitsml(mm*s^-2, symbol: mm cdot s^-2)`.
 (All variables in SYMBOL are rendered upright, as is the default for units.)
+* `unitsml(unit-string, multiplier: SYMBOL)` provides an alternate symbol for the multiliper of
+units. The options are an XML entity, or the values `space` or `nospace` (for which see discussion under _Usage_).
 
 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").
@@ -230,7 +232,7 @@ This table can be generated (in Asciidoc format) through `Asciimath2UnitsML::Con
 | ton | ton of TNT (energy equivalent): `ton_TNT` | ton of refrigeration (12 000 Btu_IT/h): `ton_refrigeration` | | | | 
 | tsp | teaspoon: `tsp` | teaspoon (FDA): `tsp_label` | | | | 
 | yd | yard: `yd` | yard (based on US survey foot): `yd_US_survey` | | | | 
-| º | degree (degree of arc): `deg` | | | | | 
+| ° | degree (degree of arc): `deg` | | | | | 
 | γ | gamma: `gamma` | | | | | 
 | μ | micron: `micron` | | | | | 
 | Ω | ohm: `Ohm` | | | | | 
@@ -258,3 +260,4 @@ This table can be generated (in Asciidoc format) through `Asciimath2UnitsML::Con
 | °R | degree Rankine: `degR` | | | | | 
 | ƛ~C~ | natural unit of length: `lambda-bar_C` | | | | | 
 |===
+

data/asciimath2unitsml.gemspec

@@ -57,7 +57,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "guard-rspec", "~> 4.7"
   spec.add_development_dependency "rake", "~> 12.0"
   spec.add_development_dependency "rspec", "~> 3.6"
-  spec.add_development_dependency "rubocop", "= 0.54.0"
+  spec.add_development_dependency "rubocop", "~> 1.5.2"
   spec.add_development_dependency "simplecov", "~> 0.15"
   spec.add_development_dependency "timecop", "~> 0.9"
   spec.add_development_dependency "rexml"

data/lib/asciimath2unitsml/conv.rb

@@ -7,70 +7,78 @@ require_relative "string"
 require_relative "parse"
 require_relative "render"
 require_relative "unit"
+require_relative "validate"
 
 module Asciimath2UnitsML
   MATHML_NS = "http://www.w3.org/1998/Math/MathML".freeze
-  UNITSML_NS = "http://unitsml.nist.gov/2005".freeze
+  UNITSML_NS = "https://schema.unitsml.org/unitsml/1.0".freeze
 
   class Conv
     def initialize(options = {})
-      @dimensions_id = read_yaml("../unitsdb/dimensions.yaml").each_with_object({}) do |(k, v), m|
+      @dimensions_id = read_yaml("../unitsdb/dimensions.yaml")
+        .each_with_object({}) do |(k, v), m|
         m[k.to_s] = UnitsDB::Dimension.new(k, v)
       end
-      @prefixes_id = read_yaml("../unitsdb/prefixes.yaml").each_with_object({}) do |(k, v), m|
+      @prefixes_id = read_yaml("../unitsdb/prefixes.yaml")
+        .each_with_object({}) do |(k, v), m|
         m[k] = UnitsDB::Prefix.new(k, v)
       end
       @prefixes = flip_name_and_symbol(@prefixes_id)
-      @quantities = read_yaml("../unitsdb/quantities.yaml").each_with_object({}) do |(k, v), m|
+      @quantities = read_yaml("../unitsdb/quantities.yaml")
+        .each_with_object({}) do |(k, v), m|
         m[k.to_s] = UnitsDB::Quantity.new(k, v)
       end
-      @units_id = read_yaml("../unitsdb/units.yaml").each_with_object({}) do |(k, v), m|
+      @units_id = read_yaml("../unitsdb/units.yaml")
+        .each_with_object({}) do |(k, v), m|
         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.each_with_object({}) do |(_k, v), m|
         v.symbolids.each { |x| m[x] = v.symbols_hash[x] }
       end
       @parser = parser
-      @multiplier = multiplier(options[:multiplier] || "\u00b7")
+      @multiplier = multiplier(options[:multiplier] || "\u22c5")
     end
 
-    def float_to_display(f)
-      ret = f.to_f.round(1).to_s.sub(/\.0$/, "")
+    def float_to_display(float)
+      float.to_f.round(1).to_s.sub(/\.0$/, "")
     end
 
     def prefix(units)
-      units.map { |u| u[:prefix] }.reject { |u| u.nil? }.uniq.map do |p|
+      units.map { |u| u[:prefix] }.reject(&:nil?).uniq.map do |p|
         <<~END
-        <Prefix xmlns='#{UNITSML_NS}' prefixBase='#{@prefixes[p].base}'
-                prefixPower='#{@prefixes[p].power}' xml:id='#{@prefixes[p].id}'>
-          <PrefixName xml:lang="en">#{@prefixes[p].name}</PrefixName>
-          <PrefixSymbol type="ASCII">#{@prefixes[p].ascii}</PrefixSymbol>
-          <PrefixSymbol type="unicode">#{@prefixes[p].unicode}</PrefixSymbol>
-          <PrefixSymbol type="LaTeX">#{@prefixes[p].latex}</PrefixSymbol>
-          <PrefixSymbol type="HTML">#{htmlent @prefixes[p].html}</PrefixSymbol>
-        </Prefix>
+          <Prefix xmlns='#{UNITSML_NS}' prefixBase='#{@prefixes[p].base}'
+                  prefixPower='#{@prefixes[p].power}' xml:id='#{@prefixes[p].id}'>
+            <PrefixName xml:lang="en">#{@prefixes[p].name}</PrefixName>
+            <PrefixSymbol type="ASCII">#{@prefixes[p].ascii}</PrefixSymbol>
+            <PrefixSymbol type="unicode">#{@prefixes[p].unicode}</PrefixSymbol>
+            <PrefixSymbol type="LaTeX">#{@prefixes[p].latex}</PrefixSymbol>
+            <PrefixSymbol type="HTML">#{htmlent @prefixes[p].html}</PrefixSymbol>
+          </Prefix>
         END
       end.join("\n")
     end
 
     def dimension_components(dims)
       return if dims.nil? || dims.empty?
+
       <<~END
-      <Dimension xmlns='#{UNITSML_NS}' xml:id="#{dim_id(dims)}">
-      #{dims.map { |u| dimension1(u) }.join("\n") }
-      </Dimension>
+        <Dimension xmlns='#{UNITSML_NS}' xml:id="#{dim_id(dims)}">
+        #{dims.map { |u| dimension1(u) }.join("\n")}
+        </Dimension>
       END
     end
 
-        U2D = {
+    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" },
+      "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" },
@@ -78,28 +86,35 @@ module Asciimath2UnitsML
 
     def units2dimensions(units)
       norm = decompose_units(units)
-      return if norm.any? { |u| u[:unit] == "unknown" || u[:prefix] == "unknown" || u[:unit].nil? }
+      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] } 
+          symbol: U2D[u[:unit]][:symbol] }
       end.sort { |a, b| U2D[a[:unit]][:order] <=> U2D[b[:unit]][:order] }
     end
 
     def dimension1(u)
-      %(<#{u[:dimension]} symbol="#{u[:symbol]}" powerNumerator="#{float_to_display(u[:exponent])}"/>)
+      %(<#{u[:dimension]} symbol="#{u[:symbol]}"
+      powerNumerator="#{float_to_display(u[: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 
+      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
+      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]))
+        U2D[d[:unit]][:symbol] +
+          (d[:exponent] == 1 ? "" : float_to_display(d[:exponent]))
       end.join("")
     end
 
@@ -108,12 +123,17 @@ module Asciimath2UnitsML
     end
 
     def gather_units(units)
-      units.sort { |a, b| a[:unit] <=> b[:unit] }.each_with_object([]) do |k, m|
+      units.sort_by { |a| a[:unit] }.each_with_object([]) do |k, m|
         if m.empty? || m[-1][:unit] != k[:unit] then m << k
         else
-          m[-1] = { prefix: combine_prefixes(@prefixes[m[-1][:prefix]], @prefixes[k[:prefix]]),
-                    unit: m[-1][:unit],
-                    exponent: (k[:exponent]&.to_f || 1) + (m[-1][:exponent]&.to_f || 1) }
+          m[-1] = {
+            prefix: combine_prefixes(
+              @prefixes[m[-1][:prefix]], @prefixes[k[:prefix]]
+            ),
+            unit: m[-1][:unit],
+            exponent: (k[:exponent]&.to_f || 1) +
+              (m[-1][:exponent]&.to_f || 1),
+          }
         end
       end
     end
@@ -128,8 +148,13 @@ module Asciimath2UnitsML
         { prefix: u[:prefix], unit: "unknown", exponent: u[:exponent] }
       else
         @units[u[:unit]].si_derived_bases.each_with_object([]) do |k, m|
-          m << { prefix: !k[:prefix].nil? && !k[:prefix].empty? ? 
-                 combine_prefixes(@prefixes_id[k[:prefix]], @prefixes[u[:prefix]]) : u[:prefix],
+          prefix = if !k[:prefix].nil? && !k[:prefix].empty?
+                     combine_prefixes(@prefixes_id[k[:prefix]],
+                                      @prefixes[u[:prefix]])
+                   else
+                     u[:prefix]
+                   end
+          m << { prefix: prefix,
                  unit: @units_id[k[:id]].symbolid,
                  exponent: (k[:power]&.to_i || 1) * (u[:exponent]&.to_f || 1) }
         end
@@ -141,6 +166,7 @@ module Asciimath2UnitsML
       return p1.symbolid if p2.nil?
       return p2.symbolid if p1.nil?
       return "unknown" if p1.base != p2.base
+
       @prefixes.each do |_, p|
         return p.symbolid if p.base == p1.base && p.power == p1.power + p2.power
       end
@@ -156,13 +182,16 @@ module Asciimath2UnitsML
     end
 
     def quantity(normtext, quantity)
-      return unless @units[normtext] && @units[normtext].quantities.size == 1 || @quantities[quantity]
+      return unless @units[normtext] && @units[normtext].quantities.size == 1 ||
+        @quantities[quantity]
+
       id = quantity || @units[normtext].quantities.first
-      dim = %( dimensionURL="##{@units[normtext].dimension}") if @units[normtext]&.dimension
+      @units[normtext]&.dimension and
+        dim = %( dimensionURL="##{@units[normtext].dimension}")
       <<~END
-      <Quantity xmlns='#{UNITSML_NS}' xml:id="#{id}"#{dim} quantityType="base">
-      #{quantityname(id)}
-      </Quantity>
+        <Quantity xmlns='#{UNITSML_NS}' xml:id="#{id}"#{dim} quantityType="base">
+        #{quantityname(id)}
+        </Quantity>
       END
     end
 
@@ -175,23 +204,24 @@ module Asciimath2UnitsML
     end
 
     def dimension(normtext)
-      return unless @units[normtext]&.dimension 
+      return unless @units[normtext]&.dimension
+
       dims = dimid2dimensions(@units[normtext]&.dimension)
       <<~END
-      <Dimension xmlns='#{UNITSML_NS}' xml:id="#{@units[normtext]&.dimension}">
-      #{dims.map { |u| dimension1(u) }.join("\n") }
-      </Dimension>
+        <Dimension xmlns='#{UNITSML_NS}' xml:id="#{@units[normtext]&.dimension}">
+        #{dims.map { |u| dimension1(u) }.join("\n")}
+        </Dimension>
       END
     end
 
     def unitsml(units, origtext, normtext, quantity, name)
       dims = units2dimensions(units)
       <<~END
-      #{unit(units, origtext, normtext, dims, name)}
-      #{prefix(units)}
-      #{dimension(normtext)}
-      #{dimension_components(dims)}
-      #{quantity(normtext, quantity)}
+        #{unit(units, origtext, normtext, dims, name)}
+        #{prefix(units)}
+        #{dimension(normtext)}
+        #{dimension_components(dims)}
+        #{quantity(normtext, quantity)}
       END
     end
   end

data/lib/asciimath2unitsml/parse.rb

@@ -3,71 +3,29 @@ module Asciimath2UnitsML
     include Rsec::Helpers
 
     def read_yaml(path)
-      validate_yaml(symbolize_keys(YAML.load_file(File.join(File.join(File.dirname(__FILE__), path)))), 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|
+      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|
+      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
-    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
+        v.symbolids.each { |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
@@ -97,14 +55,15 @@ module Asciimath2UnitsML
         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 } } 
+        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 }] } |
         seq(prefix1, "-") { |x| [{ prefix: x[0], unit: nil, display_exponent: nil }] } |
-        unit.join(multiplier)
+        units1.join(multiplier)
       parser = units.eof
     end
 
@@ -114,29 +73,32 @@ module Asciimath2UnitsML
       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)
+      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}"
       end.join("*")
-      [units, text[0], normtext, quantity, name, symbol]
+      [units, text[0], normtext, quantity, name, symbol, multiplier]
     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
@@ -153,27 +115,39 @@ module Asciimath2UnitsML
       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)
+
         text = x.text.sub(%r{^unitsml\((.+)\)$}m, "\\1")
-        units, origtext, normtext, quantity, name, symbol = parse(text)
-        rendering = symbol ? embeddedmathml(asciimath2mathml(symbol)) : mathmlsymbol(units, false)
-        delim = x&.previous_element ? delimspace(rendering) : ""
-        x.replace("#{delim}<mrow xref='#{unit_id(origtext)}'>#{rendering}</mrow>\n"\
+        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"\
                   "#{unitsml(units, origtext, normtext, quantity, name)}")
       end
       dedup_ids(xml)
     end
 
-    def delimspace(x)
-      text = HTMLEntities.new.encode(Nokogiri::XML("<mrow>#{x}</mrow>").text.strip)
-      /[[:alnum:]]/.match(text) ?
+    # 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>"
     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
@@ -183,26 +157,28 @@ module Asciimath2UnitsML
 
     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.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 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
 
@@ -211,16 +187,17 @@ 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 { |a| [-u[a].size, a.gsub(%r{\&[^;]+;}, "")
+        .gsub(/[^A-Za-z]/, "").downcase] }.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