minting 1.1.2 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9506e71f742812607fef378d4df90eaea6d2457f0d818b55b6e06b6167fa6876
-  data.tar.gz: 99b200de879dfb9ed4eaec21b02067a886c01d48116fcb669ca70b5dbf314264
+  metadata.gz: a7530401c0a722596508aab5aa587bc53a548698308f9d09ae34fac2ec671784
+  data.tar.gz: abe0501b11d4f9c77e2054443c12e1d4a5e2707fabbfac71f5bd4b8a7f5a3fb5
 SHA512:
-  metadata.gz: 01b120551584f7f6327f2db19731367dd091bfb3e7b9db91d98cd2ff0b7e1db41d4c190acc66d8cd611fe7689ddb8872b89bebe9db6506e267df121c60fbe6f1
-  data.tar.gz: 8cc6a7ffc780a555276298432de7c2929c5ffddadc4fc28b379a8c58245b70672a777e610e464b6ea485583a8b65eb7463b37e29ff422b9e065ecd1f565cb85a
+  metadata.gz: 31db7b1c31b0f1329342162cb8f868e46d14e703df5dd36898dfeb74281d674bc0f7ba0b9b367d8568f0751c09f3a219dec172ed87cc8cc4d906606550492034
+  data.tar.gz: 7090942000722ce81b302237a6b71850ef8a8ec477ded927bb5914f1e198552512ae11b0b1f46d38dd44ae0d6b4a2b1e7d34dab3ec35ea107b800c38e60c7a94

data/README.md

@@ -91,6 +91,11 @@ price_in_euros.to_s(format: '%<symbol>2s%<amount>+10f')    #=> " €    +12.34"
 
 price.to_json # => "{ "currency": "USD", "amount": "9.99" }"
 
+# Hash conversion
+
+price.to_hash #=> {currency: "USD", amount: "9.99"}
+
+
 # Proportional allocation and split
 
 ten.split(3)                           #=> [[USD 3.34], [USD 3.33], [USD 3.33]]

data/Rakefile

@@ -12,18 +12,23 @@ Rake::TestTask.new(:test) do |t|
   t.ruby_opts << '-rtest_helper.rb'
 end
 
-Rake::TestTask.new(:bench) do |t|
+Rake::TestTask.new('bench') do |t|
   t.libs = %w[lib test]
   t.pattern = 'test/performance/*_benchmark.rb'
 end
 
+Rake::TestTask.new('bench:parse') do |t|
+  t.libs = %w[lib test]
+  t.pattern = 'test/performance/parse_benchmark.rb'
+  t.ruby_opts << '-r test_helper.rb'
+end
+
 Rake::TestTask.new('bench:edge') do |t|
   t.libs = %w[lib test]
   t.pattern = 'test/performance/algorithm_benchmark.rb'
   t.ruby_opts << '-r test_helper.rb'
 end
 
-
 Rake::TestTask.new('bench:regression') do |t|
   t.libs = %w[lib test]
   t.pattern = 'test/performance/regression_benchmark.rb'

data/lib/minting/mint/currency.rb

@@ -3,12 +3,19 @@ module Mint
   #
   # @see https://www.iso.org/iso-4217-currency-codes.html
   class Currency
-    attr_reader :code, :subunit, :symbol, :priority, :minimum_amount, :country, :name
+    attr_reader :code, :subunit, :symbol,
+                :country,
+                :fractional_multiplier, :minimum_amount,
+                :name, :priority
 
     def inspect
       "<Currency:(#{code} #{symbol} #{subunit})>"
     end
 
+    def normalize_amount(amount)
+      amount.to_r.round(subunit)
+    end
+
     private
 
     def initialize(code:, symbol:, subunit: 0, priority: 0, country: nil, name: nil)
@@ -18,7 +25,8 @@ module Mint
       @priority = priority.to_i
       @country = country
       @name = name
-      @minimum_amount = 10r**-@subunit
+      @fractional_multiplier = 10**@subunit
+      @minimum_amount = 1r / fractional_multiplier
       freeze
     end
   end

data/lib/minting/mint/registry.rb

@@ -9,11 +9,14 @@ module Mint
   # @raise [ArgumentError] if the currency code is not registered
   def self.money(amount, currency_code)
     currency = currency(currency_code)
