unitsml 0.6.9 → 0.6.10

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,7 @@ 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/unsupported_payload_type_error"
 
 require "unitsml/opal/database_payload"
@@ -87,15 +88,13 @@ 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/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/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.10"
 end

data/lib/unitsml.rb

@@ -13,17 +13,15 @@ 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"
@@ -31,6 +29,6 @@ module Unitsml
   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.10
 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,13 @@ 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/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 +152,12 @@ 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/sqrt.rb
-- lib/unitsml/transform.rb
 - lib/unitsml/unit.rb
 - lib/unitsml/unitsdb.rb
 - lib/unitsml/unitsdb/database.rb

data/lib/unitsml/intermediate_exp_rules.rb

@@ -1,86 +0,0 @@
-# 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) do
-      int_exp_prefixes_units | prefixes_units_int_exp
-    end
-
-    rule(:extended_prefixed_units) do
-      extender >> spaces? >> prefixes_units_int_exp.as(:sequence)
-    end
-
-    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) do
-      spaces? >> extender >> spaces? >> dimension_rules_int_exp.as(:sequence)
-    end
-    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) do
-      sqrt >> opening_paren >> dimension_rules_int_exp.as(:sqrt) >> closing_paren
-    end
-
-    # Rules for sequence
-    rule(:sqrt_sequence) do
-      sqrt >> opening_paren >> prefixes_units_int_exp.as(:sqrt) >> closing_paren
-    end
-  end
-end

data/lib/unitsml/parse.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-require "parslet"
-
-module Unitsml
-  class Parse < Parslet::Parser
-    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(:sequence) do
-      (single_letter_prefixes >> units) | (double_letter_prefixes >> units) | units
-    end
-
-    rule(:opening_paren)   { str("(") }
-    rule(:closing_paren)   { str(")") }
-    rule(:unit_and_power)  { units >> power.maybe }
-    rule(:slashed_number)  do
-      (number >> (forward_slashes >> number).maybe).as(:integer)
-    end
-    rule(:forward_slashes) { str("//") | str("/") }
-    rule(:dimension_rules) do
-      (sqrt_dimensions | powered_dimensions) >> extended_dimension_rules.maybe
-    end
-    rule(:powered_dimensions) { dimensions >> power.maybe }
-
-    rule(:units) do
-      @@filtered_units ||= arr_to_expression(::Unitsml::Unitsdb.units.filtered,
-                                             "unit")
-    end
-
-    rule(:single_letter_prefixes) do
-      @@prefixes1 ||= arr_to_expression(::Unitsml::Unitsdb.prefixes_by_size(1),
-                                        "prefix")
-    end
-
-    rule(:double_letter_prefixes) do
-      @@prefixes2 ||= arr_to_expression(::Unitsml::Unitsdb.prefixes_by_size(2),
-                                        "prefix")
-    end
-
-    rule(:dimensions) do
-      @@dimensions ||= arr_to_expression(
-        ::Unitsml::Unitsdb.dimensions.parsables.keys, "dimension"
-      )
-    end
-
-    rule(:prefixes_units) do
-      (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
-      prefixes_units_int_exp |
-        dimension_rules_int_exp |
-        (single_letter_prefixes >> hyphen) |
-        (double_letter_prefixes >> hyphen)
-    end
-
-    root :expression
-
-    def arr_to_expression(arr, file_name)
-      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
-  end
-end