money 6.0.0 → 6.0.1

data/lib/money/money.rb

@@ -1,4 +1,7 @@
 # encoding: utf-8
+require "monetize"
+require "monetize/core_extensions"
+
 require "money/bank/variable_exchange"
 require "money/bank/single_currency"
 require "money/money/arithmetic"
@@ -15,10 +18,7 @@ require "money/money/formatting"
 #
 # @see http://en.wikipedia.org/wiki/Money
 class Money
-  include Comparable
-  include Arithmetic
-  include Formatting
-  include Parsing
+  include Comparable, Money::Arithmetic, Money::Formatting, Money::Parsing
 
   # Convenience method for fractional part of the amount. Synonym of #fractional
   #
@@ -64,68 +64,50 @@ class Money
     end
   end
 
-  def as_d(num)
-    if num.is_a?(Rational)
-      num.to_d(self.class.conversion_precision)
-    elsif num.respond_to?(:to_d)
-      num.to_d
-    else
-      BigDecimal.new(num.to_s)
-    end
-  end
-  private :as_d
-
-  # The currency the money is in.
-  #
-  # @return [Currency]
-  attr_reader :currency
-
-  # The +Money::Bank+ based object used to perform currency exchanges with.
-  #
-  # @return [Money::Bank::*]
-  attr_reader :bank
+  # @attr_reader [Currency] currency The currency the money is in.
+  # @attr_reader [Money::Bank::*] bank The +Money::Bank+ based object used to
+  # perform currency exchanges with.
+  attr_reader :currency, :bank
 
   # Class Methods
   class << self
-    # Each Money object is associated to a bank object, which is responsible
-    # for currency exchange. This property allows you to specify the default
-    # bank object. The default value for this property is an instance of
-    # +Bank::VariableExchange.+ It allows one to specify custom exchange rates.
+    # @attr_accessor [Money::Bank::*] default_bank Each Money object is
+    # associated to a bank object, which is responsible for currency exchange.
+    # This property allows you to specify the default bank object. The default
+    # value for this property is an instance of +Bank::VariableExchange.+ It
+    # allows one to specify custom exchange rates.
+    # @attr_accessor [Money::Currency] default_currency The default currency,
+    # which is used when +Money.new+ is called without an explicit currency
+    # argument. The default value is Currency.new("USD"). The value must be a
+    # valid +Money::Currency+ instance.
+    # @attr_accessor [true, false] use_i18n Use this to disable i18n even if
+    # it's used by other objects in your app.
+    # @attr_accessor [true, false] assume_from_symbol Use this to enable the
+    # ability to assume the currency from a passed symbol
+    # @attr_accessor [true, false] infinite_precision Use this to enable
+    # infinite precision cents
+    # @attr_accessor [Integer] conversion_precision Use this to specify
+    # precision for converting Rational to BigDecimal
+    attr_accessor :default_bank, :default_currency, :use_i18n,
+      :assume_from_symbol, :infinite_precision, :conversion_precision,
+      :silence_core_extensions_deprecations
+
+    # @attr_writer rounding_mode Use this to specify the rounding mode
+    attr_writer :rounding_mode
+
+    # Create a new money object with value 0.
     #
-    # @return [Money::Bank::*]
-    attr_accessor :default_bank
-
-    # The default currency, which is used when +Money.new+ is called without an
-    # explicit currency argument. The default value is Currency.new("USD"). The
-    # value must be a valid +Money::Currency+ instance.
+    # @param [Currency, String, Symbol] currency The currency to use.
     #
-    # @return [Money::Currency]
-    attr_accessor :default_currency
-
-    # Use this to disable i18n even if it's used by other objects in your app.
+    # @return [Money]
     #
