unitsml 0.6.9 → 0.6.11

data/lib/unitsml/opal/payload_generator.rb

@@ -72,8 +72,13 @@ module Unitsml
         end
       end
 
+      # Keys sorted so the output is byte-identical regardless of the
+      # hash insertion order the unitsdb/lutaml load path happens to
+      # produce on a given Ruby or gem version.
       def serialize_hash(value)
-        "{#{value.map { |k, v| "#{serialize(k)}=>#{serialize(v)}" }.join(',')}}"
+        "{#{value.sort_by do |k, _|
+          k.to_s
+        end.map { |k, v| "#{serialize(k)}=>#{serialize(v)}" }.join(',')}}"
       end
 
       def serialize_array(value)

data/lib/unitsml/opal.rb

@@ -36,6 +36,8 @@ 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/parg_load_error"
+require "unitsml/errors/quantity_errors"
 require "unitsml/errors/unsupported_payload_type_error"
 
 require "unitsml/opal/database_payload"
@@ -87,15 +89,14 @@ 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/parg"
 require "unitsml/parser"
+require "unitsml/quantity"
 require "unitsml/prefix"
 require "unitsml/prefix_adapter"
 require "unitsml/sqrt"
-require "unitsml/transform"
 require "unitsml/unit"
 require "unitsml/utility"
 require "unitsml/xml"

