unitsml 0.4.7 → 0.6.0

data/lib/unitsml/intermediate_exp_rules.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Unitsml
+  module IntermediateExpRules
+    include Parslet
+
+    # Rules for slashed number
+    rule(:slashed_number_int_exp) do
+      slashed_number | (opening_paren >> slashed_number_named_int_exp.as(:int_exp) >> closing_paren)
+    end
+    rule(:slashed_number_named_int_exp) do
+      (opening_paren.as(:open_paren) >> slashed_number_int_exp >> closing_paren.as(:close_paren)) |
+        slashed_number_int_exp
+    end
+
+    # Rules for prefixes_units
+    rule(:wrapper_prefixes_units_value) { int_exp_prefixes_units | prefixes_units_int_exp }
+
+    rule(:extended_prefixed_units) { extender >> spaces? >> prefixes_units_int_exp.as(:sequence) }
+
+    rule(:int_exp_prefixes_units) do
+      opening_paren >> spaces? >> named_int_exp_prefixes_units.as(:int_exp) >> spaces? >> closing_paren
+    end
+
+    rule(:implicit_extended) do
+      prefixes_units.as(:first_set) >> spaces.as(:extender) >> prefixes_units.as(:second_set) |
+        int_exp_prefixes_units.as(:first_int_exp_set) >> spaces? >> int_exp_prefixes_units.as(:second_int_exp_set) |
+        prefixes_units.as(:first_set) >> spaces? >> int_exp_prefixes_units.as(:second_int_exp_set) |
+        int_exp_prefixes_units.as(:first_int_exp_set) >> spaces? >> prefixes_units.as(:second_set)
+    end
+
+    rule(:prefixes_units_int_exp) do
+      implicit_extended.as(:implicit_extended) >> spaces? >> prefixes_units_int_exp.as(:sequence).maybe |
+        implicit_extended.as(:implicit_extended) >> spaces? >> extender >> spaces? >> prefixes_units_int_exp.as(:sequence).maybe |
+        int_exp_prefixes_units >> spaces? >> extender >> spaces? >> prefixes_units_int_exp.as(:sequence).maybe |
+        prefixes_units >> spaces? >> extender >> spaces? >> prefixes_units_int_exp.as(:sequence).maybe |
+        int_exp_prefixes_units >> prefixes_units_int_exp.as(:sequence).maybe |
+        prefixes_units >> prefixes_units_int_exp.as(:sequence).maybe
+    end
+
+    rule(:prefixes_units_named_int_exp) do
+      opening_paren.as(:open_paren) >> spaces? >> wrapper_prefixes_units_value.as(:int_exp) >> spaces? >> closing_paren.as(:close_paren)
+    end
+
+    rule(:named_int_exp_prefixes_units) do
+      prefixes_units_named_int_exp.as(:int_exp) >> (prefixes_units_int_exp | extended_prefixed_units).maybe |
+        prefixes_units_int_exp
+    end
+
+    # Rules for dimension_rules
+    rule(:dimension_rules_int_exp) do
+      dimension_rules.as(:first_set) >> spaces.as(:extender) >> dimension_rules.as(:second_set) >> dimension_rules_int_exp.maybe |
+        dimension_rules.as(:first_set) >> spaces? >> int_exp_dimension_rules.as(:second_int_exp_set) >> dimension_rules_int_exp.maybe |
+        int_exp_dimension_rules.as(:first_int_exp_set) >> spaces? >> dimension_rules.as(:second_set) >> dimension_rules_int_exp.maybe |
+        int_exp_dimension_rules.as(:first_int_exp_set) >> spaces? >> int_exp_dimension_rules.as(:second_int_exp_set) >> dimension_rules_int_exp.maybe |
+        int_exp_dimension_rules |
+        dimension_rules
+    end
+
+    rule(:int_exp_dimension_rules) do
+      opening_paren >> dimension_rules_named_exp.as(:int_exp) >> closing_paren >> extended_dimension_rules.maybe
+    end
+
+    rule(:extended_dimension_rules) { spaces? >> extender >> spaces? >> dimension_rules_int_exp.as(:sequence) }
+    rule(:dimension_rules_named_exp) do
+      ((opening_paren.as(:open_paren) >> dimension_rules_int_exp.as(:int_exp) >> closing_paren.as(:close_paren)).as(:int_exp) >> spaces? >> (dimension_rules_int_exp | extended_dimension_rules).as(:sequence).maybe) |
+        dimension_rules_int_exp
+    end
+
+    # Rules for dimensions
+    rule(:sqrt_dimensions) { sqrt >> opening_paren >> dimension_rules_int_exp.as(:sqrt) >> closing_paren }
+
+    # Rules for sequence
+    rule(:sqrt_sequence) { sqrt >> opening_paren >> prefixes_units_int_exp.as(:sqrt) >> closing_paren }
+  end
+end

data/lib/unitsml/model/dimension.rb

@@ -1,19 +1,9 @@
 # frozen_string_literal: true
 
