asciimath2unitsml 0.3.3 → 0.4.0

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,14 +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
 
@@ -33,14 +33,14 @@ module Asciimath2UnitsML
             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
@@ -56,18 +56,29 @@ module Asciimath2UnitsML
         else
           mathmlsymbol1(u, normalise)
         end
-      end.join("")
+      end.join
     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(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_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(unit, base)

data/lib/asciimath2unitsml/unit.rb

@@ -7,16 +7,16 @@ 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)
       <<~XML
-        <Unit xmlns='#{UNITSML_NS}' xml:id='#{unit_id(normtext)}'#{dimid ? " dimensionURL='##{dimid}'" : ""}>
+        <Unit xmlns='#{UNITSML_NS}' xml:id='#{unit_id(normtext)}'#{dimid ? " dimensionURL='##{dimid}'" : ''}>
         #{unitsystem(units)}
         #{unitname(norm_units, normtext, name)}
         #{unitsymbol(norm_units)}
@@ -43,8 +43,10 @@ module Asciimath2UnitsML
       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"
+        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")
@@ -56,7 +58,7 @@ module Asciimath2UnitsML
     end
 
     # TODO: compose name from the component units
-    def compose_name(units, text)
+    def compose_name(_units, text)
       text
     end
 
@@ -74,8 +76,8 @@ module Asciimath2UnitsML
       exp = units_only(units).map do |u|
         prefix = " prefix='#{u[:prefix]}'" if u[:prefix]
         u[:exponent] && u[:exponent] != "1" and
-          exponent = " powerNumerator='#{u[:exponent]}'"
-        "<EnumeratedRootUnit unit='#{@units[u[:unit]].name}'#{prefix}#{exponent}/>"
+          arg = " powerNumerator='#{u[:exponent]}'"
+        "<EnumeratedRootUnit unit='#{@units[u[:unit]].name}'#{prefix}#{arg}/>"
       end.join("\n")
       <<~XML
         <RootUnits>#{exp}</RootUnits>

data/lib/asciimath2unitsml/validate.rb

@@ -15,41 +15,43 @@ module Asciimath2UnitsML
     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}"
+          raise StandardError
+            .new "No quantity_reference array provided for unit: #{unit}"
       end
       if unit[:unit_name]
         unit[:unit_name].is_a?(Array) or
-          raise StandardError.new "No unit_name array provided for unit: #{unit}"
+          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(sym, k)
+    def validate_unit_symbol_cardinality(sym, key)
       return true if sym.nil?
 
       !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 #{k}: #{sym}"
+      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.3".freeze
+  VERSION = "0.4.0".freeze
 end

data/lib/unitsdb/dimensions.yaml

@@ -3,36 +3,86 @@ NISTd1:
   length:
     powerNumerator: 1
     symbol: L
+    dim_symbols:
+    - id: "dim_L"
+      ascii: "L"
+      html: "𝖫"
+      mathml: "<mi mathvariant='sans-serif'>L</mi>"
+      latex: \ensuremath{\mathsf{L}}
+      unicode: "𝖫"
+
 
 NISTd2:
   mass:
     powerNumerator: 1
     symbol: M
+    dim_symbols:
+    - id: "dim_M"
+      ascii: "M"
+      html: "&#x1D5AC;"
+      mathml: "<mi mathvariant='sans-serif'>M</mi>"
+      latex: \ensuremath{\mathsf{M}}
+      unicode: "𝖬"
 
 NISTd3:
   time:
     powerNumerator: 1
     symbol: T
+    dim_symbols:
+    - id: "dim_T"
+      ascii: "T"
+      html: "&#x1D5B3;"
+      mathml: "<mi mathvariant='sans-serif'>T</mi>"
+      latex: \ensuremath{\mathsf{T}}
+      unicode: "𝖳"
 
 NISTd4:
   electric_current:
     powerNumerator: 1
     symbol: I
+    dim_symbols:
+    - id: "dim_T"
+      ascii: "T"
+      html: "&#x1D5A8;"
+      mathml: "<mi mathvariant='sans-serif'>T</mi>"
+      latex: \ensuremath{\mathsf{T}}
+      unicode: "𝖨"
 
 NISTd5:
   thermodynamic_temperature:
     powerNumerator: 1
-    symbol:
+    symbol: Theta
+    dim_symbols:
+    - id: "dim_Theta"
+      ascii: "Theta"
+      html: "&#x1D760;"
+      mathml: "<mi mathvariant='sans-serif'>&#x398;</mi>"
+      latex: \ensuremath{\mathsf{\Theta}}
+      unicode: "𝝧"
 
 NISTd6:
   amount_of_substance:
     powerNumerator: 1
     symbol: N
+    dim_symbols:
+    - id: "dim_N"
+      ascii: "N"
+      html: "&#x1D5AD;"
+      mathml: "<mi mathvariant='sans-serif'>N</mi>"
+      latex: \ensuremath{\mathsf{N}}
+      unicode: "𝖭"
 
 NISTd7:
   luminous_intensity:
     powerNumerator: 1
     symbol: J
