money 6.13.4 → 6.19.0

data/config/currency_non_iso.json

@@ -9,6 +9,7 @@
     "subunit": "Satoshi",
     "subunit_to_unit": 100000000,
     "symbol_first": false,
+    "format": "%n %u",
     "html_entity": "₿",
     "decimal_mark": ".",
     "thousands_separator": ",",
@@ -125,5 +126,21 @@
     "thousands_separator": ",",
     "iso_numeric": "",
     "smallest_denomination": 1
+  },
+  "usdc": {
+    "priority": 100,
+    "iso_code": "USDC",
+    "name": "USD Coin",
+    "symbol": "USDC",
+    "disambiguate_symbol": "USDC",
+    "alternate_symbols": [],
+    "subunit": "Cent",
+    "subunit_to_unit": 100,
+    "symbol_first": false,
+    "html_entity": "$",
+    "decimal_mark": ".",
+    "thousands_separator": ",",
+    "iso_numeric": "",
+    "smallest_denomination": 1
   }
 }

data/lib/money/bank/variable_exchange.rb

@@ -42,7 +42,7 @@ class Money
     #   bank.get_rate 'USD', 'CAD'
     class VariableExchange < Base
 
-      attr_reader :mutex, :store
+      attr_reader :mutex
 
       # Available formats for importing/exporting rates.
       RATE_FORMATS = [:json, :ruby, :yaml].freeze
@@ -61,6 +61,10 @@ class Money
         super(&block)
       end
 
+      def store
+        @store.is_a?(String) ? Object.const_get(@store) : @store
+      end
+
       def marshal_dump
         [store.marshal_dump, @rounding_method]
       end
@@ -109,8 +113,10 @@ class Money
         else
           if rate = get_rate(from.currency, to_currency)
             fractional = calculate_fractional(from, to_currency)
