money 2.3.0 → 3.0.0

data/CHANGELOG.rdoc

@@ -1,3 +1,8 @@
+== Money 3.0.0
+ * Version Bump due to compatibility changes with ActiveRecord. See
+   http://github.com/FooBarWidget/money/issues#issue/4/comment/224880 for more
+	 information.
+
 == Money 2.3.0
  * Currency is now represented by a Currency Object instead of a string.
 

data/README.rdoc

@@ -2,13 +2,13 @@
 
 This library aids one in handling money and different currencies. Features:
 
-- Provides a Money class which encapsulates all information about an certain
+- Provides a <tt>Money</tt> class which encapsulates all information about an certain
   amount of money, such as its value and its currency.
-- Provies a Currency class which encapsulates all information about
+- Provies a <tt>Money::Currency</tt> class which encapsulates all information about
   a monerary unit.
 - Represents monetary values as integers, in cents. This avoids floating point
   rounding errors.
-- Represents currency as Currency instances providing an high level of flexibility.
+- Represents currency as <tt>Money::Currency</tt> instances providing an high level of flexibility.
 - Provides APIs for exchanging money from one currency to another.
 - Has the ability to parse a money and currency strings
   into the corresponding Money/Currency object.
@@ -48,13 +48,13 @@ The development version (hosted on Github) can be installed with:
 
 === Currency
 
-Currencies are consistently represented as instances of Money::Currency.
-The most part of Money APIs allows you to supply either a String or a Currency.
+Currencies are consistently represented as instances of <tt>Money::Currency</tt>.
+The most part of <tt>Money</tt> APIs allows you to supply either a <tt>String</tt> or a <tt>Money::Currency</tt>.
 
   Money.new(1000, "USD") == Money.new(900, Currency.new("USD"))
   Money.new(1000, "EUR").currency == Currency.new("EUR")
 
-A Money::Currency instance holds all the information about the currency, 
+A <tt>Money::Currency</tt> instance holds all the information about the currency, 
 including the currency symbol, name and much more.
 
   currency = Money.new(1000, "USD")
@@ -63,8 +63,8 @@ including the currency symbol, name and much more.
   currency.name
   # => "United States Dollar"
 