data/lib/unitsml/parg/tree_mapper.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module Unitsml
+  module Parg
+    # Maps asciiunits artifact parse trees (capture-named hashes whose leaves
+    # are {value, offset, ...} slices) onto the same object model the Parslet
+    # Transform produces. Dispatch is on the exact key set of each node
+    # (sorted), bottom-up, mirroring rule-for-rule the Transform rules in
+    # unitsml/transform.rb.
+    class TreeMapper
+      def apply(tree)
+        map(normalize(tree))
+      end
+
+      private
+
+      # The artifact runtime hands back symbol-keyed hashes with parsanol
+      # Slice leaves; the mapper works on string keys and stringified leaves.
+      def normalize(node)
+        case node
+        when Hash then node.to_h { |key, value| [key.to_s, normalize(value)] }
+        when Array then node.map { |value| normalize(value) }
+        else node
+        end
+      end
+
+      # The case below is a dispatch table mirroring unitsml/transform.rb
+      # rule-for-rule; splitting it would obscure the 1:1 parity contract.
+      # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def map(node)
+        return node unless node.is_a?(Hash)
+
+        node = node.transform_values do |value|
+          value.is_a?(Hash) ? map(value) : value
+        end
+        case node.keys.map(&:to_s).sort
+        when %w[dimension] then Dimension.new(text(node["dimension"]))
+        when %w[dimension extender power_numerator sequence]
+          Formula.new(
+            [Dimension.new(text(node["dimension"]), node["power_numerator"]),
+             Extender.new(text(node["extender"])),
+             node["sequence"]],
+          )
+        when %w[dimension extender sequence]
+          Formula.new(
+            [Dimension.new(text(node["dimension"])),
+             Extender.new(text(node["extender"])),
+             node["sequence"]],
+          )
+        when %w[dimension power_numerator]
+          Dimension.new(text(node["dimension"]), node["power_numerator"])
+        when %w[extender first_set second_set]
+          Formula.new(
+            [node["first_set"], Extender.new(text(node["extender"])),
+             node["second_set"]],
+          )
+        when %w[extender implicit_extended sequence]
+          Formula.new(
+            [node["implicit_extended"], Extender.new(text(node["extender"])),
+             node["sequence"]],
+          )
+        when %w[extender int_exp sequence]
+          Formula.new(
+            [node["int_exp"], Extender.new(text(node["extender"])),
+             node["sequence"]],
+          )
+        when %w[extender power_numerator sequence unit]
+          Formula.new(
+            [Unit.new(text(node["unit"]), node["power_numerator"]),
+             Extender.new(text(node["extender"])),
+             node["sequence"]],
+          )
+        when %w[extender power_numerator prefix sequence unit]
+          Formula.new(
+            [Unit.new(text(node["unit"]), node["power_numerator"],
+                      prefix: Prefix.new(text(node["prefix"]))),
+             Extender.new(text(node["extender"])),
+             node["sequence"]],
+          )
+        when %w[extender prefix sequence unit]
+          Formula.new(
+            [Unit.new(text(node["unit"]),
+                      prefix: Prefix.new(text(node["prefix"]))),
+             Extender.new(text(node["extender"])),
+             node["sequence"]],
+          )
+        when %w[extender sequence unit]
+          Formula.new(
+            [Unit.new(text(node["unit"])),
+             Extender.new(text(node["extender"])),
+             node["sequence"]],
+          )
+        when %w[first_int_exp_set second_int_exp_set]
+          Formula.new(
+            [set_to_fence(node["first_int_exp_set"]),
+             set_to_fence(node["second_int_exp_set"])],
+          )
+        when %w[first_int_exp_set second_set]
+          Formula.new(
+            [set_to_fence(node["first_int_exp_set"]), node["second_set"]],
+          )
+        when %w[first_set second_int_exp_set]
+          Formula.new(
+            [node["first_set"], set_to_fence(node["second_int_exp_set"])],
+          )
+        when %w[first_set second_set]
+          Formula.new([node["first_set"], node["second_set"]])
+        when %w[implicit_extended] then node["implicit_extended"]
+        when %w[int_exp] then node["int_exp"]
+        when %w[int_exp sequence]
+          Formula.new([node["int_exp"], node["sequence"]])
+        when %w[integer] then Number.new(text(node["integer"]))
+        when %w[close_paren integer open_paren]
+          Fenced.new(text(node["open_paren"]),
+                     Number.new(text(node["integer"])),
+                     text(node["close_paren"]))
+        when %w[close_paren int_exp open_paren]
+          Fenced.new(text(node["open_paren"]), node["int_exp"],
+                     text(node["close_paren"]))
+        when %w[power_numerator unit]
+          Unit.new(text(node["unit"]), node["power_numerator"])
+        when %w[power_numerator prefix unit]
+          Unit.new(text(node["unit"]), node["power_numerator"],
+                   prefix: Prefix.new(text(node["prefix"])))
+        when %w[prefix] then Prefix.new(text(node["prefix"]))
+        when %w[prefix unit]
+          Unit.new(text(node["unit"]), prefix: Prefix.new(text(node["prefix"])))
+        when %w[sqrt] then Sqrt.new(node["sqrt"])
+        when %w[unit] then Unit.new(text(node["unit"]))
+        else
+          # The Parslet Transform leaves unmatched key combinations as raw
+          # hashes with symbol keys (e.g. {sqrt:, sequence:}); mirror that.
+          # Terminal slices (identifiable by their "value" key) keep their
+          # string keys.
+          node.key?("value") ? node : node.transform_keys(&:to_sym)
+        end
+      end
+
+      def text(slice)
+        slice.is_a?(Hash) ? slice.fetch("value") : slice.to_s
+      end
+      # rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+      def set_to_fence(set)
+        return set if set.is_a?(Fenced)
+
+        Fenced.new("(", set, ")")
+      end
+    end
+  end
+end

data/lib/unitsml/parg.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Unitsml
+  module Parg
+    autoload :TreeMapper, "unitsml/parg/tree_mapper"
+  end
+end

data/lib/unitsml/parser.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module Unitsml
+  # Parses AsciiUnits expressions through the asciiunits PARG artifact
+  # (github.com/unitsml/asciiunits) into the Formula object model.
   class Parser
     attr_accessor :text
 
@@ -13,21 +15,42 @@ module Unitsml
     end
 
     def parse
-      nodes = Parse.new.parse(text)
-      transformed = Transform.new.apply(nodes)
-      formula_value = transformed.is_a?(Formula) ? transformed.value : [transformed].flatten
-      formula = Formula.new(
-        formula_value,
-        explicit_value: @extras_hash,
-        root: true,
-        orig_text: @orig_text,
-        norm_text: text,
-      )
+      tree = self.class.artifact.parse("expression", text)
+      mapped = Parg::TreeMapper.new.apply(tree)
+      formula = build_formula(mapped)
       update_units_exponents(formula.value, false)
       formula.value.first.only_instance = true if text.end_with?("-")
       formula
     end
 
