unitsml 0.6.5 → 0.6.7

data/lib/unitsml/opal/payload_generator.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "unitsdb"
+
+module Unitsml
+  module Opal
+    class PayloadGenerator
+      DEFAULT_OUTPUT_PATH =
+        File.expand_path("database_payload.rb", __dir__).freeze
+
+      RECEIVER = "Unitsml::Unitsdb::Database"
+      METHOD = "load_opal_payload"
+
+      # Maps a scalar value's class to the serializer that emits its
+      # Ruby source representation. Kept as a constant so adding a new
+      # scalar type is a one-line change (OCP).
+      SCALAR_SERIALIZERS = {
+        String => :inspect.to_proc,
+        Symbol => ->(v) { ":#{v}" },
+        Integer => :to_s.to_proc,
+        Float => :to_s.to_proc,
+      }.freeze
+
+      def initialize(unitsdb_data_dir: default_data_dir)
+        @unitsdb_data_dir = unitsdb_data_dir
+      end
+
+      def call
+        "#{header}#{body}"
+      end
+
+      def write_to(path = DEFAULT_OUTPUT_PATH)
+        File.write(path, call)
+        path
+      end
+
+      private
+
+      attr_reader :unitsdb_data_dir
+
+      def header
+        <<~RUBY
+          # frozen_string_literal: true
+
+          # AUTO-GENERATED by `bundle exec rake unitsml:generate_opal_payload`.
+          # Do not edit by hand. Edit the YAML in unitsdb-ruby/data/ and
+          # regenerate. This file is loaded by lib/unitsml/opal.rb under Opal
+          # to satisfy Unitsml::Unitsdb::Database.from_db without a filesystem.
+        RUBY
+      end
+
+      def body
+        "#{RECEIVER}.#{METHOD}(#{serialize(database_hash)}.freeze)\n"
+      end
+
+      def database_hash
+        ::Unitsdb::Database.from_db(unitsdb_data_dir).to_hash
+      end
+
+      # Custom serializer rather than Hash#inspect so the output is
+      # byte-identical across Ruby versions (3.3 vs 3.4 changed Hash#inspect
+      # to add spaces around "=>"). String#inspect is itself stable for
+      # UTF-8 clean data.
+      def serialize(value)
+        case value
+        when Hash then serialize_hash(value)
+        when Array then serialize_array(value)
+        when true then "true"
+        when false then "false"
+        when nil then "nil"
+        else serialize_scalar(value)
+        end
+      end
+
+      def serialize_hash(value)
+        "{#{value.map { |k, v| "#{serialize(k)}=>#{serialize(v)}" }.join(',')}}"
+      end
+
+      def serialize_array(value)
+        "[#{value.map { |v| serialize(v) }.join(',')}]"
+      end
+
+      def serialize_scalar(value)
+        serializer = SCALAR_SERIALIZERS[value.class]
+        return serializer.call(value) if serializer
+
+        raise Unitsml::Errors::UnsupportedPayloadTypeError, value.class
+      end
+
+      def default_data_dir
+        ::Unitsdb.data_dir
+      end
+    end
+  end
+end

data/lib/unitsml/opal.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+# Opal entry point for unitsml.
+#
+# Under MRI, lib/unitsml.rb uses autoload for lazy loading. Under Opal,
+# autoload does not lazy-execute, so this boot file eager-requires every
+# entry point. Consumers (e.g. plurimath-js) add `-r unitsml/opal` to
+# their Opal compile command.
+#
+# Load order rationale:
+#   1. Upstream boot files first — unitsml depends on lutaml-model,
+#      unitsdb, mml (and transitively omml via plurimath-js consumers).
+#   2. unitsml.rb next — sets up top-level autoloads and Configuration.
+#   3. Errors before everything else (low-level, no deps).
+#   4. The Opal payload — defines Unitsml::Unitsdb::Database::DATABASE
+#      so Unitsml::Unitsdb::Database.from_db can satisfy without a
+#      filesystem under Opal.
+#   5. Unitsdb sub-files — define classes that subclass ::Unitsdb::*
+#      and call Configuration.register_model side-effects.
+#   6. Model tree — declares the Unitsml XML model classes. Each parent
+#      module (Prefixes, Quantities, DimensionQuantities, Units) is
+#      required first to set up its own autoloads, then its leaves.
+#   7. Parser/Transform/Prefix/Unit/Dimension etc. — top-level domain
+#      classes that reference Model and Unitsdb.
+
+require "lutaml/model"
+require "unitsdb/opal"
+require "mml/opal"
+require "omml/opal"
+
+require "unitsml"
+
+require "unitsml/version"
+require "unitsml/errors"
+require "unitsml/errors/base_error"
+require "unitsml/errors/invalid_model_error"
+require "unitsml/errors/opal_payload_not_bundled_error"
+require "unitsml/errors/plurimath_load_error"
+require "unitsml/errors/unsupported_payload_type_error"
+
+require "unitsml/opal/database_payload"
+
+require "unitsml/configuration"
+require "unitsml/namespace"
+
+require "unitsml/unitsdb"
+require "unitsml/unitsdb/database"
+require "unitsml/unitsdb/dimension_details"
+require "unitsml/unitsdb/finders"
+require "unitsml/unitsdb/prefix_reference"
+require "unitsml/unitsdb/dimension"
+require "unitsml/unitsdb/dimensions"
+require "unitsml/unitsdb/unit"
+require "unitsml/unitsdb/units"
+require "unitsml/unitsdb/prefixes"
+require "unitsml/unitsdb/quantities"
+
+require "unitsml/model"
+require "unitsml/model/dimension"
+require "unitsml/model/dimension_quantities"
+require "unitsml/model/dimension_quantities/amount_of_substance"
+require "unitsml/model/dimension_quantities/electric_current"
+require "unitsml/model/dimension_quantities/length"
+require "unitsml/model/dimension_quantities/luminous_intensity"
+require "unitsml/model/dimension_quantities/mass"
+require "unitsml/model/dimension_quantities/plane_angle"
+require "unitsml/model/dimension_quantities/quantity"
+require "unitsml/model/dimension_quantities/thermodynamic_temperature"
+require "unitsml/model/dimension_quantities/time"
+require "unitsml/model/prefix"
+require "unitsml/model/prefixes"
+require "unitsml/model/prefixes/name"
+require "unitsml/model/prefixes/symbol"
+require "unitsml/model/quantities"
+require "unitsml/model/quantities/name"
+require "unitsml/model/quantity"
+require "unitsml/model/unit"
+require "unitsml/model/units"
+require "unitsml/model/units/enumerated_root_unit"
+require "unitsml/model/units/name"
+require "unitsml/model/units/root_units"
+require "unitsml/model/units/symbol"
+require "unitsml/model/units/system"
+
+require "unitsml/dimension"
+require "unitsml/extender"
+require "unitsml/fenced"
+require "unitsml/fenced_numeric"
+require "unitsml/formula"
+require "unitsml/intermediate_exp_rules"
+require "unitsml/mathml_helper"
+require "unitsml/number"
+require "unitsml/parse"
+require "unitsml/parser"
+require "unitsml/prefix"
+require "unitsml/prefix_adapter"
+require "unitsml/sqrt"
+require "unitsml/transform"
+require "unitsml/unit"
+require "unitsml/utility"
+require "unitsml/xml"
+require "unitsml/xml/formatter"

data/lib/unitsml/parser.rb

@@ -32,7 +32,7 @@ module Unitsml
       array.each do |object|
         if object.is_a?(Sqrt)
           object = object.value
-          if object.respond_to?(:power_numerator)
+          if object.is_a?(Unit)
             object.power_numerator = Number.new("0.5")
           else
             update_units_exponents([object], inverse, true)

