Empact-money 2.3.6

data/lib/money/errors.rb

@@ -0,0 +1,4 @@
+class Money
+  class UnknownRate < StandardError
+  end
+end

data/lib/money/exchange_bank.rb

@@ -0,0 +1,116 @@
+require 'money/errors'
+require 'net/http'
+require 'rubygems'
+begin
+  require "nokogiri"
+  Parser = Nokogiri
+rescue
+  require "hpricot"
+  Parser = Hpricot
+end
+# Class for aiding in exchanging money between different currencies.
+# By default, the Money class uses an object of this class (accessible through
+# Money#bank) for performing currency exchanges.
+#
+# By default, ExchangeBank has no knowledge about conversion rates.
+# One must manually specify them with +add_rate+, after which one can perform
+# exchanges with +exchange+. For example:
+#
+#  bank = Money::ExchangeBank.new
+#  bank.add_rate("CAD", 0.803115)
+#  bank.add_rate("USD", 1.24515)
+#
+#  # Exchange 100 CAD to USD:
+#  bank.exchange(100_00, "CAD", "USD")  # => 15504
+#  # Exchange 100 USD to CAD:
+#  bank.exchange(100_00, "USD", "CAD")  # => 6450
+class Money
+  class ExchangeBank
+    # Returns the singleton instance of ExchangeBank.
+    #
+    # By default, <tt>Money.default_bank</tt> returns the same object.
+    def self.instance
+      @@singleton
+    end
+
+    def initialize
+      @rates = {}
+      @mutex = Mutex.new
+    end
+
+    def add_rate(*params)
+      if rate = params.delete_at(2)
+        parse_rate(rate, *params)
+      else
+        parse_rate(params[1], Money.default_currency, params[0])
+      end
+    end
+
+    def parse_rate(rate,from,to)
+      return if from.upcase == to.upcase
+      @mutex.synchronize do
+        @rates["#{from}<>#{to}".upcase] = rate
+        @rates["#{to}<>#{from}".upcase] = 1.0/rate
+      end
+    end
+
+    def get_rate(from, to = nil)
+      from, to = Money.default_currency, from unless to
+      @mutex.synchronize do
+        @rates["#{from}<>#{to}".upcase]
+      end
+    end
+
+    # Given two currency names, checks whether they're both the same currency.
+    #
+    #   bank = ExchangeBank.new
+    #   bank.same_currency?("usd", "USD")   # => true
+    #   bank.same_currency?("usd", "EUR")   # => false
+    def same_currency?(currency1, currency2)
+      currency1.upcase == currency2.upcase
+    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.
+    #
+    # If the conversion rate is unknown, then Money::UnknownRate will be raised.
+    def exchange(cents, from_currency, to_currency)
+      rate = get_rate(from_currency, to_currency)
+      if !rate
+        raise Money::UnknownRate, "No conversion rate known for '#{from_currency}' -> '#{to_currency}'"
+      end
+      (cents * rate).floor
+    end
+
+    # Fetch rates
+    def fetch_rates
+      xml = Parser::XML(Net::HTTP.get(URI.parse('http://www.ecb.int/stats/eurofxref/eurofxref-daily.xml')))
+      curr = (xml/:Cube).select { |r| r["currency"] == Money.default_currency }.first
+      diff = Money.default_currency == "EUR" || !curr ? 1 : curr["rate"].to_f
+      (xml/:Cube).each do |x|
+        parse_rate x['rate'].to_f / diff, curr ? Money.default_currency : "EUR", x['currency'].upcase if x['currency']
+      end
+      parse_rate diff, Money.default_currency, "EUR" if curr
+      self
+    end
+
+    # Auto fetch the currencies every X seconds
+    # if no time is give, will fetch every hour
+    def auto_fetch(time = 60*60)
+      @auto_fetch.kill if (@auto_fetch && @auto_fetch.alive?)
+      @auto_fetch = Thread.new {
+        loop do
+          self.fetch_rates
+          sleep time
+        end
+      }
+    end
+
+    # stop auto fetch
+    def stop_fetch
+      @auto_fetch.kill if (@auto_fetch && @auto_fetch.alive?)
+    end
+
+    @@singleton = ExchangeBank.new
+  end
+end

data/lib/money/money.rb