-    # @return [true,false]
-    attr_accessor :use_i18n
-
-    # Use this to enable the ability to assume the currency from a passed symbol
-    #
-    # @return [true,false]
-    attr_accessor :assume_from_symbol
-
-    # Use this to enable infinite precision cents
-    #
-    # @return [true,false]
-    attr_accessor :infinite_precision
-
-    # Use this to specify the rounding mode
-    #
-    # @return [BigDecimal::ROUND_MODE]
-    attr_accessor :rounding_mode
-
-    # Use this to specify precision for converting Rational to BigDecimal
-    #
-    # @return [Integer]
-    attr_accessor :conversion_precision
+    # @example
+    #   Money.empty #=> #<Money @fractional=0>
+    def empty(currency = default_currency)
+      @empty ||= {}
+      @empty[currency] ||= Money.new(0, currency)
+    end
+    alias_method :zero, :empty
   end
 
   def self.setup_defaults
@@ -149,6 +131,9 @@ class Money
 
     # Default the conversion of Rationals precision to 16
     self.conversion_precision = 16
+
+    # Default alerting about deprecations
+    self.silence_core_extensions_deprecations = false
   end
 
   def self.inherited(base)
@@ -157,16 +142,27 @@ class Money
 
   setup_defaults
 
-  # Create a new money object with value 0.
+  # Use this to return the rounding mode.  You may also pass a
+  # rounding mode and a block to temporatly change it.  It will
+  # then return the results of the block instead.
   #
-  # @param [Currency, String, Symbol] currency The currency to use.
+  # @param [BigDecimal::ROUND_MODE] optional
   #
-  # @return [Money]
+  # @return [BigDecimal::ROUND_MODE,Yield] rounding mode or block results
   #
   # @example
-  #   Money.empty #=> #<Money @fractional=0>
-  def self.empty(currency = default_currency)
-    Money.new(0, currency)
+  #   fee = Money.rounding_mode(BigDecimal::ROUND_HALF_UP) do
+  #     Money.new(1200) * BigDecimal.new('0.029')
+  #   end
+  def self.rounding_mode(mode=nil)
+    if mode.nil?
+      Thread.current[:money_rounding_mode] || @rounding_mode
+    else
+      Thread.current[:money_rounding_mode] = mode
+      yield
+    end
+  ensure
+    Thread.current[:money_rounding_mode] = nil
   end
 
   # Creates a new Money object of the given value, using the Canadian
@@ -234,10 +230,9 @@ class Money
   # @see Money.new
   #
   def self.new_with_amount(amount, currency = Money.default_currency, bank = Money.default_bank)
-    money = from_numeric(amount, currency)
-    # Hack! You can't change a bank
-    money.instance_variable_set("@bank", bank)
-    money
+    from_numeric(amount, currency).tap do |money|
+      money.instance_variable_set("@bank", bank) # Hack! You can't change a bank
+    end
   end
 
   # Synonym of #new_with_amount
@@ -286,17 +281,14 @@ class Money
   #
   # @see Money.new_with_dollars
   #
-  def initialize(fractional, currency = Money.default_currency, bank = Money.default_bank)
-    if (fractional.is_a? Money)
-      money = fractional
-      @fractional = money.fractional
-      @currency   = money.currency
-      @bank       = money.bank
-    else
-      @fractional = as_d(fractional)
-      @currency   = Currency.wrap(currency)
-      @bank       = bank
-    end
+  def initialize(obj, currency = Money.default_currency, bank = Money.default_bank)
+    @fractional = obj.fractional
+    @currency   = obj.currency
+    @bank       = obj.bank
+  rescue NoMethodError
+    @fractional = as_d(obj)
+    @currency   = Currency.wrap(currency)
+    @bank       = bank
   end
 
   # Assuming using a currency using dollars:
@@ -391,41 +383,19 @@ class Money
   # @example
   #   Money.ca_dollar(100).to_s #=> "1.00"
   def to_s