+    class << self
+      def artifact
+        @artifact ||= load_artifact
+      end
+
+      private
+
+      def load_artifact
+        if RUBY_ENGINE == "opal"
+          raise Errors::PargLoadError.new(
+            "the asciiunits gem",
+            "the parsanol runtime is not available under Opal; " \
+            "use a runtime with native code access",
+          )
+        end
+
+        # Opal's builder statically scans literal requires; neither
+        # asciiunits nor parsanol has an Opal build, so keep the requires
+        # dynamic (this line never runs under Opal — the RUBY_ENGINE guard
+        # above raises first).
+        data_gem = "asciiunits"
+        require data_gem
+        Asciiunits.load_artifact
+      rescue LoadError => e
+        raise Errors::PargLoadError.new("the asciiunits gem", e.message)
+      end
+    end
+
     def update_units_exponents(array, inverse, sqrt = false)
       array.each do |object|
         if object.is_a?(Sqrt)
@@ -71,6 +94,17 @@ module Unitsml
 
     private
 
+    def build_formula(mapped)
+      formula_value = mapped.is_a?(Formula) ? mapped.value : [mapped].flatten
+      Formula.new(
+        formula_value,
+        explicit_value: @extras_hash,
+        root: true,
+        orig_text: @orig_text,
+        norm_text: text,
+      )
+    end
+
     def extract_equation(text)
       return text unless text&.start_with?("unitsml(")
 

