minting 0.3.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3727b084cc73e39f8fb332b083cf94a4c3fb903f616afa18023f0187e713634c
-  data.tar.gz: cd3ad31a95c5f18b6dc8af91d66dd9e25ec87a5efcaf6b4d6a2203e6a2a15764
+  metadata.gz: 4dfd2f98840b009208b9cccab86e9ca5d093300351e9e2031e70e03b93315638
+  data.tar.gz: 47a92df548558e20fd7bea3caa10a8966db91341d998e9712405af3d97fe12ae
 SHA512:
-  metadata.gz: da5ec1aa13bbeedc59d38a38c8fb0c6939253f6aa3960fb5beb64501e6660c16586b3fe1f6f03d54c1771cd2b5b78f39d92087070920b8694dfcbaccf75a99d4
-  data.tar.gz: 9cc380513733e3f9c9db95225283c82b6c1073ce9a1d4b01b606673bd1d41fc1412fc79035ab5ed823fc80b28baa8cafbf6685e4bbd06c6817080e64ff498815
+  metadata.gz: 175607c53124f16cac60c699a6ed6f042b3c3e960055bca1ccb7ba822a05b6cf8401fb66902e148a9ed50b43524ce6e708feaa72cac15f6ddd8b9cf3e9189cc6
+  data.tar.gz: 4fc09433abd38014d0d99c16aed5f88eb36ad039e422b0ffa305d3335da1753a23bae2bfcf775ce6142edf844463ed3942710d87f034375f99e04ff1b7e92812

data/README.md

@@ -1,61 +1,63 @@
 # Minting
 
-Yet another Ruby library for dealing with money and currency.
+Fast, precise, and developer-friendly money handling for Ruby.
 
