minting 1.6.3 → 1.7.0

data/lib/minting/mint/dsl/range.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+# Mint Range patch
+# @api private
+module Mint
+  if RUBY_VERSION < '4.0'
+    # Ruby < 4.0's Range#step calls rb_to_int on non-Numeric step arguments,
+    # which raises TypeError for Money objects. Ruby 4.0+ uses arithmetic
+    # iteration (+ / <=>) for non-numeric steps natively, so this patch is
+    # only needed on older Rubies.
+    module RangeStepPatch
+      def step(step_size = nil, &)
+        return super unless step_size.is_a?(Mint::Money)
+
+        raise TypeError, "can't iterate from NilClass" unless self.begin
+        raise ArgumentError, "step can't be 0" if step_size.zero?
+
+        if block_given?
+          each_money_step(step_size, &)
+          self
+        else
+          Enumerator.new do |yielder|
+            each_money_step(step_size) { |v| yielder << v }
+          end
+        end
+      end
+
+      private
+
+      def each_money_step(step_amount)
+        current = self.begin
+        last = self.end
+
+        unless last
+          loop do
+            yield current
+            current += step_amount
+          end
+          return
+        end
+
+        ascending = step_amount.positive?
+        loop do
+          break if ascending ? current > last : current < last
+          break if exclude_end? && current == last
+
+          yield current
+          current += step_amount
+        end
+      end
+    end
+    Range.prepend(Mint::RangeStepPatch)
+  end
+end

data/lib/minting/mint/{dsl.rb → dsl/refinements.rb}

@@ -19,14 +19,4 @@ module Mint
   refine String do
     def to_money(currency) = Mint.money(to_r, currency)
   end
-
-  def self.use_top_level_constants!
-    if !defined?(::Money) && !defined?(::Currency)
-      require 'minting/mint/aliases'
-    elsif ::Money == Mint::Money && ::Currency == Mint::Currency
-      warn 'Warning: Money and Currency already defined as Mint aliases, skipping'
-    else
-      raise NameError, 'Cannot define top-level Money or Currency constants: already defined'
-    end
-  end
 end

data/lib/minting/mint/dsl/top_level.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# Mint refinements
+module Mint
+  def self.use_top_level_constants!
+    if !defined?(::Money) && !defined?(::Currency)
+      require 'minting/mint/aliases'
+    elsif ::Money == Mint::Money && ::Currency == Mint::Currency
+      warn 'Warning: Money and Currency already defined as Mint aliases, skipping'
+    else
+      raise NameError, 'Cannot define top-level Money or Currency constants: already defined'
+    end
+  end
+end

data/lib/minting/mint/mint.rb

@@ -21,10 +21,10 @@ module Mint
   # @return [Currency, nil] the registered Currency instance or nil if not found
   def self.currency(currency)
     case currency
-    when nil      then nil
+    when NilClass then nil
     when Currency then currency
     when String   then CurrencyRegistry.currencies[currency]
-    else raise ArgumentError, "currency must be [Currency] ot [String] (#{currency})"
+    else          raise ArgumentError, "currency must be [Currency] ot [String] (#{currency})"
     end
   end
 

data/lib/minting/mint/parser.rb

@@ -42,27 +42,34 @@ module Mint
     Rational(numeric)
   end
 
+  def classify_separators(numeric)
+    case [numeric.count(','), numeric.count('.')]
+    in [0, 0] | [0, 1]          then :decimal_period # e.g. "1500" or "34.21".
+    in [1, 0]                   then :decimal_comma  # Only one comma: decimal (e.g. 19,99 or 1,234).
+    in [c, p] if c > 1 && p > 1 then :ambiguous      # Both separators appear multiple times
+    in [c, p] if c > 0 && p > 0 then :mixed          # Commas and dots: the rightmost one is the decimal separator.
+    else                             :thousands_only # Multiple of the same separator only (e.g. 1,234,567)
+    end
+  end
+
   # Converts locale-specific decimal/thousand separators into a plain decimal string.
   def normalize_separators(numeric)