-To define a new Money::Currency simply add a new item to the Money::Currency::TABLE hash,
-where the key is the identifier for the Currency object and the value is a hash
+To define a new <tt>Money::Currency</tt> simply add a new item to the <tt>Money::Currency::TABLE</tt> hash,
+where the key is the identifier for the currency object and the value is a hash
 containing all the currency attributes.
 
   Money::Currency::TABLE[:usd] = {
@@ -85,13 +85,13 @@ The pre-defined set of attributes includes:
   * subunit: the name of the fractional monetary unit
   * subunit_to_unit: the proportion between the unit and the subunit
 
-All attributes are optional. Some attributes, such as :symbol, are used by the Money class
-to print out a representation of the object. Other attributes, such as :name or :priority,
+All attributes are optional. Some attributes, such as <tt>:symbol</tt>, are used by the Money class
+to print out a representation of the object. Other attributes, such as <tt>:name</tt> or <tt>:priority</tt>,
 exist to provide a basic API you can take advantage of to build your application.
 
 ==== priority
 
-The priority attribute is an arbitrary numerical value you can assign to the Currency
+The priority attribute is an arbitrary numerical value you can assign to the <tt>Money::Currency</tt>
 and use in sorting/grouping operation.
 
 For instance, let's assume your Rails application needs to a currency selector
@@ -126,11 +126,11 @@ and all_currencies as follows:
 
 === Default Currency
 
-By default Money defaults to USD as its currency. This can be overwritten using
+By default <tt>Money</tt> defaults to USD as its currency. This can be overwritten using
 
   Money.default_currency = Money::Currency.new("CAD")
 
-If you use Rails, then environment.rb is a very good place to put this. 
+If you use Rails, then <tt>environment.rb</tt> is a very good place to put this. 
 
 === Currency Exchange
 
@@ -157,6 +157,13 @@ www.xe.com for the current rates or just returns <tt>rand(2)</tt>:
 
   Money.default_bank = ExchangeBankWhichScrapesXeDotCom.new
 
+=== Currency Exchange Implementations
+
+The following is a list of Money.gem compatible currency exchange rate
+implementations.
+
+* eu_central_bank.gem: http://github.com/liangzan/eu_central_bank
+
 === Ruby on Rails
 
 Use the +compose_of+ helper to let Active Record deal with embedding the money
@@ -165,15 +172,40 @@ field.
 
   class ProductUnit < ActiveRecord::Base
     belongs_to :product
-    composed_of :price, :class_name => "Money", :mapping => [%w(cents cents), %w(currency currency)]
+    composed_of :price, :class_name => "Money", :mapping => [%w(cents cents), %w(currency currency_as_string)]
     
-    private        
+    private
       validate :cents_not_zero
-      
+        
       def cents_not_zero
         errors.add("cents", "cannot be zero or less") unless cents > 0
       end
       
       validates_presence_of :sku, :currency
-      validates_uniqueness_of :sku        
+      validates_uniqueness_of :sku
+  end
+
+Also, because the <tt>currency</tt> attribute is not a simple <tt>String</tt>
+but a <tt>Money::Currency</tt> object, you need a small tweak to make it work.
+
+Extend/hack the <tt>Money</tt> class with two additional methods:
+
+  # You can put this file in the config/initializers/ folder
+  class Money
+    def currency_as_string
+      currency.to_s
+    end
+  
+    def currency_as_string=(value)
+      # WARNING: this method might cause data inconsistency.
+      # See http://github.com/FooBarWidget/money/issues/4#issue/4/comment/224930
+      # currency = Currency.wrap(value)
+    end
   end
+
+The hack is not required for Money 2.2.x and previous versions.
+In this case, simply use the following <tt>composed_of</tt> definition:
+
+  composed_of :price, :class_name => "Money", :mapping => [%w(cents cents), %w(currency currency)]
+
+For further details read the full discussion at http://github.com/FooBarWidget/money/issues/4#comment_224880

data/VERSION

@@ -1 +1 @@
-2.3.0
+3.0.0

data/lib/money/core_extensions.rb

@@ -34,20 +34,20 @@ class String
   end
 
   private
-  
+
   def calculate_cents(number)
     # remove anything that's not a number, potential delimiter, or minus sign
     num = number.gsub(/[^\d|\.|,|\'|\s|\-]/, '').strip
-    
+
     # set a boolean flag for if the number is negative or not
     negative = num.split(//).first == "-"
-    
+
     # if negative, remove the minus sign from the number
     num = num.gsub(/^-/, '') if negative
-    
+
     # gather all separators within the result number
     used_separators = num.scan /[^\d]/
-    
+
     # determine the number of unique separators within the number
     #
     # e.g.
@@ -58,8 +58,8 @@ class String
     case used_separators.uniq.length
     # no separator or delimiter; major (dollars) is the number, and minor (cents) is 0
     when 0 then major, minor = num, 0
-    
-    # two separators, so we know the last item in this array is the 
+
+    # two separators, so we know the last item in this array is the
     # major/minor delimiter and the rest are separators
     when 2
       separator, delimiter = used_separators.uniq
@@ -75,10 +75,10 @@ class String
       # 1,000,000 - comma is a separator
       # 10000,00 - comma is a delimiter
       # 1000,000 - comma is a delimiter
-      
+
       # assign first separator for reusability
       separator = used_separators.first
-      
+
       # separator is used as a separator when there are multiple instances, always
       if num.scan(separator).length > 1 # multiple matches; treat as separator
         major, minor = num.gsub(separator, ''), 0
@@ -88,7 +88,7 @@ class String
         possible_major, possible_minor = num.split(separator)
         possible_major ||= "0"
         possible_minor ||= "00"
-        
+
         # if the minor (cents) length isn't 3, assign major/minor from the possibles
         # e.g.
         #   1,00 => 1.00
@@ -99,8 +99,8 @@ class String
         else
           # minor length is three
           # let's try to figure out intent of the delimiter
-          
-          # the major length is greater than three, which means 
+
+          # the major length is greater than three, which means
           # the comma or period is used as a delimiter
           # e.g.
           #   1000,000
@@ -121,7 +121,7 @@ class String
     else
       raise ArgumentError, "Invalid currency amount"
     end
-    
+
     # build the string based on major/minor since separator/delimiters have been removed
     # avoiding floating point arithmetic here to ensure accuracy
     cents = (major.to_i * 100)
@@ -136,9 +136,9 @@ class String
     if minor.size >= 3 && minor[2..2].to_i >= 5
       cents += 1
     end
-    
+
     # if negative, multiply by -1; otherwise, return positive cents
     negative ? cents * -1 : cents
   end
-  
+
 end

data/lib/money/currency.rb

@@ -265,7 +265,7 @@ class Money
       end
 
       # Wraps the object in a Currency unless it's a Currency.
-      # 
+      #
       #   Currency.wrap(nil)
       #   # => nil
       #   Currency.wrap(Currency.new(:usd))

data/lib/money/money.rb

@@ -15,11 +15,11 @@ class Money
     #
     #   bank1 = MyBank.new
     #   bank2 = MyOtherBank.new
-    #   
+    #
     #   Money.default_bank = bank1
     #   money1 = Money.new(10)
     #   money1.bank  # => bank1
-    #   
+    #
     #   Money.default_bank = bank2
     #   money2 = Money.new(10)
     #   money2.bank  # => bank2
@@ -33,17 +33,17 @@ class Money
     #   Money.us_dollar(100).exchange_to("CAD")  # => Money.ca_dollar(124)
     #   Money.ca_dollar(100).exchange_to("USD")  # => Money.us_dollar(80)
     attr_accessor :default_bank
-    
+
     # The default currency, which is used when <tt>Money.new</tt> is called
     # without an explicit currency argument. The default value is Currency.new("USD").
     # The value must be a valid <tt>Money::Currency</tt> instance.
     attr_accessor :default_currency
   end
-  
+
   self.default_bank = VariableExchangeBank.instance
   self.default_currency = Currency.new("USD")
-  
-  
+
+
   # Create a new money object with value 0.
   def self.empty(currency = default_currency)
     Money.new(0, currency)
@@ -58,22 +58,22 @@ class Money
   def self.us_dollar(cents)
     Money.new(cents, "USD")
   end
-  
+
   # Creates a new Money object of the given value, using the Euro currency.
   def self.euro(cents)
     Money.new(cents, "EUR")
   end
-  
+
   def self.add_rate(from_currency, to_currency, rate)
     Money.default_bank.add_rate(from_currency, to_currency, rate)
   end
-  
-  
-  # Creates a new money object. 
-  #  Money.new(100) 
-  # 
-  # Alternativly you can use the convinience methods like 
-  # Money.ca_dollar and Money.us_dollar 
+
+
+  # Creates a new money object.
+  #  Money.new(100)
+  #
+  # Alternatively you can use the convinience methods like
+  # Money.ca_dollar and Money.us_dollar
   def initialize(cents, currency = Money.default_currency, bank = Money.default_bank)
     @cents = cents.round
     if currency.is_a?(Hash)
@@ -101,7 +101,7 @@ class Money
       false
     end
   end
-  
+
   # Compares this money object against another object. +other_money+ must respond
   # to #to_money.
   #
@@ -161,12 +161,17 @@ class Money
       Money.new(cents / val, currency)
     end
   end
-  
+
   # Test if the money amount is zero
   def zero?
     cents == 0
   end
 
+  # Test if the money amount is non-zero. Returns this money object if it is
+  # non-zero, or nil otherwise, like <tt>Numeric#nonzero?</tt>.
+  def nonzero?
+    cents != 0 ? self : nil
+  end
 
   # Attempts to pick a symbol that's suitable for the given currency
   # looking up the Currency::TABLE hashtable.
@@ -201,58 +206,58 @@ class Money
   # Whether a zero amount of money should be formatted of "free" or as the
   # supplied string.
   #
-  #  Money.us_dollar(0).format(:display_free => true)      => "free"
-  #  Money.us_dollar(0).format(:display_free => "gratis")  => "gratis"
-  #  Money.us_dollar(0).format => "$0.00"
+  #   Money.us_dollar(0).format(:display_free => true)      => "free"
+  #   Money.us_dollar(0).format(:display_free => "gratis")  => "gratis"
+  #   Money.us_dollar(0).format => "$0.00"
   #
   # === +:with_currency+
   #
   # Whether the currency name should be appended to the result string.
   #
-  #  Money.ca_dollar(100).format => "$1.00"
-  #  Money.ca_dollar(100).format(:with_currency => true) => "$1.00 CAD"
-  #  Money.us_dollar(85).format(:with_currency => true)  => "$0.85 USD"
+  #   Money.ca_dollar(100).format => "$1.00"
+  #   Money.ca_dollar(100).format(:with_currency => true) => "$1.00 CAD"
+  #   Money.us_dollar(85).format(:with_currency => true)  => "$0.85 USD"
   #
   # === +:no_cents+
   #
   # Whether cents should be omitted.
   #
-  #  Money.ca_dollar(100).format(:no_cents => true) => "$1"
-  #  Money.ca_dollar(599).format(:no_cents => true) => "$5"
-  #  
-  #  Money.ca_dollar(570).format(:no_cents => true, :with_currency => true) => "$5 CAD"
-  #  Money.ca_dollar(39000).format(:no_cents => true) => "$390"
+  #   Money.ca_dollar(100).format(:no_cents => true) => "$1"
+  #   Money.ca_dollar(599).format(:no_cents => true) => "$5"
+  #
+  #   Money.ca_dollar(570).format(:no_cents => true, :with_currency => true) => "$5 CAD"
+  #   Money.ca_dollar(39000).format(:no_cents => true) => "$390"
   #
   # === +:symbol+
   #
   # Whether a money symbol should be prepended to the result string. The default is true.
   # This method attempts to pick a symbol that's suitable for the given currency.
   #
-  #  Money.new(100, "USD")  => "$1.00"
-  #  Money.new(100, "GBP")  => "£1.00"
-  #  Money.new(100, "EUR")  => "€1.00"
-  #  
-  #  # Same thing.
-  #  Money.new(100, "USD").format(:symbol => true)  => "$1.00"
-  #  Money.new(100, "GBP").format(:symbol => true)  => "£1.00"
-  #  Money.new(100, "EUR").format(:symbol => true)  => "€1.00"
+  #   Money.new(100, "USD")  => "$1.00"
+  #   Money.new(100, "GBP")  => "£1.00"
+  #   Money.new(100, "EUR")  => "€1.00"
+  #
+  #   # Same thing.
+  #   Money.new(100, "USD").format(:symbol => true)  => "$1.00"
+  #   Money.new(100, "GBP").format(:symbol => true)  => "£1.00"
+  #   Money.new(100, "EUR").format(:symbol => true)  => "€1.00"
   #
   # You can specify a false expression or an empty string to disable prepending
   # a money symbol:
   #
-  #  Money.new(100, "USD").format(:symbol => false)  => "1.00"
-  #  Money.new(100, "GBP").format(:symbol => nil)    => "1.00"
-  #  Money.new(100, "EUR").format(:symbol => "")     => "1.00"
+  #   Money.new(100, "USD").format(:symbol => false)  => "1.00"
+  #   Money.new(100, "GBP").format(:symbol => nil)    => "1.00"
+  #   Money.new(100, "EUR").format(:symbol => "")     => "1.00"
+  #
   #
-  #  
   # If the symbol for the given currency isn't known, then it will default
   # to "$" as symbol:
   #
-  #  Money.new(100, "AWG").format(:symbol => true)  => "$1.00"
+  #   Money.new(100, "AWG").format(:symbol => true)  => "$1.00"
   #
   # You can specify a string as value to enforce using a particular symbol:
   #
-  #  Money.new(100, "AWG").format(:symbol => "ƒ")   => "ƒ1.00"
+  #   Money.new(100, "AWG").format(:symbol => "ƒ")   => "ƒ1.00"
   #
   # === +:separator+
   #
@@ -260,42 +265,42 @@ class Money
   #
   # If a string is specified, it's value is used:
   #
-  #  Money.new(100, "USD").format(:separator => ",") => "$1,00"
+  #   Money.new(100, "USD").format(:separator => ",") => "$1,00"
   #
   # If the separator for a given currency isn't known, then it will default to
   # "." as separator:
   #
-  #  Money.new(100, "FOO").format => "$1.00"
+  #   Money.new(100, "FOO").format => "$1.00"
   #
   # === +:delimiter+
   #
   # Whether the currency should be delimited by the specified character or ','
   #
   # If false is specified, no delimiter is used:
-  # 
-  #  Money.new(100000, "USD").format(:delimiter => false) => "1000.00"
-  #  Money.new(100000, "USD").format(:delimiter => nil)   => "1000.00"
-  #  Money.new(100000, "USD").format(:delimiter => "")    => "1000.00"
+  #
+  #   Money.new(100000, "USD").format(:delimiter => false) => "1000.00"
+  #   Money.new(100000, "USD").format(:delimiter => nil)   => "1000.00"
+  #   Money.new(100000, "USD").format(:delimiter => "")    => "1000.00"
   #
   # If a string is specified, it's value is used:
   #
-  #  Money.new(100000, "USD").format(:delimiter => ".") => "$1.000.00"
+  #   Money.new(100000, "USD").format(:delimiter => ".") => "$1.000.00"
   #
   # If the delimiter for a given currency isn't known, then it will default to
   # "," as delimiter:
   #
-  #  Money.new(100000, "FOO").format => "$1,000.00"
+  #   Money.new(100000, "FOO").format => "$1,000.00"
   #
   # === +:html+
   #
   # Whether the currency should be HTML-formatted. Only useful in combination with +:with_currency+.
   #
-  #  Money.ca_dollar(570).format(:html => true, :with_currency => true)
-  #    =>  "$5.70 <span class=\"currency\">CAD</span>"
+  #   Money.ca_dollar(570).format(:html => true, :with_currency => true)
+  #   # =>  "$5.70 <span class=\"currency\">CAD</span>"
   def format(*rules)
     # support for old format parameters
     rules = normalize_formatting_rules(rules)
-    
+
     if cents == 0
       if rules[:display_free].respond_to?(:to_str)
         return rules[:display_free]
@@ -352,10 +357,11 @@ class Money
     end
     formatted
   end
-  
+
   # Returns the amount of money as a string.
   #
-  #  Money.ca_dollar(100).to_s => "1.00"
+  #   Money.ca_dollar(100).to_s => "1.00"
+  #
   def to_s
     sprintf("%.2f", cents / 100.00)
   end
@@ -365,12 +371,13 @@ class Money
   # need to represent currency or working with another system that requires
   # decimals.
   #
-  # Money.us_dollar(100).to_f => 1.0
+  #   Money.us_dollar(100).to_f => 1.0
+  #
   def to_f
     cents / 100.0
   end
 
-  # Recieve the amount of this money object in another Currency.
+  # Receive the amount of this money object in another Currency.
   # <tt>other_currency</tt> can be either a <tt>String</tt>
   # or a <tt>Currency</tt> instance.
   #
@@ -382,31 +389,31 @@ class Money
     Money.new(@bank.exchange(self.cents, currency, other_currency), other_currency)
   end
 
-  # Recieve a money object with the same amount as the current Money object
-  # in american dollar 
+  # Receive a money object with the same amount as the current Money object
+  # in american dollar
   def as_us_dollar
     exchange_to("USD")
   end
-  
-  # Recieve a money object with the same amount as the current Money object
-  # in canadian dollar 
+
+  # Receive a money object with the same amount as the current Money object
+  # in canadian dollar
   def as_ca_dollar
     exchange_to("CAD")
   end
-  
-  # Recieve a money object with the same amount as the current Money object
+
+  # Receive a money object with the same amount as the current Money object
   # in euro
   def as_euro
     exchange_to("EUR")
   end
-  
+
   # Conversation to self
   def to_money
     self
   end
-  
+
   private
-  
+
   def normalize_formatting_rules(rules)
     if rules.size == 1
       rules = rules.pop

data/lib/money/variable_exchange_bank.rb

@@ -9,14 +9,15 @@ require 'money/errors'
 # One must manually specify them with +add_rate+, after which one can perform
 # exchanges with +exchange+. For example:
 #
-#  bank = Money::VariableExchangeBank.new
-#  bank.add_rate("USD", "CAD", 1.24515)
-#  bank.add_rate("CAD", "USD", 0.803115)
-#  
-#  # Exchange 100 CAD to USD:
-#  bank.exchange(100_00, "CAD", "USD")  # => 124
-#  # Exchange 100 USD to CAD:
-#  bank.exchange(100_00, "USD", "CAD")  # => 80
+#   bank = Money::VariableExchangeBank.new
+#   bank.add_rate("USD", "CAD", 1.24515)
+#   bank.add_rate("CAD", "USD", 0.803115)
+#
+#   # Exchange 100 CAD to USD:
+#   bank.exchange(100_00, "CAD", "USD")  # => 124
+#   # Exchange 100 USD to CAD:
+#   bank.exchange(100_00, "USD", "CAD")  # => 80
+#
 class Money
   class VariableExchangeBank
     # Returns the singleton instance of VariableExchangeBank.
@@ -25,27 +26,27 @@ class Money
     def self.instance
       @@singleton
     end
-    
+
     def initialize
       @rates = {}
       @mutex = Mutex.new
     end
-    
+
     # Registers a conversion rate. +from+ and +to+ are both currency names.
     def add_rate(from, to, rate)
       @mutex.synchronize do
         @rates["#{from}_TO_#{to}".upcase] = rate
       end
     end
-    
+
     # Gets the rate for exchanging the currency named +from+ to the currency
     # named +to+. Returns nil if the rate is unknown.
     def get_rate(from, to)
       @mutex.synchronize do
-        @rates["#{from}_TO_#{to}".upcase] 
+        @rates["#{from}_TO_#{to}".upcase]
       end
     end
-    
+
     # Given two currency names, checks whether they're both the same currency.
     #
     #   bank = VariableExchangeBank.new
@@ -54,7 +55,7 @@ class Money
     def same_currency?(currency1, currency2)
       Currency.wrap(currency1) == Currency.wrap(currency2)
     end
-    
+
     # Exchange the given amount of cents in +from_currency+ to +to_currency+.
     # Returns the amount of cents in +to_currency+ as an integer, rounded down.
     #
@@ -66,7 +67,7 @@ class Money
       end
       (cents * rate).floor
     end
-    
+
     @@singleton = VariableExchangeBank.new
   end
 end

data/money.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{money}
-  s.version = "2.3.0"
+  s.version = "3.0.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Tobias Luetke", "Hongli Lai", "Jeremy McNevin", "Shane Emmons"]
-  s.date = %q{2010-04-16}
+  s.date = %q{2010-05-07}
   s.description = %q{Money and currency exchange support library.}
   s.email = %q{hongli@phusion.nl}
   s.extra_rdoc_files = [

data/test/currency_spec.rb

@@ -55,7 +55,7 @@ describe Money::Currency do
     with_custom_definitions do
       Money::Currency::TABLE[:usd] = { :priority =>   1, :iso_code => "USD", :name => "United States Dollar",                      :symbol => "$",             :subunit => "Cent",          :subunit_to_unit => "100"   }
       Money::Currency::TABLE[:eur] = { :priority =>   2, :iso_code => "EUR", :name => "Euro",                                      :symbol => "€",             :subunit => "Cent",          :subunit_to_unit => "100"   }
-  
+
       expected = Money::Currency.new(:eur)
       Money::Currency.find(:eur).should  == expected
       Money::Currency.find(:EUR).should  == expected
@@ -63,12 +63,12 @@ describe Money::Currency do
       Money::Currency.find("EUR").should == expected
     end
   end
-  
+
   specify "#self.find should return nil unless currency matching given id" do
     with_custom_definitions do
       Money::Currency::TABLE[:usd] = { :position =>   1, :iso_code => "USD", :name => "United States Dollar",                      :symbol => "$",             :subunit => "Cent",          :subunit_to_unit => "100"   }
       Money::Currency::TABLE[:eur] = { :position =>   2, :iso_code => "EUR", :name => "Euro",                                      :symbol => "€",             :subunit => "Cent",          :subunit_to_unit => "100"   }
-  
+
       expected = Money::Currency.new(:eur)
       Money::Currency.find(:eur).should  == expected
       Money::Currency.find(:EUR).should  == expected

data/test/exchange_bank_spec.rb

@@ -5,14 +5,14 @@ describe Money::VariableExchangeBank do
   before :each do
     @bank = Money::VariableExchangeBank.new
   end
-  
+
   it "returns the previously specified conversion rate" do
     @bank.add_rate("USD", "EUR", 0.788332676)
     @bank.add_rate("EUR", "YEN", 122.631477)
     @bank.get_rate("USD", "EUR").should == 0.788332676
     @bank.get_rate("EUR", "YEN").should == 122.631477
   end
-  
+
   it "treats currency names case-insensitively" do
     @bank.add_rate("usd", "eur", 1)
     @bank.get_rate("USD", "EUR").should == 1
@@ -23,21 +23,21 @@ describe Money::VariableExchangeBank do
   it "returns nil if the conversion rate is unknown" do
     @bank.get_rate("American Pesos", "EUR").should be_nil
   end
-  
+
   it "exchanges money from one currency to another according to the specified conversion rates" do
     @bank.add_rate("USD", "EUR", 0.5)
     @bank.add_rate("EUR", "YEN", 10)
     @bank.exchange(10_00, "USD", "EUR").should == 5_00
     @bank.exchange(500_00, "EUR", "YEN").should == 5000_00
   end
-  
+
   it "rounds the exchanged result down" do
     @bank.add_rate("USD", "EUR", 0.788332676)
     @bank.add_rate("EUR", "YEN", 122.631477)
     @bank.exchange(10_00, "USD", "EUR").should == 788
     @bank.exchange(500_00, "EUR", "YEN").should == 6131573
   end
-  
+
   it "raises Money::UnknownRate upon conversion if the conversion rate is unknown" do
     block = lambda { @bank.exchange(10, "USD", "EUR") }
     block.should raise_error(Money::UnknownRate)

data/test/money_spec.rb

@@ -7,11 +7,11 @@ describe Money do
   it "is associated to the singleton instance of VariableExchangeBank by default" do
     Money.new(0).bank.object_id.should == Money::VariableExchangeBank.instance.object_id
   end
-  
+
   specify "#cents returns the amount of cents passed to the constructor" do
     Money.new(200_00, "USD").cents.should == 200_00
   end
-  
+
   it "rounds the given cents to an integer" do
     Money.new(1.00, "USD").cents.should == 1
     Money.new(1.01, "USD").cents.should == 1
@@ -21,7 +21,7 @@ describe Money do
   specify "#currency returns the currency passed to the constructor" do
     Money.new(200_00, "USD").currency.should == Money::Currency.new("USD")
   end
-  
+
   specify "#zero? returns whether the amount is 0" do
     Money.new(0, "USD").should be_zero
     Money.new(0, "EUR").should be_zero
@@ -29,56 +29,71 @@ describe Money do
     Money.new(10, "YEN").should_not be_zero
     Money.new(-1, "EUR").should_not be_zero
   end
-  
+
+  specify "#nonzero? returns whether the amount is not 0" do
+    Money.new(0, "USD").should_not be_nonzero
+    Money.new(0, "EUR").should_not be_nonzero
+    Money.new(1, "USD").should be_nonzero
+    Money.new(10, "YEN").should be_nonzero
+    Money.new(-1, "EUR").should be_nonzero
+  end
+
+  specify "#nonzero? has the same return-value semantics as Numeric#nonzero?" do
+    Money.new(0, "USD").nonzero?.should be_nil
+
+    money = Money.new(1, "USD")
+    money.nonzero?.should be_equal(money)
+  end
+
   specify "#exchange_to exchanges the amount via its exchange bank" do
     money = Money.new(100_00, "USD")
     money.bank.should_receive(:exchange).with(100_00, Money::Currency.new("USD"), Money::Currency.new("EUR")).and_return(200_00)
     money.exchange_to("EUR")
   end
-  
+
   specify "#exchange_to exchanges the amount properly" do
     money = Money.new(100_00, "USD")
     money.bank.should_receive(:exchange).with(100_00, Money::Currency.new("USD"), Money::Currency.new("EUR")).and_return(200_00)
     money.exchange_to("EUR").should == Money.new(200_00, "EUR")
   end
-  
+
   specify "#== returns true if and only if their amount and currency are equal" do
     Money.new(1_00, "USD").should == Money.new(1_00, "USD")
     Money.new(1_00, "USD").should_not == Money.new(1_00, "EUR")
     Money.new(1_00, "USD").should_not == Money.new(2_00, "USD")
     Money.new(1_00, "USD").should_not == Money.new(99_00, "EUR")
   end
-  
+
   specify "#== can be used to compare with a String money value" do
     Money.new(1_00, "USD").should == "1.00"
     Money.new(1_00, "USD").should_not == "2.00"
     Money.new(1_00, "GBP").should_not == "1.00"
   end
-  
+
   specify "#== can be used to compare with a Numeric money value" do
     Money.new(1_00, "USD").should == 1
     Money.new(1_57, "USD").should == 1.57
     Money.new(1_00, "USD").should_not == 2
     Money.new(1_00, "GBP").should_not == 1
   end
-  
+
   specify "#== can be used to compare with an object that responds to #to_money" do
     klass = Class.new do
       def initialize(money)
         @money = money
       end
-      
+
       def to_money
         @money
       end
     end
-    
+
     Money.new(1_00, "USD").should == klass.new(Money.new(1_00, "USD"))
     Money.new(2_50, "USD").should == klass.new(Money.new(2_50, "USD"))
     Money.new(2_50, "USD").should_not == klass.new(Money.new(3_00, "USD"))
     Money.new(1_00, "GBP").should_not == klass.new(Money.new(1_00, "USD"))
   end
-  
+
   specify "#== returns false if used to compare with an object that doesn't respond to #to_money" do
     Money.new(1_00, "USD").should_not == Object.new
     Money.new(1_00, "USD").should_not == Class
@@ -86,35 +101,35 @@ describe Money do
     Money.new(1_00, "USD").should_not == /foo/
     Money.new(1_00, "USD").should_not == nil
   end
-  
+
   specify "#<=> can be used to compare with a String money value" do
     (Money.new(1_00) <=> "1.00").should == 0
     (Money.new(1_00) <=> ".99").should > 0
     (Money.new(1_00) <=> "2.00").should < 0
   end
-  
+
   specify "#<=> can be used to compare with a Numeric money value" do
     (Money.new(1_00) <=> 1).should == 0
     (Money.new(1_00) <=> 0.99).should > 0
     (Money.new(1_00) <=> 2.00).should < 0
   end
-  
+
   specify "#<=> can be used to compare with an object that responds to #to_money" do
     klass = Class.new do
       def initialize(money)
         @money = money
       end
-      
+
       def to_money
         @money
       end
     end
-    
+
     (Money.new(1_00) <=> klass.new(Money.new(1_00))).should == 0
     (Money.new(1_00) <=> klass.new(Money.new(99))).should > 0
     (Money.new(1_00) <=> klass.new(Money.new(2_00))).should < 0
   end
-  
+
   specify "#<=> raises ArgumentError when used to compare with an object that doesn't respond to #to_money" do
     expected_message = /comparison .+ failed/
     lambda{ Money.new(1_00) <=> Object.new }.should raise_error(ArgumentError, expected_message)
@@ -122,39 +137,39 @@ describe Money do
     lambda{ Money.new(1_00) <=> Kernel }.should raise_error(ArgumentError, expected_message)
     lambda{ Money.new(1_00) <=> /foo/ }.should raise_error(ArgumentError, expected_message)
   end
-  
+
   specify "#* multiplies the money's amount by the multiplier while retaining the currency" do
     (Money.new(1_00, "USD") * 10).should == Money.new(10_00, "USD")
   end
-  
+
   specify "#/ divides the money's amount by the divisor while retaining the currency" do
     (Money.new(10_00, "USD") / 10).should == Money.new(1_00, "USD")
   end
-  
+
   specify "Money.empty creates a new Money object of 0 cents" do
     Money.empty.should == Money.new(0)
   end
-  
+
   specify "Money.ca_dollar creates a new Money object of the given value in CAD" do
     Money.ca_dollar(50).should == Money.new(50, "CAD")
   end
-  
+
   specify "Money.ca_dollar creates a new Money object of the given value in USD" do
     Money.us_dollar(50).should == Money.new(50, "USD")
   end
-  
+
   specify "Money.ca_dollar creates a new Money object of the given value in EUR" do
     Money.euro(50).should == Money.new(50, "EUR")
   end
-  
+
   specify "Money.new accepts { :currency => 'foo' } as the value for the 'currency' argument" do
     money = Money.new(20, :currency => "EUR")
     money.currency.should == Money::Currency.new("EUR")
-    
+
     money = Money.new(20, :currency => nil)
     money.currency.should == Money.default_currency
   end
-  
+
   specify "Money.add_rate works" do
     Money.add_rate("EUR", "USD", 10)
     Money.new(10_00, "EUR").exchange_to("USD").should == Money.new(100_00, "USD")
@@ -167,7 +182,7 @@ describe Money do
   specify "Money.to_f works" do
     Money.new(10_00).to_f.should == 10.0
   end
-  
+
   describe "#format" do
     it "returns the monetary value as a string" do
       Money.ca_dollar(100).format.should == "$1.00"
@@ -180,50 +195,50 @@ describe Money do
 
       # Pounds
       one_thousand["GBP"].should == "£1,000.00"
-      
+
       # Dollars
       one_thousand["USD"].should == "$1,000.00"
       one_thousand["CAD"].should == "$1,000.00"
       one_thousand["AUD"].should == "$1,000.00"
       one_thousand["NZD"].should == "$1,000.00"
       one_thousand["ZWD"].should == "$1,000.00"
-      
+
       # Yen
-      one_thousand["JPY"].should == "¥1,000.00"      
-      one_thousand["CNY"].should == "¥1,000.00"      
-      
+      one_thousand["JPY"].should == "¥1,000.00"
+      one_thousand["CNY"].should == "¥1,000.00"
+
       # Euro
       one_thousand["EUR"].should == "€1,000.00"
-      
+
       # Rupees
       one_thousand["INR"].should == "₨1,000.00"
       one_thousand["NPR"].should == "₨1,000.00"
       one_thousand["SCR"].should == "₨1,000.00"
       one_thousand["LKR"].should == "₨1,000.00"
-      
+
       # Brazilian Real
       one_thousand["BRL"].should == "R$ 1.000,00"
-      
+
       # Other
       one_thousand["SEK"].should == "kr1,000.00"
       one_thousand["GHC"].should == "₵1,000.00"
     end
-    
+
     describe "if the monetary value is 0" do
       before :each do
         @money = Money.us_dollar(0)
       end
-      
+
       it "returns 'free' when :display_free is true" do
         @money.format(:display_free => true).should == 'free'
       end
-    
+
       it "returns '$0.00' when :display_free is false or not given" do
         @money.format.should == '$0.00'
         @money.format(:display_free => false).should == '$0.00'
         @money.format(:display_free => nil).should == '$0.00'
       end
-      
+
       it "returns the value specified by :display_free if it's a string-like object" do
         @money.format(:display_free => 'gratis').should == 'gratis'
       end
@@ -255,7 +270,7 @@ describe Money do
         end
       end
     end
-    
+
     specify "#separator works as documented" do
       begin
         old = Money::SEPARATORS.dup
@@ -277,12 +292,12 @@ describe Money do
       Money.us_dollar(85).format(:with_currency => true).should == "$0.85 USD"
       Money.us_dollar(85).format(:with_currency).should == "$0.85 USD"
     end
-    
+
     specify "#format(:with_currency) works as documented" do
       Money.ca_dollar(100).format(:with_currency).should == "$1.00 CAD"
       Money.us_dollar(85).format(:with_currency).should == "$0.85 USD"
     end
-    
+
     specify "#format(:no_cents => true) works as documented" do
       Money.ca_dollar(100).format(:no_cents => true).should == "$1"
       Money.ca_dollar(599).format(:no_cents => true).should == "$5"
@@ -296,11 +311,11 @@ describe Money do
       Money.ca_dollar(570).format(:no_cents, :with_currency).should == "$5 CAD"
       Money.ca_dollar(39000).format(:no_cents).should == "$390"
     end
-    
+
     specify "#format(:symbol => a symbol string) uses the given value as the money symbol" do
       Money.new(100, "GBP").format(:symbol => "£").should == "£1.00"
     end
-    
+
     specify "#format(:symbol => true) returns symbol based on the given currency code" do
       one = Proc.new do |currency|
         Money.new(100, currency).format(:symbol => true)
@@ -308,61 +323,61 @@ describe Money do
 
       # Pounds
       one["GBP"].should == "£1.00"
-      
+
       # Dollars
       one["USD"].should == "$1.00"
       one["CAD"].should == "$1.00"
       one["AUD"].should == "$1.00"
       one["NZD"].should == "$1.00"
       one["ZWD"].should == "$1.00"
-      
+
       # Yen
-      one["JPY"].should == "¥1.00"      
-      one["CNY"].should == "¥1.00"      
-      
+      one["JPY"].should == "¥1.00"
+      one["CNY"].should == "¥1.00"
+
       # Euro
       one["EUR"].should == "€1.00"
-      
+
       # Rupees
       one["INR"].should == "₨1.00"
       one["NPR"].should == "₨1.00"
       one["SCR"].should == "₨1.00"
       one["LKR"].should == "₨1.00"
-      
+
       # Brazilian Real
       one["BRL"].should == "R$ 1,00"
-      
+
       # Other
       one["SEK"].should == "kr1.00"
       one["GHC"].should == "₵1.00"
     end
-    
+
     specify "#format(:symbol => true) returns $ when currency code is not recognized" do
       currency = Money::Currency.new("EUR")
       currency.should_receive(:symbol).and_return(nil)
       Money.new(100, currency).format(:symbol => true).should == "$1.00"
     end
-    
+
     specify "#format(:symbol => some non-Boolean value that evaluates to true) returs symbol based on the given currency code" do
       Money.new(100, "GBP").format(:symbol => true).should == "£1.00"
       Money.new(100, "EUR").format(:symbol => true).should == "€1.00"
       Money.new(100, "SEK").format(:symbol => true).should == "kr1.00"
     end
-    
+
     specify "#format with :symbol == "", nil or false returns the amount without a symbol" do
       money = Money.new(100, "GBP")
       money.format(:symbol => "").should == "1.00"
       money.format(:symbol => nil).should == "1.00"
       money.format(:symbol => false).should == "1.00"
     end
-    
+
     specify "#format without :symbol assumes that :symbol is set to true" do
       money = Money.new(100)
       money.format.should == "$1.00"
-      
+
       money = Money.new(100, "GBP")
       money.format.should == "£1.00"
-      
+
       money = Money.new(100, "EUR")
       money.format.should == "€1.00"
     end
@@ -388,12 +403,12 @@ describe Money do
     specify "#format will default delimiter to ',' if currency isn't recognized" do
       Money.new(100000, "ZWD").format.should == "$1,000.00"
     end
-    
+
     specify "#format(:html => true) works as documented" do
       string = Money.ca_dollar(570).format(:html => true, :with_currency => true)
       string.should == "$5.70 <span class=\"currency\">CAD</span>"
     end
-    
+
     it "should insert commas into the result if the amount is sufficiently large" do
       Money.us_dollar(1_000_000_000_12).format.should == "$1,000,000,000.12"
       Money.us_dollar(1_000_000_000_12).format(:no_cents => true).should == "$1,000,000,000"
@@ -424,11 +439,11 @@ describe "Actions involving two Money objects" do
       (Money.new(1_00, "USD") <=> Money.new(99, "USD")).should > 0
       (Money.new(1_00, "USD") <=> Money.new(2_00, "USD")).should < 0
     end
-    
+
     specify "#+ adds the other object's amount to the current object's amount while retaining the currency" do
       (Money.new(10_00, "USD") + Money.new(90, "USD")).should == Money.new(10_90, "USD")
     end
-    
+
     specify "#- substracts the other object's amount from the current object's amount while retaining the currency" do
       (Money.new(10_00, "USD") - Money.new(90, "USD")).should == Money.new(9_10, "USD")
     end
@@ -437,28 +452,28 @@ describe "Actions involving two Money objects" do
       (Money.new(10_00, "USD") / Money.new(100_00, "USD")).should == 0.1
     end
   end
-  
+
   describe "if the other Money object has a different currency" do
     specify "#<=> compares the two objects' amount after converting the other object's amount to its own currency" do
       target = Money.new(200_00, "EUR")
       target.should_receive(:exchange_to).with(Money::Currency.new("USD")).and_return(Money.new(300_00, "USD"))
       (Money.new(100_00, "USD") <=> target).should < 0
-      
+
       target = Money.new(200_00, "EUR")
       target.should_receive(:exchange_to).with(Money::Currency.new("USD")).and_return(Money.new(100_00, "USD"))
       (Money.new(100_00, "USD") <=> target).should == 0
-      
+
       target = Money.new(200_00, "EUR")
       target.should_receive(:exchange_to).with(Money::Currency.new("USD")).and_return(Money.new(99_00, "USD"))
       (Money.new(100_00, "USD") <=> target).should > 0
     end
-    
+
     specify "#+ adds the other object's amount, converted to this object's currency, to this object's amount while retaining its currency" do
       other = Money.new(90, "EUR")
       other.should_receive(:exchange_to).with(Money::Currency.new("USD")).and_return(Money.new(9_00, "USD"))
       (Money.new(10_00, "USD") + other).should == Money.new(19_00, "USD")
     end
-    
+
     specify "#- substracts the other object's amount, converted to this object's currency, from this object's amount while retaining its currency" do
       other = Money.new(90, "EUR")
       other.should_receive(:exchange_to).with(Money::Currency.new("USD")).and_return(Money.new(9_00, "USD"))

metadata

@@ -3,10 +3,10 @@ name: money
 version: !ruby/object:Gem::Version 
   prerelease: false
   segments: 
-  - 2
   - 3
   - 0
-  version: 2.3.0
+  - 0
+  version: 3.0.0
 platform: ruby
 authors: 
 - Tobias Luetke
@@ -17,7 +17,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-16 00:00:00 -04:00
+date: 2010-05-07 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency