unitsml 0.4.7 → 0.6.0

data/lib/unitsml/parser.rb

@@ -5,44 +5,50 @@ module Unitsml
     attr_accessor :text
 
     def initialize(text)
-      @regexp = %r{(quantity|name|symbol|multiplier):\s*}
-      @text = text&.match(/unitsml\((.*)\)/) ? Regexp.last_match[1] : text
+      @regexp = /(quantity|name|symbol|multiplier):\s*/
+      @text = extract_equation(text)
       @orig_text = @text
-      @text = @text.gsub("−", "-")
+      @text = @text.gsub('−', '-')
       post_extras
     end
 
     def parse
       nodes = Parse.new.parse(text)
       transformed = Transform.new.apply(nodes)
-      formula_value = transformed.is_a?(Formula) ? transformed.value : Array(transformed)
+      formula_value = transformed.is_a?(Formula) ? transformed.value : [transformed].flatten
       formula = Formula.new(
         formula_value,
         explicit_value: @extras_hash,
         root: true,
         orig_text: @orig_text,
-        norm_text: text,
+        norm_text: text
       )
       update_units_exponents(formula.value, false)
-      formula.value.first.only_instance = true if text.end_with?("-")
+      formula.value.first.only_instance = true if text.end_with?('-')
       formula
     end
 
-    def update_units_exponents(array, inverse)
+    def update_units_exponents(array, inverse, sqrt = false)
       array.each do |object|
         if object.is_a?(Sqrt)
           object = object.value
-          object.power_numerator = "0.5"
+          if object.respond_to?(:power_numerator)
+            object.power_numerator = Number.new('0.5')
+          else
+            update_units_exponents([object], inverse, true)
+          end
         end
 
         case object
         when Unit
+          next object.power_numerator = Number.new('0.5') if sqrt
           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)
+          inverse ? object.inverse_power_numerator : object.power_numerator
+        when Dimension then object.power_numerator = Number.new('0.5') if sqrt
+        when Extender then inverse = !inverse if ['/', '//'].any?(object.symbol)
         when Formula then update_units_exponents(object.value, inverse)
+        when Fenced then update_units_exponents([object.value], inverse, sqrt)
         end
       end
     end
@@ -51,7 +57,7 @@ module Unitsml
       return nil unless @regexp.match?(text)
 
       @extras_hash = {}
-      texts_array = text&.split(",")&.map(&:strip)
+      texts_array = text&.split(',')&.map(&:strip)
       @text = texts_array&.shift
       texts_array&.map { |text| parse_extras(text) }
     end
@@ -59,8 +65,16 @@ module Unitsml
     def parse_extras(text)
       return nil unless @regexp.match?(text)
 
-      key, _, value = text&.partition(":")
+      key, _, value = text&.partition(':')
       @extras_hash[key&.to_sym] ||= value&.strip
     end
+
+    private
+
+    def extract_equation(text)
+      return text unless text&.start_with?('unitsml(')
+
+      text.delete_prefix('unitsml(').delete_suffix(')')
+    end
   end
 end

data/lib/unitsml/prefix.rb

@@ -9,57 +9,57 @@ module Unitsml
       @only_instance = only_instance
     end
 
-    def ==(object)
-      self.class == object.class &&
-        prefix_name == object&.prefix_name &&
-        only_instance == object&.only_instance
+    def ==(other)
+      self.class == other.class &&
+        prefix_name == other&.prefix_name &&
+        only_instance == other&.only_instance
     end
 
     def prefix_instance
-      @prefix ||= Unitsdb.prefixes.find_by_symbol_name(prefix_name)
+      @prefix_instance ||= Unitsdb.prefixes.find_by_symbol_name(prefix_name)
     end
 
     def id
-      @prefix.id
+      @id ||= prefix_instance.identifiers.find { |prefix| prefix.type == 'nist' }&.id
     end
 
     def name
-      prefix_instance.name
+      @name ||= prefix_instance.names.find { |name| name.lang == 'en' }.value
     end
 