data/lib/unitsml/prefix_adapter.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Unitsml
+  # Value object that adapts the various "prefix-shaped" inputs flowing
+  # through Unitsml::Utility to a single, type-explicit interface.
+  #
+  # Dispatch is by `is_a?` / `case/when`, so type errors surface at the
+  # boundary instead of silently falling through.
+  #
+  # Recognized inputs:
+  #   - `Unitsml::Prefix`              — already adapted, has full API
+  #   - `::Unitsdb::Prefix`            — upstream record, has `symbols`
+  #   - `Unitsml::Unitsdb::PrefixReference` — UnitsML reference, has `symbolid`
+  #   - `::Unitsdb::PrefixReference`   — bare id/type, needs lookup
+  #   - `String`                       — prefix name, looked up
+  #   - `nil`                          — null adapter
+  class PrefixAdapter
+    attr_reader :raw
+
+    def initialize(raw)
+      @raw = raw
+    end
+
+    def self.wrap(prefix)
+      return new(nil) if prefix.nil?
+      return prefix if prefix.is_a?(PrefixAdapter)
+
+      case prefix
+      when Unitsml::Prefix, ::Unitsdb::Prefix,
+           Unitsml::Unitsdb::PrefixReference
+        new(prefix)
+      when ::Unitsdb::PrefixReference
+        from_id(prefix.id)
+      when String
+        from_name(prefix)
+      else
+        new(nil)
+      end
+    end
+
+    def self.from_name(name)
+      return new(nil) unless Unitsml::Unitsdb.prefixes_array.include?(name)
+
+      new(Unitsml::Prefix.new(name))
+    end
+
+    def self.from_id(id)
+      new(Unitsml::Unitsdb.prefixes.find_by_id(id))
+    end
+    private_class_method :from_id
+
+    def null?
+      @raw.nil?
+    end
+
+    def base
+      @raw&.base
+    end
+
+    def power
+      @raw&.power
+    end
+
+    def symbolid
+      case @raw
+      when Unitsml::Prefix, Unitsml::Unitsdb::PrefixReference
+        @raw.symbolid
+      when ::Unitsdb::Prefix
+        @raw.symbols.first&.ascii
+      end
+    end
+
+    def prefix_name
+      case @raw
+      when Unitsml::Prefix
+        @raw.prefix_name
+      when ::Unitsdb::Prefix, Unitsml::Unitsdb::PrefixReference
+        symbolid
+      end
+    end
+  end
+end

data/lib/unitsml/unitsdb/database.rb

@@ -3,18 +3,31 @@
 module Unitsml
   module Unitsdb
     class Database < ::Unitsdb::Database
-      DATABASE = nil
-
       def self.from_db(dir_path, context: Unitsml::Configuration.context.id)
         return super unless RUBY_ENGINE == "opal"
 
         context_id = context.to_sym
-        raise Unitsml::Errors::OpalPayloadNotBundledError unless DATABASE
+        raise Unitsml::Errors::OpalPayloadNotBundledError unless opal_payload
 
         Unitsml::Configuration.context
 
-        from_hash(DATABASE, register: context_id)
+        from_hash(opal_payload, register: context_id)
+      end
+
+      def self.load_opal_payload(payload)
+        @opal_payload = payload
+      end
+
+      def self.reset_opal_payload
+        return unless instance_variable_defined?(:@opal_payload)
+
+        remove_instance_variable(:@opal_payload)
+      end
+
+      def self.opal_payload
+        @opal_payload
       end
+      private_class_method :opal_payload
 
       Configuration.register_model(self, id: :database)
     end

data/lib/unitsml/unitsdb/dimension.rb

@@ -3,48 +3,38 @@
 module Unitsml
   module Unitsdb
     class Dimension < ::Unitsdb::Dimension
+      QUANTITY_KEYS = %i[
+        length
+        mass
+        time
+        thermodynamic_temperature
+        amount_of_substance
+        luminous_intensity
+        plane_angle
+        electric_current
+      ].freeze
+
       attr_reader :parsables,
                   :parsable,
                   :processed_keys,
                   :vector
 
       def initialize(attrs)
+        @quantities = {}
         @parsables = {}
         @processed_keys = []
         @parsable = false
         super
       end
 
-      def length=(value)
-        quantities_common_code(:length, value)
-      end
-
-      def mass=(value)
-        quantities_common_code(:mass, value)
-      end
-
-      def time=(value)
-        quantities_common_code(:time, value)
-      end
-
-      def thermodynamic_temperature=(value)
-        quantities_common_code(:thermodynamic_temperature, value)
-      end
-
-      def amount_of_substance=(value)
-        quantities_common_code(:amount_of_substance, value)
-      end
-
-      def luminous_intensity=(value)
-        quantities_common_code(:luminous_intensity, value)
-      end
-
-      def plane_angle=(value)
-        quantities_common_code(:plane_angle, value)
-      end
+      QUANTITY_KEYS.each do |key|
+        define_method("#{key}=") do |value|
+          register_quantity(key, value)
+        end
 
-      def electric_current=(value)
-        quantities_common_code(:electric_current, value)
+        define_method(key) do
+          @quantities[key]
+        end
       end
 
       def dim_symbols
@@ -69,11 +59,11 @@ module Unitsml
 
       private
 