-    unit, subunit = fractional().abs.divmod(currency.subunit_to_unit)
-
-    unit_str       = ""
-    subunit_str    = ""
-    fraction_str   = ""
-
-    if self.class.infinite_precision
-      subunit, fraction = subunit.divmod(BigDecimal("1"))
-
-      unit_str       = unit.to_i.to_s
-      subunit_str    = subunit.to_i.to_s
-      fraction_str   = fraction.to_s("F")[2..-1] # want fractional part "0.xxx"
-
-      fraction_str = "" if fraction_str =~ /^0+$/
-    else
-      unit_str, subunit_str = unit.to_s, subunit.to_s
-    end
-
-    absolute_str = if currency.decimal_places == 0
-      if fraction_str == ""
-        unit_str
-      else
-        "#{unit_str}#{decimal_mark}#{fraction_str}"
-      end
-    else
-      # need to pad subunit to right position,
-      # for example 1 usd 3 cents should be 1.03 not 1.3
-      subunit_str.insert(0, '0') while subunit_str.length < currency.decimal_places
+    unit, subunit, fraction = strings_from_fractional
 
-      "#{unit_str}#{decimal_mark}#{subunit_str}#{fraction_str}"
-    end
+    str = if currency.decimal_places == 0
+            if fraction == ""
+              unit
+            else
+              "#{unit}#{decimal_mark}#{fraction}"
+            end
+          else
+            "#{unit}#{decimal_mark}#{pad_subunit(subunit)}#{fraction}"
+          end
 
-    absolute_str.tap do |str|
-      str.insert(0, "-") if fractional() < 0
-    end
+    fractional < 0 ? "-#{str}" : str
   end
 
   # Return the amount of money as a BigDecimal.
@@ -455,7 +425,7 @@ class Money
   #
   # @return [self]
   def to_money(given_currency = nil)
-    given_currency = Currency.wrap(given_currency) if given_currency
+    given_currency = Currency.wrap(given_currency)
     if given_currency.nil? || self.currency == given_currency
       self
     else
@@ -527,23 +497,13 @@ class Money
   #   Money.new(100, "USD").allocate([0.33, 0.33, 0.33]) #=> [Money.new(34), Money.new(33), Money.new(33)]
   #
   def allocate(splits)
-    allocations = splits.inject(0) { |sum, n| sum + as_d(n) }
+    allocations = allocations_from_splits(splits)
 
     if (allocations - BigDecimal("1")) > Float::EPSILON
       raise ArgumentError, "splits add to more then 100%"
     end
 
-    left_over = fractional
-
-    amounts = splits.map do |ratio|
-      if self.class.infinite_precision
-        fraction = fractional * ratio
-      else
-        fraction = (fractional * ratio / allocations).floor
-        left_over -= fraction
-        fraction
-      end
-    end
+    amounts, left_over = amounts_from_splits(allocations, splits)
 
     unless self.class.infinite_precision
       left_over.to_i.times { |i| amounts[i % amounts.length] += 1 }
@@ -564,21 +524,10 @@ class Money
     raise ArgumentError, "need at least one party" if num < 1
 
     if self.class.infinite_precision
-      amt = div(as_d(num))
-      return 1.upto(num).map{amt}
-    end
-
-    low = Money.new(fractional / num, currency)
-    high = Money.new(low.fractional + 1, currency)
-
-    remainder = fractional % num
-    result = []
-
-    num.times do |index|
-      result[index] = index < remainder ? high : low
+      split_infinite(num)
+    else
+      split_flat(num)
     end
-
-    result
   end
 
   # Round the monetary amount to smallest unit of coinage.
@@ -598,10 +547,85 @@ class Money
   #
   def round(rounding_mode = self.class.rounding_mode)
     if self.class.infinite_precision
-      return Money.new(fractional.round(0, rounding_mode), self.currency)
+      Money.new(fractional.round(0, rounding_mode), self.currency)
+    else
+      self
+    end
+  end
+
+  private
+
+  def as_d(num)
+    if num.is_a?(Rational)
+      num.to_d(self.class.conversion_precision)
+    else
+      num.to_d
+    end
+  rescue NoMethodError
+    BigDecimal.new(num.to_s)
+  end
+
+  def strings_from_fractional
+    unit, subunit = fractional().abs.divmod(currency.subunit_to_unit)
+
+    if self.class.infinite_precision
+      strings_for_infinite_precision(unit, subunit)
     else