data/lib/unitsml/quantity.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module Unitsml
+  # A quantity: a magnitude plus a unit identity, with unit-aware
+  # arithmetic (unitsml-ruby#82 R-A1/A2/A4-skeleton/A5).
+  #
+  # Dimensions come from the parsed unit expression via UnitsDB; every
+  # operation checks them. Scale legality (R-A4) gates multiplication
+  # and division on non-ratio scales; the classification is pluggable
+  # per quantity until the unitsdb scale-legality data lands (#130).
+  class Quantity
+    attr_reader :value, :formula, :scale
+
+    def initialize(value:, unit_expression: nil, scale: :ratio)
+      @value = value
+      @formula = unit_expression && Unitsml.parse(unit_expression)
+      @scale = scale.to_sym
+    end
+
+    # Canonical dimension identity; "1" (dimensionless) for pure numbers.
+    def dimension_id
+      @dimension_id ||= begin
+        list = dimension_list
+        list && (Utility.dim_id(list) || "1")
+      end
+    end
+
+    # Base-dimension exponents summed across the composed expression —
+    # V (L²MT⁻³I⁻¹) times A (I¹) merges to the watt vector L²MT⁻³.
+    def dimension_vector
+      vector = raw_dimension_list.each_with_object(Hash.new(0)) do |entry, acc|
+        exponent = entry[:exponent]
+        exponent = exponent.raw_value if exponent.respond_to?(:raw_value)
+        acc[entry[:dimension]] += exponent.to_i
+      end
+      vector.delete_if { |_, exponent| exponent.zero? }
+      vector
+    end
+
+    # Normalized unit expression text; the value's to_s for pure numbers.
+    def norm_text
+      formula&.norm_text || value.to_s
+    end
+
+    def *(other)
+      if other.is_a?(Numeric)
+        gate_scaling!
+        return Quantity.new(value: value * other, unit_expression: norm_text)
+      end
+
+      scale_ratio_gate!(other, "multiplication")
+      Quantity.new(value: value * other.value,
+                   unit_expression: compose(self, other, "*"))
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    def /(other)
+      if other.is_a?(Numeric)
+        gate_zero!(other)
+        gate_scaling!
+        return Quantity.new(value: value / other, unit_expression: norm_text)
+      end
+
+      scale_ratio_gate!(other, "division")
+      if other.value.zero?
+        raise Errors::IndeterminateResultError,
+              "division by a zero quantity is indeterminate"
+      end
+
+      Quantity.new(value: value / other.value,
+                   unit_expression: compose(self, other, "/"))
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    # R-A4: differences are legal on both ratio and interval scales;
+    # only the dimension identity must match.
+    def +(other)
+      quantity_kind!(other)
+      gate_dimension!(other)
+      Quantity.new(value: value + other.value, unit_expression: norm_text)
+    end
+
+    def -(other)
+      quantity_kind!(other)
+      gate_dimension!(other)
+      Quantity.new(value: value - other.value, unit_expression: norm_text)
+    end
+
+    def ==(other)
+      other.is_a?(Quantity) && value == other.value &&
+        dimension_vector == other.dimension_vector
+    end
+
+    private
+
+    # Base dimensions in canonical DIMS_VECTOR order; nil when all
+    # exponents cancel (dimensionless).
+    def dimension_list
+      merged = Utility::DIMS_VECTOR.filter_map do |dimension|
+        exponent = dimension_vector[dimension]
+        next if exponent.zero?
+
+        { dimension: dimension, exponent: exponent }
+      end
+      merged.empty? ? nil : merged
+    end
+
+    def raw_dimension_list
+      return [] unless formula
+
+      Utility.units2dimensions(extract_units(formula.value))
+    end
+
+    # Formula#units renders XML; the dimension identity needs the raw
+    # decomposition, so extract it the same way Formula does internally.
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity
+    def extract_units(formula)
+      formula.each_with_object([]) do |term, units_arr|
+        case term
+        when Unit
+          units_arr << term.dup
+        when Formula
+          units_arr.concat(extract_units(term.value.dup))
+        when Sqrt
+          next unless term.value.is_a?(Unit)
+
+          sqrt_unit = term.value.dup
+          sqrt_unit.power_numerator = Number.new("0.5")
+          units_arr << sqrt_unit
+        when Fenced
+          units_arr.concat(extract_units(term.value.value.dup))
+        end
+      end
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity
+
+    # R-A4: ratio-scale operations are specified errors on non-ratio
+    # quantities. Differences and comparisons remain legal on both.
+    # Scalar multiplication/division scales the magnitude: legal on
+    # ratio scales, a specified error on non-ratio ones.
+    def gate_scaling!
+      return if scale == :ratio
+
+      raise Errors::ScaleOperationError,
+            "scaling is not legal on a #{scale} scale quantity"
+    end
+
+    def scale_ratio_gate!(other, operation)
+      return if scale == :ratio && other.scale == :ratio
+
+      raise Errors::ScaleOperationError,
+            "#{operation} is not legal between #{scale} and " \
+            "#{other.scale} scale quantities"
+    end
+
+    def quantity_kind!(other)
+      unless other.is_a?(Quantity)
+        raise ArgumentError, "expected a Unitsml::Quantity, got #{other.class}"
+      end
+    end
+
+    def gate_dimension!(other)
+      return if dimension_vector == other.dimension_vector
+
+      raise Errors::DimensionMismatchError,
+            "dimension mismatch: #{dimension_vector.inspect} " \
+            "vs #{other.dimension_vector.inspect}"
+    end
+
+    def gate_zero!(other)
+      return unless other.zero?
+
+      raise Errors::IndeterminateResultError,
+            "division by a zero quantity is indeterminate"
+    end
+
+    def compose(left, right, operator)
+      "#{left.norm_text}#{operator}#{right.norm_text}"
+    end
+  end
+end

data/lib/unitsml/unitsdb/units.rb

@@ -19,6 +19,12 @@ module Unitsml
         end
       end
 
+      def prefixed_symbols
+        @prefixed_symbols ||= symbols_ids.select do |unit|
+          find_by_symbol_id(unit).prefixed && !%r{\*|\^|/|^1$}.match?(unit)
+        end
+      end
+
       def find_by_symbol_id(sym_id)
         symbols_hash[sym_id]
       end

