unitsml 0.4.7 → 0.5.1

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
@@ -67,10 +57,14 @@ module Unitsml
 
       def set_vector
         @vector ||= Utility::DIMS_VECTOR.map do |h|
-          public_send(Utility.underscore(h))&.power_numerator
+          public_send(Utility.underscore(h))&.power
         end.join(":")
       end
 
+      def id
+        identifiers.find { |id| id.type == "nist" }&.id
+      end
+
       private
 
       def quantities_common_code(instance_var, value)
@@ -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

data/lib/unitsml/unitsdb/dimensions.rb

@@ -2,11 +2,9 @@
 
 module Unitsml
   module Unitsdb
-    class Dimensions
-      attr_accessor :dimensions
-
+    class Dimensions < ::Unitsdb::Dimensions
       def find_by_vector(vector)
-        vectored
+        @vectored ||= dimensions.each(&:set_vector)
         find(:vector, vector)
       end
 
@@ -26,13 +24,11 @@ module Unitsml
 
       private
 
-      def vectored
-        @vectored ||= dimensions.each(&:set_vector)
-      end
-
       def find(field, matching_data)
         dimensions.find { |dim| dim.send(field) == matching_data }
       end
     end
   end
 end
+
+Unitsml.register.register_model(Unitsml::Unitsdb::Dimensions, id: :unitsdb_dimensions)

data/lib/unitsml/unitsdb/prefix_reference.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Unitsml
+  module Unitsdb
+    class PrefixReference < ::Unitsdb::PrefixReference
+      def base
+        prefix.base
+      end
+
+      def symbolid
+        prefix.symbols.first.ascii
+      end
+
+      def power
+        prefix.power
+      end
+
+      def prefix
+        @prefix ||= Unitsdb.prefixes.find_by_id(id)
+      end
+    end
+  end
+end

data/lib/unitsml/unitsdb/prefixes.rb

@@ -2,21 +2,35 @@
 
 module Unitsml
   module Unitsdb
-    class Prefixes
-      attr_accessor :prefixes
+    class Prefixes < ::Unitsdb::Prefixes
+      def find_by_id(p_id)
+        find(p_id, :id, :identifiers)
+      end
 
       def find_by_symbol_name(ascii_sym)
-        prefixes.find { |prefix| prefix.symbol.ascii == ascii_sym }
+        find(ascii_sym, :ascii, :symbols)
       end
 
       def ascii_symbols
         prefixes.each_with_object([]) do |prefix, names_array|
-          symbol = prefix.symbol.ascii
+          symbol = prefix.symbols.map(&:ascii)
           next if symbol.empty?
 
-          names_array << symbol
+          names_array.concat(symbol)
+        end
+      end
+
+      private
+
+      def find(matching_data, field, prefix_method)
+        prefixes.find do |prefix|
+          prefix.public_send(prefix_method.to_sym).find do |object|
+            object.public_send(field) == matching_data
+          end
         end
       end
     end
   end
 end
+
+Unitsml.register.register_model(Unitsml::Unitsdb::Prefixes, id: :unitsdb_prefixes)

data/lib/unitsml/unitsdb/quantities.rb

@@ -2,12 +2,14 @@
 
 module Unitsml
   module Unitsdb
-    class Quantities
-      attr_accessor :quantities
-
+    class Quantities < ::Unitsdb::Quantities
       def find_by_id(q_id)
-        quantities.find { |quantity| quantity.id == q_id }
+        quantities.find do |quantity|
+          quantity.identifiers.find { |id| id.id == q_id }
+        end
       end
     end
   end
 end
+
+Unitsml.register.register_model(Unitsml::Unitsdb::Quantities, id: :unitsdb_quantities)

data/lib/unitsml/unitsdb/unit.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Unitsml
+  module Unitsdb
+    class Unit < ::Unitsdb::Unit
+      def dimension_url
+        quantity_id = quantity_references[0].id
+        quantity = Unitsdb.quantities.find_by_id(quantity_id)
+        quantity.dimension_reference.id
+      end
+
+      def en_name
+        names.find { |name| name.lang == "en" }&.value
+      end
+
+      def nist_id
+        identifiers.find { |id| id.type == "nist" }&.id
+      end
+    end
+  end
+end

