unitsml 0.2.0

data/lib/unitsml/utility.rb

@@ -0,0 +1,311 @@
+# frozen_string_literal: true
+
+require "ox"
+module Unitsml
+  module Utility
+
+    UNITSML_NS = "https://schema.unitsml.org/unitsml/1.0".freeze
+    # Unit to dimension
+    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
+    # Dimesion for dim_(dimesion) input
+    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
+    DIMS_VECTOR = %w[
+      ThermodynamicTemperature
+      AmountOfSubstance
+      LuminousIntensity
+      ElectricCurrent
+      PlaneAngle
+      Length
+      Mass
+      Time
+    ].freeze
+
+    class << self
+      include Unitsml::Unitsdb
+
+      def fields(unit)
+        Unitsdb.units.dig(unit, :fields)
+      end
+
+      def units2dimensions(units)
+        norm = decompose_units_list(units)
+        return if norm.any? { |u| u.nil? || u[:unit].unit_name == "unknown" || u[:prefix] == "unknown" }
+
+        norm.map do |u|
+          unit_name = u[:unit].unit_name
+          {
+            dimension: U2D[unit_name][:dimension],
+            unit: unit_name,
+            exponent: u[:unit].power_numerator || 1,
+            symbol: U2D[unit_name][:symbol],
+          }
+        end.sort { |a, b| U2D[a[:unit]][:order] <=> U2D[b[:unit]][:order] }
+      end
+
+      def dim_id(dims)
+        return nil if dims.nil? || dims.empty?
+
+        dimensions = Unitsdb.dimensions_hash.values
+        dim_hash = dims.each_with_object({}) { |h, m| m[h[:dimension]] = h }
+        dims_vector = DIMS_VECTOR.map { |h| dim_hash.dig(h, :exponent) }.join(":")
+        id = dimensions.select { |d| d[:vector] == dims_vector }&.first&.dig(: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_list(units)
+        gather_units(units.map { |u| decompose_unit(u) }.flatten)
+      end
+
+      def decompose_unit(u)
+        if u&.unit_name == "g" || u.system_type == "SI_base"
+          { unit: u, prefix: u&.prefix }
+        elsif !u.si_derived_bases
+          { unit: Unit.new("unknown") }
+        else
+          u.si_derived_bases.each_with_object([]) do |k, m|
+            prefix = if !k["prefix"].nil? && !k["prefix"].empty?
+                       combine_prefixes(prefix_object(k["prefix"]), u.prefix)
+                     else
+                       u.prefix
+                     end
+            unit_name = Unitsdb.load_units.dig(k.dig("id"), "unit_symbols", 0, "id")
+            exponent = (k["power"]&.to_i || 1) * (u.power_numerator&.to_f || 1)
+            m << { prefix: prefix,
+                   unit: Unit.new(unit_name, exponent, prefix: prefix),
+                 }
+          end
+        end
+      end
+
+      def gather_units(units)
+        units.sort_by { |a| a[:unit]&.unit_name }.each_with_object([]) do |k, m|
+          if m.empty? || m[-1][:unit]&.unit_name != k[:unit]&.unit_name
+            m << k
+          else
+            m[-1][:unit]&.power_numerator = (k[:unit]&.power_numerator&.to_f || 1) + (m[-1][:unit]&.power_numerator&.to_f || 1)
+            m[-1] = {
+              prefix: combine_prefixes(prefix_object(m[-1][:prefix]), prefix_object(k[:prefix])),
+              unit: m[-1][:unit],
+            }
+          end
+        end
+      end
+
+      def prefix_object(prefix)
+        return prefix unless prefix.is_a?(String)
+        return nil unless Unitsdb.prefixes.any?(prefix)
+
+        prefix.is_a?(String) ? Prefix.new(prefix) : prefix
+      end
+
+      def combine_prefixes(p1, p2)
+        return nil if p1.nil? && p2.nil?
+        return p1.symbolid if p2.nil?
+        return p2.symbolid if p1.nil?
+        return "unknown" if p1.base != p2.base
+
+        Unitsdb.prefixes_hash.each do |prefix_name, _|
+          p = prefix_object(prefix_name)
+          return p if p.base == p1.base && p.power == p1.power + p2.power
+        end
+
+        "unknown"
+      end
+
+      def unit(units, formula, dims, norm_text, name)
+        attributes = { xmlns: UNITSML_NS, "xml:id": unit_id(norm_text) }
+        attributes[:dimensionURL] = "##{dim_id(dims)}" if dims
+        unit_node = ox_element("Unit", attributes: attributes)
+        nodes = Array(unitsystem(units))
+        nodes += Array(unitname(units, norm_text, name))
+        nodes += Array(unitsymbols(formula))
+        nodes += Array(rootunits(units))
+        Ox.dump(update_nodes(unit_node, nodes))
+          .gsub("&lt;", "<")
+          .gsub("&gt;", ">")
+          .gsub("&amp;", "&")
+          .gsub(/−/, "&#x2212;")
+          .gsub(/⋅/, "&#x22c5;")
+      end
+
+      def unitname(units, text, name)
+        name ||= Unitsdb.units[text] ? Unit.new(text).enumerated_name : text
+        ox_element("UnitName", attributes: { "xml:lang": "en" }) << name
+      end
+
+      def postprocess_normtext(units)
+        units.map { |u| "#{u.prefix_name}#{u.unit_name}#{display_exp(u)}" }.join("*")
+      end
+
+      def display_exp(unit)
+        unit.power_numerator && unit.power_numerator != "1" ? "^#{unit.power_numerator}" : ""
+      end
+
+      def unitsymbols(formula)
+        [
+          (ox_element("UnitSymbol", attributes: { type: "HTML" }) << formula.to_html),
+          (ox_element("UnitSymbol", attributes: { type: "MathMl" }) << Ox.parse(formula.to_mathml)),
+        ]
+      end
+
+      def unitsystem(units)
+        ret = []
+        if units.any? { |u| u.system_name != "SI" }
+          ret << ox_element("UnitSystem", attributes: { name: "not_SI", type: "not_SI", "xml:lang": 'en-US' })
+        end
+        if units.any? { |u| u.system_name == "SI" }
+          if units.size == 1
+            base = units[0].system_type == "SI-base"
+            base = true if units[0].unit_name == "g" && units[0]&.prefix_name == "k"
+          end
+          ret << ox_element("UnitSystem", attributes: { name: "SI", type: (base ? 'SI_base' : 'SI_derived'), "xml:lang": 'en-US' })
+        end
+        ret
+      end
+
+      def dimension(norm_text)
+        return unless fields(norm_text)&.dig("dimension_url")
+
+        dim_id = fields(norm_text).dig("dimension_url").sub("#", '')
+        dim_node = ox_element("Dimension", attributes: { xmlns: UNITSML_NS, "xml:id": dim_id })
+        Ox.dump(
+          update_nodes(
+            dim_node,
+            dimid2dimensions(dim_id)&.compact&.map { |u| dimension1(u) }
+          )
+        )
+      end
+
+      def dimension1(dim)
+        attributes = {
+          symbol: dim[:symbol],
+          powerNumerator: float_to_display(dim[:exponent])
+        }
+        ox_element(dim[:dimension], attributes: attributes)
+      end
+
+      def float_to_display(float)
+        float.to_f.round(1).to_s.sub(/\.0$/, "")
+      end
+
+      def dimid2dimensions(normtext)
+        dims ||= Unitsdb.load_dimensions[normtext]
+        dims&.keys&.reject { |d| d.is_a?(Symbol) }&.map do |k|
+          humanized = k.split("_").map(&:capitalize).join
+          next unless DIMS_VECTOR.include?(humanized)
+
+          {
+            dimension: humanized,
+            symbol: dims.dig(k, "symbol"),
+            exponent: dims.dig(k, "powerNumerator")
+          }
+        end
+      end
+
+      def prefixes(units)
+        uniq_prefixes = units.map { |unit| unit.prefix }.compact.uniq {|d| d.prefix_name }
+        uniq_prefixes.map do |p|
+          prefix_attr = { xmlns: UNITSML_NS, prefixBase: p&.base, prefixPower: p&.power, "xml:id": p&.id }
+          prefix_node = ox_element("Prefix", attributes: prefix_attr)
+          contents = []
+          contents << (ox_element("PrefixName", attributes: { "xml:lang": "en" }) << p&.name)
+          contents << (ox_element("PrefixSymbol", attributes: { type: "ASCII" }) << p&.to_asciimath)
+          contents << (ox_element("PrefixSymbol", attributes: { type: "unicode" }) << p&.to_unicode)
+          contents << (ox_element("PrefixSymbol", attributes: { type: "LaTex" }) << p&.to_latex)
+          contents << (ox_element("PrefixSymbol", attributes: { type: "HTML" }) << p&.to_html)
+          Ox.dump(update_nodes(prefix_node, contents)).gsub("&amp;", "&")
+        end.join("\n")
+      end
+
+      def rootunits(units)
+        return if units.size == 1 && !units[0].prefix
+
+        root_unit = ox_element("RootUnits")
+        units.each do |u|
+          attributes = { unit: u.enumerated_name }
+          attributes[:prefix] = u.prefix_name if u.prefix
+          u.power_numerator && u.power_numerator != "1" and
+            attributes[:powerNumerator] = u.power_numerator
+          root_unit << ox_element("EnumeratedRootUnit", attributes: attributes)
+        end
+        root_unit
+      end
+
+      def unit_id(text)
+        norm_text = text
+        text = text&.gsub(/[()]/, "")
+        /-$/.match(text) and return Unitsdb.prefixes[text.sub(/-$/, "")][:id]
+        unit_hash = Unitsdb.units[norm_text]
+        "U_#{unit_hash ? unit_hash[:id]&.gsub(/'/, '_') : norm_text&.gsub(/\*/, '.')&.gsub(/\^/, '')}"
+      end
+
+      def dimension_components(dims)
+        return if dims.nil? || dims.empty?
+
+        attributes = { xmlns: UNITSML_NS, "xml:id": dim_id(dims) }
+        dim_node = ox_element("Dimension", attributes: attributes)
+        Ox.dump(update_nodes(dim_node, dims.map { |u| dimension1(u) }))
+      end
+
+      def quantity(normtext, quantity)
+        units = Unitsdb.units
+        quantity_references = units.dig(normtext, :fields, "quantity_reference")
+        return unless units[normtext] && quantity_references.size == 1 ||
+          Unitsdb.quantities[quantity]
+
+        id = quantity || quantity_references&.first&.dig("url")
+        attributes = { xmlns: UNITSML_NS, "xml:id": id.sub('#', '') }
+        dim_url = units.dig(normtext, :fields, "dimension_url")
+        dim_url and attributes[:dimensionURL] = "#{dim_url}"
+        attributes[:quantityType] = "base"
+        quantity_element = ox_element("Quantity", attributes: attributes)
+        Ox.dump(update_nodes(quantity_element, quantity_name(id.sub('#', ''))))
+      end
+
+      def quantity_name(id)
+        ret = []
+        Unitsdb.quantities[id]&.dig("quantity_name")&.each do |q|
+          node = (ox_element("QuantityName", attributes: { "xml:lang": "en-US" }) << q)
+          ret << node
+        end
+        ret
+      end
+
+      def ox_element(node, attributes: [])
+        element = Ox::Element.new(node)
+        attributes&.each { |attr_key, attr_value| element[attr_key] = attr_value }
+        element
+      end
+
+      def update_nodes(element, nodes)
+        nodes&.each { |node| element << node unless node.nil? }
+        element
+      end
+    end
+  end
+end

data/lib/unitsml/version.rb

@@ -0,0 +1,3 @@
+module Unitsml
+  VERSION = "0.2.0"
+end

data/lib/unitsml.rb

@@ -0,0 +1,17 @@
+require "unitsml/sqrt"
+require "unitsml/unit"
+require "unitsml/parse"
+require "unitsml/parser"
+require "unitsml/prefix"
+require "unitsml/formula"
+require "unitsml/version"
+require "unitsml/unitsdb"
+require "unitsml/extender"
+require "unitsml/dimension"
+require "unitsml/transform"
+
+module Unitsml
+  def self.parse(string)
+    Unitsml::Parser.new(string).parse
+  end
+end