unitsml 0.5.1 → 0.6.0

data/lib/unitsml/dimension.rb

@@ -9,63 +9,59 @@ module Unitsml
       @power_numerator = power_numerator
     end
 
-    def ==(object)
-      self.class == object.class &&
-        dimension_name == object&.dimension_name &&
-        power_numerator == object&.power_numerator
+    def ==(other)
+      self.class == other.class &&
+        dimension_name == other&.dimension_name &&
+        power_numerator == other&.power_numerator
     end
 
     def dim_instance
-      @dim ||= Unitsdb.dimensions.find_parsables_by_id(dimension_name)
+      @dim_instance ||= Unitsdb.dimensions.find_parsables_by_id(dimension_name)
     end
 
     def dim_symbols
-      dim_instance.send(@dim.processed_keys.last).symbols.first
-    end
-
-    def to_mathml(_)
-      # MathML key's value in unitsdb/dimensions.yaml file includes mi tags only.
-      value = ::Mml::Mi.from_xml(dim_symbols.mathml)
-      method_name = power_numerator ? :msup : :mi
-      if power_numerator
-        value = ::Mml::Msup.new(
-          mrow_value: [
-            ::Mml::Mrow.new(mi_value: [value]),
-            ::Mml::Mrow.new(
-              mn_value: [::Mml::Mn.new(value: power_numerator)],
-            ),
-          ]
-        )
-      end
+      dim_instance.send(dim_instance.processed_keys.last).symbols.first
+    end
+
+    def to_mathml(options)
+      # MathML key's value in unitsdb/dimensions.yaml
+      # file includes mi tags only.
+      value = ::Mml::V4::Mi.from_xml(dim_symbols.mathml)
+      method_name = if power_numerator
+                      value = msup_tag(value, options)
+                      :msup
+                    else
+                      :mi
+                    end
       { method_name: method_name, value: value }
     end
 
-    def to_latex(_)
-      power_numerator_generic_code(:latex)
+    def to_latex(options)
+      power_numerator_generic_code(:latex, options)
     end
 
-    def to_asciimath(_)
-      power_numerator_generic_code(:ascii)
+    def to_asciimath(options)
+      power_numerator_generic_code(:ascii, options)
     end
 
-    def to_unicode(_)
-      power_numerator_generic_code(:unicode)
+    def to_unicode(options)
+      power_numerator_generic_code(:unicode, options)
     end
 
-    def to_html(_)
+    def to_html(options)
       value = dim_symbols.html
-      value = "#{value}<sup>#{power_numerator}</sup>" if power_numerator
+      value = "#{value}#{html_numerator_conversion(options)}" if power_numerator
       value
     end
 
     def generate_id
-      "#{dimension_name.split('_').last}#{power_numerator}"
+      "#{dimension_name.split('_').last}#{power_numerator&.raw_value}"
     end
 
     def to_xml(_)
       attributes = {
         symbol: dim_instance.processed_symbol,
-        power_numerator: power_numerator || 1,
+        power_numerator: power_numerator&.raw_value || 1
       }
       Model::DimensionQuantities.const_get(modelize(element_name)).new(attributes)
     end
@@ -75,20 +71,38 @@ module Unitsml
     end
 
     def modelize(value)
-      value&.split("_")&.map(&:capitalize)&.join
+      value&.split('_')&.map(&:capitalize)&.join
     end
 
     private
 
-    def power_numerator_generic_code(method_name)
+    def html_numerator_conversion(options)
+      "<sup>#{power_numerator.to_html(options)}</sup>"
+    end
+
+    def power_numerator_generic_code(method_name, options)
       value = dim_symbols.public_send(method_name)
       return value unless power_numerator
 
-      "#{value}^#{power_numerator}"
+      method_name = :asciimath if method_name == :ascii
+      "#{value}^#{power_numerator&.public_send(:"to_#{method_name}", options)}"
     end
 
     def element_name
       dim_instance.processed_keys.first
     end
+
+    def msup_tag(value, options)
+      mathml = power_numerator.to_mathml(options)
+      msup = ::Mml::V4::Msup.new(
+        mrow_value: [::Mml::V4::Mrow.new(mi_value: [value])]
+      )
+      [mathml].flatten.each do |record|
+        record_values = msup.public_send("#{record[:method_name]}_value") || []
+        record_values += [record[:value]]
+        msup.public_send("#{record[:method_name]}_value=", record_values)
+      end
+      msup
+    end
   end
 end

data/lib/unitsml/errors/base_error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Unitsml
+  module Errors
+    class BaseError < StandardError
+    end
+  end
+end