+    dim_symbols:
+    - id: "dim_J"
+      ascii: "J"
+      html: "&#x1D5A9;"
+      mathml: "<mi mathvariant='sans-serif'>J</mi>"
+      latex: \ensuremath{\mathsf{J}}
+      unicode: "𝖩"
 
 NISTd8:
   length:
@@ -44,6 +94,13 @@ NISTd9:
   plane_angle:
     powerNumerator: 1
     symbol: phi
+    dim_symbols:
+    - id: "dim_phi"
+      ascii: "phi"
+      html: "&#x1D785;"
+      mathml: "<mi mathvariant='sans-serif'>&#x3c6;</mi>"
+      latex: \ensuremath{\mathsf{\phi}}
+      unicode: "𝞅"
 
 NISTd10:
   length:
@@ -312,7 +369,7 @@ NISTd39:
     symbol: T
   thermodynamic_temperature:
     powerNumerator: -1
-    symbol:
+    symbol: Theta
 
 NISTd36:
   length:
@@ -367,7 +424,7 @@ NISTd40:
     symbol: T
   thermodynamic_temperature:
     powerNumerator: -1
-    symbol:
+    symbol: Theta
 
 NISTd41:
   length:
@@ -381,7 +438,7 @@ NISTd41:
     symbol: T
   thermodynamic_temperature:
     powerNumerator: -1
-    symbol:
+    symbol: Theta
 
 NISTd46:
   length:
@@ -475,7 +532,7 @@ NISTd48:
     symbol: T
   thermodynamic_temperature:
     powerNumerator: -1
-    symbol:
+    symbol: Theta
   amount_of_substance:
     powerNumerator: -1
     symbol: N
@@ -603,7 +660,7 @@ NISTd60:
 NISTd68:
   thermodynamic_temperature:
     powerNumerator: -1
-    symbol:
+    symbol: Theta
 
 NISTd69:
   length:
@@ -617,7 +674,7 @@ NISTd69:
     symbol: T
   thermodynamic_temperature:
     powerNumerator: -1
-    symbol:
+    symbol: Theta
 
 NISTd70:
   length:
@@ -639,7 +696,7 @@ NISTd71:
     symbol: T
   thermodynamic_temperature:
     powerNumerator: -1
-    symbol:
+    symbol: Theta
 
 NISTd64:
   dimensionless: true

data/lib/unitsdb_ruby/unitsdb.rb

@@ -1,29 +1,49 @@
 module UnitsDB
   class Dimension
-    attr_reader :id, :length, :mass, :time, :electric_current,
-      :thermodynamic_temperature,
-      :amount_of_substance, :luminous_intensity, :plane_angle, :dimensionless
+    attr_reader :id, :name, :symbols, :symbols_hash,
+                :length, :mass, :time, :electric_current,
+                :thermodynamic_temperature,
+                :amount_of_substance, :luminous_intensity, :plane_angle,
+                :dimensionless
 
     def initialize(id, hash)
-      begin
-        @id = id
-        @dimensionless = hash[:dimensionless]
-        hash[:length] and @length = hash[:length][:powerNumerator].to_i
-        hash[:mass] and @mass = hash[:mass][:powerNumerator].to_i
-        hash[:time] and @time = hash[:time][:powerNumerator].to_i
-        hash[:electric_current] and
-          @electric_current = hash[:electric_current][:powerNumerator].to_i
-        hash[:thermodynamic_temperature] and
-          @thermodynamic_temperature = hash[:thermodynamic_temperature][:powerNumerator].to_i
-        hash[:amount_of_substance] and
-          @amount_of_substance = hash[:amount_of_substance][:powerNumerator].to_i
-        hash[:luminous_intensity] and
-          @luminous_intensity = hash[:luminous_intensity][:powerNumerator].to_i
-        hash[:plane_angle] and
-          @plane_angle = hash[:plane_angle][:powerNumerator].to_i
-      rescue
-        raise StandardError.new "Parse fail on Dimension #{id}: #{hash}"
+      @id = id
+      @dimensionless = hash[:dimensionless]
+      init_dimension(hash)
+      name_dimension(hash)
+    rescue StandardError
+      raise StandardError.new "Parse fail on Dimension #{id}: #{hash}"
+    end
+
+    def init_dimension(hash)
+      hash[:length] and @length = hash[:length][:powerNumerator].to_i
+      hash[:mass] and @mass = hash[:mass][:powerNumerator].to_i
+      hash[:time] and @time = hash[:time][:powerNumerator].to_i
+      hash[:electric_current] and
+        @electric_current = hash[:electric_current][:powerNumerator].to_i
+      hash[:thermodynamic_temperature] and
+        @thermodynamic_temperature = hash[:thermodynamic_temperature][:powerNumerator].to_i
+      hash[:amount_of_substance] and
+        @amount_of_substance = hash[:amount_of_substance][:powerNumerator].to_i
+      hash[:luminous_intensity] and
+        @luminous_intensity = hash[:luminous_intensity][:powerNumerator].to_i
+      hash[:plane_angle] and
+        @plane_angle = hash[:plane_angle][:powerNumerator].to_i
+    end
+
+    def name_dimension(hash)
+      acc = %i(length mass time electric_current thermodynamic_temperature
+               amount_of_substance luminous_intensity plane_angle)
+        .each_with_object({}) do |x, m|
+        hash[x] and m[x] = hash[x][:powerNumerator]
       end
