money2 7.0.0.rc1

data/lib/money/formatter/to_string.rb

@@ -0,0 +1,9 @@
+class Money
+  class Formatter
+    class ToString < self
+      def format(*)
+        self.class.decimal_str(money).sub('.', separator)
+      end
+    end
+  end
+end

data/lib/money/rates_store/memory.rb

@@ -0,0 +1,120 @@
+class Money
+  module RatesStore
+
+    # Class for thread-safe storage of exchange rate pairs.
+    # Used by instances of +Money::Bank::VariableExchange+.
+    #
+    # @example
+    #   store = Money::RatesStore::Memory.new
+    #   store.add_rate 'USD', 'CAD', 0.98
+    #   store.get_rate 'USD', 'CAD' # => 0.98
+    #   # iterates rates
+    #   store.each_rate {|iso_from, iso_to, rate| puts "#{from} -> #{to}: #{rate}" }
+    class Memory
+      INDEX_KEY_SEPARATOR = '_TO_'.freeze
+
+      # Initializes a new +Money::RatesStore::Memory+ object.
+      #
+      # @param [Hash] opts Optional store options.
+      # @option opts [Boolean] :without_mutex disables the usage of a mutex
+      # @param [Hash] rt Optional initial exchange rate data.
+      def initialize(opts = {}, rt = {})
+        @options, @index = opts, rt
+        @mutex = Mutex.new
+        @in_transaction = false
+      end
+
+      # Registers a conversion rate and returns it. Uses +Mutex+ to synchronize data access.
+      #
+      # @param [String] currency_iso_from Currency to exchange from.
+      # @param [String] currency_iso_to Currency to exchange to.
+      # @param [Numeric] rate Rate to use when exchanging currencies.
+      #
+      # @return [Numeric]
+      #
+      # @example
+      #   store = Money::RatesStore::Memory.new
+      #   store.add_rate("USD", "CAD", 1.24515)
+      #   store.add_rate("CAD", "USD", 0.803115)
+      def add_rate(currency_iso_from, currency_iso_to, rate)
+        transaction { index[rate_key_for(currency_iso_from, currency_iso_to)] = rate }
+      end
+
+      # Retrieve the rate for the given currencies. Uses +Mutex+ to synchronize data access.
+      # Delegates to +Money::RatesStore::Memory+
+      #
+      # @param [String] currency_iso_from Currency to exchange from.
+      # @param [String] currency_iso_to Currency to exchange to.
+      #
+      # @return [Numeric]
+      #
+      # @example
+      #   store = Money::RatesStore::Memory.new
+      #   store.add_rate("USD", "CAD", 1.24515)
+      #
+      #   store.get_rate("USD", "CAD") #=> 1.24515
+      def get_rate(currency_iso_from, currency_iso_to)
+        transaction { index[rate_key_for(currency_iso_from, currency_iso_to)] }
+      end
+
+      def marshal_dump
+        [self.class, index, options]
+      end
+
+
+      # Wraps block execution in a thread-safe transaction
+      def transaction(&block)
+        if @in_transaction || options[:without_mutex]
+          block.call self
+        else
+          @mutex.synchronize do
+            @in_transaction = true
+            result = block.call
+            @in_transaction = false
+            result
+          end
+        end
+      end
+
+      # Iterate over rate tuples (iso_from, iso_to, rate)
+      #
+      # @yieldparam iso_from [String] Currency ISO string.
+      # @yieldparam iso_to [String] Currency ISO string.
+      # @yieldparam rate [Numeric] Exchange rate.
+      #
+      # @return [Enumerator]
+      #
+      # @example
+      #   store.each_rate do |iso_from, iso_to, rate|
+      #     puts [iso_from, iso_to, rate].join
+      #   end
+      def each_rate(&block)
+        enum = Enumerator.new do |yielder|
+          index.each do |key, rate|
+            iso_from, iso_to = key.split(INDEX_KEY_SEPARATOR)
+            yielder.yield iso_from, iso_to, rate                  
+          end
+        end
+
+        block_given? ? enum.each(&block) : enum
+      end
+
+      private
+
+      attr_reader :index, :options
+
+      # Return the rate hashkey for the given currencies.
+      #
+      # @param [String] currency_iso_from The currency to exchange from.
+      # @param [String] currency_iso_to The currency to exchange to.
+      #
+      # @return [String]
+      #
+      # @example
+      #   rate_key_for("USD", "CAD") #=> "USD_TO_CAD"
+      def rate_key_for(currency_iso_from, currency_iso_to)
+        [currency_iso_from, currency_iso_to].join(INDEX_KEY_SEPARATOR).upcase
+      end
+    end
+  end
+end

data/lib/money/unaccent.rb

