amounts 0.0.2 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cf7f88449ef3636b2ad506b569793e7943f6cd16b82bb1013d8eb7c8a866c41b
-  data.tar.gz: 49e3027de827e8cd1747fd5df795e3a605736a6192298cc403a1a9de19ad158f
+  metadata.gz: 8b7620b025be07f1166e655108c2b9cea0232acb60d814cf91b71ecb47ddf1fb
+  data.tar.gz: 8f8ab43608f4ced54ab5020c7cbcf69b0741c9203e549558b27356766187efb5
 SHA512:
-  metadata.gz: 51e5cc2f4c0e9c1cad9289933283c9d687c36618edb09ed7524c7a366e104c98d46386ebafac1db67f129c72a2605248d3a0bf44b4962cc83aab4ae7154c7af6
-  data.tar.gz: 738dcbbc4f4aae614d002f4c127ecdb820585e0fee51ec61ddc9381d55acd264ea7db87d1150afb15a96bd803af03d9f2dbd9b672415d4fdf81ec3400e67f06c
+  metadata.gz: 466350a8fbfff01e84bd044f23ced9d63288eb4147f13d70df2a3db9b37745cafee46e03cb3d1d9b0b805fff8ece3ca13df029c19786204f21e2fe1336b1e564
+  data.tar.gz: 807ba283121158491de02a78084dae5ce12c6360ac106a7d72a1bde6a7f536ac3009fdf329b9e75972fe3631ade8bdae3dd0f2d1f2d2e74f9a023f28d46f5cb1

data/CHANGELOG.md

@@ -1,5 +1,65 @@
 # Changelog
 
+## 0.0.4 - 2026-04-26
+
+### Changed (breaking)
+
+- The opt-in RSpec integration moved into a dedicated `Amount::RSpec` namespace
+  with one file per concern. Constants and require paths changed:
+
+  | Old | New |
+  | --- | --- |
+  | `Amount::RSpecMatchers` | `Amount::RSpec::Matchers` |
+  | `Amount::RSpecSupport`  | `Amount::RSpec::Support`  |
+  | `lib/amount/rspec_matchers.rb` | `lib/amount/rspec/matchers.rb` |
+  | `lib/amount/rspec_support.rb`  | `lib/amount/rspec/support.rb`  |
+
+  The ActiveRecord-specific matchers also live in their own file under the same
+  pattern (`Amount::ActiveRecord::RSpec::Matchers` in
+  `lib/amount/active_record/rspec/matchers.rb`). Top-level `require` paths
+  (`require "amount/rspec"` and `require "amount/active_record/rspec"`) are
+  unchanged.
+
+  Update any direct constant references; no backwards-compatibility aliases are
+  shipped.
+
+### Changed
+
+- The `Amount` instance behavior is now composed from focused mixins instead
+  of all living in a single 500+ line file. New modules under `lib/amount/`:
+  `Arithmetic` (`+`, `-`, `*`, `/`, `abs`, `-@`),
+  `Comparison` (`<=>`, `==`, `eql?`, `hash`, `same_type?`, sign predicates),
+  `Conversion` (`to(target_symbol, rate:)`),
+  `Allocation` (`split`, `allocate`),
+  and `Serialization` (instance `to_h` plus `Serialization::ClassMethods.load`
+  auto-extended via the `included` hook).
+  Public API unchanged. Shared private helpers (`build`,
+  `coerce_other_to_self_type[!]`, `ensure_same_type!`, `infer_value`,
+  `infer_type`, `ui_to_atomic`) remain on the main `Amount` class so every
+  mixin can call them.
+
+### Removed
+
+- `Amount::Serializer` is gone. Its `dump`/`load` class methods moved into
+  `Amount::Serialization` (instance `to_h` plus `ClassMethods.load`).
+  `Amount.load(hash)` and `Amount#to_h` are unchanged.
+
+## 0.0.3 - 2026-04-26
+
+### Fixed
+
+- Rational scalars and rates are now accepted everywhere they are documented to
+  work: `Amount#*`, `Amount#/`, `Amount#to(rate:)`, `Amount.register_default_rate`,
+  and `display_units[unit][:scale]`. Previously each of these called
+  `BigDecimal(value.to_s)`, which raises `ArgumentError` for `Rational#to_s`
+  (`"3/2"`). All five sites now go through a single internal helper,
+  `Amount.coerce_decimal`, that handles `BigDecimal`, `Rational`, and string-or-
+  numeric inputs uniformly.
+- `Amount.load` wraps a missing `:atomic` or `:symbol` key as
+  `Amount::InvalidInput` (`"amount payload missing key: atomic"`) instead of
+  leaking a raw `KeyError`. This matches the AR adapter's `Type#cast_hash`
+  behavior so callers can rescue a single error class.
+
 ## 0.0.2 - 2026-04-26
 
 ### Fixed