-            from.class.new(
-              exchange(fractional, rate, &block), to_currency
+            from.dup_with(
+              fractional: exchange(fractional, rate, &block),
+              currency: to_currency,
+              bank: self
             )
           else
             raise UnknownRate, "No conversion rate known for '#{from.currency.iso_code}' -> '#{to_currency}'"
@@ -213,8 +219,7 @@ class Money
       #   s = bank.export_rates(:json)
       #   s #=> "{\"USD_TO_CAD\":1.24515,\"CAD_TO_USD\":0.803115}"
       def export_rates(format, file = nil, opts = {})
-        raise Money::Bank::UnknownRateFormat unless
-          RATE_FORMATS.include? format
+        raise Money::Bank::UnknownRateFormat unless RATE_FORMATS.include?(format)
 
         store.transaction do
           s = FORMAT_SERIALIZERS[format].dump(rates)
@@ -254,8 +259,13 @@ class Money
       #   bank.get_rate("USD", "CAD") #=> 1.24515
       #   bank.get_rate("CAD", "USD") #=> 0.803115
       def import_rates(format, s, opts = {})
-        raise Money::Bank::UnknownRateFormat unless
-          RATE_FORMATS.include? format
+        raise Money::Bank::UnknownRateFormat unless RATE_FORMATS.include?(format)
+
+        if format == :ruby
+          warn '[WARNING] Using :ruby format when importing rates is potentially unsafe and ' \
+            'might lead to remote code execution via Marshal.load deserializer. Consider using ' \
+            'safe alternatives such as :json and :yaml.'
+        end
 
         store.transaction do
           data = FORMAT_SERIALIZERS[format].load(s)

data/lib/money/currency.rb

@@ -128,7 +128,7 @@ class Money
       # @return [Array]
       #
       # @example
-      #   Money::Currency.iso_codes()
+      #   Money::Currency.all()
       #   [#<Currency ..USD>, 'CAD', 'EUR']...
       def all
         table.keys.map do |curr|
@@ -206,6 +206,10 @@ class Money
         all.each { |c| yield(c) }
       end
 
+      def reset!
+        @@instances = {}
+        @table = Loader.load_currencies
+      end
 
       private
 
@@ -253,7 +257,7 @@ class Money
 
     attr_reader :id, :priority, :iso_code, :iso_numeric, :name, :symbol,
       :disambiguate_symbol, :html_entity, :subunit, :subunit_to_unit, :decimal_mark,
-      :thousands_separator, :symbol_first, :smallest_denomination
+      :thousands_separator, :symbol_first, :smallest_denomination, :format
 
     alias_method :separator, :decimal_mark
     alias_method :delimiter, :thousands_separator
@@ -341,7 +345,7 @@ class Money
     # @example
     #   Money::Currency.new(:usd) #=> #<Currency id: usd ...>
     def inspect
-      "#<#{self.class.name} id: #{id}, priority: #{priority}, symbol_first: #{symbol_first}, thousands_separator: #{thousands_separator}, html_entity: #{html_entity}, decimal_mark: #{decimal_mark}, name: #{name}, symbol: #{symbol}, subunit_to_unit: #{subunit_to_unit}, exponent: #{exponent}, iso_code: #{iso_code}, iso_numeric: #{iso_numeric}, subunit: #{subunit}, smallest_denomination: #{smallest_denomination}>"
+      "#<#{self.class.name} id: #{id}, priority: #{priority}, symbol_first: #{symbol_first}, thousands_separator: #{thousands_separator}, html_entity: #{html_entity}, decimal_mark: #{decimal_mark}, name: #{name}, symbol: #{symbol}, subunit_to_unit: #{subunit_to_unit}, exponent: #{exponent}, iso_code: #{iso_code}, iso_numeric: #{iso_numeric}, subunit: #{subunit}, smallest_denomination: #{smallest_denomination}, format: #{format}>"
     end
 
     # Returns a string representation corresponding to the upcase +id+
@@ -414,7 +418,7 @@ class Money
 
     # Returns the relation between subunit and unit as a base 10 exponent.
     #
-    # Note that MGA and MRO are exceptions and are rounded to 1
+    # Note that MGA and MRU are exceptions and are rounded to 1
     # @see https://en.wikipedia.org/wiki/ISO_4217#Active_codes
     #
     # @return [Integer]
@@ -441,6 +445,7 @@ class Money
       @symbol                = data[:symbol]
       @symbol_first          = data[:symbol_first]
       @thousands_separator   = data[:thousands_separator]
+      @format                = data[:format]
     end
   end
 end

data/lib/money/money/allocation.rb

@@ -2,20 +2,32 @@
 
 class Money
   class Allocation
-    # Splits a given amount in parts without loosing pennies.
-    # The left-over pennies will be distributed round-robin amongst the parties. This means that
-    # parties listed first will likely receive more pennies than ones that are listed later.
+    # Splits a given amount in parts. The allocation is based on the parts' proportions
+    # or evenly if parts are numerically specified.
     #
     # The results should always add up to the original amount.
     #
-    # The parts can be specified as:
-    #   Numeric — performs the split between a given number of parties evenely
-    #   Array<Numeric> — allocates the amounts proportionally to the given array
+    # @param amount [Numeric] The total amount to be allocated.
+    # @param parts [Numeric, Array<Numeric>] Number of parts to split into or an array (proportions for allocation)
+    # @param whole_amounts [Boolean] Specifies whether to allocate whole amounts only. Defaults to true.
     #
+    # @return [Array<Numeric>] An array containing the allocated amounts.
+    # @raise [ArgumentError] If parts is empty or not provided.
     def self.generate(amount, parts, whole_amounts = true)
-      parts = parts.is_a?(Numeric) ? Array.new(parts, 1) : parts.dup
+      parts = if parts.is_a?(Numeric)
+        Array.new(parts, 1)
+      elsif parts.all?(&:zero?)
+        Array.new(parts.count, 1)
+      else
+        parts.dup
+      end
+
+      raise ArgumentError, 'need at least one part' if parts.empty?
 
-      raise ArgumentError, 'need at least one party' if parts.empty?
+      if [amount, *parts].any? { |i| i.is_a?(BigDecimal) || i.is_a?(Float) || i.is_a?(Rational) }
+        amount = convert_to_big_decimal(amount)
+        parts.map! { |p| convert_to_big_decimal(p) }
+      end
 
       result = []
       remaining_amount = amount
@@ -36,5 +48,21 @@ class Money
 
       result
     end
+
+    # Converts a given number to BigDecimal.
+    # This method supports inputs of BigDecimal, Rational, and other numeric types by ensuring they are all returned
+    # as BigDecimal instances for consistent handling.
+    #
+    # @param number [Numeric, BigDecimal, Rational] The number to convert.
+    # @return [BigDecimal] The converted number as a BigDecimal.
+    def self.convert_to_big_decimal(number)
+      if number.is_a? BigDecimal
+        number
+      elsif number.is_a? Rational
+        BigDecimal(number.to_f.to_s)
+      else
+        BigDecimal(number.to_s)
+      end
+    end
   end
 end

data/lib/money/money/arithmetic.rb

@@ -16,7 +16,7 @@ class Money
     # @example
     #    - Money.new(100) #=> #<Money @fractional=-100>
     def -@
-      self.class.new(-fractional, currency, bank)
+      dup_with(fractional: -fractional)
     end
 
     # Checks whether two Money objects have the same currency and the same
@@ -46,7 +46,7 @@ class Money
     # Compares two Money objects. If money objects have a different currency it
     # will attempt to convert the currency.
     #
-    # @param [Money] other_money Value to compare with.
+    # @param [Money] other Value to compare with.
     #
     # @return [Integer]
     #
@@ -57,7 +57,12 @@ class Money
         return unless other.respond_to?(:zero?) && other.zero?
         return other.is_a?(CoercedNumeric) ? 0 <=> fractional : fractional <=> 0
       end
-      return 0 if zero? && other.zero?
+
+      # Always allow comparison with zero
+      if zero? || other.zero?
+        return fractional <=> other.fractional
+      end
+
       other = other.exchange_to(currency)
       fractional <=> other.fractional
     rescue Money::Bank::UnknownRate
@@ -103,7 +108,7 @@ class Money
     # values. If +other_money+ has a different currency then its monetary value
     # is automatically exchanged to this object's currency using +exchange_to+.
     #
-    # @param [Money] other_money Other +Money+ object to add.
+    # @param [Money] other Other +Money+ object to add.
     #
     # @return [Money]
     #
@@ -116,7 +121,7 @@ class Money
     # its monetary value is automatically exchanged to this object's currency
     # using +exchange_to+.
     #
-    # @param [Money] other_money Other +Money+ object to subtract.
+    # @param [Money] other Other +Money+ object to subtract.
     #
     # @return [Money]
     #
@@ -132,10 +137,10 @@ class Money
         when Money
           other = other.exchange_to(currency)
           new_fractional = fractional.public_send(op, other.fractional)
-          self.class.new(new_fractional, currency, bank)
+          dup_with(fractional: new_fractional)
         when CoercedNumeric
           raise TypeError, non_zero_message.call(other.value) unless other.zero?
-          self.class.new(other.value.public_send(op, fractional), currency)
+          dup_with(fractional: other.value.public_send(op, fractional))
         when Numeric
           raise TypeError, non_zero_message.call(other) unless other.zero?
           self
@@ -162,7 +167,7 @@ class Money
     def *(value)
       value = value.value if value.is_a?(CoercedNumeric)
       if value.is_a? Numeric
-        self.class.new(fractional * value, currency, bank)
+        dup_with(fractional: fractional * value)
       else
         raise TypeError, "Can't multiply a #{self.class.name} by a #{value.class.name}'s value"
       end
@@ -188,7 +193,7 @@ class Money
         fractional / as_d(value.exchange_to(currency).fractional).to_f
       else
         raise TypeError, 'Can not divide by Money' if value.is_a?(CoercedNumeric)
-        self.class.new(fractional / as_d(value), currency, bank)
+        dup_with(fractional: fractional / as_d(value))
       end
     end
 
@@ -226,13 +231,13 @@ class Money
     def divmod_money(val)
       cents = val.exchange_to(currency).cents
       quotient, remainder = fractional.divmod(cents)
-      [quotient, self.class.new(remainder, currency, bank)]
+      [quotient, dup_with(fractional: remainder)]
     end
     private :divmod_money
 
     def divmod_other(val)
       quotient, remainder = fractional.divmod(as_d(val))
-      [self.class.new(quotient, currency, bank), self.class.new(remainder, currency, bank)]
+      [dup_with(fractional: quotient), dup_with(fractional: remainder)]
     end
     private :divmod_other
 
@@ -276,7 +281,7 @@ class Money
       if (fractional < 0 && val < 0) || (fractional > 0 && val > 0)
         self.modulo(val)
       else
-        self.modulo(val) - (val.is_a?(Money) ? val : self.class.new(val, currency, bank))
+        self.modulo(val) - (val.is_a?(Money) ? val : dup_with(fractional: val))
       end
     end
 
@@ -287,7 +292,7 @@ class Money
     # @example
     #   Money.new(-100).abs #=> #<Money @fractional=100>
     def abs
-      self.class.new(fractional.abs, currency, bank)
+      dup_with(fractional: fractional.abs)
     end
 
     # Test if the money amount is zero.

data/lib/money/money/formatter.rb

@@ -124,11 +124,14 @@ class Money
     #  the currency should be delimited by the specified character or ','
     #
     # @example
-    #   # If false is specified, no thousands_separator is used.
+    #   # If a falsey value is specified, no thousands_separator is used.
     #   Money.new(100000, "USD").format(thousands_separator: false) #=> "1000.00"
     #   Money.new(100000, "USD").format(thousands_separator: nil)   #=> "1000.00"
     #   Money.new(100000, "USD").format(thousands_separator: "")    #=> "1000.00"
     #
+    #   # If true is specified, the locale or default thousands_separator is used.
+    #   Money.new(100000, "USD").format(thousands_separator: true) #=> "1,000.00"
+    #
     #   # If a string is specified, it's value is used.
     #   Money.new(100000, "USD").format(thousands_separator: ".") #=> "$1.000.00"
     #
@@ -211,6 +214,12 @@ class Money
     #   Money.new(89000, :btc).format(drop_trailing_zeros: true) #=> B⃦0.00089
     #   Money.new(110, :usd).format(drop_trailing_zeros: true)   #=> $1.1
     #
+    # @option rules [Boolean] :delimiter_pattern (/(\d)(?=(?:\d{3})+(?:[^\d]{1}|$))/) Regular expression to set the placement
+    #   for the thousands delimiter
+    #
+    # @example
+    #   Money.new(89000, :btc).format(delimiter_pattern: /(\d)(?=\d)/) #=> B⃦8,9,0.00
+    #
     # @option rules [String] :format (nil) Provide a template for formatting. `%u` will be replaced
     # with the symbol (if present) and `%n` will be replaced with the number.
     #
@@ -235,7 +244,11 @@ class Money
     end
 
     def thousands_separator
-      lookup :thousands_separator
+      val = lookup :thousands_separator
+
+      return val unless val == true
+
+      lookup_default :thousands_separator
     end
 
     def decimal_mark
@@ -330,7 +343,9 @@ class Money
 
     def format_whole_part(value)
       # Apply thousands_separator
-      value.gsub regexp_format, "\\1#{thousands_separator}"
+      value.gsub(rules[:delimiter_pattern]) do |digit_to_delimit|
+        "#{digit_to_delimit}#{thousands_separator}"
+      end
     end
 
     def extract_whole_and_decimal_parts
@@ -347,7 +362,7 @@ class Money
     end
 
     def format_decimal_part(value)
-      return nil if currency.decimal_places == 0 && !Money.infinite_precision
+      return nil if currency.decimal_places == 0 && !Money.default_infinite_precision
       return nil if rules[:no_cents]
       return nil if rules[:no_cents_if_whole] && value.to_i == 0
 
@@ -363,16 +378,11 @@ class Money
     def lookup(key)
       return rules[key] || DEFAULTS[key] if rules.has_key?(key)
 
-      (Money.locale_backend && Money.locale_backend.lookup(key, currency)) || DEFAULTS[key]
+      lookup_default key
     end
 
-    def regexp_format
-      if rules[:south_asian_number_formatting]
-        # from http://blog.revathskumar.com/2014/11/regex-comma-seperated-indian-currency-format.html
-        /(\d+?)(?=(\d\d)+(\d)(?!\d))(\.\d+)?/
-      else
-        /(\d)(?=(?:\d{3})+(?:[^\d]{1}|$))/
-      end
+    def lookup_default(key)
+      (Money.locale_backend && Money.locale_backend.lookup(key, currency)) || DEFAULTS[key]
     end
 
     def symbol_value_from(rules)

data/lib/money/money/formatting_rules.rb

@@ -12,6 +12,7 @@ class Money
       @rules = localize_formatting_rules(@rules)
       @rules = translate_formatting_rules(@rules) if @rules[:translate]
       @rules[:format] ||= determine_format_from_formatting_rules(@rules)
+      @rules[:delimiter_pattern] ||= delimiter_pattern_rule(@rules)
 
       warn_about_deprecated_rules(@rules)
     end
@@ -79,6 +80,8 @@ class Money
     end
 
     def determine_format_from_formatting_rules(rules)
+      return currency.format if currency.format && !rules.has_key?(:symbol_position)
+
       symbol_position = symbol_position_from(rules)
 
       if symbol_position == :before
@@ -88,6 +91,15 @@ class Money
       end
     end
 
+    def delimiter_pattern_rule(rules)
+      if rules[:south_asian_number_formatting]
+        # from http://blog.revathskumar.com/2014/11/regex-comma-seperated-indian-currency-format.html
+        /(\d+?)(?=(\d\d)+(\d)(?!\d))(\.\d+)?/
+      else
+        /(\d)(?=(?:\d{3})+(?:[^\d]{1}|$))/
+      end
+    end
+
     def symbol_position_from(rules)
       if rules.has_key?(:symbol_position)
         if [:before, :after].include?(rules[:symbol_position])
@@ -105,7 +117,7 @@ class Money
     def warn_about_deprecated_rules(rules)
       if rules.has_key?(:symbol_position)
         position = rules[:symbol_position]
-        template = position == :before ? '%u %n' : '%n %u'
+        template = position == :before ? '%u%n' : '%n%u'
 
         warn "[DEPRECATION] `symbol_position: :#{position}` is deprecated - you can replace it with `format: #{template}`"
       end