-    def prefixes_symbols
-      prefix_instance.symbol
+    def prefix_symbols
+      prefix_instance.symbols.last
     end
 
     def to_mathml(_)
       symbol = Utility.string_to_html_entity(
         Utility.html_entity_to_unicode(
-          prefixes_symbols.html
-        ),
+          prefix_symbols.html
+        )
       )
       return symbol unless only_instance
 
-      { method_name: :mi, value: ::Mml::Mi.new(value: symbol)}
+      { method_name: :mi, value: ::Mml::V4::Mi.new(value: symbol) }
     end
 
     def to_latex(_)
-      prefixes_symbols.latex
+      prefix_symbols.latex
     end
 
     def to_asciimath(_)
-      prefixes_symbols.ascii
+      prefix_symbols.ascii
     end
 
     def to_html(_)
-      prefixes_symbols.html
+      prefix_symbols.html
     end
 
     def to_unicode(_)
-      prefixes_symbols.unicode
+      prefix_symbols.unicode
     end
 
     def symbolid
-      prefixes_symbols.ascii if prefixes_symbols
+      prefix_symbols&.ascii
     end
 
     def base

data/lib/unitsml/sqrt.rb

@@ -8,9 +8,9 @@ module Unitsml
       @value = value
     end
 
-    def ==(object)
-      self.class == object.class &&
-        value == object&.value
+    def ==(other)
+      self.class == other.class &&
+        value == other&.value
     end
 
     def to_asciimath(options)

data/lib/unitsml/transform.rb

@@ -1,111 +1,204 @@
 # frozen_string_literal: true
 
-require "parslet"
+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(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(dimensions: simple(:dimension),
-         integer: simple(:integer)) do
-      Dimension.new(dimension.to_s, integer.to_s)
+    rule(first_set: simple(:first_set),
+         second_set: simple(:second_set)) do
+      Formula.new(
+        [
+          first_set,
+          second_set
+        ]
+      )
+    end
+
+    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(prefixes: simple(:prefix),
-         units: simple(:unit),
-         integer: simple(:integer),
+    rule(dimension: simple(:dimension),
+         power_numerator: simple(:power_numerator)) do
+      Dimension.new(dimension.to_s, power_numerator)
+    end
+
+    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),
-         sequence: simple(:sequence),) do
-      prefix_obj = Prefix.new(prefix.to_s)
-      unit_object = Unit.new(unit.to_s, integer.to_s, prefix: prefix_obj)
+         second_set: simple(:second_set)) do
       Formula.new(
         [
-          unit_object,
+          first_set,
           Extender.new(extender.to_s),
-          sequence,
-        ],
+          second_set
+        ]
       )
     end
 
-    rule(prefixes: simple(:prefix),
-         units: simple(:unit),
+    rule(implicit_extended: simple(:implicit_extended),
          extender: simple(:extender),
          sequence: simple(:sequence)) do
       Formula.new(
         [
-          Unit.new(unit.to_s, prefix: Prefix.new(prefix.to_s)),
+          implicit_extended,
           Extender.new(extender.to_s),
-          sequence,
-        ],
+          sequence
+        ]
       )
     end
 
-    rule(units: simple(:unit),
+    rule(int_exp: simple(:int_exp),
          extender: simple(:extender),
          sequence: simple(:sequence)) do
       Formula.new(
         [
-          Unit.new(unit.to_s),
+          int_exp,
           Extender.new(extender.to_s),
-          sequence,
-        ],
+          sequence
+        ]
       )
     end
 
-    rule(units: simple(:unit),
-         integer: simple(:integer),
+    rule(unit: simple(:unit),
          extender: simple(:extender),
          sequence: simple(:sequence)) do
       Formula.new(
         [
-          Unit.new(unit.to_s, integer.to_s),
+          Unit.new(unit.to_s),
           Extender.new(extender.to_s),
-          sequence,
-        ],
+          sequence
+        ]
       )
     end
 
-    rule(dimensions: simple(:dimension),
+    rule(dimension: simple(:dimension),
          extender: simple(:extender),
          sequence: simple(:sequence)) do
       Formula.new(
         [
           Dimension.new(dimension.to_s),
           Extender.new(extender.to_s),
-          sequence,
-        ],
+          sequence
+        ]
       )
     end
 