data/lib/unitsml/errors/plurimath_load_error.rb

@@ -2,7 +2,7 @@
 
 module Unitsml
   module Errors
-    class PlurimathLoadError < Unitsml::Error
+    class PlurimathLoadError < Unitsml::Errors::BaseError
       def to_s
         <<~MESSAGE
           [unitsml] Error: Failed to require 'plurimath'.

data/lib/unitsml/errors.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Unitsml
+  module Errors
+    autoload :BaseError, 'unitsml/errors/base_error'
+    autoload :PlurimathLoadError, 'unitsml/errors/plurimath_load_error'
+  end
+end

data/lib/unitsml/extender.rb

@@ -8,22 +8,22 @@ module Unitsml
       @symbol = symbol
     end
 
-    def ==(object)
-      self.class == object.class &&
-        symbol == object&.symbol
+    def ==(other)
+      self.class == other.class &&
+        symbol == other&.symbol
     end
 
     def to_mathml(options)
-      rspace = "thickmathspace" if options[:multiplier] == :space
-      extender = multiplier(options[:multiplier] || "⋅", unicode: true)
+      rspace = 'thickmathspace' if options[:multiplier] == :space
+      extender = multiplier(options[:multiplier] || '⋅', unicode: true)
       {
         method_name: :mo,
-        value: ::Mml::Mo.new(value: extender, rspace: rspace),
+        value: ::Mml::V4::Mo.new(value: extender, rspace: rspace)
       }
     end
 
     def to_latex(options)
-      multiplier(options[:multiplier] || "/")
+      multiplier(options[:multiplier] || '/')
     end
 
     def to_asciimath(options)
@@ -31,12 +31,11 @@ module Unitsml
     end
 
     def to_html(options)
-      multiplier(options[:multiplier] || "⋅", unicode: true, html: true)
+      multiplier(options[:multiplier] || '⋅', unicode: true, html: true)
     end
 
     def to_unicode(options)
-      extender = options[:multiplier] ||
-                   symbol == "*" ? "·" : symbol
+      extender = options[:multiplier] || unicode_extender
       multiplier(extender)
     end
 
@@ -45,16 +44,22 @@ module Unitsml
     def multiplier(extender, unicode: false, html: false)
       case extender
       when :space
-        if html
-          " "
-        else
-          unicode ? "⁢" : " "
-        end
+        space_extender(html, unicode)
       when :nospace
-        unicode ? "⁢" : ""
+        unicode ? '⁢' : ''
       else
         unicode ? Utility.string_to_html_entity(extender) : extender
       end
     end
+
+    def space_extender(html, unicode)
+      return ' ' if html
+
+      unicode ? '⁢' : ' '
+    end
+
+    def unicode_extender
+      symbol == '*' ? '·' : symbol
+    end
   end
 end

data/lib/unitsml/fenced.rb

@@ -1,5 +1,9 @@
+# frozen_string_literal: true
+
 module Unitsml
   class Fenced
+    include FencedNumeric
+
     attr_reader :open_paren, :value, :close_paren
 
     def initialize(open_paren, value, close_paren)
@@ -8,11 +12,11 @@ module Unitsml
       @close_paren = close_paren
     end
 
-    def ==(object)
-      self.class == object.class &&
-        open_paren == object&.open_paren &&
-        value == object&.value &&
-        close_paren == object&.close_paren
+    def ==(other)
+      self.class == other.class &&
+        open_paren == other&.open_paren &&
+        value == other&.value &&
+        close_paren == other&.close_paren
     end
 
     def to_asciimath(options = {})
@@ -27,15 +31,31 @@ module Unitsml
       mathml = value.to_mathml(options)
       return mathml unless options[:explicit_parenthesis]
 
-      fenced = ::Mml::Mrow.new(mo_value: [::Mml::Mo.new(value: open_paren)])
+      fenced = ::Mml::V4::Mrow.new(mo_value: [::Mml::V4::Mo.new(value: open_paren)])
       fenced.ordered = true
-      fenced.element_order ||= [xml_order_element("mo")]
+      fenced.element_order ||= [xml_order_element('mo')]
       [mathml].flatten.each { |record| add_math_element(fenced, record) }
-      fenced.mo_value << ::Mml::Mo.new(value: close_paren)
-      fenced.element_order << xml_order_element("mo")
+      fenced.mo_value << ::Mml::V4::Mo.new(value: close_paren)
+      fenced.element_order << xml_order_element('mo')
       { method_name: :mrow, value: fenced }
     end
 