data/lib/unitsml/unitsdb/units.rb

@@ -2,43 +2,46 @@
 
 module Unitsml
   module Unitsdb
-    class Units
-      attr_accessor :units
-
+    class Units < ::Unitsdb::Units
       def find_by_id(u_id)
-        units.find { |unit| unit.id == u_id }
+        find(u_id, :id, :identifiers)
       end
 
       def find_by_name(u_name)
-        units.find do |unit|
-          unit.unit_symbols.find { |u_sym| u_sym.id == u_name }
-        end
+        find(u_name, :id, :symbols)
       end
 
       def filtered
-        @filtered ||= units_symbol_ids.reject do |unit|
+        @filtered ||= symbols_ids.reject do |unit|
           ((/\*|\^|\/|^1$/).match?(unit) || find_by_symbol_id(unit).prefixed)
         end
       end
 
       def find_by_symbol_id(sym_id)
-        units_symbol_hash[sym_id]
+        symbols_hash[sym_id]
+      end
+
+      def symbols_ids
+        symbols_hash.keys
       end
 
-      def units_symbol_ids
-        units_symbol_hash.keys
+      def symbols_hash
+        @symbol_ids_hash ||= units.each_with_object({}) do |unit, object|
+          unit.symbols&.each { |unit_sym| object[unit_sym.id] = unit }
+        end
       end
 
-      def units_symbol_hash
-        @symbol_ids_hash ||= {}
+      private
 
-        if @symbol_ids_hash.empty?
-          units.each_with_object(@symbol_ids_hash) do |unit, object|
-            unit.unit_symbols.each { |unit_sym| object[unit_sym.id] = unit }
+      def find(matching_data, field, unit_method)
+        units.find do |unit|
+          unit.public_send(unit_method.to_sym).find do |id|
+            id.public_send(field) == matching_data
           end
         end
-        @symbol_ids_hash
       end
     end
   end
 end
+
+Unitsml.register.register_model(Unitsml::Unitsdb::Units, id: :unitsdb_units)

data/lib/unitsml/unitsdb.rb

@@ -9,19 +9,19 @@ module Unitsml
       end
 
       def units
-        @@units_file ||= ::Unitsdb::Units.from_yaml(load_file(:units))
+        @@units_file ||= get_class_from_register(:unitsdb_units).from_yaml(load_file(:units))
       end
 
       def prefixes
-        @@prefixes ||= ::Unitsdb::Prefixes.from_yaml(load_file(:prefixes))
+        @@prefixes ||= get_class_from_register(:unitsdb_prefixes).from_yaml(load_file(:prefixes))
       end
 
       def dimensions
-        @@dim_file ||= ::Unitsdb::Dimensions.from_yaml(load_file(:dimensions))
+        @@dim_file ||= get_class_from_register(:unitsdb_dimensions).from_yaml(load_file(:dimensions))
       end
 
       def quantities
-        @@quantities ||= ::Unitsdb::Quantities.from_yaml(load_file(:quantities))
+        @@quantities ||= get_class_from_register(:unitsdb_quantities).from_yaml(load_file(:quantities))
       end
 
       def prefixes_array
@@ -40,6 +40,10 @@ module Unitsml
           File.join(__dir__, "..", "..","unitsdb", "#{file_name}.yaml")
         )
       end
+
+      def get_class_from_register(class_name)
+        Unitsml.register.get_class(class_name)
+      end
     end
   end
 end

data/lib/unitsml/utility.rb

@@ -74,6 +74,7 @@ module Unitsml
         dim_hash = dims.each_with_object({}) { |h, m| m[h[:dimension]] = h }
         dims_vector = DIMS_VECTOR.map { |h| dim_hash.dig(h, :exponent) }.join(":")
         id = Unitsdb.dimensions.find_by_vector(dims_vector)&.id and return id.to_s
