unitsml 0.2.0

data/lib/unitsml/parse.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "parslet"
+require_relative "unitsdb"
+module Unitsml
+  class Parse < Parslet::Parser
+    include Unitsml::Unitsdb
+
+    rule(:power)    { str("^") >> intermediate_exp(number) }
+    rule(:hyphen)   { str("-") }
+    rule(:number)   { (hyphen.maybe >> match(/[0-9]/).repeat(1)).as(:integer) }
+    rule(:extender) { (str("//") | str("/") | str("*")).as(:extender) }
+    rule(:sequence) { single_letter_prefixes >> units | double_letter_prefixes >> units | units }
+    rule(:unit_and_power) { units >> power.maybe }
+
+    rule(:units) do
+      @@filtered_units ||= arr_to_expression(Unitsdb.filtered_units, "units")
+    end
+
+    rule(:single_letter_prefixes) do
+      @@prefixes1 ||= arr_to_expression(Unitsdb.prefixes.select { |p| p.size == 1 }, "prefixes")
+    end
+
+    rule(:double_letter_prefixes) do
+      @@prefixes2 ||= arr_to_expression(Unitsdb.prefixes.select { |p| p.size == 2 }, "prefixes")
+    end
+
+    rule(:dimensions) do
+      @@dimensions ||= arr_to_expression(Unitsdb.parsable_dimensions.keys, "dimensions")
+    end
+
+    rule(:prefixes_units) do
+      (sqrt(sequence) >> extend_exp(prefixes_units)) |
+        (str("1").as(:units) >> extend_exp(prefixes_units)) |
+        (unit_and_power >> extender >> intermediate_exp(prefixes_units).as(:sequence)) |
+        unit_and_power |
+        (single_letter_prefixes >> unit_and_power >> extender >> intermediate_exp(prefixes_units).as(:sequence)) |
+        (single_letter_prefixes >> unit_and_power) |
+        (double_letter_prefixes >> unit_and_power >> extender >> intermediate_exp(prefixes_units).as(:sequence)) |
+        (double_letter_prefixes >> unit_and_power)
+    end
+
+    rule(:dimension_rules) do
+      (sqrt(intermediate_exp(dimensions >> power.maybe)) >> extend_exp(dimension_rules)) |
+        (dimensions >> power.maybe >> extend_exp(dimension_rules))
+    end
+
+    rule(:expression) do
+      intermediate_exp(prefixes_units) |
+        intermediate_exp(dimension_rules) |
+        single_letter_prefixes >> hyphen |
+        double_letter_prefixes >> hyphen
+    end
+
+    root :expression
+
+    def arr_to_expression(arr, file_name)
+      array = arr&.flatten&.compact&.sort_by(&:length).reverse
+      array&.reduce do |expression, expr_string|
+        expression = str(expression).as(file_name.to_sym) if expression.is_a?(String)
+        expression | str(expr_string).as(file_name.to_sym)
+      end
+    end
+
+    def sqrt(rule)
+      str("sqrt(") >> rule.as(:sqrt) >> str(")")
+    end
+
+    def extend_exp(rule)
+      (extender >> intermediate_exp(rule).as(:sequence)).maybe
+    end
+
+    def intermediate_exp(rule)
+      rule | (str("(") >> rule >> str(")"))
+    end
+  end
+end

data/lib/unitsml/parser.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Unitsml
+  class Parser
+    attr_accessor :text
+
+    def initialize(text)
+      @regexp = %r{(quantity|name|symbol|multiplier):\s*}
+      @text = text&.match(/unitsml\((.*)\)/) ? Regexp.last_match[1] : text
+      @orig_text = @text
+      post_extras
+    end
+
+    def parse
+      nodes = Parse.new.parse(text)
+      formula = Formula.new(
+        [
+          Transform.new.apply(nodes),
+        ],
+        explicit_value: @extras_hash,
+        root: true,
+        orig_text: @orig_text,
+        norm_text: text,
+      )
+      update_units_exponents(formula.value, false)
+      formula
+    end
+
+    def update_units_exponents(array, inverse)
+      array.each do |object|
+        if object.is_a?(Sqrt)
+          object = object.value
+          object.power_numerator = "0.5"
+        end
+
+        case object
+        when Unit
+          next unless inverse
+
+          exponent = inverse ? "-#{object&.power_numerator || '1'}" : object.power_numerator
+          object.power_numerator = exponent&.sub(/^--+/, "")
+        when Extender then inverse = !inverse if ["/", "//"].any?(object.symbol)
+        when Formula then update_units_exponents(object.value, inverse)
+        end
+      end
+    end
+
+    def post_extras
+      return nil unless @regexp.match?(text)
+
+      @extras_hash = {}
+      texts_array = text&.split(",")&.map(&:strip)
+      @text = texts_array&.shift
+      texts_array&.map { |text| parse_extras(text) }
+    end
+
+    def parse_extras(text)
+      return nil unless @regexp.match?(text)
+
+      key, _, value = text&.partition(":")
+      @extras_hash[key&.to_sym] ||= value&.strip
+    end
+  end
+end

data/lib/unitsml/prefix.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Unitsml
+  class Prefix
+    attr_accessor :prefix_name
+
+    def initialize(prefix_name)
+      @prefix_name = prefix_name
+    end
+
+    def ==(object)
+      self.class == object.class &&
+        prefix_name == object&.prefix_name
+    end
+
+    def id
+      Unitsdb.prefixes_hash.dig(prefix_name, :id)
+    end
+
+    def name
+      fields.dig("name")
+    end
+
+    def fields
+      Unitsdb.prefixes_hash.dig(prefix_name, :fields)
+    end
+
+    def prefixes_symbols
+      fields&.dig("symbol")
+    end
+
+    def to_mathml
+      prefixes_symbols["html"]
+    end
+
+    def to_latex
+      prefixes_symbols["latex"]
+    end
+
+    def to_asciimath
+      prefixes_symbols["ascii"]
+    end
+
+    def to_html
+      prefixes_symbols["html"]
+    end
+
+    def to_unicode
+      prefixes_symbols["unicode"]
+    end
+
+    def symbolid
+      prefixes_symbols["ascii"] if prefixes_symbols
+    end
+
+    def base
+      fields&.dig("base")
+    end
+
+    def power
+      fields&.dig("power")
+    end
+  end
+end

data/lib/unitsml/sqrt.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Unitsml
+  class Sqrt
+    attr_accessor :value
+
+    def initialize(value)
+      @value = value
+    end
+
+    def ==(object)
+      self.class == object.class &&
+        value == object&.value
+    end
+
+    def to_asciimath
+      value&.to_asciimath
+    end
+
+    def to_latex
+      value&.to_latex
+    end
+
+    def to_mathml
+      value&.to_mathml
+    end
+
+    def to_html
+      value&.to_html
+    end
+
+    def to_unicode
+      value.to_unicode
+    end
+  end
+end