data/lib/amount/active_record/rspec/matchers.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+class Amount
+  module ActiveRecord
+    module RSpec
+      # ActiveRecord-specific matcher definitions. Companion to
+      # `Amount::RSpec::Matchers` which holds the gem-core matchers.
+      module Matchers
+        module_function
+
+        def define_amount_column_matcher
+          ::RSpec::Matchers.define :have_amount_column do |name, *expected_arguments|
+            match do |record|
+              @name = name
+              @expected = Amount::RSpec::Support.coerce_amount_arguments(expected_arguments)
+              @definition = record.class.amount_attribute_definitions.fetch(name.to_sym)
+
+              @definition.read(record) == @expected &&
+                record.public_send(@definition.atomic_column).to_i == @expected.atomic &&
+                (@definition.fixed_symbol? ||
+                  record.public_send(@definition.symbol_column) == @expected.symbol.to_s)
+            end
+
+            failure_message do |record|
+              "expected #{record.inspect} to have #{@name} column matching #{@expected.inspect}"
+            end
+          end
+        end
+
+        def define_amount_sum_matcher
+          ::RSpec::Matchers.define :match_amounts do |expected_hash|
+            match do |actual_hash|
+              @expected = expected_hash.to_h do |symbol, value|
+                amount = Amount.new(value, symbol)
+                [amount.symbol, amount]
+              end
+              @actual = Amount::RSpec::Support.normalize_amount_sums(actual_hash)
+
+              @actual == @expected
+            end
+
+            failure_message do |_actual_hash|
+              "expected grouped amounts #{@actual.inspect} to match #{@expected.inspect}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/amount/active_record/rspec.rb

@@ -3,6 +3,7 @@
 require_relative "../active_record"
 require "rspec/expectations"
 require_relative "../rspec"
+require_relative "rspec/matchers"
 
-Amount::RSpecMatchers.define_amount_column_matcher
-Amount::RSpecMatchers.define_amount_sum_matcher
+Amount::ActiveRecord::RSpec::Matchers.define_amount_column_matcher
+Amount::ActiveRecord::RSpec::Matchers.define_amount_sum_matcher

data/lib/amount/active_record/type.rb

@@ -77,12 +77,11 @@ class Amount
       private
 
       def cast_hash(value)
-        if value.key?(:atomic) || value.key?("atomic")
+        value = value.transform_keys(&:to_sym)
+        if value.key?(:atomic)
           ::Amount.load(value)
         else
-          symbol = value.fetch(:symbol) { value.fetch("symbol", fixed_symbol) }
-          amount_value = value.fetch(:value) { value.fetch("value") }
-          ::Amount.new(amount_value, symbol)
+          ::Amount.new(value.fetch(:value), value.fetch(:symbol, fixed_symbol))
         end
       rescue KeyError
         raise ::Amount::InvalidInput, "hash input must contain atomic/symbol or value/symbol"