+
         "D_" + dims.map do |d|
           (U2D.dig(d[:unit], :symbol) || Dim2D.dig(d[:id], :symbol)) +
             (d[:exponent] == 1 ? "" : float_to_display(d[:exponent]))
@@ -85,18 +86,18 @@ module Unitsml
       end
 
       def decompose_unit(u)
-        if u&.unit_name == "g" || u.system_type == "SI_base"
+        if u&.unit_name == "g" || Lutaml::Model::Utils.snake_case(u.system_type) == "si_base"
           { unit: u, prefix: u&.prefix }
         elsif u.si_derived_bases.nil? || u.si_derived_bases.empty?
           { unit: Unit.new("unknown") }
         else
           u.si_derived_bases.each_with_object([]) do |k, object|
-            prefix = if !k.prefix.nil? && !k.prefix.empty?
-                       combine_prefixes(prefix_object(k.prefix), u.prefix)
+            prefix = if !k.prefix_reference.nil?
+                       combine_prefixes(prefix_object(k.prefix_reference), u.prefix)
                      else
                        u.prefix
                      end
-            unit_name = Unitsdb.units.find_by_id(k.id).unit_symbols.first.id
+            unit_name = Unitsdb.units.find_by_id(k.unit_reference.id).symbols.first.id
             exponent = (k.power&.to_i || 1) * (u.power_numerator&.to_f || 1)
             object << { prefix: prefix,
                    unit: Unit.new(unit_name, exponent, prefix: prefix),
@@ -144,7 +145,7 @@ module Unitsml
         attributes = {
           id: unit_id(norm_text),
           system: unitsystem(units),
-          name: unitname(units, norm_text, name),
+          name: unitname(norm_text, name),
           symbol: unitsymbols(formula, options),
           root_units: rootunits(units),
         }
@@ -157,34 +158,28 @@ module Unitsml
           .gsub(/⋅/, "&#x22c5;")
       end
 
-      def unitname(units, text, name)
-        Model::Units::Name.new(
-          name: unit_instance(text)&.unit_name&.first || text
-        )
-      end
-
-      def postprocess_normtext(units)
-        units.map { |u| "#{u.prefix_name}#{u.unit_name}#{display_exp(u)}" }.join("*")
-      end
-
-      def display_exp(unit)
-        unit.power_numerator && unit.power_numerator != "1" ? "^#{unit.power_numerator}" : ""
+      def unitname(text, name)
+        name ||= unit_instance(text)&.en_name || text
+        Model::Units::Name.new(name: name)
       end
 
       def unitsymbols(formula, options)
         %w[HTML MathMl].map do |lang|
-          Model::Units::Symbol.new(type: lang, content: formula.public_send(:"to_#{lang.downcase}", options))
+          Model::Units::Symbol.new(
+            type: lang,
+            content: formula.public_send(:"to_#{lang.downcase}", options),
+          )
         end
       end
 
       def unitsystem(units)
         ret = []
-        if units.any? { |u| u.system_name != "SI" }
+        if units.any? { |u| !u.si_system_type? }
           ret << Model::Units::System.new(name: "not_SI", type: "not_SI")
         end
-        if units.any? { |u| u.system_name == "SI" }
+        if units.any?(&:si_system_type?)
           if units.size == 1
-            base = units[0].system_type == "SI-base"
+            base = units[0].downcase_system_type == "si_base"
             base = true if units[0].unit_name == "g" && units[0]&.prefix_name == "k"
           end
           ret << Model::Units::System.new(name: "SI", type: (base ? 'SI_base' : 'SI_derived'))
@@ -193,10 +188,9 @@ module Unitsml
       end
 
       def dimension(norm_text)
-        dim_url = unit_instance(norm_text)&.dimension_url
-        return unless dim_url
+        dim_id = unit_instance(norm_text)&.dimension_url
+        return unless dim_id
 
-        dim_id = dim_url.sub("#", '')
         dim_attrs = { id: dim_id }
         dimid2dimensions(dim_id)&.compact&.each { |u| dimension1(u, dim_attrs) }
         Model::Dimension.new(dim_attrs).to_xml
@@ -225,13 +219,13 @@ module Unitsml
           {
             dimension: humanized,
             symbol: dim_quantity.symbol,
-            exponent: dim_quantity.power_numerator,
+            exponent: dim_quantity.power,
           }
         end
       end
 
       def prefixes(units, options)
-        uniq_prefixes = units.map { |unit| unit.prefix }.compact.uniq {|d| d.prefix_name }
+        uniq_prefixes = units.map { |unit| unit.prefix }.compact.uniq { |d| d.prefix_name }
         uniq_prefixes.map do |prefix|
           prefix_attrs = { prefix_base: prefix&.base, prefix_power: prefix&.power, id: prefix&.id }
           type_and_methods = { ASCII: :to_asciimath, unicode: :to_unicode, LaTeX: :to_latex, HTML: :to_html }
@@ -260,10 +254,10 @@ module Unitsml
       end
 
       def unit_id(text)
-        norm_text = text
         text = text&.gsub(/[()]/, "")
-        unit = unit_instance(norm_text)
-        "U_#{unit ? unit.id&.gsub(/'/, '_') : norm_text&.gsub(/\*/, '.')&.gsub(/\^/, '')}"
+        unit = unit_instance(text)
+
+        "U_#{unit ? unit.nist_id&.gsub(/'/, '_') : text&.gsub(/\*/, '.')&.gsub(/\^/, '')}"
       end
 
       def dimension_components(dims)
@@ -276,41 +270,39 @@ module Unitsml
 
       def quantity(normtext, quantity)
         unit = unit_instance(normtext)
-        return unless unit && unit.quantity_reference.size == 1 ||
+        return unless unit && unit.quantity_references.size == 1 ||
           quantity_instance(quantity)
 
-        id = (quantity || unit.quantity_reference&.first&.url).sub('#', '')
-        dim_url = unit.dimension_url
-        attributes = { id: id, name: quantity_name(id), dimension_url: dim_url }
-        Model::Quantity.new(attributes).to_xml
+        id = (quantity || unit.quantity_references&.first&.id)
+        Model::Quantity.new(
+          id: id,
+          name: quantity_name(id),
+          dimension_url: "##{unit.dimension_url}",
+        ).to_xml
       end
 
       def quantity_name(id)
-        quantity_instance(id)&.quantity_name&.map do |content|
-          Model::Quantities::Name.new(content: content)
+        quantity_instance(id)&.names&.filter_map do |name|
+          next unless name.lang == "en"
+
+          Model::Quantities::Name.new(content: name.value)
         end
       end
 
       def string_to_html_entity(string)
-        entities = HTMLEntities.new
-        entities.encode(
+        HTMLEntities.new.encode(
           string.frozen? ? string : string.force_encoding('UTF-8'),
           :hexadecimal,
         )
       end
 
       def html_entity_to_unicode(string)
-        entities = HTMLEntities.new
-        entities.decode(string)
+        HTMLEntities.new.decode(string)
       end
 
       def underscore(str)
         str.gsub(/([a-z])([A-Z])/, '\1_\2').downcase
       end
-
-      def class_name(klass)
-        klass.name.split("::").last
-      end
     end
   end
 end

data/lib/unitsml/version.rb

@@ -1,3 +1,3 @@
 module Unitsml
-  VERSION = "0.4.7"
+  VERSION = "0.5.1"
 end

data/lib/unitsml.rb

@@ -1,43 +1,61 @@
 # frozen_string_literal: true
 
+require "lutaml/model"
 module Unitsml
-  UNITSML_NS = "https://schema.unitsml.org/unitsml/1.0".freeze
+  extend self
 
-  def self.parse(string)
+  UNITSML_NS = "https://schema.unitsml.org/unitsml/1.0"
+  REGISTER_ID = :unitsml_ruby
+
+  def parse(string)
     Unitsml::Parser.new(string).parse
   end
+
+  def register
+    @register ||= Lutaml::Model::GlobalRegister.lookup(REGISTER_ID)
+  end
 end
 
+Lutaml::Model::GlobalRegister.register(
+  Lutaml::Model::Register.new(Unitsml::REGISTER_ID)
+)
+
+require "unitsdb"
 require "unitsml/error"
 require "unitsml/sqrt"
 require "unitsml/unit"
 require "unitsml/parse"
 require "unitsml/parser"
 require "unitsml/prefix"
+require "unitsml/fenced"
 require "unitsml/formula"
 require "unitsml/version"
 require "unitsml/unitsdb"
 require "unitsml/extender"
 require "unitsml/dimension"
 require "unitsml/transform"
+require "unitsml/unitsdb/unit"
 require "unitsml/unitsdb/units"
 require "unitsml/unitsdb/prefixes"
 require "unitsml/unitsdb/dimension"
 require "unitsml/unitsdb/dimensions"
 require "unitsml/unitsdb/quantities"
+require "unitsml/unitsdb/prefix_reference"
 require "unitsml/unitsdb/dimension_quantity"
-require "unitsdb/config"
-Unitsdb::Config.models = {
-  units: Unitsml::Unitsdb::Units,
-  prefixes: Unitsml::Unitsdb::Prefixes,
-  dimension: Unitsml::Unitsdb::Dimension,
-  dimensions: Unitsml::Unitsdb::Dimensions,
-  quantities: Unitsml::Unitsdb::Quantities,
-  dimension_quantity: Unitsml::Unitsdb::DimensionQuantity,
-}
-require "unitsdb"
 
-DEFAULT_XML_ADAPTER = RUBY_ENGINE == "opal" ? :oga :  :ox
-Lutaml::Model::Config.xml_adapter_type = DEFAULT_XML_ADAPTER
-# TODO: Remove Moxml adapter assignment when Lutaml::Model utilizes Moxml completely
-Moxml::Config.default_adapter = DEFAULT_ADAPTER
+{
+  ::Unitsdb::Unit => Unitsml::Unitsdb::Unit,
+  ::Unitsdb::Units => Unitsml::Unitsdb::Units,
+  ::Unitsdb::Prefixes => Unitsml::Unitsdb::Prefixes,
+  ::Unitsdb::Dimension => Unitsml::Unitsdb::Dimension,
+  ::Unitsdb::PrefixReference => Unitsml::Unitsdb::PrefixReference,
+  ::Unitsdb::DimensionDetails => Unitsml::Unitsdb::DimensionQuantity,
+}.each do |key, value|
+  Unitsml.register
+    .register_global_type_substitution(
+      from_type: key,
+      to_type: value,
+    )
+end
+
+Lutaml::Model::Config.xml_adapter_type = RUBY_ENGINE == "opal" ? :oga : :ox

data/unitsdb/LICENSE.md

@@ -0,0 +1,53 @@
+Licenses & Copyright
+====================
+
+This license file adheres to the formatting guidelines of
+[readable-licenses](https://github.com/nevir/readable-licenses).
+
+
+CalConnect MIT License
+----------------------
+
+Copyright 2020-2025, CalConnect
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the “Software”), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+NIST Public Domain Notice (SPDX: NIST-PD)
+-----------------------------------------
+
+This software was developed by employees of the National Institute of Standards
+and Technology (NIST), and others.
+
+This software has been contributed to the public domain.
+
+Pursuant to title 15 Untied States Code Section 105, works of NIST employees are
+not subject to copyright protection in the United States and are considered to
+be in the public domain.
+
+As a result, a formal license is not needed to use this software.
+
+This software is provided "AS IS."
+
+NIST MAKES NO WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR STATUTORY, INCLUDING,
+WITHOUT LIMITATION, THE IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE, NON-INFRINGEMENT AND DATA ACCURACY.
+
+NIST does not warrant or make any representations regarding the use of the
+software or the results thereof, including but not limited to the correctness,
+accuracy, reliability or usefulness of this software.