unitsml 0.5.1 → 0.6.1

data/lib/unitsml/model/prefixes/name.rb

@@ -2,15 +2,16 @@
 
 module Unitsml
   module Model
-    class Prefixes
+    module Prefixes
       class Name < Lutaml::Model::Serializable
-        attribute :lang, :string, default: -> { "en" }
+        attribute :lang, :xml_lang, default: -> { "en" }
         attribute :content, :string
 
         xml do
-          root "PrefixName"
+          element "PrefixName"
+          namespace ::Unitsml::Namespace
 
-          map_attribute :lang, to: :lang, namespace: nil, prefix: "xml", render_default: true
+          map_attribute :lang, to: :lang, render_default: true
           map_content to: :content
         end
       end

data/lib/unitsml/model/prefixes/symbol.rb

@@ -2,13 +2,14 @@
 
 module Unitsml
   module Model
-    class Prefixes
+    module Prefixes
       class Symbol < Lutaml::Model::Serializable
         attribute :type, :string
         attribute :content, :string
 
         xml do
-          root "PrefixSymbol"
+          element "PrefixSymbol"
+          namespace ::Unitsml::Namespace
 
           map_attribute :type, to: :type
           map_content to: :content

data/lib/unitsml/model/prefixes.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Unitsml
+  module Model
+    module Prefixes
+      autoload :Name, "#{__dir__}/prefixes/name"
+      autoload :Symbol, "#{__dir__}/prefixes/symbol"
+    end
+  end
+end

data/lib/unitsml/model/quantities/name.rb

@@ -4,13 +4,14 @@ module Unitsml
   module Model
     module Quantities
       class Name < Lutaml::Model::Serializable
-        attribute :lang, :string, default: -> { "en-US" }
+        attribute :lang, :xml_lang, default: -> { "en" }
         attribute :content, :string
 
         xml do
-          root "QuantityName"
+          element "QuantityName"
+          namespace ::Unitsml::Namespace
 
-          map_attribute :lang, to: :lang, namespace: nil, prefix: "xml", render_default: true
+          map_attribute :lang, to: :lang, render_default: true
           map_content to: :content
         end
       end

data/lib/unitsml/model/quantities.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Unitsml
+  module Model
+    module Quantities
+      autoload :Name, "#{__dir__}/quantities/name"
+    end
+  end
+end

data/lib/unitsml/model/quantity.rb

@@ -1,20 +1,18 @@
 # frozen_string_literal: true
 
-require "unitsml/model/quantities/name"
-
 module Unitsml
   module Model
     class Quantity < Lutaml::Model::Serializable
-      attribute :id, :string
+      attribute :id, :xml_id
       attribute :name, Quantities::Name, collection: true
       attribute :quantity_type, :string, default: -> { "base" }
       attribute :dimension_url, :string
 
       xml do
-        root "Quantity"
-        namespace Unitsml::UNITSML_NS
+        namespace ::Unitsml::Namespace
+        element "Quantity"
 
-        map_attribute :id, to: :id, namespace: nil, prefix: "xml"
+        map_attribute :id, to: :id
         map_attribute :quantityType, to: :quantity_type, render_default: true
         map_attribute :dimensionURL, to: :dimension_url
         map_element :QuantityName, to: :name

data/lib/unitsml/model/unit.rb

@@ -1,14 +1,9 @@
 # frozen_string_literal: true
 
-require "unitsml/model/units/name"
-require "unitsml/model/units/symbol"
-require "unitsml/model/units/system"
-require "unitsml/model/units/root_units"
-
 module Unitsml
   module Model
     class Unit < Lutaml::Model::Serializable
-      attribute :id, :string
+      attribute :id, :xml_id
       attribute :name, Units::Name
       attribute :dimension_url, :string
       attribute :symbol, Units::Symbol, collection: true
@@ -16,11 +11,11 @@ module Unitsml
       attribute :root_units, Units::RootUnits
 
       xml do
-        root "Unit"
-        namespace Unitsml::UNITSML_NS
+        namespace ::Unitsml::Namespace
+        element "Unit"
 
         map_attribute :dimensionURL, to: :dimension_url
-        map_attribute :id, to: :id, namespace: nil, prefix: "xml"
+        map_attribute :id, to: :id
         map_element :UnitSystem, to: :system
         map_element :UnitName, to: :name
         map_element :UnitSymbol, to: :symbol

data/lib/unitsml/model/units/enumerated_root_unit.rb

@@ -9,6 +9,7 @@ module Unitsml
         attribute :power_numerator, :string
 
         xml do
+          namespace ::Unitsml::Namespace
           map_attribute :unit, to: :unit
           map_attribute :prefix, to: :prefix
           map_attribute :powerNumerator, to: :power_numerator

data/lib/unitsml/model/units/name.rb

@@ -5,13 +5,14 @@ module Unitsml
     module Units
       class Name < Lutaml::Model::Serializable
         attribute :name, :string
-        attribute :lang, :string, default: -> { "en" }
+        attribute :lang, :xml_lang, default: -> { "en" }
 
         xml do
-          root "UnitName"
+          element "UnitName"
+          namespace ::Unitsml::Namespace
 
           map_content to: :name
-          map_attribute :lang, to: :lang, namespace: nil, prefix: "xml", render_default: true
+          map_attribute :lang, to: :lang, render_default: true
         end
       end
     end

data/lib/unitsml/model/units/root_units.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "unitsml/model/units/enumerated_root_unit"
-
 module Unitsml
   module Model
     module Units
@@ -9,6 +7,9 @@ module Unitsml
         attribute :enumerated_root_unit, EnumeratedRootUnit, collection: true
 
         xml do
+          element "RootUnits"
+          namespace ::Unitsml::Namespace
+
           map_element :EnumeratedRootUnit, to: :enumerated_root_unit
         end
       end

data/lib/unitsml/model/units/symbol.rb

@@ -8,10 +8,13 @@ module Unitsml
         attribute :content, :string
 
         xml do
-          root "UnitSymbol"
+          element "UnitSymbol"
+          namespace ::Unitsml::Namespace
 
           map_attribute :type, to: :type
-          map_content to: :content, with: { from: :content_from_xml, to: :content_to_xml }
+          map_content to: :content,
+                      with: { from: :content_from_xml,
+                              to: :content_to_xml }
         end
 
         # Not reading any XML for now.

data/lib/unitsml/model/units/system.rb

@@ -6,14 +6,15 @@ module Unitsml
       class System < Lutaml::Model::Serializable
         attribute :name, :string
         attribute :type, :string
-        attribute :lang, :string, default: -> { "en-US" }
+        attribute :lang, :xml_lang, default: -> { "en" }
 
         xml do
-          root "UnitSystem"
+          element "UnitSystem"
+          namespace ::Unitsml::Namespace
 
           map_attribute :name, to: :name
           map_attribute :type, to: :type
-          map_attribute :lang, to: :lang, namespace: nil, prefix: "xml", render_default: true
+          map_attribute :lang, to: :lang, render_default: true
         end
       end
     end

data/lib/unitsml/model/units.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Unitsml
+  module Model
+    module Units
+      autoload :EnumeratedRootUnit, "unitsml/model/units/enumerated_root_unit"
+      autoload :Name, "unitsml/model/units/name"
+      autoload :RootUnits, "unitsml/model/units/root_units"
+      autoload :Symbol, "unitsml/model/units/symbol"
+      autoload :System, "unitsml/model/units/system"
+    end
+  end
+end

data/lib/unitsml/model.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Unitsml
+  module Model
+    autoload :Dimension, "#{__dir__}/model/dimension"
+    autoload :DimensionQuantities, "#{__dir__}/model/dimension_quantities"
+    autoload :Namespace, "#{__dir__}/model/namespace"
+    autoload :Prefix, "#{__dir__}/model/prefix"
+    autoload :Prefixes, "#{__dir__}/model/prefixes"
+    autoload :Quantities, "#{__dir__}/model/quantities"
+    autoload :Quantity, "#{__dir__}/model/quantity"
+    autoload :Unit, "#{__dir__}/model/unit"
+    autoload :Units, "#{__dir__}/model/units"
+  end
+end