-      def quantities_common_code(instance_var, value)
+      def register_quantity(key, value)
         return if value.nil?
 
-        instance_variable_set(:"@#{instance_var}", value)
-        @processed_keys << instance_var.to_s
+        @quantities[key] = value
+        @processed_keys << key.to_s
         dim_symbols = dimension_symbols_for(value)
         return if Lutaml::Model::Utils.empty?(dim_symbols)
 
@@ -83,12 +73,10 @@ module Unitsml
 
       def dimension_symbols_for(value)
         return [] if value.nil?
+        return Array(value.dim_symbols) if value.is_a?(::Unitsdb::Dimension)
+        return Array(value.symbols) if value.is_a?(::Unitsdb::DimensionDetails)
 
-        if value.respond_to?(:dim_symbols)
-          Array(value.dim_symbols)
-        else
-          Array(value.symbols)
-        end
+        []
       end
     end
 

data/lib/unitsml/unitsdb/dimensions.rb

@@ -3,6 +3,8 @@
 module Unitsml
   module Unitsdb
     class Dimensions < ::Unitsdb::Dimensions
+      include Unitsml::Unitsdb::Finders
+
       def dimensions=(value)
         super(value.map { |d| Dimension.new(d.to_hash) })
       end
@@ -13,11 +15,11 @@ module Unitsml
       end
 
       def find_by_id(d_id)
-        find(:id, d_id)
+        find_first_in(dimensions, field: :id, value: d_id)
       end
 
       def find_parsables_by_id(d_id)
-        find(:id, parsables[d_id])
+        find_first_in(dimensions, field: :id, value: parsables[d_id])
       end
 
       def parsables
@@ -25,12 +27,6 @@ module Unitsml
           object.merge!(dimension.parsables)
         end
       end
-
-      private
-
-      def find(field, matching_data)
-        dimensions.find { |dim| dim.send(field) == matching_data }
-      end
     end
 
     Configuration.register_model(Dimensions, id: :dimensions)

data/lib/unitsml/unitsdb/finders.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Unitsml
+  module Unitsdb
+    # Shared lookup helpers for Unitsml collection wrappers. Each host
+    # collection (Units, Prefixes, Dimensions) keeps its own public
+    # find_by_* API; this module owns the two scanning shapes that the
+    # host implementations previously duplicated.
+    module Finders
+      # Find the first item in `collection` where `item.<field> == value`.
+      def find_first_in(collection, field:, value:)
+        collection.find { |item| item.public_send(field) == value }
+      end
+
+      # Find the first item in `collection` where `item.<via>` contains
+      # an element whose `<field>` equals `value`. Used for collections
+      # of items that expose a nested list of identifiers or symbols.
+      def find_first_through(collection, via:, field:, value:)
+        collection.find do |item|
+          item.public_send(via).any? do |inner|
+            inner.public_send(field) == value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/unitsml/unitsdb/prefixes.rb

@@ -3,12 +3,15 @@
 module Unitsml
   module Unitsdb
     class Prefixes < ::Unitsdb::Prefixes
+      include Unitsml::Unitsdb::Finders
+
       def find_by_id(p_id)
-        find(p_id, :id, :identifiers)
+        find_first_through(prefixes, via: :identifiers, field: :id, value: p_id)
       end
 
       def find_by_symbol_name(ascii_sym)
-        find(ascii_sym, :ascii, :symbols)
+        find_first_through(prefixes, via: :symbols, field: :ascii,
+                                     value: ascii_sym)
       end
 
       def ascii_symbols
@@ -19,16 +22,6 @@ module Unitsml
           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
 
     Configuration.register_model(Prefixes, id: :prefixes)

data/lib/unitsml/unitsdb/unit.rb

@@ -4,9 +4,11 @@ module Unitsml
   module Unitsdb
     class Unit < ::Unitsdb::Unit
       def dimension_url
-        quantity_id = quantity_references[0].id
+        quantity_id = quantity_references.first&.id
+        return unless quantity_id
+
         quantity = Unitsml::Unitsdb.quantities.find_by_id(quantity_id)
-        quantity.dimension_reference.id
+        quantity&.dimension_reference&.id
       end
 
       def en_name

data/lib/unitsml/unitsdb/units.rb

@@ -3,12 +3,14 @@
 module Unitsml
   module Unitsdb
     class Units < ::Unitsdb::Units