@@ -0,0 +1,344 @@
+# -*- coding: utf-8 -*-
+require 'money/exchange_bank'
+
+# Represents an amount of money in a certain currency.
+class Money
+  include Comparable
+  attr_reader :cents, :currency, :bank
+  alias :to_i :cents
+
+  class << self
+    # Each Money object is associated to a bank object, which is responsible
+    # for currency exchange. This property allows one to specify the default
+    # bank object.
+    #
+    #   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
+    #   money1.bank  # => bank1
+    #
+    # The default value for this property is an instance if VariableExchangeBank.
+    # It allows one to specify custom exchange rates:
+    #
+    #   Money.default_bank.add_rate("USD", "CAD", 1.24515)
+    #   Money.default_bank.add_rate("CAD", "USD", 0.803115)
+    #   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 "USD".
+    attr_accessor :default_currency
+  end
+
+  self.default_bank = ExchangeBank.instance
+  self.default_currency = "USD"
+
+  CURRENCIES = {
+    "USD" => { :delimiter => ",", :separator => ".", :symbol => "$" },
+    "CAD" => { :delimiter => ",", :separator => ".", :symbol => "$" },
+    "HKD" => { :delimiter => ",", :separator => ".", :symbol => "$" },
+    "SGD" => { :delimiter => ",", :separator => ".", :symbol => "$" },
+    "BRL" => { :delimiter => ".", :separator => ",", :symbol => "R$" },
+    "EUR" => { :delimiter => ",", :separator => ".", :symbol => '€', :html => '&euro;' },
+    "GBP" => { :delimiter => ",", :separator => ".", :symbol => '£', :html => '&pound;' },
+    "JPY" => { :delimiter => ".", :separator => ".", :symbol => '¥', :html => '&yen;' },
+  }
+
+  # Create a new money object with value 0.
+  def self.empty(currency = default_currency)
+    Money.new(0, currency)
+  end
+
+  # Creates a new Money object of the given value, using the Canadian dollar currency.
+  def self.ca_dollar(cents)
+    Money.new(cents, "CAD")
+  end
+
+  # Creates a new Money object of the given value, using the American dollar currency.
+  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
+
+  # Creates a new Money object of the given value, using the Brazilian Real currency.
+  def self.real(cents)
+    Money.new(cents, "BRL")
+  end
+
+  def self.add_rate(*params)
+    Money.default_bank.add_rate(*params)
+  end
+
+  # Creates a new money object.
+  #  Money.new(100)
+  #
+  # Alternativly you can use the convinience methods like
+  # Money.ca_dollar and Money.us_dollar
+  def initialize(cents, currency = nil, bank = nil)
+    @cents = cents.to_i
+    @currency = (currency || Money.default_currency).upcase
+    @bank = bank || Money.default_bank
+  end
+
+  # Do two money objects equal? Only works if both objects are of the same currency
+  def ==(other_money)
+    other_money.respond_to?(:cents) && cents == other_money.cents &&
+      other_money.respond_to?(:currency) && bank.same_currency?(currency, other_money.currency)
+  end
+
+  def <=>(other_money)
+    if bank.same_currency?(currency, other_money.currency)
+      cents <=> other_money.cents
+    else
+      cents <=> other_money.exchange_to(currency).cents
+    end
+  end
+
+  def +(other_money)
+    other_money = Money.new(other_money) unless other_money.is_a? Money
+    if currency == other_money.currency
+      Money.new(cents + other_money.cents, other_money.currency)
+    else
+      Money.new(cents + other_money.exchange_to(currency).cents,currency)
+    end
+  end
+
+  def -(other_money)
+    other_money = Money.new(other_money) unless other_money.is_a? Money
+    if currency == other_money.currency
+      Money.new(cents - other_money.cents, other_money.currency)
+    else
+      Money.new(cents - other_money.exchange_to(currency).cents, currency)
+    end
+  end
+
+  # multiply money by fixnum
+  def *(fixnum)
+    Money.new(cents * fixnum, currency)
+  end
+
+  # divide money by fixnum
+  # check out split_in_installments method too
+  def /(fixnum)
+    Money.new(cents / fixnum, currency)
+  end
+
+  def %(fixnum)
+    Money.new(cents % fixnum, currency)
+  end
+
+  # Test if the money amount is zero
+  def zero?
+    cents == 0
+  end
+
+  # Calculates compound interest
+  # Returns a money object with the sum of self + it
+  def compound_interest(rate, count = 1, period = 12)
+    Money.new(cents * ((1 + rate / 100.0 / period) ** count - 1))
+  end
+
+  # Calculate self + simple interest
+  def simple_interest(rate, count = 1, period = 12)
+    Money.new(rate / 100 / period * cents * count)
+  end
+
+  # Round to nearest coin value
+  # basically, we don't have coins for cents in CZK,
+  # our smallest fraction is 0.50CZK
+  #
+  #    Money.new(14_58).round_to_coin(50) => 14.50
+  #
+  def round_to_coin(coin)
+    coef = 1.0/coin
+    val = (cents * coef).floor / coef
+    Money.new(val, currency)
+  end
+
+  # Returns array a where
+  #  a[0] is price _after_ applying tax (tax base)
+  #  a[1] is tax
+  def tax_breakdown(tax)
+    _tax = (cents * (tax / 100.0)).round
+    [Money.new(cents + _tax, currency), Money.new(_tax, currency)]
+  end
+
+  #Returns array a where
+  # a[0] is price _before_ applying tax (tax base)
+  # a[1] is tax
+  def tax_reverse_breakdown(tax)
+    coef = tax/100.0
+    [Money.new((cents / (1+coef)).round, currency),
+     Money.new((cents*coef/(1+coef)).round, currency) ]
+  end
+
+  # Just a helper if you got tax inputs in percentage.
+  # Ie. add_tax(20) =>  cents * 1.20
+  def add_tax(tax)
+    tax_breakdown(tax)[0]
+  end
+
+  # Split money in number of installments
+  #
+  # Money.new(10_00).split_in_installments(3)
+  # => [ 3.34, 3.33, 3.33 ]  (All Money instances)
+  #
+  def split_in_installments(fixnum, order=false)
+    wallet = Wallet.new(fixnum, Money.new(cents/fixnum,currency))
+    to_add = cents % fixnum
+    to_add.times { |m| wallet[m] += Money.new(1) }
+    wallet.reverse! if order
+    wallet
+  end
+
+  # Split money in installments based on payment value
+  #
+  # Money.new(1000_00).split_in_installments(Money.new(300_00))
+  # => [ 334_00, 333_00, 333_00 ]  (All Money instances)
+  #
+  def in_installments_of(other_money, order=false)
+    split_in_installments(cents/other_money.cents, order)
+  end
+
+  # Format the price according to several rules
+  # Currently supported are :with_currency, :no_cents, :symbol and :html
+  #
+  # with_currency:
+  #
+  #  Money.ca_dollar(0).format => "free"
+  #  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:
+  #
+  #  Money.ca_dollar(100).format(:no_cents) => "$1"
+  #  Money.ca_dollar(599).format(:no_cents) => "$5"
+  #
+  #  Money.ca_dollar(570).format(:no_cents, :with_currency) => "$5 CAD"
+  #  Money.ca_dollar(39000).format(:no_cents) => "$390"
+  #
+  # symbol:
+  #
+  #  Money.new(100, :currency => "GBP").format(:symbol => "£") => "£1.00"
+  #
+  # html:
+  #
+  #  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]
+      elsif rules[:display_free]
+        return "free"
+      end
+    end
+
+    if rules.has_key?(:symbol)
+      if rules[:symbol]
+        symbol = rules[:symbol]
+      else
+        symbol = ""
+      end
+    else
+      symbol = (CURRENCIES[currency] ? CURRENCIES[currency][:symbol] : "$")
+    end
+    self.currency
+
+    delimiter = (CURRENCIES[currency] ? CURRENCIES[currency][:delimiter] : "," )
+    separator = (CURRENCIES[currency] ? CURRENCIES[currency][:separator] : "." )
+
+    if rules[:no_cents]
+      formatted = sprintf("#{symbol}%d", cents.to_f / 100)
+      formatted.gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{delimiter}")
+    else
+      formatted = sprintf("#{symbol}%.2f", cents.to_f / 100).split('.')
+      formatted[0].gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{delimiter}")
+      formatted = formatted.join(separator)
+    end
+
+    # Commify ("10000" => "10,000")
+    formatted.gsub!(/(\d)(?=\d{3}+(?:\.|$))(\d{3}\..*)?/,'\1,\2')
+
+    if rules[:with_currency]
+      formatted << " "
+      formatted << '<span class="currency">' if rules[:html]
+      formatted << currency
+      formatted << '</span>' if rules[:html]
+    end
+    formatted.gsub!(symbol,CURRENCIES[currency][:html]) if rules[:html]
+    formatted
+   end
+
+   def normalize_formatting_rules(rules)
+    if rules.size == 1
+      rules = rules.pop
+      rules = { rules => true } if rules.is_a?(Symbol)
+    else
+      rules = rules.inject({}) do |h,s|
+        h[s] = true
+        h
+      end
+    end
+    rules
+  end
+
+  # Money.ca_dollar(100).to_s => "1.00"
+  def to_s
+    sprintf("%.2f", cents / 100.0)
+  end
+
+  # Money.ca_dollar(100).to_f => "1.0"
+  def to_f
+    cents / 100.0
+  end
+
+  # Recieve the amount of this money object in another currency.
+  def exchange_to(other_currency)
+    Money.new(@bank.exchange(self.cents, currency, other_currency), other_currency)
+  end
+
+  # Conversation to self
+  def to_money
+    self
+  end
+
+  def method_missing(m,*x)
+    if m.to_s =~ /^as/
+      exchange_to(m.to_s.split("_").last.upcase)
+    else
+      super
+    end
+  end
+end
+
+#
+# Represent a financial array.
+# Investment/Time/Installments...TODO...
+#
+class Wallet < Array
+
+  def to_s
+    map &:to_s
+  end
+
+  def sum
+    Money.new(inject(0){ |sum,m| sum + m.cents })
+  end
+
+end