minting 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c15130af9a863ae0ed77f63bd1fe5c9bf4c89e2f64bf116be16e5ace6407ede7
+  data.tar.gz: 749015ea7226c1ea4eafaa71d25461a812b29c0ec11541d686894aa55675bfe7
+SHA512:
+  metadata.gz: 797bd7de317d1038b3b5bf154cea1f0386dd7901bc598822820a51b680f600d0fce15219f8533f5da342092378639b6c663fe979b79ce7ac07578c1c13b9e59b
+  data.tar.gz: 0fc814e5e15fc40915baef2cef206c55a773072b67587b9e32373898bdb806194b78d63cf85e804c16939aabed753d7ad2b82e7db2948f749fa017ede7ca1172

data/README.md

@@ -0,0 +1,92 @@
+# Minting
+
+Yet another Ruby library for dealing with money and currency.
+
+Work in progress, please wait release 1.0.0
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'minting', git: 'https://github.com/gferraz/minting.git'
+```
+
+And then execute:
+
+$ bundle
+
+Or install it yourself with:
+
+$ git clone https://github.com/gferraz/minting.git
+$ cd minting && gem build minting.gemspec
+$ gem install minting-0.2.0.gem
+
+## 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"
+
+# Comparisons
+ten_dollars = Mint.money(10, 'USD')
+
+ten_dollars == Mint.money(10, 'USD') #=> true
+ten_dollars == Mint.money(11, 'USD') #=> false
+ten_dollars == Mint.money(10, 'EUR') #=> false
+
+ten_dollars.eql? Mint.money(10, 'USD')         #=> true
+ten_dollars.hash == Mint.money(10, 'USD').hash #=> true
+
+# Format (uses Kernel.format internally)
+price = Mint.money(9.99, 'USD')
+
+price.to_s                                  #=> "$9.99",
+price.to_s(format: '%<amount>d')            #=> "9",
+price.to_s(format: '%<symbol>s%<amount>f')  #=> "$9.99",
+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.to_s(format: '--%<amount>7d')               #=> "--      9"
+price.to_s(format: '  %<amount>10f %<currency>s') #=> "        9.99 USD"
+(-price).to_s(format: '  %<amount>10f')           #=> "       -9.99"
+
+price_in_euros.to_s(format: '%<symbol>2s%<amount>+10f')    #=> " €    +12.34"
+
+# Json serialization
+
+price.to_json # "{"currency": "USD", "amount": "9.99"}
+
+# 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_dollars.allocate([1, 2, 3]) #=> [[USD 1.67], [USD 3.33], [USD 5.00]]
+
+# Numeric refinements
+uning Mint
+
+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
+```
+
+## Release 1.0 Plan
+
+- Rails
+- Localization: I18n
+- Arithmetics: div, mod
+- Mint.parse
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/gferraz/minting.

data/Rakefile

@@ -0,0 +1,21 @@
+require 'bundler/gem_tasks'
+require 'rubocop/rake_task'
+require 'rake/testtask'
+
+CLOBBER.include %w[tmp]
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+  t.ruby_opts << '-rtest_helper.rb'
+end
+
+Rake::TestTask.new(:bench) do |t|
+  t.libs = %w[lib test]
+  t.pattern = 'test/**/*_benchmark.rb'
+end
+
+RuboCop::RakeTask.new(:cop)
+
+task default: :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'minting'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/minting/currency.rb

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

data/lib/minting/mint/currency.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Mint
+  # Represents a specific currency unit, identified by ISO 4217 alphabetic ocde
+  #
+  # @see https://www.iso.org/iso-4217-currency-codes.html
+  class Currency
+    attr_reader :code, :subunit, :symbol
+
+    def inspect
+      "<Currency:(#{code} #{symbol} #{subunit})>"
+    end
+
+    def minimum_amount
+      @minimum_amount ||= 10r**-subunit
+    end
+
+    private
+
+    def initialize(code, subunit:, symbol:)
+      @code = code
+      @subunit = subunit
+      @symbol = symbol
+    end
+  end
+end

data/lib/minting/mint/refinements.rb

@@ -0,0 +1,30 @@
+# Mint is a library to operate with monetary values
+module Mint
+  refine Numeric do
+    def reais
+      Mint.money(self, 'BRL')
+    end
+
+    def dollars
+      Mint.money(self, 'USD')
+    end
+
+    def euros
+      Mint.money(self, 'EUR')
+    end
+
+    def to_money(currency)
+      Mint.money(self, currency)
+    end
+
+    alias_method :dollar, :dollars
+    alias_method :euro, :euros
+    alias_method :mint, :to_money
+  end
+
+  refine String do
+    def to_money(currency)
+      Mint.money(to_r, currency)
+    end
+  end
+end