-    case [numeric.count(','), numeric.count('.')]
-    in [0, 0] | [0, 1] then numeric              # Nothing to normalize (e.g. "1500" or "34.21").
-    in [1, 0]          then numeric.tr(',', '.') # Only one comma: decimal (e.g. 19,99 or 1,234).
-    in [c, p] if c > 1 && p > 1 # Both separators appear multiple times
-      raise ArgumentError, "could not distinguish decimal and thousand separators in '#{numeric}'"
-    in [c, p] if c > 0 && p > 0 # Commas and dots: the rightmost one is the decimal separator.
+    case classify_separators(numeric)
+    when :decimal_period then numeric              # Nothing to normalize (e.g. "1500" or "34.21").
+    when :decimal_comma  then numeric.tr(',', '.') # Only one comma: decimal (e.g. 19,99 or 1,234).
+    when :thousands_only then numeric.delete(',.')
+    when :ambiguous then raise ArgumentError, "could not distinguish decimal and thousand separators in '#{numeric}'"
+    when :mixed # Commas and dots: the rightmost one is the decimal separator.
       if numeric.rindex(',') > numeric.rindex('.')
         numeric.delete('.').tr(',', '.')
       else
         numeric.delete(',')
       end
-    else # Multiple of the same separator only (e.g. 1,234,567) — all are thousands.
-      numeric.delete(',.')
     end
   end
 
   def parse_currency(input)
     case input
-    when nil then return nil
     when String
       # Prefer an explicit ISO 4217 code (e.g. "USD 1,234.56") over symbol matching.
       currency = Mint.currency(input[/\b([A-Z_]+)\b/, 1])

data/lib/minting/mint.rb

@@ -3,7 +3,9 @@
 require 'minting/mint/currency/currency'
 require 'minting/mint/currency/currency_registry'
 require 'minting/mint/currency/world_currencies'
-require 'minting/mint/dsl'
+require 'minting/mint/dsl/range'
+require 'minting/mint/dsl/refinements'
+require 'minting/mint/dsl/top_level'
 require 'minting/mint/mint'
 require 'minting/mint/parser'
 require 'minting/money/allocation'

data/lib/minting/money/allocation.rb

@@ -19,41 +19,41 @@ module Mint
 
       subunit = currency.subunit
       amounts = proportions.map { |rate| Rational(amount * rate, whole).round(subunit) }
-      allocate_left_over!(amounts: amounts, left_over: amount - amounts.sum)
+      allocate_left_over(amounts: amounts, left_over: amount - amounts.sum)
     end
 
     # Splits the monetary amount into a given quantity of equal parts.
     # Disperses any fractional subunit rounding differences across the initial slots
     # so that the sum is preserved.
     #
-    # @param quantity [Integer] the number of equal parts to divide the money into (must be > 0)
+    # @param slices [Integer] the number of equal parts to divide the money into (must be > 0)
     # @return [Array<Money>] the list of newly split Money objects
     # @raise [ArgumentError] if quantity is not a positive integer
     #
     # @example Even split
     #   money = Mint.money(10.00, 'USD')
     #   money.split(3) #=> [[USD 3.34], [USD 3.33], [USD 3.33]]
-    def split(quantity)
-      unless  quantity.positive? && quantity.integer?
-        raise ArgumentError,
-              'quantity must be an integer > 0'
-      end
+    def split(slices)
+      raise ArgumentError, 'Slices quantity must be an poitive integer' unless slices.positive? && slices.integer?
 
-      fraction = (amount / quantity).round(currency.subunit)
-      allocate_left_over!(amounts: Array.new(quantity, fraction),
-                          left_over: amount - (fraction * quantity))
+      fraction = (amount / slices).round(currency.subunit)
+      allocate_left_over(amounts: Array.new(slices, fraction),
+                         left_over: amount - (fraction * slices))
     end
 
     private
 
-    def allocate_left_over!(amounts:, left_over:)
+    # Distributes any leftover amount across the allocation slots by adjusting
+    # individual amounts by the currency's minimum unit, and converting to Money.
+    # Caution: amounts array is mutated by this method
+    def allocate_left_over(amounts:, left_over:)
       if left_over.nonzero?
         minimum = currency.minimum_amount
         minimum = -minimum if left_over.negative?
-        last_slot = (left_over / minimum).to_i - 1
-        (0..last_slot).each { |slot| amounts[slot] += minimum }
+        slots_to_adjust = (left_over / minimum).to_i
+        (0...slots_to_adjust).each { |slot| amounts[slot] += minimum }
       end
-      amounts.map { |amount| Money.new(amount, currency) }
+      amounts.map! { |amount| Money.new(amount, currency) }
     end
   end
 end

data/lib/minting/money/arithmetics.rb

@@ -31,10 +31,10 @@ module Mint
     # @raise [TypeError] if addition involves a different currency or incompatible types
     def +(addend)
       case addend
-      when 0     then return self
-      when Money then return mint(amount + addend.amount) if same_currency?(addend)
+      in 0 then self
+      in Money if same_currency?(addend) then mint(amount + addend.amount)
+      else raise TypeError, "#{addend} can't be added to #{self}"
       end