-    return Money.new(amount, currency) if currency
+    return Money.create(amount, currency) if currency
 
-    raise ArgumentError, "Currency [#{currency_code}] not registered. Check Mint.currencies"
+    raise ArgumentError, "[#{currency.inspect}] is not a registered currency. Check Mint.currencies"
   end
 
+  # Returns default zero, no currency money
+  def self.zero = @zero ||= Money.new(0, Mint.currency('XXX'))
+
   # Finds a registered currency by its code, symbol,
   # or retrieves it directly if already a Currency object.
   #
@@ -34,11 +37,11 @@ module Mint
   #
   # @param code [String, Symbol] the unique currency code (e.g. 'USD', :EUR)
   # @param subunit [Integer] the decimal subunit precision (defaults to 2)
-  # @param symbol [String] the display symbol (defaults to '$')
+  # @param symbol [String] the display symbol (defaults to '')
   # @param priority [Integer] parser precedence priority (defaults to 0)
   # @return [Currency] the registered or existing Currency instance
   # @raise [ArgumentError] if the code layout is invalid or register throws an error
-  def self.register_currency(code:, subunit: 2, symbol: '$', priority: 0)
+  def self.register_currency(code:, subunit: 2, symbol: '', priority: 0)
     code = code.to_s
     currencies[code] || register_currency!(code:, subunit:, symbol:, priority:)
   end
@@ -63,9 +66,9 @@ module Mint
             "Currency: #{code} already registered"
     end
 
-    currencies[code] = Currency.new(code:, subunit:, symbol:, priority:)
+    currency = currencies[code] = Currency.new(code:, subunit:, symbol:, priority:)
     @currency_symbols = nil
-    currencies[code]
+    currency
   end
 
   # Returns the hash of all registered currencies.

data/lib/minting/money/allocation.rb

@@ -14,7 +14,8 @@ module Mint
       raise ArgumentError, 'Need at least 1 proportion element' if proportions.empty?
       raise ArgumentError, 'Proportions total must not be zero' if whole.zero?
 
-      amounts = proportions.map { |rate| (amount * rate.to_r / whole).round(currency.subunit) }
+      subunit = currency.subunit
+      amounts = proportions.map { |rate| (amount * rate.to_r / whole).round(subunit) }
       allocate_left_over!(amounts: amounts, left_over: amount - amounts.sum)
     end
 
@@ -44,11 +45,12 @@ module Mint
 
     def allocate_left_over!(amounts:, left_over:)
       if left_over.nonzero?
-        minimum = left_over.positive? ? currency.minimum_amount : -currency.minimum_amount
+        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 }
       end
-      amounts.map { mint it }
+      amounts.map { Money.new(it, currency) }
     end
   end
 end

data/lib/minting/money/arithmetics.rb

@@ -3,7 +3,7 @@ module Mint
     # Returns the absolute value of the monetary amount as a new {Money} instance.
     #
     # @return [Money] the absolute value
-    def abs =     mint(amount.abs)
+    def abs = mint(amount.abs)
 
     # Returns true if the monetary amount is less than zero.
     #
@@ -60,7 +60,7 @@ 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.to_r) if multiplicand.is_a?(Numeric)
+      return mint(amount * multiplicand) if multiplicand.is_a?(Numeric)
 
       raise TypeError, "#{self} can't be multiplied by #{multiplicand}"
     end

data/lib/minting/money/coercion.rb

@@ -13,8 +13,6 @@ module Mint
     # Coerced Number contains the arithmetic logic for numeric compatible ops.
     # @private
     class CoercedNumber
-      include Comparable
-
       # @private
       def initialize(value)
         @value = value
@@ -44,19 +42,21 @@ module Mint
         raise_coercion_error(:/, other)
       end
 
-      # @private
+      # Only zero is dimensionless and comparable to Money.
+      # e.g. 0 < price is meaningful; 0.5 < price is not (what currency is 0.5?).
       def <=>(other)
-        return nil if @value.nil? || other.nil?
         return @value <=> other.amount if @value.zero? || other.zero?
 
         raise_coercion_error(:<=>, other)
       end
 
-      # @private
+      private
+
       def raise_coercion_error(operation, operand)
         raise TypeError,