@@ -0,0 +1,18 @@
+begin
+  require 'sixarm_ruby_unaccent'
+rescue LoadError
+  raise 'Money gem doesnt install sixarm_ruby_unaccent by default. ' \
+    'Add it to your gemfile if you use Currency.analyze'
+end
+
+# Overwrites unaccent method of sixarm_ruby_unaccent.
+class String
+  def unaccent
+    accentmap = ACCENTMAP
+    accentmap.delete("\u{0142}") # Delete ł symbol from ACCENTMAP used in PLN currency
+    accentmap.delete("\u{010D}") # Delete č symbol from ACCENTMAP used in CZK currency
+    accentmap.delete("\u{FDFC}") # Delete ﷼ symbol from ACCENTMAP used in IRR, SAR and YER currencies
+    accentmap.delete("\u{20A8}") # Delete ₨ symbol from ACCENTMAP used in INR, LKR, MUR, NPR, PKR and SCR currencies
+    split(//u).map {|c| accentmap[c] || c }.join("")
+  end
+end

data/lib/money/v6_compatibility.rb

@@ -0,0 +1,5 @@
+require 'money/v6_compatibility/arithmetic'
+require 'money/v6_compatibility/currency_id'
+require 'money/v6_compatibility/format'
+require 'money/v6_compatibility/fractional'
+require 'money/v6_compatibility/bank_rounding_block'

data/lib/money/v6_compatibility/arithmetic.rb

@@ -0,0 +1,61 @@
+class Money
+  module V6Compatibility
+    module_function
+
+    def arithmetic
+      Money.prepend Arithmetic
+    end
+
+    module Arithmetic
+      # Wrapper for coerced numeric values to distinguish
+      # when numeric was on the 1st place in operation.
+      CoercedNumeric = Struct.new(:value) do
+        # Proxy #zero? method to skip unnecessary typecasts. See #- and #+.
+        def zero?
+          value.zero?
+        end
+      end
+
+      def coerce(value)
+        [self, CoercedNumeric.new(value)]
+      end
+
+      def <=>(other)
+        if !other.is_a?(Money) && other.respond_to?(:zero?) && other.zero?
+          return other.is_a?(CoercedNumeric) ? 0 <=> fractional : fractional <=> 0
+        end
+        super
+      end
+
+      # Uses Comparable's implementation but raises ArgumentError if non-zero
+      # numeric value is given.
+      def ==(other)
+        if other.is_a?(Numeric) && !other.zero?
+          raise ArgumentError, 'Money#== supports only zero numerics'
+        end
+        super
+      end
+
+      def +(other)
+        return self if !other.is_a?(Money) && other.zero?
+        super
+      end
+
+      def -(other)
+        return self if !other.is_a?(Money) && other.zero?
+        super
+      end
+
+      def *(other)
+        other = other.value if other.is_a?(CoercedNumeric)
+        super
+      end
+
+      def /(other)
+        raise TypeError, 'Can not divide by Money' if other.is_a?(CoercedNumeric)
+        super
+      end
+      alias_method :div, :/
+    end
+  end
+end

data/lib/money/v6_compatibility/bank_rounding_block.rb

@@ -0,0 +1,38 @@
+class Money
+  module V6Compatibility
+    module_function
+
+    def bank_rounding_block
+      Bank::VariableExchange.prepend BankRoundingBlock
+    end
+
+    module BankRoundingBlock
+      def exchange_with(from, to_currency, &block)
+        to_currency = Currency.wrap(to_currency)
+        if from.currency == to_currency
+          from
+        else
+          rate = get_rate(from.currency, to_currency)
+          unless rate
+            raise Bank::UnknownRate, "No conversion rate known for " \
+              "'#{from.currency.code}' -> '#{to_currency}'"
+          end
+          new_fractional = exchange(from.fractional, rate, &block).to_d
+          from.send(:build_new, new_fractional / to_currency.subunit_to_unit, to_currency)
+        end
+      end
+
+      def exchange(value, rate, &block)
+        rate = BigDecimal.new(rate.to_s) unless rate.is_a?(BigDecimal)
+        ex = rate * value
+        if block_given?
+          yield ex
+        elsif rounding_method
+          rounding_method.call(ex)
+        else
+          ex
+        end
+      end
+    end
+  end
+end

data/lib/money/v6_compatibility/currency_id.rb

@@ -0,0 +1,29 @@
+class Money
+  module V6Compatibility
+    module_function
+
+    def currency_id
+      Currency.prepend(CurrencyId)
+      Currency.instances.clear
+    end
+
+    module CurrencyId
+      def initialize(*)
+        super
+        @id = @code.downcase.to_sym
+      end
+
+      def to_sym
+        @code.to_sym
+      end
+
+      def code
+        symbol || @code
+      end
+
+      def iso_code
+        @code
+      end
+    end
+  end
+end

data/lib/money/v6_compatibility/format.rb

@@ -0,0 +1,53 @@
+class Money
+  module V6Compatibility
+    module_function
+
+    def format
+      Money.formatter = Formatter
+      Money.prepend Formatting
+    end
+
+    module Formatting
+      def format(old_rule = nil, **options)
+        options = {old_rule => true} if old_rule.is_a?(Symbol)
+        super(options)
+      end
+    end
+
+    class Formatter < Money::Formatter
+      def prepare_rules
+        super
+        {
+          translate: :translate_symbol,
+          south_asian_number_formatting: :south_asian,
+          thousands_separator: :delimiter,
+          decimal_mark: :separator,
+          rounded_infinite_precision: :round,
+        }.each do |old_key, new_key|
+          rules[new_key] = rules[old_key] if rules.key?(old_key)
+        end
+
+        symbol_position = self.symbol_position
+        if rules.key?(:symbol_after_without_space) && symbol_position == :after
+          rules[:symbol_space] = !rules[:symbol_after_without_space]
+        end
+        if rules.key?(:symbol_before_without_space) && symbol_position == :before
+          rules[:symbol_space] = !rules[:symbol_before_without_space]
+        end
+
+        localize_formatting_rules
+      end
+
+      def localize_formatting_rules
+        if currency.code == 'JPY' && I18n.locale == :ja
+          rules[:symbol] = '円' unless rules[:symbol] == false
+          rules[:symbol_position] = :after
+          rules[:symbol_space] = false
+        end
+      end
+
+      alias_method :thousands_separator, :delimiter
+      alias_method :decimal_mark, :separator
+    end
+  end
+end

data/lib/money/v6_compatibility/fractional.rb

@@ -0,0 +1,74 @@
+class Money
+  module V6Compatibility
+    module_function
+
+    def fractional
+      Money.prepend Fractional
+      Money.extend Fractional::ClassMethods
+    end
+
+    module Fractional
+      module ClassMethods
+        def from_amount(amount, currency = nil, bank = nil)
+          Numeric === amount or raise ArgumentError, "'amount' must be numeric"
+          new(amount, currency, bank, true)
+        end
+
+        def from_subunits(amount, currency = nil, bank = nil)
+          raise 'Use .new'
+        end
+
+        def new(val, currency = nil, bank = nil, from_amount = false)
+          return super(val, currency, bank) if val.is_a?(self) || from_amount
+          currency = Currency.wrap(currency || default_currency)
+          amount = as_d(val) / currency.subunit_to_unit
+          super(amount, currency, bank)
+        end
+
+        def as_d(value)
+          if value.respond_to?(:to_d)
+            value.is_a?(Rational) ? value.to_d(conversion_precision) : value.to_d
+          else
+            BigDecimal.new(value.to_s)
+          end
+        end
+      end
+
+      def to_f
+        amount.to_f
+      end
+
+      def yaml_initialize(_tag, attrs)
+        super
+        fractional = attrs['fractional']
+        @amount = as_d(fractional) / currency.subunit_to_unit if fractional
+      end
+
+      def round_to_nearest_cash_value
+        value = super * currency.subunit_to_unit
+        self.class.infinite_precision ? value : value.to_i
+      end
+
+      def %(other)
+        other = other.to_d / currency.subunit_to_unit unless other.is_a?(Money)
+        super
+      end
+      alias_method :modulo, :%
+
+      def remainder(other)
+        other = other.to_d / currency.subunit_to_unit unless other.is_a?(Money)
+        super
+      end
+
+      private
+
+      def build_new(amount, currency = self.currency, bank = self.bank)
+        self.class.new(amount, currency, bank, true)
+      end
+
+      def as_d(num)
+        self.class.as_d(num)
+      end
+    end
+  end
+end

data/lib/money/version.rb

@@ -0,0 +1,3 @@
+class Money
+  VERSION = '7.0.0.rc1'.freeze
+end

data/lib/money2.rb

@@ -0,0 +1 @@
+require 'money'

data/money.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'money/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'money2'
+  s.version     = Money::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Shane Emmons']
+  s.email       = ['shane@emmons.io']
+  s.homepage    = 'http://rubymoney.github.io/money'
+  s.summary     = 'A Ruby Library for dealing with money and currency conversion.'
+  s.description = 'A Ruby Library for dealing with money and currency conversion.'
+  s.license     = 'MIT'
+
+  s.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^spec/}) }
+  s.bindir        = 'exe'
+  s.executables   = s.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  s.add_dependency 'i18n', ['>= 0.6.4', '<= 0.7.0']
+
+  s.add_development_dependency 'bundler', '~> 1.3'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec', '~> 3.4.0'
+  s.add_development_dependency 'rspec-its', '~> 1.1.0'
+  s.add_development_dependency 'yard', '~> 0.8'
+  s.add_development_dependency 'kramdown', '~> 1.1'
+  s.add_development_dependency 'sixarm_ruby_unaccent', ['>= 1.1.1', '< 2']
+end