data/lib/minting/mint/registry.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# :nodoc
+module Mint
+  def self.money(amount, currency_code)
+    Money.new(amount, currency(currency_code))
+  end
+
+  def self.currency(currency)
+    case currency
+    when Currency
+      currency
+    when Symbol
+      currencies[currency.to_s]
+    else
+      currencies[currency]
+    end
+  end
+
+  def self.register_currency(code, subunit: 2, symbol: '$')
+    code = code.to_s
+    currencies[code] || register_currency!(code, subunit: subunit, symbol: symbol)
+  end
+
+  def self.register_currency!(code, subunit:, symbol: '')
+    code = code.to_s
+    unless code.match?(/^[A-Z_]+$/)
+      raise ArgumentError,
+            "Currency code must be String or Symbol ('USD', :EUR)"
+    end
+    if currencies[code]
+      raise KeyError,
+            "Currency: #{code} already registered"
+    end
+
+    currencies[code] =
+      Currency.new(code, subunit: subunit.to_i, symbol: symbol.to_s).freeze
+  end
+
+  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: '¥'),
+      '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: '$'),
+      'NZD' => Currency.new('NZD', subunit: 2, symbol: '$'),
+      'PEN' => Currency.new('PEN', subunit: 2, symbol: 'S/.'),
+      'SEK' => Currency.new('SEK', subunit: 2, symbol: 'kr'),
+      'USD' => Currency.new('USD', subunit: 2, symbol: '$')
+    }
+  end
+end

data/lib/minting/mint.rb

@@ -0,0 +1,3 @@
+require 'minting/mint/currency'
+require 'minting/mint/refinements'
+require 'minting/mint/registry'

data/lib/minting/money/allocation.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Mint
+  # :nodoc
+  # split and allocation methods
+  class Money
+    def allocate(proportions)
+      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)
+    end
+
+    def split(quantity)
+      unless quantity.positive? && quantity.integer?
+        raise ArgumentError,
+              'quantitity 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)
+    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
+    end
+  end
+end

data/lib/minting/money/arithmetics.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Mint
+  # :nodoc
+  # Arithmetic funcions for money ojects
+  class Money
+    def abs
+      mint(amount.abs)
+    end
+
+    def negative?
+      amount.negative?
+    end
+
+    def positive?
+      amount.positive?
+    end
+
+    def +(addend)
+      return mint(amount + addend.amount) if same_currency?(addend)
+      return self unless addend.is_a?(Money) || addend.nonzero?
+
+      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)
+
+      raise TypeError, "#{subtrahend} can't be subtracted from #{self}"
+    end
+
+    def -@
+      mint(-amount)
+    end
+
+    def *(multiplicand)
+      return mint(amount * multiplicand.to_r) if multiplicand.is_a?(Numeric)
+
+      raise TypeError, "#{self} can't be multiplied by #{multiplicand}"
+    end
+
+    def /(divisor)
+      return mint(amount / divisor) if divisor.is_a?(Numeric)
+      return amount / divisor.amount if same_currency? divisor
+
+      raise TypeError, "#{self} can't be divided by #{divisor}"
+    end
+  end
+end

data/lib/minting/money/coercion.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Mint
+  # :nodoc
+  # Coercion logic
+  class Money
+    def coerce(other)
+      [CoercedNumber.new(other), self]
+    end
+
+    # :nodoc
+    # Coerced Number contains the arithmetic logic for numeric compatible ops.
+    class CoercedNumber
+      include Comparable
+
+      def initialize(value)
+        @value = value
+      end
+
+      def +(other)
+        return other if @value.zero?
+
+        raise_coercion_error(:+, other)
+      end
+
+      def -(other)
+        return -other if @value.zero?
+
+        raise_coercion_error(:-, other)
+      end
+
+      def *(other)
+        other.mint(@value * other.amount)
+      end
+
+      def /(other)
+        raise_coercion_error(:/, other)
+      end
+
+      def <=>(other)
+        return nil if @value.nil? || other.nil?
+        return @value <=> other.amount if @value.zero? || other.zero?
+
+        raise_coercion_error(:<=>, other)
+      end
+
+      def raise_coercion_error(operation, operand)
+        raise TypeError,
+              "#{self} #{operation} #{operand} : incompatible operands"
+      end
+    end
+  end
+end

data/lib/minting/money/comparable.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Mint
+  # :nodoc
+  # Comparision 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 false unless other.is_a?(Mint::Money)
+      return false if nonzero? && currency != other.currency
+
+      amount == other.amount
+    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 > 1
+    #   => TypeError: [$ 2.00] can't be compared to 1
+    #   two_usd > Mint.money(2, Currency['BRL'])
+    #   => TypeError: [$ 2.00] can't be compared to [R$ 2.00]
+    #
+    def <=>(other)
+      case other
+      when Numeric
+        return amount <=> other if other.zero?
+      when Mint::Money
+        return amount <=> other.amount if currency == other.currency
+      end
+      raise TypeError, "#{inspect} can't be compared to #{other.inspect}"
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def hash
+      @hash ||= zero? ? 0.hash : [amount, currency].hash
+    end
+
+    def nonzero?
+      amount.nonzero?
+    end
+
+    def zero?
+      amount.zero?
+    end
+  end
+end