data/lib/unitsml/transform.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "parslet"
+module Unitsml
+  class Transform < Parslet::Transform
+    rule(sqrt: simple(:sqrt))       { Sqrt.new(sqrt) }
+    rule(units: simple(:unit))      { Unit.new(unit.to_s) }
+    rule(prefixes: simple(:prefix)) { Prefix.new(prefix.to_s) }
+    rule(dimensions: simple(:dimension)) { Dimension.new(dimension.to_s) }
+
+    rule(units: simple(:unit),
+         integer: simple(:integer)) do
+      Unit.new(unit.to_s, integer.to_s)
+    end
+
+    rule(dimensions: simple(:dimension),
+         integer: simple(:integer)) do
+      Dimension.new(dimension.to_s, integer.to_s)
+    end
+
+    rule(prefixes: simple(:prefix),
+         units: simple(:unit)) do
+      Unit.new(unit.to_s, prefix: Prefix.new(prefix.to_s))
+    end
+
+    rule(prefixes: simple(:prefix),
+         units: simple(:unit),
+         integer: simple(:integer)) do
+      prefix_obj = Prefix.new(prefix.to_s)
+      Unit.new(unit.to_s, integer.to_s, prefix: prefix_obj)
+    end
+
+    rule(prefixes: simple(:prefix),
+         units: simple(:unit),
+         integer: simple(:integer),
+         extender: simple(:extender),
+         sequence: simple(:sequence),) do
+      prefix_obj = Prefix.new(prefix.to_s)
+      unit_object = Unit.new(unit.to_s, integer.to_s, prefix: prefix_obj)
+      Formula.new(
+        [
+          unit_object,
+          Extender.new(extender.to_s),
+          sequence,
+        ],
+      )
+    end
+
+    rule(prefixes: simple(:prefix),
+         units: simple(:unit),
+         extender: simple(:extender),
+         sequence: simple(:sequence)) do
+      Formula.new(
+        [
+          Unit.new(unit.to_s, prefix: Prefix.new(prefix.to_s)),
+          Extender.new(extender.to_s),
+          sequence,
+        ],
+      )
+    end
+
+    rule(units: simple(:unit),
+         extender: simple(:extender),
+         sequence: simple(:sequence)) do
+      Formula.new(
+        [
+          Unit.new(unit.to_s),
+          Extender.new(extender.to_s),
+          sequence,
+        ],
+      )
+    end
+
+    rule(units: simple(:unit),
+         integer: simple(:integer),
+         extender: simple(:extender),
+         sequence: simple(:sequence)) do
+      Formula.new(
+        [
+          Unit.new(unit.to_s, integer.to_s),
+          Extender.new(extender.to_s),
+          sequence,
+        ],
+      )
+    end
+
+    rule(dimensions: simple(:dimension),
+         extender: simple(:extender),
+         sequence: simple(:sequence)) do
+      Formula.new(
+        [
+          Dimension.new(dimension.to_s),
+          Extender.new(extender.to_s),
+          sequence,
+        ],
+      )
+    end
+
+    rule(dimensions: simple(:dimension),
+         integer: simple(:integer),
+         extender: simple(:extender),
+         sequence: simple(:sequence)) do
+      Formula.new(
+        [
+          Dimension.new(dimension.to_s, integer.to_s),
+          Extender.new(extender.to_s),
+          sequence,
+        ],
+      )
+    end
+  end
+end

data/lib/unitsml/unit.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Unitsml
+  class Unit
+    attr_accessor :unit_name, :power_numerator, :prefix
+
+    def initialize(unit_name,
+                   power_numerator = nil,
+                   prefix: nil)
+      @prefix = prefix
+      @unit_name = unit_name
+      @power_numerator = power_numerator
+    end
+
+    def ==(object)
+      self.class == object.class &&
+        prefix == object&.prefix &&
+        unit_name == object&.unit_name &&
+        power_numerator == object&.power_numerator
+    end
+
+    def fields_hash
+      Unitsdb.units.dig(unit_name, :fields)
+    end
+
+    def unit_symbols
+      symbols = fields_hash.dig("unit_symbols")
+      symbols.find{|symbol| symbol["id"] == unit_name }
+    end
+
+    def numerator_value(mathml = true)
+      integer = power_numerator.to_s
+      unless integer.match?(/-/)
+        return mathml ? [Ox.parse("<mn>#{integer}</mn>")] : integer
+      end
+
+      return integer.sub(/(-)(.+)/, '&#x2212;\2') unless mathml
+
+      integer = integer.sub(/(-)(.+)/, '<mn>\2</mn>')
+      integer = Ox.parse(integer)
+      mo_tag = (Utility.ox_element("mo") << "&#x2212;")
+      [mo_tag, integer]
+    end
+
+    def to_mathml
+      value = unit_symbols&.dig("mathml")
+      value = Ox.parse(value)
+      value.nodes.insert(0, prefix.to_mathml) if prefix
+      if power_numerator
+        msup = Utility.ox_element("msup")
+        msup << (Utility.ox_element("mrow") << value)
+        msup << Utility.update_nodes(
+          Utility.ox_element("mrow"),
+          numerator_value,
+        )
+        value = msup
+      end
+      value
+    end
+
+    def to_latex
+      value = unit_symbols&.dig("latex")
+      value = "#{value}^#{power_numerator}" if power_numerator
+      value = "#{prefix.to_latex}#{value}" if prefix
+      value
+    end
+
+    def to_asciimath
+      value = unit_symbols&.dig("ascii")
+      value = "#{value}^#{power_numerator}" if power_numerator
+      value = "#{prefix.to_asciimath}#{value}" if prefix
+      value
+    end
+
+    def to_html
+      value = unit_symbols&.dig("html")
+      if power_numerator
+        value = "#{value}<sup>#{numerator_value(false)}</sup>"
+      end
+      value = "#{prefix.to_html}#{value}" if prefix
+      value
+    end
+
+    def to_unicode
+      value = unit_symbols&.dig("unicode")
+      value = "#{value}^#{power_numerator}" if power_numerator
+      value = "#{prefix.to_unicode}#{value}" if prefix
+      value
+    end
+
+    def enumerated_name
+      fields_hash.dig("unit_name")&.first
+    end
+
+    def prefix_name
+      prefix&.prefix_name
+    end
+
+    def system_type
+      fields_hash.dig("unit_system", "type")
+    end
+
+    def system_name
+      fields_hash.dig("unit_system", "name")
+    end
+
+    def si_derived_bases
+      fields_hash.dig("si_derived_bases")
+    end
+  end
+end