data/lib/unitsml/namespace.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Unitsml
+  class Namespace < Lutaml::Xml::Namespace
+    uri "https://schema.unitsml.org/unitsml/1.0"
+    prefix_default "unitsml"
+  end
+end

data/lib/unitsml/number.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Unitsml
+  class Number
+    include FencedNumeric
+
+    attr_accessor :value
+    alias raw_value value
+
+    def initialize(value)
+      @value = value
+    end
+
+    def ==(other)
+      self.class == other.class &&
+        value == other&.value
+    end
+
+    def to_mathml(_options)
+      matched_value = value&.match(/-?(.+)/)
+      mn_value = matched_value ? matched_value[1] : value
+      mn_tag = ::Mml::V4::Mn.new(value: mn_value)
+      value.start_with?("-") ? mrow_hash(mn_tag) : mn_hash(mn_tag)
+    end
+
+    def to_html(_options)
+      value.sub("-", "−")
+    end
+
+    def to_latex(_options)
+      value
+    end
+
+    def to_asciimath(_options)
+      value
+    end
+
+    def to_unicode(_options)
+      value
+    end
+
+    def negative?
+      value.start_with?("-")
+    end
+
+    def update_negative_sign
+      self.value = if negative?
+                     value.delete_prefix("-")
+                   else
+                     ["-", value].join
+                   end
+    end
+
+    def float_to_display
+      return "" if value.nil?
+
+      value.to_f.round(1).to_s.sub(/\.0$/, "")
+    end
+
+    private
+
+    def mrow_hash(mn_tag)
+      {
+        method_name: :mrow,
+        value: ::Mml::V4::Mrow.new(
+          mo_value: [::Mml::V4::Mo.new(value: "−")],
+          mn_value: [mn_tag],
+        ),
+      }
+    end
+
+    def mn_hash(mn_tag)
+      {
+        method_name: :mn,
+        value: mn_tag,
+      }
+    end
+  end
+end

data/lib/unitsml/parse.rb

@@ -1,66 +1,78 @@
 # frozen_string_literal: true
 
 require "parslet"
-require "unitsml/unitsdb"
-require_relative "intermediate_exp_rules"
+
 module Unitsml
   class Parse < Parslet::Parser
     include IntermediateExpRules
 
-    rule(:power)  { str("^") >> slashed_number_int_exp }
+    rule(:sqrt)  { str("sqrt") }
+    rule(:power) { str("^") >> slashed_number_int_exp.as(:power_numerator) }
     rule(:hyphen) { str("-") }
     rule(:number) { hyphen.maybe >> match(/[0-9]/).repeat(1) }
+    rule(:spaces) { match(/\s/).repeat(1) }
+    rule(:spaces?) { spaces.maybe }
 
     rule(:extender) { (forward_slashes | str("*")).as(:extender) }
-    rule(:sequence) { single_letter_prefixes >> units | double_letter_prefixes >> units | units }
+    rule(:sequence) do
+      (single_letter_prefixes >> units) | (double_letter_prefixes >> units) | units
+    end
 
+    rule(:opening_paren)   { str("(") }
+    rule(:closing_paren)   { str(")") }
     rule(:unit_and_power)  { units >> power.maybe }
-    rule(:slashed_number)  { (number >> (forward_slashes >> number).maybe).as(:integer) }
+    rule(:slashed_number)  do
+      (number >> (forward_slashes >> number).maybe).as(:integer)
+    end
     rule(:forward_slashes) { str("//") | str("/") }
+    rule(:dimension_rules) do
+      (sqrt_dimensions | powered_dimensions) >> extended_dimension_rules.maybe
+    end
+    rule(:powered_dimensions) { dimensions >> power.maybe }
 
     rule(:units) do
-      @@filtered_units ||= arr_to_expression(Unitsdb.units.filtered, "units")
+      @@filtered_units ||= arr_to_expression(::Unitsml::Unitsdb.units.filtered,
+                                             "unit")
     end
 
     rule(:single_letter_prefixes) do
-      @@prefixes1 ||= arr_to_expression(Unitsdb.prefixes_by_size(1), "prefixes")
+      @@prefixes1 ||= arr_to_expression(::Unitsml::Unitsdb.prefixes_by_size(1),
+                                        "prefix")
     end
 
     rule(:double_letter_prefixes) do
-      @@prefixes2 ||= arr_to_expression(Unitsdb.prefixes_by_size(2), "prefixes")
+      @@prefixes2 ||= arr_to_expression(::Unitsml::Unitsdb.prefixes_by_size(2),
+                                        "prefix")
     end
 
     rule(:dimensions) do
-      @@dimensions ||= arr_to_expression(Unitsdb.dimensions.parsables.keys, "dimensions")
+      @@dimensions ||= arr_to_expression(
+        ::Unitsml::Unitsdb.dimensions.parsables.keys, "dimension"
+      )
     end
 
     rule(:prefixes_units) do
       (sqrt_sequence >> extended_prefixed_units.maybe) |
-        (str("1").as(:units) >> extended_prefixed_units.maybe) |
+        (str("1").as(:unit) >> extended_prefixed_units.maybe) |
         (unit_and_power >> extended_prefixed_units) |
-        unit_and_power >> (str(")").present? | any.absent?) |
+        (unit_and_power >> (any.absent? | (extender | opening_paren | closing_paren | spaces).present?)) |
         (double_letter_prefixes >> unit_and_power >> extended_prefixed_units) |
         (double_letter_prefixes >> unit_and_power) |
         (single_letter_prefixes >> unit_and_power >> extended_prefixed_units) |
         (single_letter_prefixes >> unit_and_power)
     end
 
-    rule(:dimension_rules) do
-      (sqrt_dimensions >> extended_dimension_rules.maybe) |
-        (powered_dimensions >> extended_dimension_rules.maybe)
-    end
-
     rule(:expression) do
       prefixes_units_int_exp |
         dimension_rules_int_exp |
-        single_letter_prefixes >> hyphen |
-        double_letter_prefixes >> hyphen
+        (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 = 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)

data/lib/unitsml/parser.rb

@@ -5,7 +5,7 @@ module Unitsml
     attr_accessor :text
 
     def initialize(text)
-      @regexp = %r{(quantity|name|symbol|multiplier):\s*}
+      @regexp = /(quantity|name|symbol|multiplier):\s*/
       @text = extract_equation(text)
       @orig_text = @text
       @text = @text.gsub("−", "-")
@@ -33,7 +33,7 @@ module Unitsml
         if object.is_a?(Sqrt)
           object = object.value
           if object.respond_to?(:power_numerator)
-            object.power_numerator = "0.5"
+            object.power_numerator = Number.new("0.5")
           else
             update_units_exponents([object], inverse, true)
           end
@@ -41,12 +41,11 @@ module Unitsml
 
         case object
         when Unit
-          next object.power_numerator = "0.5" if sqrt
+          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 Dimension then object.power_numerator = "0.5" if sqrt
+          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)

data/lib/unitsml/prefix.rb

@@ -9,18 +9,20 @@ 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
-      @id ||= prefix_instance.identifiers.find { |prefix| prefix.type == "nist" }&.id
+      @id ||= prefix_instance.identifiers.find do |prefix|
+        prefix.type == "nist"
+      end&.id
     end
 
     def name
@@ -34,12 +36,12 @@ module Unitsml
     def to_mathml(_)
       symbol = Utility.string_to_html_entity(
         Utility.html_entity_to_unicode(
-          prefix_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(_)
@@ -59,7 +61,7 @@ module Unitsml
     end
 
     def symbolid
-      prefix_symbols.ascii if prefix_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)