-      return self
+      strings_for_base_precision(unit, subunit)
+    end
+  end
+
+  def strings_for_infinite_precision(unit, subunit)
+    subunit, fraction = subunit.divmod(BigDecimal("1"))
+    fraction = fraction.to_s("F")[2..-1] # want fractional part "0.xxx"
+    fraction = "" if fraction =~ /^0+$/
+
+    [unit.to_i.to_s, subunit.to_i.to_s, fraction]
+  end
+
+  def strings_for_base_precision(unit, subunit)
+    [unit.to_s, subunit.to_s, ""]
+  end
+
+  def pad_subunit(subunit)
+    cnt = currency.decimal_places
+    padding = "0" * cnt
+    "#{padding}#{subunit}"[-1 * cnt, cnt]
+  end
+
+  def allocations_from_splits(splits)
+    splits.inject(0) { |sum, n| sum + as_d(n) }
+  end
+
+  def amounts_from_splits(allocations, splits)
+    left_over = fractional
+
+    amounts = splits.map do |ratio|
+      if self.class.infinite_precision
+        fractional * ratio
+      else
+        (fractional * ratio / allocations).floor.tap do |frac|
+          left_over -= frac
+        end
+      end
     end
+
+    [amounts, left_over]
   end
 
+  def split_infinite(num)
+    amt = div(as_d(num))
+    1.upto(num).map{amt}
+  end
+
+  def split_flat(num)
+    low = Money.new(fractional / num, currency)
+    high = Money.new(low.fractional + 1, currency)
+
+    remainder = fractional % num
+
+    Array.new(num).each_with_index.map do |_, index|
+      index < remainder ? high : low
+    end
+  end
 end

data/lib/money/version.rb

@@ -0,0 +1,3 @@
+class Money
+  VERSION = "6.0.1"
+end

data/lib/money.rb

@@ -1,7 +1,9 @@
 require "bigdecimal"
 require "bigdecimal/util"
-require "i18n" rescue LoadError
+require "i18n"
 require "money/currency"
 require "money/money"
-require "money/core_extensions"
+require "money/core_extensions/numeric"
+require "money/core_extensions/string"
+require "money/core_extensions/symbol"
 require "money/deprecations"

data/money.gemspec

@@ -1,16 +1,20 @@
 # -*- 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        = "money"
-  s.version     = "6.0.0"
+  s.version     = Money::VERSION
   s.platform    = Gem::Platform::RUBY
-  s.authors     = ["Tobias Luetke", "Hongli Lai", "Jeremy McNevin",
-                   "Shane Emmons", "Simone Carletti"]
-  s.email       = ["semmons99+RubyMoney@gmail.com"]
-  s.homepage    = "http://rubymoney.github.com/money"
-  s.summary     = "Money and currency exchange support library."
-  s.description = "This library aids one in handling money and different currencies."
-
-  s.post_install_message = '''
+  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.post_install_message = <<MSG
 Please note the following API changes in Money version 6
 
  - Money#amount, Money#dollars methods now return instances of BigDecimal (rather than Float).
@@ -19,21 +23,19 @@ Please read the migration notes at https://github.com/RubyMoney/money#migration-
 and choose the migration that best suits your application.
 
 Test responsibly :-)
-'''
-
-  s.required_ruby_version     = ">= 1.8.7"
-
-  s.add_dependency "i18n",       "~> 0.6.4"
-
-  s.add_development_dependency "rspec",       "~> 2.14"
-  s.add_development_dependency "yard",        "~> 0.8"
-  s.add_development_dependency "kramdown",    "~> 1.1"
+MSG
 
-  s.license = "MIT"
+  s.add_dependency "i18n", "~> 0.6.4"
+  s.add_dependency "monetize", "~> 0.1.3"
 
-  s.files =  Dir.glob("{config,lib,spec}/**/*")
-  s.files += %w(CHANGELOG.md LICENSE README.md)
-  s.files += %w(Rakefile money.gemspec)
+  s.add_development_dependency "bundler", "~> 1.3"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec", "~> 2.14"
+  s.add_development_dependency "yard", "~> 0.8"
+  s.add_development_dependency "kramdown", "~> 1.1"
 