data/lib/amount/allocation.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+class Amount
+  # Splitting and proportional allocation. Both operations return
+  # `[parts, remainder]`, preserving the invariant that the parts plus
+  # remainder always sum back to the receiver's atomic value (including
+  # the sign).
+  module Allocation
+    # Splits into equal parts and returns the leftover explicitly.
+    #
+    # @param n [Integer]
+    # @return [Array<(Array<Amount>, Amount)>]
+    # @raise [ArgumentError] if `n` is not a positive integer
+    # @example
+    #   parts, remainder = Amount.new(10, :LOGS).split(3)
+    #   parts.map(&:atomic)
+    #   # => [3, 3, 3]
+    #   remainder.atomic
+    #   # => 1
+    def split(n)
+      raise ArgumentError, "n must be positive" unless n.is_a?(Integer) && n.positive?
+
+      sign = atomic_sign
+      base, remainder = @atomic.abs.divmod(n)
+      parts = Array.new(n) { build(sign * base) }
+
+      [parts, build(sign * remainder)]
+    end
+
+    # Allocates proportionally by integer weights and returns the leftover explicitly.
+    #
+    # @param weights [Array<Integer>]
+    # @return [Array<(Array<Amount>, Amount)>]
+    # @raise [ArgumentError] if weights are empty, negative, or sum to zero
+    # @example
+    #   parts, remainder = Amount.new(10, :LOGS).allocate([1, 1, 2])
+    #   parts.map(&:atomic)
+    #   # => [2, 2, 5]
+    #   remainder.atomic
+    #   # => 1
+    def allocate(weights)
+      raise ArgumentError, "weights must be non-empty" if weights.empty?
+      raise ArgumentError, "weights must be non-negative integers" unless weights.all? { |weight| weight.is_a?(Integer) && weight >= 0 }
+
+      total = weights.sum
+      raise ArgumentError, "weights must sum to positive value" unless total.positive?
+
+      sign = atomic_sign
+      absolute_atomic = @atomic.abs
+      allocations = weights.map { |weight| absolute_atomic * weight / total }
+      remainder = absolute_atomic - allocations.sum
+
+      parts = allocations.map { |allocation| build(sign * allocation) }
+      [parts, build(sign * remainder)]
+    end
+
+    private
+
+    def atomic_sign
+      return 1 if @atomic.positive?
+      return(-1) if @atomic.negative?
+
+      0
+    end
+  end
+end

data/lib/amount/arithmetic.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+class Amount
+  # Arithmetic operators for `Amount`. Mixed into `Amount` and inherited by
+  # any registered subclass.
+  #
+  # All operators preserve the receiver's class via `build`, so subclass
+  # identity (`GoldAmount`) survives through `+`, `-`, `*`, `/`, `abs`, `-@`.
+  module Arithmetic
+    # @return [Amount]
+    # @example
+    #   Amount.usdc("-1").abs
+    #   # => #<Amount USDC $1.00>
+    def abs
+      build(@atomic.abs)
+    end
+
+    # @return [Amount]
+    # @example
+    #   -Amount.usdc("1")
+    #   # => #<Amount USDC -$1.00>
+    def -@
+      build(-@atomic)
+    end
+
+    # @param other [Amount]
+    # @return [Amount]
+    # @raise [TypeMismatch]
+    # @example Same-type addition
+    #   Amount.usdc("1.50") + Amount.usdc("0.50")
+    #
+    # @example Cross-type addition using a registered directional rate
+    #   Amount.register_default_rate :USD, :USDC, "1"
+    #   Amount.usdc("10.00") + Amount.new("5.00", :USD)
+    def +(other)
+      rhs = coerce_other_to_self_type!(other)
+      build(@atomic + rhs.atomic)
+    end
+
+    # @param other [Amount]
+    # @return [Amount]
+    # @raise [TypeMismatch]
+    # @example
+    #   Amount.usdc("2.00") - Amount.usdc("0.50")
+    def -(other)
+      rhs = coerce_other_to_self_type!(other)
+      build(@atomic - rhs.atomic)
+    end
+
+    # @param scalar [Numeric]
+    # @return [Amount]
+    # @raise [TypeMismatch]
+    # @example
+    #   Amount.usdc("1.25") * 2
+    def *(scalar)
+      ensure_scalar!(scalar)
+      build((BigDecimal(@atomic) * Amount.coerce_decimal(scalar)).to_i)
+    end
+
+    # @param other [Amount, Numeric]
+    # @return [Amount, BigDecimal]
+    # @raise [TypeMismatch, ZeroDivisionError]
+    # @example Dividing by a scalar returns an amount
+    #   Amount.usdc("1.00") / 2
+    #
+    # @example Dividing by an amount returns a ratio
+    #   Amount.usdc("10.00") / Amount.usdc("2.00")
+    def /(other)
+      if other.is_a?(Amount)
+        ensure_same_type!(other)
+        raise ZeroDivisionError if other.zero?
+
+        BigDecimal(@atomic) / BigDecimal(other.atomic)
+      else
+        ensure_scalar!(other)
+        raise ZeroDivisionError if other.zero?
+
+        build((BigDecimal(@atomic) / Amount.coerce_decimal(other)).to_i)
+      end
+    end
+
+    private
+
+    def ensure_scalar!(value)
+      return if value.is_a?(Integer) || value.is_a?(Float) ||
+                value.is_a?(BigDecimal) || value.is_a?(Rational)
+
+      raise TypeMismatch, "expected scalar, got #{value.class}"
+    end
+  end
+end