+      include Unitsml::Unitsdb::Finders
+
       def find_by_id(u_id)
-        find(u_id, :id, :identifiers)
+        find_first_through(units, via: :identifiers, field: :id, value: u_id)
       end
 
       def find_by_name(u_name)
-        find(u_name, :id, :symbols)
+        find_first_through(units, via: :symbols, field: :id, value: u_name)
       end
 
       def filtered
@@ -30,16 +32,6 @@ module Unitsml
           unit.symbols&.each { |unit_sym| object[unit_sym.id] = unit }
         end
       end
-
-      private
-
-      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
-      end
     end
 
     Configuration.register_model(Units, id: :units)

data/lib/unitsml/unitsdb.rb

@@ -2,24 +2,28 @@
 
 require "unitsdb"
 
-require_relative "unitsdb/database"
-require_relative "unitsdb/dimension_details"
-require_relative "unitsdb/prefix_reference"
-require_relative "unitsdb/dimension"
-require_relative "unitsdb/dimensions"
-require_relative "unitsdb/unit"
-require_relative "unitsdb/units"
-require_relative "unitsdb/prefixes"
-require_relative "unitsdb/quantities"
 module Unitsml
   module Unitsdb
+    autoload :Database, "unitsml/unitsdb/database"
+    autoload :DimensionDetails, "unitsml/unitsdb/dimension_details"
+    autoload :Finders, "unitsml/unitsdb/finders"
+    autoload :PrefixReference, "unitsml/unitsdb/prefix_reference"
+    autoload :Dimension, "unitsml/unitsdb/dimension"
+    autoload :Dimensions, "unitsml/unitsdb/dimensions"
+    autoload :Unit, "unitsml/unitsdb/unit"
+    autoload :Units, "unitsml/unitsdb/units"
+    autoload :Prefixes, "unitsml/unitsdb/prefixes"
+    autoload :Quantities, "unitsml/unitsdb/quantities"
+
     class << self
-      REQUIRED_DATABASE_FILES = %w[
-        prefixes.yaml
-        dimensions.yaml
-        units.yaml
-        quantities.yaml
-        unit_systems.yaml
+      CACHE_INSTANCE_VARIABLES = %i[
+        @units
+        @prefixes
+        @dimensions
+        @quantities
+        @prefixes_array
+        @sized_prefixes
+        @database
       ].freeze
 
       def units
@@ -65,19 +69,23 @@ module Unitsml
         @database ||= load_database
       end
 
+      def reset_caches
+        CACHE_INSTANCE_VARIABLES.each do |ivar|
+          remove_instance_variable(ivar) if instance_variable_defined?(ivar)
+        end
+      end
+
       private
 
+      # Delegates to the upstream loader, falling back to the UnitsML
+      # Database subclass when the upstream cannot satisfy the request
+      # (e.g. context substitution not yet wired up). Both paths load
+      # from `Unitsdb.data_dir` — the upstream `Unitsdb.database` calls
+      # `Database.from_db(data_dir, ...)` internally, and so does the
+      # fallback.
       def load_database
         context_id = Configuration.context.id
 
-        if ::Unitsdb.respond_to?(:database)
-          return load_unitsdb_database(context_id)
-        end
-
-        Database.from_db(database_path, context: context_id)
-      end
-
-      def load_unitsdb_database(context_id)
         ::Unitsdb.database(context: context_id)
       rescue ::Unitsdb::Errors::DatabaseNotFoundError,
              ::Unitsdb::Errors::DatabaseFileNotFoundError
@@ -85,27 +93,7 @@ module Unitsml
       end
 
       def database_path
-        candidate_database_paths.find do |path|
-          database_files_present?(path)
-        end ||
-          File.join(unitsdb_gem_path, "vendor", "unitsdb")
-      end
-
-      def candidate_database_paths
-        [
-          File.join(unitsdb_gem_path, "data"),
-          File.join(unitsdb_gem_path, "vendor", "unitsdb"),
-        ]
-      end
-
-      def database_files_present?(dir_path)
-        REQUIRED_DATABASE_FILES.all? do |file_name|
-          File.exist?(File.join(dir_path, file_name))
-        end
-      end
-
-      def unitsdb_gem_path
-        Gem.loaded_specs.fetch("unitsdb").full_gem_path
+        ::Unitsdb.data_dir
       end
     end
   end