data/lib/unitsml/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Unitsml
-  VERSION = "0.6.9"
+  VERSION = "0.6.11"
 end

data/lib/unitsml.rb

@@ -13,24 +13,23 @@ module Unitsml
   autoload :Fenced, "unitsml/fenced"
   autoload :FencedNumeric, "unitsml/fenced_numeric"
   autoload :Formula, "unitsml/formula"
-  autoload :IntermediateExpRules, "unitsml/intermediate_exp_rules"
   autoload :MathmlHelper, "unitsml/mathml_helper"
   autoload :Model, "unitsml/model"
   autoload :Namespace, "unitsml/namespace"
   autoload :Number, "unitsml/number"
-  autoload :Parse, "unitsml/parse"
+  autoload :Parg, "unitsml/parg"
   autoload :Parser, "unitsml/parser"
   autoload :Prefix, "unitsml/prefix"
   autoload :PrefixAdapter, "unitsml/prefix_adapter"
   autoload :Sqrt, "unitsml/sqrt"
-  autoload :Transform, "unitsml/transform"
   autoload :Unit, "unitsml/unit"
   autoload :Unitsdb, "unitsml/unitsdb"
   autoload :Utility, "unitsml/utility"
   autoload :VERSION, "unitsml/version"
+  autoload :Quantity, "unitsml/quantity"
   autoload :Xml, "unitsml/xml"
 
   def parse(string)
-    Unitsml::Parser.new(string).parse
+    Parser.new(string).parse
   end
 end

data/unitsml.gemspec

@@ -32,10 +32,9 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "asciiunits", "~> 0.1"
   spec.add_dependency "htmlentities"
   spec.add_dependency "lutaml-model", "~> 0.8.0"
   spec.add_dependency "mml", "~> 2.4.0"
-  spec.add_dependency "ox"
-  spec.add_dependency "parslet"
   spec.add_dependency "unitsdb", "~> 2.2.5"
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: unitsml
 version: !ruby/object:Gem::Version
-  version: 0.6.9
+  version: 0.6.11
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-17 00:00:00.000000000 Z
+date: 2026-10-24 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: asciiunits
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
 - !ruby/object:Gem::Dependency
   name: htmlentities
   requirement: !ruby/object:Gem::Requirement
@@ -52,34 +66,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 2.4.0
-- !ruby/object:Gem::Dependency
-  name: ox
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: parslet
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: unitsdb
   requirement: !ruby/object:Gem::Requirement
@@ -127,13 +113,14 @@ files:
 - lib/unitsml/errors/base_error.rb
 - lib/unitsml/errors/invalid_model_error.rb
 - lib/unitsml/errors/opal_payload_not_bundled_error.rb
+- lib/unitsml/errors/parg_load_error.rb
 - lib/unitsml/errors/plurimath_load_error.rb
+- lib/unitsml/errors/quantity_errors.rb
 - lib/unitsml/errors/unsupported_payload_type_error.rb
 - lib/unitsml/extender.rb
 - lib/unitsml/fenced.rb
 - lib/unitsml/fenced_numeric.rb
 - lib/unitsml/formula.rb
-- lib/unitsml/intermediate_exp_rules.rb
 - lib/unitsml/mathml_helper.rb
 - lib/unitsml/model.rb
 - lib/unitsml/model/dimension.rb
@@ -166,12 +153,13 @@ files:
 - lib/unitsml/opal.rb
 - lib/unitsml/opal/database_payload.rb
 - lib/unitsml/opal/payload_generator.rb
-- lib/unitsml/parse.rb
+- lib/unitsml/parg.rb
+- lib/unitsml/parg/tree_mapper.rb
 - lib/unitsml/parser.rb
 - lib/unitsml/prefix.rb
 - lib/unitsml/prefix_adapter.rb
+- lib/unitsml/quantity.rb
 - lib/unitsml/sqrt.rb
-- lib/unitsml/transform.rb
 - lib/unitsml/unit.rb
 - lib/unitsml/unitsdb.rb
 - lib/unitsml/unitsdb/database.rb