data/lib/minting/money/conversion.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Mint
+  # Conversion logic
+  class Money
+    def to_d
+      amount.to_d 0
+    end
+
+    def to_f
+      amount.to_f
+    end
+
+    def to_html(format = DEFAULT_FORMAT)
+      title = Kernel.format("#{currency_code} %0.#{currency.subunit}f", amount)
+      %(<data class='money' title='#{title}'>#{to_s(format: format)}</data>)
+    end
+
+    def to_i
+      amount.to_i
+    end
+
+    def to_json(*_args)
+      subunit = currency.subunit
+      Kernel.format(
+        %({"currency": "#{currency_code}", "amount": "%0.#{subunit}f"}),
+        amount
+      )
+    end
+
+    def to_r
+      amount
+    end
+
+    def to_s(format: '%<symbol>s%<amount>f', delimiter: false, separator: '.')
+      format = format.gsub(/%<amount>(\+?\d*)f/,
+                           "%<amount>\\1.#{currency.subunit}f")
+      formatted = Kernel.format(format, amount: amount, currency: currency_code,
+                                        symbol: currency.symbol)
+      if delimiter
+        # Thanks Money gem for the regular expression
+        formatted.gsub!(/(\d)(?=(?:\d{3})+(?:[^\d]{1}|$))/, "\\1#{delimiter}")
+      end
+      formatted.tr!('.', separator) if separator != '.'
+      formatted
+    end
+  end
+end

data/lib/minting/money/money.rb

@@ -0,0 +1,39 @@
+# 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'
+
+    attr_reader :amount, :currency
+
+    def initialize(amount, currency)
+      raise ArgumentError, 'amount must be Numeric' unless amount.is_a?(Numeric)
+
+      unless currency.is_a?(Currency)
+        raise ArgumentError,
+              'currency must be a Currency object'
+      end
+
+      @amount = amount.to_r.round(currency.subunit)
+      @currency = currency
+    end
+
+    def currency_code
+      currency.code
+    end
+
+    def mint(new_amount)
+      new_amount.to_r == amount ? self : Money.new(new_amount, currency)
+    end
+
+    def inspect
+      Kernel.format "[#{currency_code} %0.#{currency.subunit}f]", amount
+    end
+
+    def same_currency?(other)
+      other.respond_to?(:currency) && other.currency == currency
+    end
+  end
+end

data/lib/minting/money.rb

@@ -0,0 +1,6 @@
+require 'minting/money/allocation'
+require 'minting/money/arithmetics'
+require 'minting/money/coercion'
+require 'minting/money/comparable'
+require 'minting/money/conversion'
+require 'minting/money/money'

data/lib/minting/version.rb

@@ -0,0 +1,3 @@
+module Minting
+  VERSION = '0.3.0'.freeze
+end

data/lib/minting.rb

@@ -0,0 +1,3 @@
+require 'minting/mint'
+require 'minting/money'
+require 'minting/version'

data/minting.gemspec

@@ -0,0 +1,36 @@
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'minting/version'
+
+Gem::Specification.new do |s|
+  s.name          = 'minting'
+  s.summary       = 'Library to manipulate currency values'
+  s.description   = s.summary
+  s.homepage      = 'https://github.com/gferraz/minting'
+  s.version       = Minting::VERSION
+  s.authors       = ['Gilson Ferraz']
+  s.email         = []
+  s.license = 'MIT'
+
+  # 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)
+
+  s.metadata = {
+    'bug_tracker_uri' => "#{s.homepage}/issues",
+    'changelog_uri' => "#{s.homepage}/blob/master/CHANGELOG.md",
+    'homepage_uri' => s.homepage,
+    'source_code_uri' => s.homepage,
+    'allowed_push_host' => 'https://rubygems.org',
+    'rubygems_mfa_required' => 'true'
+  }
+
+  s.required_ruby_version = '>= 3.0.0'
+
+  s.files = Dir.glob('{bin,doc,lib}/**/*')
+  s.files += %w[minting.gemspec Rakefile README.md]
+
+  s.bindir        = 'bin'
+  s.require_paths = ['lib']
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: minting
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Gilson Ferraz
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-05-22 00:00:00.000000000 Z
+dependencies: []
+description: Library to manipulate currency values
+email: []
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- 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
+- lib/minting/mint/registry.rb
+- lib/minting/money.rb
+- lib/minting/money/allocation.rb
+- lib/minting/money/arithmetics.rb
+- lib/minting/money/coercion.rb
+- lib/minting/money/comparable.rb
+- lib/minting/money/conversion.rb
+- lib/minting/money/money.rb
+- lib/minting/version.rb
+- minting.gemspec
+homepage: https://github.com/gferraz/minting
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/gferraz/minting/issues
+  changelog_uri: https://github.com/gferraz/minting/blob/master/CHANGELOG.md
+  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
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.9
+signing_key:
+specification_version: 4
+summary: Library to manipulate currency values
+test_files: []