-              "#{self} #{operation} #{operand} : incompatible operands"
+              "#{@value} #{operation} #{operand} : incompatible operands"
       end
     end
+    private_constant :CoercedNumber
   end
 end

data/lib/minting/money/conversion.rb

@@ -39,15 +39,17 @@ module Mint
       amount.to_i
     end
 
+    def to_hash
+      { currency: currency_code, amount: Kernel.format("%0.#{currency.subunit}f", amount) }
+    end
+
     # Serializes the money instance to a standard JSON object containing the amount and currency.
     # Highly optimized to run without external dependencies.
     #
     # @return [String] the JSON serialized string representation
     def to_json(*_args)
-      subunit = currency.subunit
       Kernel.format(
-        %({"currency": "#{currency_code}", "amount": "%0.#{subunit}f"}),
-        amount
+        %({"currency": "#{currency_code}", "amount": "%0.#{currency.subunit}f"}), amount
       )
     end
 

data/lib/minting/money/money.rb

@@ -10,13 +10,16 @@ module Mint
     # @param amount [Numeric] The monetary amount
     # @param currency [Currency] The currency object
     # @raise [ArgumentError] If amount is not numeric or currency is invalid
-    def initialize(amount, currency)
+    def self.create(amount, currency)
       raise ArgumentError, 'amount must be Numeric' unless amount.is_a?(Numeric)
-      raise ArgumentError, 'currency must be a Currency object' unless currency.is_a?(Currency)
 
-      @amount = amount.to_r.round(currency.subunit)
-      @currency = currency
-      freeze
+      checked_currency = Mint.currency(currency)
+      unless checked_currency
+        raise ArgumentError,
+              "Currency not found (#{currency}). Check Mint.currencies"
+      end
+
+      new(checked_currency.normalize_amount(amount), checked_currency)
     end
 
     # Returns the ISO 3-letter currency code string.
@@ -24,6 +27,8 @@ module Mint
     # @return [String] the ISO currency code
     def currency_code = currency.code
 
+    def fractional = (amount * currency.fractional_multiplier).to_i
+
     # Generates a stable hash key for Money instances.
     #
     # @return [Integer] the calculated hash value
@@ -33,7 +38,8 @@ module Mint
     # @param new_amount [Numeric] The new amount
     # @return [Money] A new Money object or self
     def mint(new_amount)
-      new_amount.to_r == amount ? self : Money.new(new_amount, currency)
+      new_amount = new_amount.to_r.round(currency.subunit)
+      new_amount == amount ? self : Money.new(new_amount, currency)
     end
 
     # Returns a standard developer-oriented string inspection of the Money object.
@@ -49,7 +55,15 @@ module Mint
     # @return [Boolean] true if currencies match, false otherwise
     def same_currency?(other) = other.respond_to?(:currency) && other.currency == currency
 
-    # Returns default zero no currency money
-    def self.zero = @zero ||= new(0, Mint.currencies('XXX'))
+    private
+
+    # Initializes a new Money object with the given amount and currency.
+    # @param amount [Numeric] The monetary amount
+    # @param currency [Currency] The currency object
+    def initialize(amount, currency)
+      @amount = amount
+      @currency = currency
+      freeze
+    end
   end
 end

data/lib/minting/money/parse.rb

@@ -25,14 +25,14 @@ module Mint
       currency = currency ? Mint.currency(currency) : parse_currency(input)
       raise ArgumentError, "Currency [#{currency}] not registered" unless currency
 
-      amount = parse_amount(input)
+      amount = currency.normalize_amount(parse_amount(input))
       new(amount, currency)
     end
 
     # Extracts a numeric value from input that should only contain an amount.
     def self.parse_amount(input)
       # Remove any charater that is not a digit, comma or period
-      numeric = input.scan(/[\d.\-,]/).join
+      numeric = input.scan(/[\d.,-]/).join
       numeric = normalize_separators(numeric)
       Rational(numeric)
     end

data/lib/minting/version.rb

@@ -1,5 +1,5 @@
 # Root namespace for the Minting library.
 module Minting
   # Current version of the Minting gem.
-  VERSION = '1.1.2'.freeze
+  VERSION = '1.3.0'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: minting
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.3.0
 platform: ruby
 authors:
 - Gilson Ferraz