-    rule(dimensions: simple(:dimension),
+    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(
         [
-          Dimension.new(dimension.to_s, integer.to_s),
-          Extender.new(extender.to_s),
-          sequence,
-        ],
+          Unit.new(unit.to_s, power_numerator),
+          Extender.new(ext.to_s),
+          sequence
+        ]
+      )
+    end
+
+    rule(dimension: simple(:dimension),
+         power_numerator: simple(:power_numerator),
+         extender: simple(:ext),
+         sequence: simple(:sequence)) do
+      Formula.new(
+        [
+          Dimension.new(dimension.to_s, power_numerator),
+          Extender.new(ext.to_s),
+          sequence
+        ]
+      )
+    end
+
+    rule(prefix: simple(:prefix),
+         unit: simple(:unit),
+         extender: simple(:ext),
+         sequence: simple(:sequence)) do
+      Formula.new(
+        [
+          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
+        ]
       )
     end
   end

data/lib/unitsml/unit.rb

@@ -4,6 +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
+
     def initialize(unit_name,
                    power_numerator = nil,
                    prefix: nil)
@@ -12,46 +14,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.unit_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
@@ -60,36 +50,34 @@ 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
 
     def enumerated_name
-      unit_instance&.unit_name&.first
+      unit_instance.names.find { |name| name.lang == 'en' }&.value
     end
 
     def prefix_name
@@ -97,15 +85,57 @@ module Unitsml
     end
 
     def system_type
-      unit_instance.unit_system.type
-    end
-
-    def system_name
-      unit_instance.unit_system.name
+      system_reference&.first&.id
     end
 
     def si_derived_bases
       unit_instance.si_derived_bases
     end
+
+    def xml_postprocess_name
+      "#{prefix_name}#{unit_name}#{display_exp}"
+    end
+
+    def si_system_type?
+      SI_UNIT_SYSTEM.include?(downcase_system_type)
+    end
+
+    def downcase_system_type
+      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
+
+      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

@@ -2,24 +2,14 @@
 
 module Unitsml
   module Unitsdb
-    class Dimension
-      attr_accessor :vector,
-                    :id,
-                    :dimensionless
-
-      attr_reader :length,
-                  :mass,
-                  :time,
-                  :electric_current,
-                  :thermodynamic_temperature,
-                  :amount_of_substance,
-                  :luminous_intensity,
-                  :plane_angle,
-                  :parsables,
+    class Dimension < ::Unitsdb::Dimension
+      attr_reader :parsables,
                   :parsable,
-                  :processed_keys
+                  :processed_keys,
+                  :vector
 
-      def initialize
+      def initialize(attrs)
+        super
         @parsables = {}
         @processed_keys = []
         @parsable = false
@@ -66,9 +56,13 @@ module Unitsml
       end
 
       def set_vector
-        @vector ||= Utility::DIMS_VECTOR.map do |h|
-          public_send(Utility.underscore(h))&.power_numerator
-        end.join(":")
+        @set_vector ||= Utility::DIMS_VECTOR.map do |h|
+          public_send(Utility.underscore(h))&.power
+        end.join(':')
+      end
+
+      def id
+        identifiers.find { |id| id.type == 'nist' }&.id
       end
 
       private
@@ -78,7 +72,7 @@ module Unitsml
 
         instance_variable_set(:"@#{instance_var}", value)
         @processed_keys << instance_var.to_s
-        return if value.dim_symbols.nil? || value.dim_symbols.empty?
+        return if Lutaml::Model::Utils.empty?(value.symbols)
 
         @parsable = true
         value.dim_symbols_ids(@parsables, id)

data/lib/unitsml/unitsdb/dimension_quantity.rb

@@ -2,13 +2,9 @@
 
 module Unitsml
   module Unitsdb
-    class DimensionQuantity
-      attr_accessor :power_numerator,
-                    :symbol,
-                    :dim_symbols
-
+    class DimensionQuantity < ::Unitsdb::DimensionDetails
       def dim_symbols_ids(hash, dim_id)
-        dim_symbols.each { |dim_sym| hash[dim_sym.id] = dim_id }
+        symbols&.each { |dim_sym| hash[dim_sym.id] = dim_id }
       end
     end
   end