data/lib/unitsml/unitsdb.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "yaml"
+module Unitsml
+  module Unitsdb
+    class << self
+      def load_yaml(file_name)
+        @@hash ||= {}
+        file_path = File.path(valid_path(file_name))
+        @@hash[file_name.to_sym] ||= YAML.load_file(file_path)
+      end
+
+      def load_dimensions
+        @@dim_file = load_yaml("dimensions")
+      end
+
+      def load_units
+        @@units_file = load_yaml("units")
+      end
+
+      def units
+        @@units ||= {}
+        return @@units unless @@units.empty?
+
+        load_units.each do |key, value|
+          value["unit_symbols"]&.each do |symbol|
+            @@units[symbol["id"]] = { id: key, fields: value } unless symbol["id"]&.empty?
+          end
+        end
+        @@units
+      end
+
+      def prefixes
+        @@prefixes_array ||= prefixes_hash.keys.sort_by(&:length)
+      end
+
+      def parsable_dimensions
+        @@parsable_dimensions ||= {}
+        return @@parsable_dimensions unless @@parsable_dimensions.empty?
+
+        dimensions_hash.each do |key, value|
+          value.each do |_, v|
+            @@parsable_dimensions[find_id(v)] = { id: key, fields: value }
+          end
+        end
+        @@parsable_dimensions
+      end
+
+      def quantities
+        @@quantities ||= load_yaml("quantities")
+      end
+
+      def filtered_units
+        @@filtered_units_array ||= units.keys.reject do |unit|
+          ((/\*|\^|\/|^1$/).match?(unit) || units.dig(unit, :fields, "prefixed"))
+        end
+      end
+
+      def prefixes_hash
+        @@prefixes_hashes ||= prefixs_ids(load_yaml("prefixes"))
+      end
+
+      def dimensions_hash
+        @@dimensions_hashs ||= insert_vectors(load_dimensions)
+      end
+
+      def prefixs_ids(prefixe_hash, hash = {})
+        prefixe_hash&.each do |key, value|
+          symbol = value&.dig("symbol", "ascii")
+          hash[symbol] = { id: key, fields: value } unless symbol&.empty?
+        end
+        hash
+      end
+
+      def find_id(value)
+        return if value == true
+        return unless value.is_a?(Hash)
+
+        value&.dig("dim_symbols")&.map { |symbol| symbol&.dig("id") }&.first
+      end
+
+      def vector(dim_hash)
+        Utility::DIMS_VECTOR.map { |h| dim_hash.dig(underscore(h), "powerNumerator") }.join(":")
+      end
+
+      def underscore(str)
+        str.gsub(/([a-z])([A-Z])/, '\1_\2').downcase
+      end
+
+      def insert_vectors(dims)
+        dims.each do |key, value|
+          value[:vector] = vector(value)
+          value[:id] = key
+        end
+      end
+
+      def valid_path(file_name)
+        path = "unitsdb/#{file_name}.yaml"
+        File.file?(path) ? path : "../#{path}"
+      end
+    end
+  end
+end