-require "unitsml/model/dimension_quantities/quantity"
-require "unitsml/model/dimension_quantities/length"
-require "unitsml/model/dimension_quantities/mass"
-require "unitsml/model/dimension_quantities/time"
-require "unitsml/model/dimension_quantities/electric_current"
-require "unitsml/model/dimension_quantities/thermodynamic_temperature"
-require "unitsml/model/dimension_quantities/amount_of_substance"
-require "unitsml/model/dimension_quantities/luminous_intensity"
-require "unitsml/model/dimension_quantities/plane_angle"
-
 module Unitsml
   module Model
     class Dimension < Lutaml::Model::Serializable
-      attribute :id, :string
+      attribute :id, :xml_id
       attribute :length, DimensionQuantities::Length
       attribute :mass, DimensionQuantities::Mass
       attribute :time, DimensionQuantities::Time
@@ -24,10 +14,10 @@ module Unitsml
       attribute :plane_angle, DimensionQuantities::PlaneAngle
 
       xml do
-        root "Dimension"
-        namespace Unitsml::UNITSML_NS
+        namespace ::Unitsml::Namespace
+        element 'Dimension'
 
-        map_attribute :id, to: :id, namespace: nil, prefix: "xml"
+        map_attribute :id, to: :id
         map_element :Length, to: :length
         map_element :Mass, to: :mass
         map_element :Time, to: :time

data/lib/unitsml/model/dimension_quantities/quantity.rb

@@ -8,6 +8,8 @@ module Unitsml
         attribute :power_numerator, :string
 
         xml do
+          namespace ::Unitsml::Namespace
+
           map_attribute :symbol, to: :symbol
           map_attribute :powerNumerator, to: :power_numerator
         end

data/lib/unitsml/model/dimension_quantities.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Unitsml
+  module Model
+    module DimensionQuantities
+      autoload :AmountOfSubstance, "#{__dir__}/dimension_quantities/amount_of_substance"
+      autoload :ElectricCurrent, "#{__dir__}/dimension_quantities/electric_current"
+      autoload :Length, "#{__dir__}/dimension_quantities/length"
+      autoload :LuminousIntensity, "#{__dir__}/dimension_quantities/luminous_intensity"
+      autoload :Mass, "#{__dir__}/dimension_quantities/mass"
+      autoload :PlaneAngle, "#{__dir__}/dimension_quantities/plane_angle"
+      autoload :Quantity, "#{__dir__}/dimension_quantities/quantity"
+      autoload :ThermodynamicTemperature, "#{__dir__}/dimension_quantities/thermodynamic_temperature"
+      autoload :Time, "#{__dir__}/dimension_quantities/time"
+    end
+  end
+end

data/lib/unitsml/model/prefix.rb

@@ -1,25 +1,21 @@
 # frozen_string_literal: true
 
-require "unitsml/model/prefixes/name"
-require "unitsml/model/prefixes/symbol"
-
-
 module Unitsml
   module Model
     class Prefix < Lutaml::Model::Serializable
       attribute :name, Prefixes::Name
-      attribute :id, :string
+      attribute :id, :xml_id
       attribute :symbol, Prefixes::Symbol, collection: true
       attribute :prefix_base, :string
       attribute :prefix_power, :string
 
       xml do
-        root "Prefix"
-        namespace Unitsml::UNITSML_NS
+        namespace ::Unitsml::Namespace
+        element 'Prefix'
 
         map_attribute :prefixBase, to: :prefix_base
         map_attribute :prefixPower, to: :prefix_power
-        map_attribute :id, to: :id, namespace: nil, prefix: "xml"
+        map_attribute :id, to: :id
         map_element :PrefixName, to: :name
         map_element :PrefixSymbol, to: :symbol
       end

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 :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,7 +8,8 @@ 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 }

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,55 +1,59 @@
 # frozen_string_literal: true
 
-require "parslet"
-require "unitsml/unitsdb"
+require 'parslet'
+
 module Unitsml
   class Parse < Parslet::Parser
-    rule(:power)  { str("^") >> intermediate_exp(slashed_number) }
-    rule(:hyphen) { str("-") }
+    include IntermediateExpRules
+
+    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(:extender) { (forward_slashes | str('*')).as(:extender) }
     rule(:sequence) { single_letter_prefixes >> units | double_letter_prefixes >> units | units }
 
+    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(:forward_slashes) { str("//") | str("/") }
+    rule(:forward_slashes) { str('//') | str('/') }
+    rule(:dimension_rules) { (sqrt_dimensions | powered_dimensions) >> extended_dimension_rules.maybe }
+    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) >> 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))
+      (sqrt_sequence >> extended_prefixed_units.maybe) |
+        (str('1').as(:unit) >> extended_prefixed_units.maybe) |
+        (unit_and_power >> extended_prefixed_units) |
+        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(:expression) do
-      intermediate_exp(prefixes_units) |
-        intermediate_exp(dimension_rules) |
+      prefixes_units_int_exp |
+        dimension_rules_int_exp |
         single_letter_prefixes >> hyphen |
         double_letter_prefixes >> hyphen
     end
@@ -57,23 +61,11 @@ module Unitsml
     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)
       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