-  s.require_path = "lib"
+  s.files         = `git ls-files`.split($/)
+  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ["lib"]
 end

data/spec/bank/variable_exchange_spec.rb

@@ -96,6 +96,16 @@ describe Money::Bank::VariableExchange do
     it "raises an UnknownCurrency exception when an unknown currency is passed" do
       expect { subject.set_rate('AAA', 'BBB', 1.25) }.to raise_exception(Money::Currency::UnknownCurrency)
     end
+
+    it "uses a mutex by default" do
+      subject.instance_variable_get(:@mutex).should_receive(:synchronize)
+      subject.set_rate('USD', 'EUR', 1.25)
+    end
+
+    it "doesn't use mutex if requested not to" do
+      subject.instance_variable_get(:@mutex).should_not_receive(:synchronize)
+      subject.set_rate('USD', 'EUR', 1.25, :without_mutex => true)
+    end
   end
 
   describe "#get_rate" do
@@ -107,6 +117,16 @@ describe Money::Bank::VariableExchange do
     it "raises an UnknownCurrency exception when an unknown currency is passed" do
       expect { subject.get_rate('AAA', 'BBB') }.to raise_exception(Money::Currency::UnknownCurrency)
     end
+
+    it "uses a mutex by default" do
+      subject.instance_variable_get(:@mutex).should_receive(:synchronize)
+      subject.get_rate('USD', 'EUR')
+    end
+
+    it "doesn't use mutex if requested not to" do
+      subject.instance_variable_get(:@mutex).should_not_receive(:synchronize)
+      subject.get_rate('USD', 'EUR', :without_mutex => true)
+    end
   end
 
   describe "#export_rates" do
@@ -152,6 +172,16 @@ describe Money::Bank::VariableExchange do
         subject.export_rates(:json, 'null')
       end
     end
+
+    it "uses a mutex by default" do
+      subject.instance_variable_get(:@mutex).should_receive(:synchronize)
+      subject.export_rates(:yaml)
+    end
+
+    it "doesn't use mutex if requested not to" do
+      subject.instance_variable_get(:@mutex).should_not_receive(:synchronize)
+      subject.export_rates(:yaml, nil, :without_mutex => true)
+    end
   end
 
   describe "#import_rates" do
@@ -187,6 +217,18 @@ describe Money::Bank::VariableExchange do
         expect { subject.import_rates(:foo, "")}.to raise_error Money::Bank::UnknownRateFormat
       end
     end
+
+    it "uses a mutex by default" do
+      subject.instance_variable_get(:@mutex).should_receive(:synchronize)
+      s = "--- \nUSD_TO_EUR: 1.25\nUSD_TO_JPY: 2.55\n"
+      subject.import_rates(:yaml, s)
+    end
+
+    it "doesn't use mutex if requested not to" do
+      subject.instance_variable_get(:@mutex).should_not_receive(:synchronize)
+      s = "--- \nUSD_TO_EUR: 1.25\nUSD_TO_JPY: 2.55\n"
+      subject.import_rates(:yaml, s, :without_mutex => true)
+    end
   end
 
   describe "#rate_key_for" do

data/spec/core_extensions_spec.rb

@@ -110,8 +110,8 @@ describe Money, "core extensions" do
         "10.10 USD".to_money('USD').should == Money.new(1010, 'USD')
       end
 
-      it "raises error if optional currency doesn't match string currency" do
-        expect { "10.10 USD".to_money('EUR') }.to raise_error(/Mismatching Currencies/)
+      it "uses the parsed currency even if a currency was specified by the method" do
+        expect("10.10 USD".to_money("EUR")).to eq Money.new(1010, "USD")
       end
 
       it "ignores unrecognized data" do

data/spec/currency_spec.rb

@@ -112,6 +112,8 @@ describe Money::Currency do
     
     it "allows direct comparison of currencies and symbols/strings" do
       Money::Currency.new(:eur).should     == 'eur'