-Work in progress, please wait release 1.0.0
+[![Gem Version](https://badge.fury.io/rb/minting.svg)](https://badge.fury.io/rb/minting)
 
-## Installation
+## Why Minting?
 
-Option 1: Via bundler command
+**Tired of floating-point errors in financial calculations?** Minting uses Rational numbers for perfect precision.
 
-```shell
-bundle add minting
-bundle install
-```
+**Need performance?** Minting is 2x faster than alternatives.
 
-Option 2: add the line below to your application's Gemfile:
+**Want a clean API?** Minting provides an intuitive interface with helpful error messages.
 
-```ruby
-gem 'minting'
-```
+**Looking for a proven alternative?** Check out the established [Money gem](https://github.com/RubyMoney/money) with thousands of stars on GitHub.
 
-or, if you want latest development version from Github
+**Rails**? Use the [minting-rails](https://github.com/gferraz/minting-rails) companion gem
+
+## Quick start
 
 ```ruby
-gem 'minting', git: 'https://github.com/gferraz/minting.git'
-```
+require 'minting'
 
-and execute:
+price = Mint.money(19.99, 'USD')       #=> [USD 19.99]
+tax   = price * 0.08                   #=> [USD 1.60]
+total = price + tax                    #=> [USD 21.59]
 
-```shell
-bundle install
+total.to_s                             #=> "$21.59"
+total.currency_code                    #=> "USD"
 ```
 
-Option3: Install it yourself with:
+## Features
 
-```shell
-gem install minting
-````
+- Arithmetic: `+ - * /`, unary minus, `abs`
+- Comparisons: `==`, `<=>`, `zero?`, `nonzero?`, `positive?`, `negative?`
+- Formatting: `to_s` with custom formats, delimiters, separators
+- Serialization: `to_json`, `to_i`, `to_f`, `to_r`, `to_d`
+- Allocation utilities: `split(quantity)`, `allocate([ratios])`
+- Numeric Refinements for ergonomics: `10.dollars`, `3.euros`, `4.to_money('USD')`
+- Currency registry with 117+ currencies and custom registration
 
 ## Usage
 
 ```ruby
 require 'minting'
 
-# 10.00 USD
-ten_dollars = Mint.money(10, 'USD') #=> [USD 10.00]
-ten_dollars.to_i            #=> 10
-ten_dollars.currency_code   #=> "USD"
+# Create money
+ten = Mint.money(10, 'USD')            #=> [USD 10.00]
 
-# Comparisons
-ten_dollars = Mint.money(10, 'USD')
+# Create money using Numeric refinements
+using Mint
 
-ten_dollars == Mint.money(10, 'USD') #=> true
-ten_dollars == Mint.money(11, 'USD') #=> false
-ten_dollars == Mint.money(10, 'EUR') #=> false
+1.dollar == Mint.money(1, 'USD') #=> true
+ten = 10.dollars                 #=> [USD 10.00]
+4.to_money('USD')                #=> [USD 4.00]
 
-ten_dollars.eql? Mint.money(10, 'USD')         #=> true
-ten_dollars.hash == Mint.money(10, 'USD').hash #=> true
+# Comparisons
+ten == 10.dollars                #=> true
+ten == Mint.money(10, 'EUR')     #=> false
+ten > Mint.money(9.99, 'USD')    #=> true
 
 # Format (uses Kernel.format internally)
 price = Mint.money(9.99, 'USD')
@@ -67,7 +69,7 @@ price.to_s(format: '%<symbol>s%<amount>+f') #=> "$+9.99",
 (-price).to_s(format: '%<amount>f')         #=> "-9.99",
 
 # Format with padding
-price_in_euros = euro.money(12.34, 'EUR')
+price_in_euros = Mint.money(12.34, 'EUR')
 
 price.to_s(format: '--%<amount>7d')               #=> "--      9"
 price.to_s(format: '  %<amount>10f %<currency>s') #=> "        9.99 USD"
@@ -77,31 +79,97 @@ price_in_euros.to_s(format: '%<symbol>2s%<amount>+10f')    #=> " €    +12.34"
 
 # Json serialization
 
-price.to_json # "{"currency": "USD", "amount": "9.99"}
+price.to_json # => "{ "currency": "USD", "amount": "9.99" }"
 
-# Allocation and split
+# Proportional allocation and split
 
-ten_dollars.split(3) #=> [[USD 3.34], [USD 3.33], [USD 3.33]]
-ten_dollars.split(7) #=> [[USD 1.42], [USD 1.43], [USD 1.43], [USD 1.43], [USD 1.43], [USD 1.43], [USD 1.43]]
+ten.split(3)                           #=> [[USD 3.34], [USD 3.33], [USD 3.33]]
+ten.allocate([1, 2, 3])                #=> [[USD 1.67], [USD 3.33], [USD 5.00]]
 
-ten_dollars.allocate([1, 2, 3]) #=> [[USD 1.67], [USD 3.33], [USD 5.00]]
+# Ranges and enumeration are supported
 
-# Numeric refinements
-uning Mint
+1.dollar..10.dollars                      #=> [USD 1.00]..[USD 10.00]
+(1.dollar..3.dollars).step(1.dollar).to_a #=> [[USD 1.00], [USD 2.00], [USD 3.00]]
 
-1.dollar == Mint.money(1, 'USD') #=> true
-3.euros == Mint.money(2, 'EUR')  #=> true
-4.mint('USD') == 4.dollars #=> true
-4.to_money('USD') == 4.dollars #=> true
+```
+
+## Installation
 
+Option 1: Via bundler command
+
+```shell
+bundle add minting
+bundle install
 ```
 
-## Release 1.0 Plan
+Option 2: add the line below to your application's Gemfile:
 
-- Localization: I18n
-- Arithmetics: div, mod
-- Mint.parse
+```ruby
+gem 'minting'
+```
+
+or, if you want latest development version from Github
+
+```ruby
+gem 'minting', git: 'https://github.com/gferraz/minting.git'
+```
+
+and execute:
+
+```shell
+bundle install
+```
+
+Option 3: Install it yourself with:
+
+```shell
+gem install minting
+```
+
+## Roadmap
+
+- Improve formatting features
+- Localization (I18n-aware formatting)
+- `Mint.parse` for parsing human strings into money
+- Basic exchange-rate conversions
 
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at <https://github.com/gferraz/minting>.
+
+1. Fork and create a feature branch
+2. Run the test suite: `rake`
+3. Run performance suites as needed: `BENCH=true rake bench:performance`
+4. Open a PR with a clear description and benchmarks if relevant
+
+
+## Performance
+
+This gem includes a performance suite under `test/performance`:
+
+- Core operations (creation, arithmetic, comparisons)
+- Algorithm benchmarks (split, allocate)
+- Memory and GC pressure tests
+- Competitive benchmarks vs `money` gem
+
+On a typical machine, reference numbers are:
+
+- Money creation: ~1.6M ops/sec
+- Addition: ~1.7M ops/sec
+
+Run locally:
+
+```bash
+# All performance suites
+BENCH=true rake bench:performance
+
+# Competitive vs money gem
+BENCH=true rake bench:competitive
+
+# Regression checks
+rake bench:regression
+```
+
+## License
+
+MIT

data/Rakefile

@@ -16,6 +16,27 @@ Rake::TestTask.new(:bench) do |t|
   t.pattern = 'test/**/*_benchmark.rb'
 end
 
+# Performance benchmark tasks
+Rake::TestTask.new('bench:performance') do |t|
+  t.libs = %w[lib test]
+  t.pattern = 'test/performance/*_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'
+  t.ruby_opts << '-r test_helper.rb'
+end
+
+Rake::TestTask.new('bench:competitive') do |t|
+  t.libs = %w[lib test]
+  t.pattern = 'test/performance/competitive_benchmark.rb'
+  t.ruby_opts << '-r test_helper.rb'
+end
+
+task 'bench:all' => ['bench', 'bench:performance']
+
 RuboCop::RakeTask.new(:cop)
 
 task default: :test

data/lib/minting/mint/currency.rb

@@ -1,7 +1,5 @@
-# frozen_string_literal: true
-
 module Mint
-  # Represents a specific currency unit, identified by ISO 4217 alphabetic ocde
+  # Represents a specific currency unit, identified by ISO 4217 alphabetic code
   #
   # @see https://www.iso.org/iso-4217-currency-codes.html
   class Currency

data/lib/minting/mint/registry.rb

@@ -1,12 +1,11 @@
-# frozen_string_literal: true
-
 # :nodoc
 module Mint
   def self.money(amount, currency_code)
     currency = currency(currency_code)
-    raise ArgumentError, "Currency [#{currency_code}] no registered" unless currency
+    return Money.new(amount, currency) if currency
 
-    Money.new(amount, currency)
+    available = currencies.keys.join(', ')
+    raise ArgumentError, "Currency [#{currency_code}] not registered. Available: #{available}"
   end
 
   def self.currency(currency)
@@ -29,7 +28,7 @@ module Mint
     code = code.to_s
     unless code.match?(/^[A-Z_]+$/)
       raise ArgumentError,
-            "Currency code must be String or Symbol ('USD', :EUR)"
+            "Currency code must be String or Symbol ('USD', :EUR, 'FUEL', 'MY_COIN')"
     end
     if currencies[code]
       raise KeyError,
@@ -42,19 +41,136 @@ module Mint
 
   def self.currencies
     @currencies ||= {
-      'AUD' => Currency.new('AUD', subunit: 2, symbol: '$'),
-      'BRL' => Currency.new('BRL', subunit: 2, symbol: 'R$'),
-      'CAD' => Currency.new('CAD', subunit: 2, symbol: 'R$'),
-      'CHF' => Currency.new('CHF', subunit: 2, symbol: 'Fr'),
-      'CNY' => Currency.new('CNY', subunit: 2, symbol: '¥'),
+      # Major Global Currencies
+      'USD' => Currency.new('USD', subunit: 2, symbol: '$'),
       'EUR' => Currency.new('EUR', subunit: 2, symbol: '€'),
       'GBP' => Currency.new('GBP', subunit: 2, symbol: '£'),
       'JPY' => Currency.new('JPY', subunit: 0, symbol: '¥'),
-      'MXN' => Currency.new('MXN', subunit: 2, symbol: '$'),
+      'CHF' => Currency.new('CHF', subunit: 2, symbol: 'Fr'),
+      'CAD' => Currency.new('CAD', subunit: 2, symbol: '$'),
+      'AUD' => Currency.new('AUD', subunit: 2, symbol: '$'),
+      'CNY' => Currency.new('CNY', subunit: 2, symbol: '¥'),
+      'SEK' => Currency.new('SEK', subunit: 2, symbol: 'kr'),
       'NZD' => Currency.new('NZD', subunit: 2, symbol: '$'),
+
+      # Asia-Pacific
+      'HKD' => Currency.new('HKD', subunit: 2, symbol: 'HK$'),
+      'SGD' => Currency.new('SGD', subunit: 2, symbol: 'S$'),
+      'KRW' => Currency.new('KRW', subunit: 0, symbol: '₩'),
+      'INR' => Currency.new('INR', subunit: 2, symbol: '₹'),
+      'THB' => Currency.new('THB', subunit: 2, symbol: '฿'),
+      'MYR' => Currency.new('MYR', subunit: 2, symbol: 'RM'),
+      'IDR' => Currency.new('IDR', subunit: 2, symbol: 'Rp'),
+      'PHP' => Currency.new('PHP', subunit: 2, symbol: '₱'),
+      'VND' => Currency.new('VND', subunit: 0, symbol: '₫'),
+      'TWD' => Currency.new('TWD', subunit: 2, symbol: 'NT$'),
+      'PKR' => Currency.new('PKR', subunit: 2, symbol: '₨'),
+      'BDT' => Currency.new('BDT', subunit: 2, symbol: '৳'),
+      'LKR' => Currency.new('LKR', subunit: 2, symbol: '₨'),
+      'NPR' => Currency.new('NPR', subunit: 2, symbol: '₨'),
+      'MMK' => Currency.new('MMK', subunit: 2, symbol: 'K'),
+      'KHR' => Currency.new('KHR', subunit: 2, symbol: '៛'),
+      'LAK' => Currency.new('LAK', subunit: 2, symbol: '₭'),
+      'BND' => Currency.new('BND', subunit: 2, symbol: 'B$'),
+
+      # Middle East & Central Asia
+      'AED' => Currency.new('AED', subunit: 2, symbol: 'د.إ'),
+      'SAR' => Currency.new('SAR', subunit: 2, symbol: '﷼'),
+      'QAR' => Currency.new('QAR', subunit: 2, symbol: '﷼'),
+      'KWD' => Currency.new('KWD', subunit: 3, symbol: 'د.ك'),
+      'BHD' => Currency.new('BHD', subunit: 3, symbol: '.د.ب'),
+      'OMR' => Currency.new('OMR', subunit: 3, symbol: '﷼'),
+      'JOD' => Currency.new('JOD', subunit: 3, symbol: 'د.ا'),
+      'ILS' => Currency.new('ILS', subunit: 2, symbol: '₪'),
+      'TRY' => Currency.new('TRY', subunit: 2, symbol: '₺'),
+      'IRR' => Currency.new('IRR', subunit: 2, symbol: '﷼'),
+      'IQD' => Currency.new('IQD', subunit: 3, symbol: 'د.ع'),
+      'AFN' => Currency.new('AFN', subunit: 2, symbol: '؋'),
+      'KZT' => Currency.new('KZT', subunit: 2, symbol: '₸'),
+      'UZS' => Currency.new('UZS', subunit: 2, symbol: 'лв'),
+      'KGS' => Currency.new('KGS', subunit: 2, symbol: 'лв'),
+      'TJS' => Currency.new('TJS', subunit: 2, symbol: 'SM'),
+
+      # Europe
+      'NOK' => Currency.new('NOK', subunit: 2, symbol: 'kr'),
+      'DKK' => Currency.new('DKK', subunit: 2, symbol: 'kr'),
+      'ISK' => Currency.new('ISK', subunit: 0, symbol: 'kr'),
+      'PLN' => Currency.new('PLN', subunit: 2, symbol: 'zł'),
+      'CZK' => Currency.new('CZK', subunit: 2, symbol: 'Kč'),
+      'HUF' => Currency.new('HUF', subunit: 2, symbol: 'Ft'),
+      'RON' => Currency.new('RON', subunit: 2, symbol: 'lei'),
+      'BGN' => Currency.new('BGN', subunit: 2, symbol: 'лв'),
+      'HRK' => Currency.new('HRK', subunit: 2, symbol: 'kn'),
+      'RSD' => Currency.new('RSD', subunit: 2, symbol: 'Дин.'),
+      'RUB' => Currency.new('RUB', subunit: 2, symbol: '₽'),
+      'UAH' => Currency.new('UAH', subunit: 2, symbol: '₴'),
+      'BYN' => Currency.new('BYN', subunit: 2, symbol: 'Br'),
+      'MDL' => Currency.new('MDL', subunit: 2, symbol: 'L'),
+      'GEL' => Currency.new('GEL', subunit: 2, symbol: '₾'),
+      'AMD' => Currency.new('AMD', subunit: 2, symbol: '֏'),
+      'AZN' => Currency.new('AZN', subunit: 2, symbol: '₼'),
+
+      # Africa
+      'ZAR' => Currency.new('ZAR', subunit: 2, symbol: 'R'),
+      'EGP' => Currency.new('EGP', subunit: 2, symbol: '£'),
+      'NGN' => Currency.new('NGN', subunit: 2, symbol: '₦'),
+      'KES' => Currency.new('KES', subunit: 2, symbol: 'KSh'),
+      'GHS' => Currency.new('GHS', subunit: 2, symbol: '¢'),
+      'UGX' => Currency.new('UGX', subunit: 0, symbol: 'USh'),
+      'TZS' => Currency.new('TZS', subunit: 2, symbol: 'TSh'),
+      'ETB' => Currency.new('ETB', subunit: 2, symbol: 'Br'),
+      'MAD' => Currency.new('MAD', subunit: 2, symbol: 'د.م.'),
+      'TND' => Currency.new('TND', subunit: 3, symbol: 'د.ت'),
+      'DZD' => Currency.new('DZD', subunit: 2, symbol: 'د.ج'),
+      'LYD' => Currency.new('LYD', subunit: 3, symbol: 'ل.د'),
+      'AOA' => Currency.new('AOA', subunit: 2, symbol: 'Kz'),
+      'BWP' => Currency.new('BWP', subunit: 2, symbol: 'P'),
+      'NAD' => Currency.new('NAD', subunit: 2, symbol: 'N$'),
+      'SZL' => Currency.new('SZL', subunit: 2, symbol: 'L'),
+      'LSL' => Currency.new('LSL', subunit: 2, symbol: 'L'),
+      'MZN' => Currency.new('MZN', subunit: 2, symbol: 'MT'),
+      'ZMW' => Currency.new('ZMW', subunit: 2, symbol: 'ZK'),
+      'MWK' => Currency.new('MWK', subunit: 2, symbol: 'MK'),
+      'RWF' => Currency.new('RWF', subunit: 0, symbol: 'R₣'),
+      'BIF' => Currency.new('BIF', subunit: 0, symbol: 'FBu'),
+
+      # Americas
+      'MXN' => Currency.new('MXN', subunit: 2, symbol: '$'),
+      'BRL' => Currency.new('BRL', subunit: 2, symbol: 'R$'),
+      'ARS' => Currency.new('ARS', subunit: 2, symbol: '$'),
+      'CLP' => Currency.new('CLP', subunit: 0, symbol: '$'),
       'PEN' => Currency.new('PEN', subunit: 2, symbol: 'S/.'),
-      'SEK' => Currency.new('SEK', subunit: 2, symbol: 'kr'),
-      'USD' => Currency.new('USD', subunit: 2, symbol: '$')
+      'COP' => Currency.new('COP', subunit: 2, symbol: '$'),
+      'VES' => Currency.new('VES', subunit: 2, symbol: 'Bs.'),
+      'UYU' => Currency.new('UYU', subunit: 2, symbol: '$U'),
+      'PYG' => Currency.new('PYG', subunit: 0, symbol: 'Gs'),
+      'BOB' => Currency.new('BOB', subunit: 2, symbol: '$b'),
+      'CRC' => Currency.new('CRC', subunit: 2, symbol: '₡'),
+      'GTQ' => Currency.new('GTQ', subunit: 2, symbol: 'Q'),
+      'HNL' => Currency.new('HNL', subunit: 2, symbol: 'L'),
+      'NIO' => Currency.new('NIO', subunit: 2, symbol: 'C$'),
+      'PAB' => Currency.new('PAB', subunit: 2, symbol: 'B/.'),
+      'DOP' => Currency.new('DOP', subunit: 2, symbol: 'RD$'),
+      'HTG' => Currency.new('HTG', subunit: 2, symbol: 'G'),
+      'JMD' => Currency.new('JMD', subunit: 2, symbol: 'J$'),
+      'TTD' => Currency.new('TTD', subunit: 2, symbol: 'TT$'),
+      'BBD' => Currency.new('BBD', subunit: 2, symbol: 'Bds$'),
+      'BSD' => Currency.new('BSD', subunit: 2, symbol: 'B$'),
+      'BZD' => Currency.new('BZD', subunit: 2, symbol: 'BZ$'),
+      'GYD' => Currency.new('GYD', subunit: 2, symbol: 'G$'),
+      'SRD' => Currency.new('SRD', subunit: 2, symbol: 'Sr$'),
+
+      # Pacific & Others
+      'FJD' => Currency.new('FJD', subunit: 2, symbol: 'FJ$'),
+      'PGK' => Currency.new('PGK', subunit: 2, symbol: 'K'),
+      'SBD' => Currency.new('SBD', subunit: 2, symbol: 'SI$'),
+      'VUV' => Currency.new('VUV', subunit: 0, symbol: 'VT'),
+      'TOP' => Currency.new('TOP', subunit: 2, symbol: 'T$'),
+      'WST' => Currency.new('WST', subunit: 2, symbol: 'WS$'),
+      'XCD' => Currency.new('XCD', subunit: 2, symbol: 'EC$'),
+      'XOF' => Currency.new('XOF', subunit: 0, symbol: 'CFA'),
+      'XAF' => Currency.new('XAF', subunit: 0, symbol: 'FCFA'),
+      'XPF' => Currency.new('XPF', subunit: 0, symbol: '₣')
     }
   end
 end

data/lib/minting/money/allocation.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Mint
   # :nodoc
   # split and allocation methods
@@ -8,32 +6,30 @@ module Mint
       raise ArgumentError, 'Need at least 1 proportion element' if proportions.empty?
 
       whole = proportions.sum.to_r
-      allocation = proportions.map { |rate| mint(amount * rate.to_r / whole) }
-      left_over =  self - allocation.sum
-      allocate_left_over(allocation, left_over)
+      amounts = proportions.map! { |rate| (amount * rate.to_r / whole).round(currency.subunit) }
+      allocate_left_over!(amounts: amounts, left_over: amount - amounts.sum)
     end
 
     def split(quantity)
-      unless quantity.positive? && quantity.integer?
+      unless  quantity.positive? && quantity.integer?
         raise ArgumentError,
-              'quantitity must be an integer > 0'
+              'quantity must be an integer > 0'
       end
 
-      fraction = self / quantity
-      allocation = Array.new(quantity, fraction)
-      left_over = self - (fraction * quantity)
-      allocate_left_over(allocation, left_over)
+      fraction = (amount / quantity).round(currency.subunit)
+      allocate_left_over!(amounts: Array.new(quantity, fraction),
+                          left_over: amount - (fraction * quantity))
     end
 
     private
 
-    def allocate_left_over(allocation, left_over)
-      minimum = currency.minimum_amount
-      minimum = mint(left_over.positive? ? minimum : -minimum)
-
-      slots = (left_over / minimum).to_i - 1
-      (0..slots).each { |slot| allocation[slot] += minimum }
-      allocation
+    def allocate_left_over!(amounts:, left_over:)
+      if left_over.nonzero?
+        minimum = left_over.positive? ? currency.minimum_amount : -currency.minimum_amount
+        last_slot = (left_over / minimum).to_i - 1
+        (0..last_slot).each { |slot| amounts[slot] += minimum }
+      end
+      amounts.map { mint(it) }
     end
   end
 end

data/lib/minting/money/arithmetics.rb

@@ -1,31 +1,27 @@
-# frozen_string_literal: true
-
 module Mint
   # :nodoc
-  # Arithmetic funcions for money ojects
+  # Arithmetic functions for money objects
   class Money
-    def abs
-      mint(amount.abs)
-    end
+    def abs =     mint(amount.abs)
 
-    def negative?
-      amount.negative?
-    end
+    def negative? = amount.negative?
 
-    def positive?
-      amount.positive?
-    end
+    def positive? = amount.positive?
+
+    def succ = mint(amount + currency.minimum_amount)
 
     def +(addend)
-      return mint(amount + addend.amount) if same_currency?(addend)
-      return self unless addend.is_a?(Money) || addend.nonzero?
+      return self if addend.respond_to?(:zero?) && addend.zero?
+      return mint(amount + addend.amount) if addend.is_a?(Money) && same_currency?(addend)
 
       raise TypeError, "#{addend} can't be added to #{self}"
     end
 
     def -(subtrahend)
-      return self if subtrahend.zero?
-      return mint(amount - subtrahend.amount) if same_currency?(subtrahend)
+      return self if subtrahend.respond_to?(:zero?) && subtrahend.zero?
+      if subtrahend.is_a?(Money) && same_currency?(subtrahend)
+        return mint(amount - subtrahend.amount)
+      end
 
       raise TypeError, "#{subtrahend} can't be subtracted from #{self}"
     end

data/lib/minting/money/coercion.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Mint
   # :nodoc
   # Coercion logic

data/lib/minting/money/comparable.rb

@@ -1,27 +1,24 @@
-# frozen_string_literal: true
-
 module Mint
   # :nodoc
-  # Comparision methods
+  # Comparison methods
   class Money
     include Comparable
 
     # @return true if both are zero, or both have same amount and same currency
     def ==(other)
-      return true if other.is_a?(Numeric) && zero? && other.zero?
+      return true if zero? && other.respond_to?(:zero?) && other.zero?
       return false unless other.is_a?(Mint::Money)
-      return false if nonzero? && currency != other.currency
 
-      amount == other.amount
+      amount == other.amount && currency == other.currency
     end
 
     # @example
-    #   two_usd == Mint.money(2r, Currency['USD']) #=> [$ 2.00]
-    #   two_usd > 0                                    #=> true
-    #   two_usd > Mint.money(1r, Currency['USD'])  #=> true
+    #   two_usd == Mint.money(2r, 'USD']) #=> [$ 2.00]
+    #   two_usd > 0                       #=> true
+    #   two_usd > Mint.money(2, 'USD'])  #=> true
     #   two_usd > 1
     #   => TypeError: [$ 2.00] can't be compared to 1
-    #   two_usd > Mint.money(2, Currency['BRL'])
+    #   two_usd > Mint.money(2, 'BRL'])
     #   => TypeError: [$ 2.00] can't be compared to [R$ 2.00]
     #
     def <=>(other)
@@ -38,10 +35,6 @@ module Mint
       self == other
     end
 
-    def hash
-      @hash ||= zero? ? 0.hash : [amount, currency].hash
-    end
-
     def nonzero?
       amount.nonzero?
     end

data/lib/minting/money/conversion.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Mint
   # Conversion logic
   class Money

data/lib/minting/money/money.rb

@@ -1,13 +1,13 @@
-# frozen_string_literal: true
-
 module Mint
-  # Money is a value object for monetary values
-  # Money is immutable
   class Money
-    DEFAULT_FORMAT = '%<symbol>s%<amount>f'
+    DEFAULT_FORMAT = '%<symbol>s%<amount>f'.freeze
 
     attr_reader :amount, :currency
 
+    # Creates a new Money immutable object with the specified amount and currency
+    # @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)
       raise ArgumentError, 'amount must be Numeric' unless amount.is_a?(Numeric)
 
@@ -24,6 +24,13 @@ module Mint
       currency.code
     end
 
+    def hash
+      @hash ||= zero? ? 0.hash : [amount, currency.code].hash
+    end
+
+    # Returns a new Money object with the specified amount, or self if unchanged
+    # @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)
     end

data/lib/minting/version.rb

@@ -1,3 +1,3 @@
 module Minting
-  VERSION = '0.3.1'.freeze
+  VERSION = '1.0.0'.freeze
 end

data/minting.gemspec

@@ -15,7 +15,7 @@ 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.0 or newer is required' unless s.respond_to?(:metadata)
+  raise 'RubyGems 3.2 or newer is required' unless s.respond_to?(:metadata)
 
   s.metadata = {
     'bug_tracker_uri' => "#{s.homepage}/issues",
@@ -26,7 +26,7 @@ Gem::Specification.new do |s|
     'rubygems_mfa_required' => 'true'
   }
 
-  s.required_ruby_version = '>= 3.0.0'
+  s.required_ruby_version = '>= 3.2.0'
 
   s.files = Dir.glob('{bin,doc,lib}/**/*')
   s.files += %w[minting.gemspec Rakefile README.md]

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: minting
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Gilson Ferraz
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-25 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: Library to manipulate currency values
 email: []
@@ -21,7 +20,6 @@ files:
 - bin/console
 - bin/setup
 - lib/minting.rb
-- lib/minting/currency.rb
 - lib/minting/mint.rb
 - lib/minting/mint/currency.rb
 - lib/minting/mint/refinements.rb
@@ -45,7 +43,6 @@ metadata:
   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
@@ -53,15 +50,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.10
-signing_key:
+rubygems_version: 3.7.1
 specification_version: 4
 summary: Library to manipulate currency values
 test_files: []

data/lib/minting/currency.rb

@@ -1,2 +0,0 @@
-require 'minting/currency/mint_currency'
-require 'minting/currency/currency'