+      return unless acc.keys.size == 1 && acc.values[0] == 1
+
+      dim = acc.keys[0]
+      @name = dim.to_s
+      @symbols = hash[dim][:dim_symbols]
+      @symbols_hash =
+        @symbols&.each_with_object({}) { |h, m| m[h[:id]] = h } || {}
     end
 
     def keys
@@ -57,21 +77,27 @@ module UnitsDB
         "#{@thermodynamic_temperature}:#{@amount_of_substance}:"\
         "#{@luminous_intensity}:#{@plane_angle}"
     end
+
+    def symbolid
+      @symbols ? @symbols.first[:id] : nil
+    end
+
+    def symbolids
+      @symbols ? @symbols.map { |s| s[:id] } : []
+    end
   end
 
   class Prefix
     attr_reader :id, :name, :base, :power, :symbol
 
     def initialize(id, hash)
-      begin
-        @id = id
-        @name = hash[:name]
-        @base = hash[:base]
-        @power = hash[:power]
-        @symbol = hash[:symbol] # always is a hash
-      rescue
-        raise StandardError.new "Parse fail on Prefix #{id}: #{hash}"
-      end
+      @id = id
+      @name = hash[:name]
+      @base = hash[:base]
+      @power = hash[:power]
+      @symbol = hash[:symbol] # always is a hash
+    rescue StandardError
+      raise StandardError.new "Parse fail on Prefix #{id}: #{hash}"
     end
 
     def ascii
@@ -103,16 +129,14 @@ module UnitsDB
     attr_reader :id, :dimension, :type, :names, :units
 
     def initialize(id, hash)
-      begin
-        @id = id
-        @dimension = hash[:dimension_url].sub(/^#/, "")
-        @type = hash[:quantity_type]
-        hash[:quantity_name] and @names = hash[:quantity_name]
-        hash[:unit_reference] and
-          @units = hash[:unit_reference].map { |x| x[:url].sub(/^#/, "") }
-      rescue
-        raise StandardError.new "Parse fail on Quantity #{id}: #{hash}"
-      end
+      @id = id
+      @dimension = hash[:dimension_url].sub(/^#/, "")
+      @type = hash[:quantity_type]
+      hash[:quantity_name] and @names = hash[:quantity_name]
+      hash[:unit_reference] and
+        @units = hash[:unit_reference].map { |x| x[:url].sub(/^#/, "") }
+    rescue StandardError
+      raise StandardError.new "Parse fail on Quantity #{id}: #{hash}"
     end
 
     def name
@@ -126,29 +150,27 @@ module UnitsDB
 
   class Unit
     attr_reader :id, :dimension, :short, :root, :unit_system, :names,
-      :symbols, :symbols_hash, :root_units, :quantities,
-      :si_derived_bases, :prefixed
+                :symbols, :symbols_hash, :root_units, :quantities,
+                :si_derived_bases, :prefixed
 
     def initialize(id, hash)
-      begin
-        @id = id
-        @short = short
-        @dimension = hash[:dimension_url].sub(/^#/, "")
-        hash[:short] && !hash[:short].empty? and @short = hash[:short]
-        @unit_system = hash[:unit_system]
-        @names = hash[:unit_name]
-        @symbols_hash =
-          hash[:unit_symbols]&.each_with_object({}) { |h, m| m[h[:id]] = h } || {}
-        @symbols = hash[:unit_symbols]
-        hash[:root_units] and hash[:root_units][:enumerated_root_units] and
-          @root = hash[:root_units][:enumerated_root_units]
-        hash[:quantity_reference] and
-          @quantities = hash[:quantity_reference].map { |x| x[:url].sub(/^#/, "") }
-        hash[:si_derived_bases] and @si_derived_bases = hash[:si_derived_bases]
-        @prefixed = (hash[:prefixed] == true)
-      rescue
-        raise StandardError.new "Parse fail on Unit #{id}: #{hash}"
-      end
+      @id = id
+      @short = short
+      @dimension = hash[:dimension_url].sub(/^#/, "")
+      hash[:short] && !hash[:short].empty? and @short = hash[:short]
+      @unit_system = hash[:unit_system]
+      @names = hash[:unit_name]
+      @symbols_hash =
+        hash[:unit_symbols]&.each_with_object({}) { |h, m| m[h[:id]] = h } || {}
+      @symbols = hash[:unit_symbols]
+      hash[:root_units] and hash[:root_units][:enumerated_root_units] and
+        @root = hash[:root_units][:enumerated_root_units]
+      hash[:quantity_reference] and
+        @quantities = hash[:quantity_reference].map { |x| x[:url].sub(/^#/, "") }
+      hash[:si_derived_bases] and @si_derived_bases = hash[:si_derived_bases]
+      @prefixed = (hash[:prefixed] == true)
+    rescue StandardError
+      raise StandardError.new "Parse fail on Unit #{id}: #{hash}"
     end
 
     def system_name