-      raise TypeError, "#{addend} can't be added to #{self}"
     end
 
     # Performs subtraction with another {Money} instance or standard zero Numeric.
@@ -61,9 +61,9 @@ module Mint
     # @return [Money] the multiplied Money instance
     # @raise [TypeError] if multiplier is not Numeric or is a Money object
     def *(multiplicand)
-      return mint(amount * multiplicand) if multiplicand.is_a?(Numeric)
+      raise TypeError, "#{self} can't be multiplied by #{multiplicand}" unless multiplicand.is_a?(Numeric)
 
-      raise TypeError, "#{self} can't be multiplied by #{multiplicand}"
+      mint(amount * multiplicand)
     end
 
     # Performs division of the monetary value by a scalar Numeric or identical currency {Money}.

data/lib/minting/money/coercion.rb

@@ -4,13 +4,13 @@ module Mint
   # Implements the standard Ruby coercion protocol.
   class Money
     # Allows {Money} to interact seamlessly as the right-hand operand in Numeric arithmetic.
-    # This enables expressions like `5 + money` where `5` is a Numeric and `money` is a Money object.
+    # This enables expressions like `5 * money` where `5` is a Numeric and `money` is a Money object.
     #
     # @param other [Numeric] the left-hand operand to coerce
     # @return [Array(CoercedNumber, Money)] coerced operand array
     # @example
     #   price = Mint.money(10, 'USD')
-    #   5 + price  #=> [USD 15.00] (via coercion)
+    #   5 * price  #=> [USD 50.00] (via coercion)
     def coerce(other)
       [CoercedNumber.new(other), self]
     end
@@ -20,22 +20,20 @@ module Mint
     # @private
     class CoercedNumber
       # @private
-      def initialize(value)
-        @value = value
-      end
+      def initialize(value) = @value = value
 
       # @private
       def +(other)
-        return other if @value.zero?
+        raise_coercion_error(:+, other) unless @value.zero?
 
-        raise_coercion_error(:+, other)
+        other
       end
 
       # @private
       def -(other)
-        return -other if @value.zero?
+        raise_coercion_error(:-, other) unless @value.zero?
 
-        raise_coercion_error(:-, other)
+        -other
       end
 
       # @private
@@ -59,8 +57,7 @@ module Mint
       private
 
       def raise_coercion_error(operation, operand)
-        raise TypeError,
-              "#{@value} #{operation} #{operand} : incompatible operands"
+        raise TypeError, "#{@value} #{operation} #{operand} : incompatible operands"
       end
     end
     private_constant :CoercedNumber

data/lib/minting/money/formatting.rb

@@ -45,10 +45,10 @@ module Mint
     #
     def to_s(format: '%<symbol>s%<amount>f', decimal: '.', thousand: ',', width: nil)
       case format
-      when {}, '', nil then raise ArgumentError, 'format must not be empty or null'
-      when Hash        then validate_format_hash!(format)
-      when String # noop
-      else raise ArgumentError, 'Invalid format'
+      when {}, '' then raise ArgumentError, 'format must not be empty'
+      when Hash   then validate_format_hash(format)
+      when String then format = { positive: format }
+      else        raise ArgumentError, 'Invalid format. Only String or Hash are accepted'
       end
 
       formatted = format_amount(format)
@@ -61,44 +61,39 @@ module Mint
         formatted.gsub!(/(\d)(?=(?:\d{3})+(?:[^\d]{1}|$))/, "\\1#{thousand}")
       end
 
-      formatted = formatted.rjust(width) if width
-      formatted
+      width ? formatted.rjust(width) : formatted
     end
 
     private
 
-    def validate_format_hash!(format)
-      unknown = format.keys - %i[positive negative zero]
-
-      raise ArgumentError, "Unknown format parameter(s): #{unknown.inspect}. " unless unknown.empty?
-    end
-
-    def format_amount(format)
-      format = { positive: format } if format.is_a?(String)
-      positive_format = format[:positive]
+    def select_format(format)
       negative_format = format[:negative]
       zero_format = format[:zero]
 
       if amount.negative? && negative_format
-        format = negative_format
-        value = -amount
+        [negative_format, -amount]
       elsif amount.zero? && zero_format
-        format = zero_format
-        value = amount
+        [zero_format,     amount]
       else
-        format = positive_format
-        value = amount
+        [format[:positive], amount]
       end
-      format ||= '%<symbol>s%<amount>f'
+    end
 
+    def validate_format_hash(format)
+      unknown = format.keys - %i[positive negative zero]
+
+      raise ArgumentError, "Unknown format parameter(s): #{unknown.inspect}. " unless unknown.empty?
+    end
+
+    def format_amount(format)
+      format, value = select_format(format)
+      format ||= '%<symbol>s%<amount>f'
       # Automatically adjust decimal places based on currency subunit if missing