data/lib/amount/comparison.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+class Amount
+  # Comparison, equality, hashing, and sign predicates for `Amount`.
+  #
+  # Pulls in `Comparable` itself so consumers only need `include Comparison`
+  # to get `<`, `<=`, `>`, `>=`, `between?`, `clamp`, and `Enumerable#min`/
+  # `#max` alongside the explicit `<=>` / `==` / `eql?` / `hash` defined here.
+  module Comparison
+    include Comparable
+    # @param other [Object]
+    # @return [Boolean]
+    # @example
+    #   Amount.usdc("1").same_type?(Amount.usdc("2"))
+    #   # => true
+    def same_type?(other)
+      other.is_a?(Amount) && other.symbol == symbol
+    end
+
+    # @return [Boolean]
+    # @example
+    #   Amount.usdc(0, from: :atomic).zero?
+    #   # => true
+    def zero? = @atomic.zero?
+
+    # @return [Boolean]
+    # @example
+    #   Amount.usdc("1").positive?
+    #   # => true
+    def positive? = @atomic.positive?
+
+    # @return [Boolean]
+    # @example
+    #   Amount.usdc("-1").negative?
+    #   # => true
+    def negative? = @atomic.negative?
+
+    # @param other [Object]
+    # @return [-1, 0, 1, nil]
+    # @example
+    #   Amount.usdc("1") <=> Amount.usdc("2")
+    #   # => -1
+    def <=>(other)
+      return nil unless other.is_a?(Amount)
+
+      comparable = coerce_other_to_self_type(other)
+      return nil unless comparable
+
+      @atomic <=> comparable.atomic
+    end
+
+    # @param other [Object]
+    # @return [Boolean]
+    # @example
+    #   Amount.usdc("1.50") == Amount.usdc("1.50")
+    #   # => true
+    def ==(other)
+      same_type?(other) && @atomic == other.atomic
+    end
+
+    # @param other [Object]
+    # @return [Boolean]
+    # @example Hash-key equality keeps class and symbol identity
+    #   Amount.usdc("1").eql?(Amount.usdc("1"))
+    #   # => true
+    def eql?(other)
+      other.class == self.class && symbol == other.symbol && @atomic == other.atomic
+    end
+
+    # @return [Integer]
+    # @example
+    #   { Amount.usdc("1") => :ok }[Amount.usdc("1")]
+    #   # => :ok
+    def hash
+      [self.class, symbol, @atomic].hash
+    end
+  end
+end

data/lib/amount/conversion.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+class Amount
+  # Cross-type conversion via `to(target_symbol, rate:)`. Uses an explicitly
+  # passed rate when provided, otherwise looks up the registered directional
+  # default rate. The result class is taken from the target symbol's registry
+  # entry, so a `class:`-registered subclass becomes the natural identity for
+  # conversion outputs.
+  module Conversion
+    # @param target_symbol [Symbol, String]
+    # @param rate [String, Numeric, BigDecimal, nil]
+    # @return [Amount]
+    # @raise [Amount::Registry::NoDefaultRate] if no explicit or registered rate is available
+    # @example Using an explicit one-off rate
+    #   Amount.usdc("100").to(:GOLD, rate: "0.00042")
+    #
+    # @example Using a registered default rate
+    #   Amount.register_default_rate :USDC, :USD, "1"
+    #   Amount.usdc("1.50").to(:USD)
+    def to(target_symbol, rate: nil)
+      target_symbol = target_symbol.to_sym
+      return self.class.new(@atomic, symbol, from: :atomic) if target_symbol == symbol
+
+      rate = resolve_rate(target_symbol, rate)
+      target_entry = self.class.registry.lookup(target_symbol)
+
+      decimal_result = decimal * Amount.coerce_decimal(rate)
+      atomic_result = (decimal_result * (BigDecimal(10)**target_entry.decimals)).to_i
+
+      target_entry.amount_class.new(atomic_result, target_symbol, from: :atomic)
+    end
+
+    private
+
+    def resolve_rate(target, provided)
+      return provided if provided
+
+      self.class.registry.default_rate(symbol, target)
+    end
+  end
+end

data/lib/amount/display.rb

@@ -32,7 +32,7 @@ class Amount
     # @return [BigDecimal]
     def in_unit(unit)
       unit_spec = fetch_display_unit(unit)
