unitsml 0.5.1 → 0.6.1

data/lib/unitsml/transform.rb

@@ -3,138 +3,200 @@
 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(intermediate_exp: simple(:int_exp)) { int_exp }
+    rule(sqrt: simple(:sqrt)) { Sqrt.new(sqrt) }
+    rule(unit: simple(:unit)) { Unit.new(unit.to_s) }
+    rule(dimension: simple(:dimension)) { Dimension.new(dimension.to_s) }
+    rule(prefix: simple(:prefix)) { Prefix.new(prefix.to_s) }
+    rule(integer: simple(:integer)) { Number.new(integer.to_s) }
+    rule(int_exp: simple(:int_exp)) { int_exp }
+    rule(implicit_extended: simple(:implicit_extended)) { implicit_extended }
 
-    rule(units: simple(:unit),
-         integer: simple(:integer)) do
-      Unit.new(unit.to_s, integer.to_s)
+    rule(int_exp: simple(:int_exp),
+         sequence: simple(:sequence)) do
+      Formula.new([int_exp, sequence])
+    end
+
+    rule(first_int_exp_set: simple(:first_set),
+         second_set: simple(:second_set)) do
+      Formula.new([Utility.set_to_fence(first_set), second_set])
+    end
+
+    rule(first_int_exp_set: simple(:first_set),
+         second_int_exp_set: simple(:second_set)) do
+      Formula.new(
+        [Utility.set_to_fence(first_set), Utility.set_to_fence(second_set)],
+      )
+    end
+
+    rule(first_set: simple(:first_set),
+         second_set: simple(:second_set)) do
+      Formula.new(
+        [
+          first_set,
+          second_set,
+        ],
+      )
     end
 
-    rule(dimensions: simple(:dimension),
-         integer: simple(:integer)) do
-      Dimension.new(dimension.to_s, integer.to_s)
+    rule(first_set: simple(:first_set),
+         second_int_exp_set: simple(:second_set)) do
+      Formula.new(
+        [
+          first_set,
+          Utility.set_to_fence(second_set),
+        ],
+      )
     end
 
-    rule(prefixes: simple(:prefix),
-         units: simple(:unit)) do
+    rule(prefix: simple(:prefix),
+         unit: 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)
+    rule(unit: simple(:unit),
+         power_numerator: simple(:power_numerator)) do
+      Unit.new(unit.to_s, power_numerator)
     end
 
-    rule(open_parenthesis: simple(:open_paren),
-         int_exp: simple(:exp),
-         close_parenthesis: simple(:close_paren)) do
-      Fenced.new(open_paren.to_s, exp, close_paren.to_s)
+    rule(dimension: simple(:dimension),
+         power_numerator: simple(:power_numerator)) do
+      Dimension.new(dimension.to_s, power_numerator)
     end
 
-    rule(open_parenthesis: simple(:open_paren),
-         int_exp: simple(:exp),
-         close_parenthesis: simple(:close_paren),
-         sequence: sequence(:sequence)) do
+    rule(prefix: simple(:prefix),
+         unit: simple(:unit),
+         power_numerator: simple(:power_numerator)) do
+      Unit.new(unit.to_s, power_numerator, prefix: Prefix.new(prefix.to_s))
+    end
+
+    rule(first_set: simple(:first_set),
+         extender: simple(:extender),
+         second_set: simple(:second_set)) do
       Formula.new(
         [
-          Fenced.new(open_paren.to_s, exp, close_paren.to_s),
-          sequence,
+          first_set,
+          Extender.new(extender.to_s),
+          second_set,
         ],
       )
     end
 