+    def negative?
+      value.negative?
+    end
+
+    def update_negative_sign
+      value.update_negative_sign
+    end
+
+    def float_to_display
+      value.float_to_display
+    end
+
+    def raw_value
+      value.raw_value
+    end
+
     def to_html(options = {})
       fenced_conversion_for(lang: :html, options: options)
     end
@@ -64,7 +84,7 @@ module Unitsml
     end
 
     def xml_order_element(tag_name)
-      Lutaml::Model::Xml::Element.new("Element", tag_name)
+      Lutaml::Xml::Element.new('Element', tag_name)
     end
 
     def fenced_conversion_for(lang:, options:)

data/lib/unitsml/fenced_numeric.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Unitsml
+  module FencedNumeric
+    def to_i
+      value.to_i
+    end
+
+    def to_f
+      value.to_f
+    end
+  end
+end

data/lib/unitsml/formula.rb

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 
-require "mml"
-require "htmlentities"
-require "unitsml/utility"
+require 'mml'
+require 'htmlentities'
 
 module Unitsml
   class Formula
@@ -20,25 +19,25 @@ module Unitsml
       @norm_text = norm_text
     end
 
-    def ==(object)
-      self.class == object.class &&
-        value == object&.value &&
-        explicit_value == object&.explicit_value &&
-        root == object.root
+    def ==(other)
+      self.class == other.class &&
+        value == other&.value &&
+        explicit_value == other&.explicit_value &&
+        root == other.root
     end
 
     def to_mathml(options = {})
       if root
         options = update_options(options)
         nullify_mml_models if plurimath_available?
-        math = ::Mml::MathWithNamespace.new(display: "block")
+        math = ::Mml::V4::Math.new(display: 'block')
         math.ordered = true
         math.element_order ||= []
         value.each { |instance| process_value(math, instance.to_mathml(options)) }
-
-        generated_math = math.to_xml.gsub(/&amp;(.*?)(?=<\/)/, '&\1')
+        generated_math = math.to_xml.gsub(%r{&amp;(.*?)(?=</)}, '&\1')
         reset_mml_models if plurimath_available?
-        generated_math
+
+        generated_math.force_encoding('UTF-8')
       else
         value.map { |obj| obj.to_mathml(options) }
       end
@@ -87,19 +86,20 @@ module Unitsml
 
     def extract_dimensions(formula)
       formula.each_with_object([]) do |term, dimensions|
-        if term.is_a?(Dimension)
+        case term
+        when Dimension
           dimensions << term
-        elsif term.is_a?(Sqrt)
+        when Sqrt
           if term.value.is_a?(Dimension)
             sqrt_term = term.value.dup
-            sqrt_term.power_numerator = "0.5"
+            sqrt_term.power_numerator = Number.new('0.5')
             dimensions << sqrt_term
           elsif term.value.is_a?(Fenced)
             dimensions.concat(Array(term.value.dimensions_extraction))
           end
-        elsif term.is_a?(Formula)
+        when Formula
           dimensions.concat(extract_dimensions(term.value))
-        elsif term.is_a?(Fenced)
+        when Fenced
           dimensions.concat(Array(term.dimensions_extraction))
         end
       end
@@ -124,20 +124,20 @@ module Unitsml
 
     def units(options)
       all_units = extract_units(value)
-      norm_text = all_units.map(&:xml_postprocess_name).join("*")
+      norm_text = all_units.map(&:xml_postprocess_name).join('*')
       dims = Utility.units2dimensions(extract_units(value))
       [
         Utility.unit(all_units, self, dims, norm_text, explicit_value&.dig(:name), options),
         Utility.prefixes(all_units, options),
         *unique_dimensions(dims, norm_text),
-        Utility.quantity(norm_text, explicit_value&.dig(:quantity)),
+        Utility.quantity(norm_text, explicit_value&.dig(:quantity))
       ].join
     end
 
     def unique_dimensions(dims, norm_text)
       [
         Utility.dimension(norm_text),
-        Utility.dimension_components(dims),
+        Utility.dimension_components(dims)
       ].uniq
     end
 
@@ -145,31 +145,31 @@ module Unitsml
       dim_id = dims.map(&:generate_id).join
       attributes = { id: "D_#{dim_id}" }
       dims.each { |dim| attributes.merge!(dim.xml_instances_hash(options)) }
-      Model::Dimension.new(attributes).to_xml
+      Model::Dimension.new(attributes).to_xml.force_encoding('UTF-8')
     end
 
     def sort_dims(values)
-      dims_hash = Utility::Dim2D
+      dims_hash = Utility::DIM2D
       values.sort do |first, second|
         dims_hash.dig(first.dimension_name, :order) <=> dims_hash.dig(second.dimension_name, :order)
       end
     end
 
     def prefixes(options)
-      norm_text = @norm_text&.split("-")&.first
-      prefix_object = Unit.new("", prefix: Prefix.new(norm_text))
+      norm_text = @norm_text&.split('-')&.first
+      prefix_object = Unit.new('', prefix: Prefix.new(norm_text))
       [
         Utility.prefixes([prefix_object], options),
         Utility.dimension(norm_text),
-        Utility.quantity(norm_text, explicit_value&.dig(:quantity)),
+        Utility.quantity(norm_text, explicit_value&.dig(:quantity))
       ].join
     end
 
     def ensure_plurimath_defined!
       return if plurimath_available?
 
-      require "plurimath"
-    rescue LoadError => e
+      require 'plurimath'
+    rescue LoadError
       raise Errors::PlurimathLoadError
     end
 
@@ -178,7 +178,7 @@ module Unitsml
       method_value = math_instance.public_send(:"#{method_name}_value") || []
       method_value += Array(child_hash[:value])
       math_instance.public_send(:"#{method_name}_value=", method_value)
-      math_instance.element_order << Lutaml::Model::Xml::Element.new("Element", method_name.to_s)
+      math_instance.element_order << Lutaml::Xml::Element.new('Element', method_name.to_s)
     end
 
     def plurimath_available?
@@ -192,7 +192,7 @@ module Unitsml
     end
 
     def reset_mml_models
-      ::Mml::Configuration.custom_models = Plurimath::Mathml::Parser::CONFIGURATION
+      ::Mml::V4::Configuration.custom_models = Plurimath::Mathml::Parser::CONFIGURATION
     end
 
     def process_value(math, mathml_instances)

data/lib/unitsml/intermediate_exp_rules.rb

@@ -1,35 +1,76 @@
+# frozen_string_literal: true
+
 module Unitsml
   module IntermediateExpRules
     include Parslet
 
     # Rules for slashed number
-    rule(:slashed_number_int_exp) { slashed_number | (str("(") >> slashed_number >> str(")")) }
+    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(:prefixes_units_int_exp) { prefixes_units | (str("(") >> prefixes_units_named_exp.as(:intermediate_exp) >> str(")") >> extended_prefixed_units.maybe) }
-    rule(:extended_prefixed_units) { extender >> prefixes_units_int_exp.as(:sequence) }
-    rule(:prefixes_units_named_exp) do
-      prefixes_units |
-        ((str("(").as(:open_parenthesis) >> prefixes_units_int_exp.as(:int_exp) >> str(")").as(:close_parenthesis)).as(:intermediate_exp) >> extended_prefixed_units.maybe)
+    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) { dimension_rules | (str("(") >> dimension_rules_named_exp.as(:intermediate_exp) >> str(")") >> extended_dimension_rules.maybe) }
-    rule(:extended_dimension_rules) { extender >> dimension_rules_int_exp.as(:sequence) }
+    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
-      dimension_rules |
-        ((str("(").as(:open_parenthesis) >> dimension_rules_int_exp.as(:int_exp) >> str(")").as(:close_parenthesis)).as(:intermediate_exp) >> extended_dimension_rules.maybe)
+      ((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) { str("sqrt(") >> dimensions_int_exp.as(:sqrt) >> str(")") }
-    rule(:powered_dimensions) { dimensions >> power.maybe }
-    rule(:dimensions_int_exp) { powered_dimensions | (str("(") >> dimensions_named_exp.as(:intermediate_exp) >> str(")")) }
-    rule(:dimensions_named_exp) { powered_dimensions | (str("(").as(:open_parenthesis) >> dimensions_int_exp.as(:int_exp) >> str(")").as(:close_parenthesis)) }
+    rule(:sqrt_dimensions) { sqrt >> opening_paren >> dimension_rules_int_exp.as(:sqrt) >> closing_paren }
 
     # Rules for sequence
-    rule(:sqrt_sequence) { str("sqrt(") >> sequence_int_exp.as(:sqrt) >> str(")") }
-    rule(:sequence_int_exp) { sequence | (str("(") >> sequence_named_exp.as(:intermediate_exp)>> str(")")) }
-    rule(:sequence_named_exp) { sequence | (str("(").as(:open_parenthesis) >> sequence_int_exp.as(:int_exp) >> str(")").as(:close_parenthesis)) }
+    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