-      @amount.decimal * BigDecimal(unit_spec[:scale].to_s)
+      @amount.decimal * Amount.coerce_decimal(unit_spec[:scale])
     end
 
     private
@@ -44,7 +44,7 @@ class Amount
 
     def render_display_unit(unit, direction)
       spec = fetch_display_unit(unit)
-      scaled = @amount.decimal * BigDecimal(spec[:scale].to_s)
+      scaled = @amount.decimal * Amount.coerce_decimal(spec[:scale])
       decimals = spec[:ui_decimals] || @entry.ui_decimals
       rounded = round(scaled, decimals, direction)
 

data/lib/amount/parser.rb

@@ -3,8 +3,8 @@
 class Amount
   # Parses compact amount strings such as `USDC|1.50`.
   class Parser
-    VERSION_PREFIX = /\A(v\d+):(.*)\z/
     SUPPORTED_VERSION = "v1"
+    VERSION_PREFIX = /\A(v\d+):(.*)\z/
 
     def initialize(input)
       @input = input

data/lib/amount/registry.rb

@@ -21,23 +21,30 @@ class Amount
   #   Amount.registry.lock!
   class Registry
     class UnknownType < StandardError; end
-    class AlreadyRegistered < StandardError; end
-    class InvalidDisplayUnit < StandardError; end
     class NoDefaultRate < StandardError; end
     class RegistryLocked < StandardError; end
+    class AlreadyRegistered < StandardError; end
+    class InvalidDisplayUnit < StandardError; end
 
     Entry = Struct.new(
-      :symbol, :decimals, :display_symbol, :display_position,
-      :ui_decimals, :display_units, :default_display, :amount_class,
+      :symbol,
+      :decimals,
+      :display_symbol,
+      :display_position,
+      :ui_decimals,
+      :display_units,
+      :default_display,
+      :amount_class,
       keyword_init: true
     )
 
     def initialize
-      @entries = {}
+      @entries       = {}
       @default_rates = {}
-      @generated_constructors = GeneratedConstructors.new
-      @locked = false
+      @locked        = false
+
       @lock = Mutex.new
+      @generated_constructors = GeneratedConstructors.new
     end
 
     # Registers a new fungible type.
@@ -67,6 +74,8 @@ class Amount
     def register(symbol, decimals:, display_symbol: symbol.to_s, display_position: :suffix,
                  ui_decimals: decimals, display_units: nil, default_display: nil,
                  class: nil)
+      raise ArgumentError, "symbol must not be blank" if symbol.nil? || symbol.to_s.empty?
+
       symbol = symbol.to_sym
 
       @lock.synchronize do
@@ -151,7 +160,7 @@ class Amount
 
       @lock.synchronize do
         ensure_unlocked!
-        @default_rates[[from, to]] = BigDecimal(rate.to_s)
+        @default_rates[[from, to]] = Amount.coerce_decimal(rate)
       end
     end
 