-      adjusted_format = format
-                        .gsub(/%<amount>(\s*\+?\d*)f/, "%<amount>\\1.#{currency.subunit}f")
+      format = format.gsub(/%<amount>(\s*\+?\d*)f/, "%<amount>\\1.#{currency.subunit}f")
 
-      Kernel.format(adjusted_format,
-                    amount: value,
-                    currency: currency_code,
-                    symbol: currency.symbol)
+      refs = format.scan(/%<(\w+)>/).flatten.map(&:to_sym)
+      all_args = { amount: value, currency: currency_code, symbol: currency.symbol }
+      Kernel.format(format, **all_args.slice(*refs))
     end
   end
 end

data/lib/minting/version.rb

@@ -3,5 +3,5 @@
 # Root namespace for the Minting library.
 module Minting
   # Current version of the Minting gem.
-  VERSION = '1.6.3'
+  VERSION = '1.7.0'
 end

data/minting.gemspec

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'minting/version'
@@ -15,18 +17,19 @@ Gem::Specification.new do |s|
   # Prevent pushing this gem to RubyGems.org.
   # To allow pushes either set the 'allowed_push_host' to allow pushing to
   # a single host or delete this section to allow pushing to any host.
-  raise 'RubyGems 3.2 or newer is required' unless s.respond_to?(:metadata)
+  raise 'RubyGems 3.3 or newer is required' unless s.respond_to?(:metadata)
 
   s.metadata = {
     'bug_tracker_uri' => "#{s.homepage}/issues",
     'changelog_uri' => "#{s.homepage}/blob/master/CHANGELOG.md",
+    'documentation_uri' => 'https://www.rubydoc.info/gems/minting',
     'homepage_uri' => s.homepage,
     'source_code_uri' => s.homepage,
     'allowed_push_host' => 'https://rubygems.org',
     'rubygems_mfa_required' => 'true'
   }
 
-  s.required_ruby_version = '>= 3.2.0'
+  s.required_ruby_version = '>= 3.3.0'
   s.add_dependency 'bigdecimal', '>= 4.0'
 
   s.files = Dir.glob('{bin,doc,lib}/**/*')

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: minting
 version: !ruby/object:Gem::Version
-  version: 1.6.3
+  version: 1.7.0
 platform: ruby
 authors:
 - Gilson Ferraz
+autorequire:
 bindir: bin
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-06-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -35,11 +36,31 @@ files:
 - bin/check-currencies
 - bin/console
 - bin/setup
+- doc/Mint.html
+- doc/Mint/Currency.html
+- doc/Mint/CurrencyRegistry.html
+- doc/Mint/Money.html
+- doc/Mint/UnknownCurrency.html
+- doc/Minting.html
+- doc/_index.html
 - doc/agents/AGENTS.md
 - doc/agents/copilot-instructions.md
 - doc/agents/gemini_gem_evaluation.md
 - doc/agents/recommendations.md
 - doc/agents/rubocop-issues.md
+- doc/class_list.html
+- doc/css/common.css
+- doc/css/full_list.css
+- doc/css/style.css
+- doc/file.README.html
+- doc/file_list.html
+- doc/frames.html
+- doc/index.html
+- doc/js/app.js
+- doc/js/full_list.js
+- doc/js/jquery.js
+- doc/method_list.html
+- doc/top-level-namespace.html
 - lib/minting.rb
 - lib/minting/data/world-currencies.yaml
 - lib/minting/mint.rb
@@ -47,7 +68,9 @@ files:
 - lib/minting/mint/currency/currency.rb
 - lib/minting/mint/currency/currency_registry.rb
 - lib/minting/mint/currency/world_currencies.rb
-- lib/minting/mint/dsl.rb
+- lib/minting/mint/dsl/range.rb
+- lib/minting/mint/dsl/refinements.rb
+- lib/minting/mint/dsl/top_level.rb
 - lib/minting/mint/mint.rb
 - lib/minting/mint/parser.rb
 - lib/minting/money/allocation.rb
@@ -66,10 +89,12 @@ licenses:
 metadata:
   bug_tracker_uri: https://github.com/gferraz/minting/issues
   changelog_uri: https://github.com/gferraz/minting/blob/master/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/gems/minting
   homepage_uri: https://github.com/gferraz/minting
   source_code_uri: https://github.com/gferraz/minting
   allowed_push_host: https://rubygems.org
   rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -77,14 +102,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.2.0
+      version: 3.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.9
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: Library to manipulate currency values
 test_files: []