+      Money::Currency.new(:eur).should     == 'EUR'
+      Money::Currency.new(:eur).should     == :eur
       Money::Currency.new(:eur).should     == :EUR
       Money::Currency.new(:eur).should_not == 'usd'
     end
@@ -154,6 +156,20 @@ describe Money::Currency do
     end
   end
 
+  describe "#to_str" do
+    it "works as documented" do
+      Money::Currency.new(:usd).to_str.should == "USD"
+      Money::Currency.new(:eur).to_str.should == "EUR"
+    end
+  end
+
+  describe "#to_sym" do
+    it "works as documented" do
+      Money::Currency.new(:usd).to_sym.should == :USD
+      Money::Currency.new(:eur).to_sym.should == :EUR
+    end
+  end
+
   describe "#to_currency" do
     it "works as documented" do
       usd = Money::Currency.new(:usd)

data/spec/money/deprecations_spec.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+require "spec_helper"
+
+describe Money do
+  describe "::deprecate" do
+    it "should send a deprecation message with caller" do
+      error_message = "Deprecated method triggered here"
+
+      Money.should_receive(:warn).with do |message|
+        message.should =~ /DEPRECATION WARNING: #{error_message} \(called from:.*:\d+\)/
+      end
+
+      Money.deprecate(error_message)
+    end
+
+    context "when silenced" do
+      it "should not warn" do
+        Money.should_not_receive(:warn)
+
+        while_silenced { Money.deprecate("anything") }
+      end
+    end
+  end
+
+  describe "core extensions" do
+    it "does not print deprecations when silenced" do
+      while_silenced do
+        expect_no_deprecation_for { "$1.00".to_money }
+        expect_no_deprecation_for { "USD".to_currency }
+        expect_no_deprecation_for { 1.to_money }
+        expect_no_deprecation_for { :USD.to_currency }
+      end
+    end
+
+    def expect_no_deprecation_for(&block)
+      Money.should_not_receive(:warn)
+      yield
+    end
+  end
+
+  def while_silenced(&block)
+    begin
+      old_setting = Money.silence_core_extensions_deprecations
+      Money.silence_core_extensions_deprecations = true
+      yield
+    ensure
+      Money.silence_core_extensions_deprecations = old_setting
+    end
+  end
+end

data/spec/money/parsing_spec.rb

@@ -8,7 +8,7 @@ describe Money, "parsing" do
   eu4 = '{ "priority": 1, "iso_code": "EU4", "iso_numeric": "841", "name": "Euro with 4 decimal places", "symbol": "€", "subunit": "Cent", "subunit_to_unit": 10000, "symbol_first": true, "html_entity": "€", "decimal_mark": ",", "thousands_separator": "." }'
 
   describe ".parse" do
-    it "is depreciated" do
+    it "is deprecated" do
       Money.should_receive(:deprecate).at_least(1).times
       Money.parse("1.95")
     end
@@ -17,9 +17,6 @@ describe Money, "parsing" do
       five_ninety_five = Money.new(595, 'EUR')
 
       Money.parse('EUR 5,95').should    == five_ninety_five
-      #TODO: try and handle these
-      #Money.parse('€5,95').should       == five_ninety_five
-      #Money.parse('$5.95').should  == five_ninety_five
     end
 
     it "parses european-formatted inputs with multiple thousands-seperators" do
@@ -291,9 +288,9 @@ describe Money, "parsing" do
     end
 
     it "optimizes workload" do
-      Money.should_receive(:from_fixnum).with(1, "USD").and_return(Money.new(1_00,  "USD"))
+      Monetize.should_receive(:from_fixnum).with(1, "USD").and_return(Money.new(1_00,  "USD"))
       Money.from_numeric(1, "USD").should == Money.new(1_00,  "USD")
-      Money.should_receive(:from_bigdecimal).with(BigDecimal.new("1.0"), "USD").and_return(Money.new(1_00,  "USD"))
+      Monetize.should_receive(:from_bigdecimal).with(BigDecimal.new("1.0"), "USD").and_return(Money.new(1_00,  "USD"))
       Money.from_numeric(1.0, "USD").should == Money.new(1_00,  "USD")
     end