data/lib/amount/rspec/matchers.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+class Amount
+  module RSpec
+    # Internal matcher helpers for the opt-in RSpec integration.
+    #
+    # All bare `RSpec` references inside this module are fully qualified to
+    # `::RSpec` to dodge the constant-lookup ambiguity introduced by living
+    # under `Amount::RSpec`.
+    module Matchers
+      module_function
+
+      def define_amount_equality_matcher(name, &expected_builder)
+        ::RSpec::Matchers.define name do |*arguments|
+          match do |actual|
+            @expected = instance_exec(*arguments, &expected_builder)
+            actual.is_a?(Amount) && actual == @expected
+          end
+
+          failure_message do |actual|
+            return "expected #{actual.inspect} to be an Amount equal to #{@expected.inspect}" unless actual.is_a?(Amount)
+
+            "expected #{actual.inspect} to equal amount #{@expected.inspect}"
+          end
+        end
+      end
+
+      def define_amount_predicate_matcher(name, description, &predicate)
+        ::RSpec::Matchers.define name do
+          match do |actual|
+            actual.is_a?(Amount) && instance_exec(actual, &predicate)
+          end
+
+          failure_message do |actual|
+            "expected #{actual.inspect} to be #{description}"
+          end
+        end
+      end
+
+      def define_amount_type_matcher
+        ::RSpec::Matchers.define :be_amount_of do |expected_symbol|
+          match do |actual|
+            @expected_symbol = expected_symbol.to_sym
+            actual.is_a?(Amount) && actual.symbol == @expected_symbol
+          end
+
+          failure_message do |actual|
+            "expected #{actual.inspect} to be an Amount of #{@expected_symbol}"
+          end
+        end
+      end
+
+      def define_approximate_amount_matcher
+        ::RSpec::Matchers.define :be_approximately_amount do |*expected_arguments, within:|
+          match do |actual|
+            @expected = Amount::RSpec::Support.coerce_amount_arguments(expected_arguments)
+            @within = Amount::RSpec::Support.coerce_delta(@expected, within)
+
+            actual.is_a?(Amount) &&
+              actual.same_type?(@expected) &&
+              @within.same_type?(@expected) &&
+              (actual - @expected).abs.atomic <= @within.atomic
+          end
+
+          failure_message do |actual|
+            return "expected #{actual.inspect} to be an Amount within #{@within.inspect} of #{@expected.inspect}" unless actual.is_a?(Amount)
+
+            "expected #{actual.inspect} to be within #{@within.inspect} of #{@expected.inspect}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/amount/rspec/support.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+class Amount
+  module RSpec
+    # Shared coercion helpers for opt-in RSpec integrations.
+    module Support
+      module_function
+
+      def coerce_amount_arguments(arguments)
+        case arguments.length
+        when 1
+          coerce_amount(arguments.first)
+        when 2
+          Amount.new(arguments.last, arguments.first)
+        else
+          raise ArgumentError, "expected an Amount, a parse string, or a symbol/value pair"
+        end
+      end
+
+      def coerce_amount(value)
+        case value
+        when Amount then value
+        when String then Amount.parse(value)
+        when Hash then Amount.load(value)
+        else
+          raise ArgumentError, "cannot coerce #{value.inspect} into an Amount"
+        end
+      end
+
+      def coerce_delta(expected_amount, within)
+        case within
+        when Amount
+          within
+        when Integer, Float, BigDecimal, Rational, String
+          Amount.new(within, expected_amount.symbol)
+        else
+          raise ArgumentError, "cannot coerce #{within.inspect} into an amount delta"
+        end
+      end
+
+      def normalize_amount_sums(sum_hash)
+        sum_hash.to_h do |symbol, atomic|
+          amount = Amount.new(atomic, symbol, from: :atomic)
+          [amount.symbol, amount]
+        end
+      end
+    end
+  end
+end

data/lib/amount/rspec.rb

@@ -2,8 +2,8 @@
 
 require_relative "../amount"
 require "rspec/expectations"
-require_relative "rspec_support"
-require_relative "rspec_matchers"
+require_relative "rspec/support"
+require_relative "rspec/matchers"
 
 # Opt-in RSpec matchers for `Amount`.
 #
@@ -16,12 +16,12 @@ require_relative "rspec_matchers"
 #   expect(Amount.usdc("1.50")).to be_amount_of(:USDC)
 #   expect(Amount.usdc("1.50")).to be_positive_amount
 #   expect(Amount.usdc("1.55")).to be_approximately_amount(:USDC, "1.50", within: "0.10")
-Amount::RSpecMatchers.define_amount_equality_matcher(:eq_amount) do |*expected_arguments|
-  Amount::RSpecSupport.coerce_amount_arguments(expected_arguments)
+Amount::RSpec::Matchers.define_amount_equality_matcher(:eq_amount) do |*expected_arguments|
+  Amount::RSpec::Support.coerce_amount_arguments(expected_arguments)
 end
 
-Amount::RSpecMatchers.define_amount_type_matcher
-Amount::RSpecMatchers.define_amount_predicate_matcher(:be_zero_amount, "a zero Amount", &:zero?)
-Amount::RSpecMatchers.define_amount_predicate_matcher(:be_positive_amount, "a positive Amount", &:positive?)
-Amount::RSpecMatchers.define_amount_predicate_matcher(:be_negative_amount, "a negative Amount", &:negative?)
-Amount::RSpecMatchers.define_approximate_amount_matcher
+Amount::RSpec::Matchers.define_amount_type_matcher
+Amount::RSpec::Matchers.define_approximate_amount_matcher
+Amount::RSpec::Matchers.define_amount_predicate_matcher(:be_zero_amount, "a zero Amount", &:zero?)
+Amount::RSpec::Matchers.define_amount_predicate_matcher(:be_positive_amount, "a positive Amount", &:positive?)
+Amount::RSpec::Matchers.define_amount_predicate_matcher(:be_negative_amount, "a negative Amount", &:negative?)