-    rule(intermediate_exp: simple(:intermediate_exp),
+    rule(implicit_extended: simple(:implicit_extended),
          extender: simple(:extender),
          sequence: simple(:sequence)) do
       Formula.new(
         [
-          intermediate_exp,
+          implicit_extended,
           Extender.new(extender.to_s),
           sequence,
         ],
       )
     end
 
-    rule(prefixes: simple(:prefix),
-         units: simple(:unit),
-         integer: simple(:integer),
+    rule(int_exp: simple(:int_exp),
          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)
+         sequence: simple(:sequence)) do
       Formula.new(
         [
-          unit_object,
+          int_exp,
           Extender.new(extender.to_s),
           sequence,
         ],
       )
     end
 
-    rule(prefixes: simple(:prefix),
-         units: simple(:unit),
+    rule(unit: simple(:unit),
          extender: simple(:extender),
          sequence: simple(:sequence)) do
       Formula.new(
         [
-          Unit.new(unit.to_s, prefix: Prefix.new(prefix.to_s)),
+          Unit.new(unit.to_s),
           Extender.new(extender.to_s),
           sequence,
         ],
       )
     end
 
-    rule(units: simple(:unit),
+    rule(dimension: simple(:dimension),
          extender: simple(:extender),
          sequence: simple(:sequence)) do
       Formula.new(
         [
-          Unit.new(unit.to_s),
+          Dimension.new(dimension.to_s),
           Extender.new(extender.to_s),
           sequence,
         ],
       )
     end
 
-    rule(units: simple(:unit),
+    rule(open_paren: simple(:open_paren),
+         int_exp: simple(:int_exp),
+         close_paren: simple(:close_paren)) do
+      Fenced.new(
+        open_paren.to_s,
+        int_exp,
+        close_paren.to_s,
+      )
+    end
+
+    rule(open_paren: simple(:open_paren),
          integer: simple(:integer),
-         extender: simple(:extender),
+         close_paren: simple(:close_paren)) do
+      Fenced.new(
+        open_paren.to_s,
+        Number.new(integer.to_s),
+        close_paren.to_s,
+      )
+    end
+
+    rule(unit: simple(:unit),
+         power_numerator: simple(:power_numerator),
+         extender: simple(:ext),
          sequence: simple(:sequence)) do
       Formula.new(
         [
-          Unit.new(unit.to_s, integer.to_s),
-          Extender.new(extender.to_s),
+          Unit.new(unit.to_s, power_numerator),
+          Extender.new(ext.to_s),
           sequence,
         ],
       )
     end
 
-    rule(dimensions: simple(:dimension),
-         extender: simple(:extender),
+    rule(dimension: simple(:dimension),
+         power_numerator: simple(:power_numerator),
+         extender: simple(:ext),
          sequence: simple(:sequence)) do
       Formula.new(
         [
-          Dimension.new(dimension.to_s),
-          Extender.new(extender.to_s),
+          Dimension.new(dimension.to_s, power_numerator),
+          Extender.new(ext.to_s),
           sequence,
         ],
       )
     end
 
-    rule(dimensions: simple(:dimension),
-         integer: simple(:integer),
-         extender: simple(:extender),
+    rule(prefix: simple(:prefix),
+         unit: simple(:unit),
+         extender: simple(:ext),
          sequence: simple(:sequence)) do
       Formula.new(
         [
-          Dimension.new(dimension.to_s, integer.to_s),
-          Extender.new(extender.to_s),
+          Unit.new(unit.to_s, prefix: Prefix.new(prefix.to_s)),
+          Extender.new(ext.to_s),
+          sequence,
+        ],
+      )
+    end
+
+    rule(prefix: simple(:prefix),
+         unit: simple(:unit),
+         power_numerator: simple(:power_numerator),
+         extender: simple(:ext),
+         sequence: simple(:sequence)) do
+      Formula.new(
+        [
+          Unit.new(unit.to_s, power_numerator, prefix: Prefix.new(prefix.to_s)),
+          Extender.new(ext.to_s),
           sequence,
         ],
       )

data/lib/unitsml/unit.rb

@@ -4,7 +4,8 @@ module Unitsml
   class Unit
     attr_accessor :unit_name, :power_numerator, :prefix
 
-    SI_UNIT_SYSTEM = %w[si_base si_derived_special si_derived_non_special].freeze
+    SI_UNIT_SYSTEM = %w[si_base si_derived_special
+                        si_derived_non_special].freeze
 
     def initialize(unit_name,
                    power_numerator = nil,
@@ -14,46 +15,34 @@ module Unitsml
       @power_numerator = power_numerator
     end
 
-    def ==(object)
-      self.class == object.class &&
-        prefix == object&.prefix &&
-        unit_name == object&.unit_name &&
-        power_numerator == object&.power_numerator
+    def ==(other)
+      self.class == other.class &&
+        prefix == other&.prefix &&
+        unit_name == other&.unit_name &&
+        power_numerator == other&.power_numerator
     end
 
     def unit_instance
       Unitsdb.units.find_by_name(unit_name)
     end
 
-    def unit_symbols
-      unit_instance.symbols.find { |symbol| symbol.id == unit_name }
+    def unknown_name?
+      unit_name == Utility::UNKNOWN
     end
 
-    def numerator_value(mathml = true)
-      integer = power_numerator.to_s
-      unless integer.match?(/-/)
-        return mathml ? { mn_value: [::Mml::Mn.from_xml("<mn>#{integer}</mn>")] } : integer
-      end
-
-      return integer.sub(/(-)(.+)/, '&#x2212;\2') unless mathml
-
-      integer = integer.sub(/(-)(.+)/, '<mn>\2</mn>')
-      integer = ::Mml::Mn.from_xml(integer)
-      mo_tag = ::Mml::Mo.new(value: "&#x2212;")
-      { mo_value: [mo_tag], mn_value: [integer] }
+    def unit_symbols
+      unit_instance.symbols.find { |symbol| symbol.id == unit_name }
     end
 
     def to_mathml(options)
       value = unit_symbols&.mathml
       tag_name = value.match(/^<(?<tag>\w+)/)[:tag]
-      value = ::Mml.const_get(tag_name.capitalize).from_xml(value)
+      value = ::Mml::V4.const_get(tag_name.capitalize).from_xml(value)
       value.value = "#{prefix.to_mathml(options)}#{value.value}" if prefix
       if power_numerator
-        value = ::Mml::Msup.new(
-          mrow_value: [
-            ::Mml::Mrow.new("#{tag_name}_value": Array(value)),
-            ::Mml::Mrow.new(numerator_value),
-          ]
+        value = msup_tag(
+          { method_name: tag_name, value: value },
+          options,
         )
         tag_name = :msup
       end
@@ -62,30 +51,28 @@ module Unitsml
 
     def to_latex(options)
       value = unit_symbols&.latex
-      value = "#{value}^#{power_numerator}" if power_numerator
+      value = "#{value}^#{power_numerator.to_latex(options)}" if power_numerator
       value = "#{prefix.to_latex(options)}#{value}" if prefix
       value
     end
 
     def to_asciimath(options)
       value = unit_symbols&.ascii
-      value = "#{value}^#{power_numerator}" if power_numerator
+      value = "#{value}^#{power_numerator.to_asciimath(options)}" if power_numerator
       value = "#{prefix.to_asciimath(options)}#{value}" if prefix
       value
     end
 
     def to_html(options)
       value = unit_symbols&.html
-      if power_numerator
-        value = "#{value}<sup>#{numerator_value(false)}</sup>"
-      end
+      value = "#{value}<sup>#{power_numerator.to_html(options)}</sup>" if power_numerator
       value = "#{prefix.to_html(options)}#{value}" if prefix
       value
     end
 
     def to_unicode(options)
       value = unit_symbols&.unicode
-      value = "#{value}^#{power_numerator}" if power_numerator
+      value = "#{value}^#{power_numerator.to_unicode(options)}" if power_numerator
       value = "#{prefix.to_unicode(options)}#{value}" if prefix
       value
     end
@@ -118,16 +105,39 @@ module Unitsml
       Lutaml::Model::Utils.snake_case(system_type)
     end
 
+    def inverse_power_numerator
+      if power_numerator
+        power_numerator.update_negative_sign
+      else
+        @power_numerator = Number.new("-1")
+      end
+    end
+
     private
 
     def display_exp
       return unless power_numerator
 
-      "^#{power_numerator}" if power_numerator != "1"
+      exp = power_numerator.raw_value
+      "^#{exp}" if exp != "1"
     end
 
     def system_reference
       unit_instance.unit_system_reference
     end
+
+    def msup_tag(value, options)
+      msup = ::Mml::V4::Msup.new
+      msup.ordered = true
+      msup.element_order = []
+      [value, power_numerator.to_mathml(options)].flatten.each do |record|
+        values = msup.public_send("#{record[:method_name]}_value") || []
+        values += [record[:value]]
+        msup.element_order << Lutaml::Xml::Element.new("Element",
+                                                       record[:method_name].to_s)
+        msup.public_send("#{record[:method_name]}_value=", values)
+      end
+      msup
+    end
   end
 end

data/lib/unitsml/unitsdb/dimension.rb

@@ -9,10 +9,10 @@ module Unitsml
                   :vector
 
       def initialize(attrs)
-        super
         @parsables = {}
         @processed_keys = []
         @parsable = false
+        super
       end
 
       def length=(value)
@@ -48,7 +48,9 @@ module Unitsml
       end
 
       def dim_symbols
-        processed_keys.map { |vec| public_send(vec)&.dim_symbols&.map(&:id) }.flatten.compact
+        processed_keys.map do |vec|
+          public_send(vec)&.dim_symbols&.map(&:id)
+        end.flatten.compact
       end
 
       def processed_symbol
@@ -56,7 +58,7 @@ module Unitsml
       end
 
       def set_vector
-        @vector ||= Utility::DIMS_VECTOR.map do |h|
+        @set_vector ||= Utility::DIMS_VECTOR.map do |h|
           public_send(Utility.underscore(h))&.power
         end.join(":")
       end

data/lib/unitsml/unitsdb/dimensions.rb

@@ -3,9 +3,13 @@
 module Unitsml
   module Unitsdb
     class Dimensions < ::Unitsdb::Dimensions
+      def dimensions=(value)
+        super(value.map { |d| Dimension.new(d.to_hash) })
+      end
+
       def find_by_vector(vector)
-        @vectored ||= dimensions.each(&:set_vector)
-        find(:vector, vector)
+        dimensions.each(&:set_vector)
+        dimensions.find { |dim| dim.set_vector == vector }
       end
 
       def find_by_id(d_id)
@@ -30,5 +34,3 @@ module Unitsml
     end
   end
 end
-
-Unitsml.register.register_model(Unitsml::Unitsdb::Dimensions, id: :unitsdb_dimensions)

data/lib/unitsml/unitsdb/prefixes.rb

@@ -32,5 +32,3 @@ module Unitsml
     end
   end
 end
-
-Unitsml.register.register_model(Unitsml::Unitsdb::Prefixes, id: :unitsdb_prefixes)

data/lib/unitsml/unitsdb/quantities.rb

@@ -11,5 +11,3 @@ module Unitsml
     end
   end
 end
-
-Unitsml.register.register_model(Unitsml::Unitsdb::Quantities, id: :unitsdb_quantities)

data/lib/unitsml/unitsdb/units.rb

@@ -3,6 +3,10 @@
 module Unitsml
   module Unitsdb
     class Units < ::Unitsdb::Units
+      def units=(value)
+        super(value.map { |u| Unit.new(u.to_hash) })
+      end
+
       def find_by_id(u_id)
         find(u_id, :id, :identifiers)
       end
@@ -13,7 +17,7 @@ module Unitsml
 
       def filtered
         @filtered ||= symbols_ids.reject do |unit|
-          ((/\*|\^|\/|^1$/).match?(unit) || find_by_symbol_id(unit).prefixed)
+          %r{\*|\^|/|^1$}.match?(unit) || find_by_symbol_id(unit).prefixed
         end
       end
 
@@ -26,7 +30,7 @@ module Unitsml
       end
 
       def symbols_hash
-        @symbol_ids_hash ||= units.each_with_object({}) do |unit, object|
+        @symbols_hash ||= units.each_with_object({}) do |unit, object|
           unit.symbols&.each { |unit_sym| object[unit_sym.id] = unit }
         end
       end
@@ -43,5 +47,3 @@ module Unitsml
     end
   end
 end
-
-Unitsml.register.register_model(Unitsml::Unitsdb::Units, id: :unitsdb_units)

data/lib/unitsml/unitsdb.rb

@@ -2,47 +2,41 @@
 
 module Unitsml
   module Unitsdb
-    class << self
-      def load_file(file_name)
-        @@hash ||= {}
-        @@hash[file_name] ||= File.read(valid_path(file_name))
-      end
+    autoload :Unit, "#{__dir__}/unitsdb/unit"
+    autoload :Units, "#{__dir__}/unitsdb/units"
+    autoload :Prefixes, "#{__dir__}/unitsdb/prefixes"
+    autoload :Dimension, "#{__dir__}/unitsdb/dimension"
+    autoload :Dimensions, "#{__dir__}/unitsdb/dimensions"
+    autoload :Quantities, "#{__dir__}/unitsdb/quantities"
+    autoload :PrefixReference, "#{__dir__}/unitsdb/prefix_reference"
+    autoload :DimensionQuantity, "#{__dir__}/unitsdb/dimension_quantity"
 
+    class << self
       def units
-        @@units_file ||= get_class_from_register(:unitsdb_units).from_yaml(load_file(:units))
+        Units.new(units: ::Unitsdb.database.units)
       end
 
       def prefixes
-        @@prefixes ||= get_class_from_register(:unitsdb_prefixes).from_yaml(load_file(:prefixes))
+        Prefixes.new(prefixes: ::Unitsdb.database.prefixes)
       end
 
       def dimensions
-        @@dim_file ||= get_class_from_register(:unitsdb_dimensions).from_yaml(load_file(:dimensions))
+        Dimensions.new(dimensions: ::Unitsdb.database.dimensions)
       end
 
       def quantities
-        @@quantities ||= get_class_from_register(:unitsdb_quantities).from_yaml(load_file(:quantities))
+        Quantities.new(quantities: ::Unitsdb.database.quantities)
       end
 
       def prefixes_array
-        @@prefixes_array ||= prefixes.ascii_symbols.sort_by(&:length)
+        @prefixes_array ||= prefixes.ascii_symbols.sort_by(&:length)
       end
 
       def prefixes_by_size(size)
-        @@sized_prefixes ||= {}
-        return @@sized_prefixes[size] if @@sized_prefixes.key?(size)
-
-        @@sized_prefixes[size] = prefixes_array.select { |p| p.size == size }
-      end
-
-      def valid_path(file_name)
-        File.expand_path(
-          File.join(__dir__, "..", "..","unitsdb", "#{file_name}.yaml")
-        )
-      end
+        @sized_prefixes ||= {}
+        return @sized_prefixes[size] if @sized_prefixes.key?(size)
 
-      def get_class_from_register(class_name)
-        Unitsml.register.get_class(class_name)
+        @sized_prefixes[size] = prefixes_array.select { |p| p.size == size }
       end
     end
   end