acvwilson-acvwilson-currency 0.5.0

data/lib/currency/config.rb

@@ -0,0 +1,91 @@
+# Copyright (C) 2006-2007 Kurt Stephens <ruby-currency(at)umleta.com>
+# See LICENSE.txt for details.
+
+# The Currency::Config class is responsible for
+# maintaining global configuration for the Currency package.
+#
+# TO DO:
+# 
+# Migrate all class variable configurations to this object.
+class Currency::Config
+  @@default = nil
+
+  # Returns the default Currency::Config object.
+  #
+  # If one is not specfied an instance is
+  # created.  This is a global, not thread-local.
+  def self.default 
+    @@default ||= 
+      self.new
+  end
+  
+  # Sets the default Currency::Config object.
+  def self.default=(x)
+    @@default = x
+  end
+  
+  # Returns the current Currency::Config object used during
+  # in the current thread.
+  #
+  # If #current= has not been called and #default= has not been called,
+  # then UndefinedExchange is raised.
+  def self.current
+    Thread.current[:Currency__Config] ||= 
+      self.default || 
+      (raise ::Currency::Exception::UndefinedConfig, "Currency::Config.default not defined")
+  end
+  
+  # Sets the current Currency::Config object used
+  # in the current thread.
+  def self.current=(x)
+    Thread.current[:Currency__Config] = x
+  end
+
+  # Clones the current configuration and makes it current
+  # during the execution of a block.  After block completes,
+  # the previous configuration is restored.
+  #
+  #   Currency::Config.configure do | c |
+  #     c.float_ref_filter = Proc.new { | x | x.round }
+  #     "123.448".money.rep == 12345
+  #   end
+  def self.configure(&blk)
+    c_prev = current
+    c_new = self.current = current.clone
+    result = nil
+    begin
+      result = yield c_new
+    ensure
+      self.current = c_prev
+    end
+    result
+  end
+
+  
+  @@identity = Proc.new { |x| x } # :nodoc:
+  
+  # Returns the current Float conversion filter.
+  # Can be used to set rounding or truncation policies when converting
+  # Float values to Money values.
+  # Defaults to an identity function.
+  # See Float#Money_rep.
+  def float_ref_filter
+    @float_ref_filter ||= 
+      @@identity
+  end
+  
+  # Sets the current Float conversion filter.
+  def float_ref_filter=(x)
+    @float_ref_filter = x
+  end
+
+  
+  # Defines the table name for Historical::Rate records.
+  # Defaults to 'currency_historical_rates'.
+  attr_accessor :historical_table_name
+  def historical_table_name
+    @historical_table_name ||= 'currency_historical_rates'
+  end
+
+end # module
+

data/lib/currency/core_extensions.rb

@@ -0,0 +1,48 @@
+# Copyright (C) 2006-2007 Kurt Stephens <ruby-currency(at)umleta.com>
+# See LICENSE.txt for details.
+
+
+
+class Object 
+  # Exact conversion to Money representation value.
+  def money(*opts)
+    Currency::Money(self, *opts)
+  end
+end
+
+
+
+class Integer 
+  # Exact conversion to Money representation value.
+  def Money_rep(currency, time = nil)
+    Integer(self * currency.scale)
+  end
+end
+
+
+
+class Float 
+  # Inexact conversion to Money representation value.
+  def Money_rep(currency, time = nil)  
+    Integer(Currency::Config.current.float_ref_filter.call(self * currency.scale))
+  end
+  
+  def round_with_precision(precision = nil)
+    precision.nil? ? round_without_precision : (self * (10 ** precision)).round_without_precision / (10 ** precision).to_f
+  end
+  alias_method :round_without_precision, :round
+  alias_method :round, :round_with_precision
+end
+
+
+
+
+class String
+  # Exact conversion to Money representation value.
+  def Money_rep(currency, time = nil)
+    x = currency.parse(self, :currency => currency, :time => time)
+    x = x.rep if x.respond_to?(:rep)
+    x
+  end
+end
+

data/lib/currency/currency.rb

@@ -0,0 +1,175 @@
+# Copyright (C) 2006-2007 Kurt Stephens <ruby-currency(at)umleta.com>
+# See LICENSE.txt for details.
+
+
+# Represents a currency.
+#
+# Currency objects are created on-demand by Currency::Currency::Factory.
+#
+# See Currency.get method.
+#
+class Currency::Currency
+    # Returns the ISO three-letter currency code as a symbol.
+    # e.g. :USD, :CAD, etc.
+    attr_reader :code
+
+    # The Currency's scale factor.  
+    # e.g: the :USD scale factor is 100.
+    attr_reader :scale
+
+    # The Currency's scale factor.  
+    # e.g: the :USD scale factor is 2, where 10 ^ 2 == 100.
+    attr_reader :scale_exp
+
+    # Used by Formatter.
+    attr_reader :format_right
+
+    # Used by Formatter.
+    attr_reader :format_left
+
+    # The Currency's symbol. 
+    # e.g: USD symbol is '$'
+    attr_accessor :symbol
+
+    # The Currency's symbol as HTML.
+    # e.g: EUR symbol is '&#8364;' (:html &#8364; :) or '&euro;' (:html &euro; :)
+    attr_accessor :symbol_html
+
+    # The default Formatter.
+    attr_accessor :formatter
+
+    # The default parser.
+    attr_accessor :parser
+
+
+    # Create a new currency.
+    # This should only be called from Currency::Currency::Factory.
+    def initialize(code, symbol = nil, scale = 1000000)
+      self.code = code
+      self.symbol = symbol
+      self.scale = scale
+
+      @formatter =
+        @parser = 
+        nil
+    end
+
+
+    # Returns the Currency object from the default Currency::Currency::Factory
+    # by its three-letter uppercase Symbol, such as :USD, or :CAD.
+    def self.get(code)
+      # $stderr.puts "#{self}.get(#{code.inspect})"
+      return nil unless code
+      return code if code.kind_of?(::Currency::Currency)
+      Factory.default.get_by_code(code)
+    end
+
+
+    # Internal method for converting currency codes to internal
+    # Symbol format.
+    def self.cast_code(x)
+      x = x.upcase.intern if x.kind_of?(String)
+      raise ::Currency::Exception::InvalidCurrencyCode, x unless x.kind_of?(Symbol)
+      raise ::Currency::Exception::InvalidCurrencyCode, x unless x.to_s.length == 3
+      x
+    end
+
+
+    # Returns the hash of the Currency's code.
+    def hash
+      @code.hash
+    end
+
+
+    # Returns true if the Currency's are equal.
+    def eql?(x)
+      self.class == x.class && @code == x.code
+    end
+
+
+    # Returns true if the Currency's are equal.
+    def ==(x)
+      self.class == x.class && @code == x.code
+    end
+
+
+    # Clients should never call this directly.
+    def code=(x)
+      x = self.class.cast_code(x) unless x.nil?
+      @code = x
+      #$stderr.puts "#{self}.code = #{@code}"; x
+    end
+
+
+    # Clients should never call this directly.
+    def scale=(x)
+      @scale = x
+      return x if x.nil?
+      @scale_exp = Integer(Math.log10(@scale));
+      @format_right = - @scale_exp
+      @format_left = @format_right - 1
+      x
+    end
+
+
+    # Parse a Money string in this Currency.
+    #
+    # See Currency::Parser#parse.
+    #
+    def parse(str, *opt)
+      parser_or_default.parse(str, *opt)
+    end
+
+
+    def parser_or_default
+      (@parser || ::Currency::Parser.default)
+    end
+
+
+    # Formats the Money value as a string using the current Formatter.
+    # See Currency::Formatter#format.
+    def format(m, *opt)
+       formatter_or_default.format(m, *opt)
+    end
+
+
+    def formatter_or_default
+      (@formatter || ::Currency::Formatter.default)
+    end
+
+
+    # Returns the Currency code as a String.
+    def to_s
+      @code.to_s
+    end
+
+
+    # Returns the default Factory's currency.
+    def self.default
+      Factory.default.currency
+    end
+
+
+    # Sets the default Factory's currency.
+    def self.default=(x)
+      x = self.get(x) unless x.kind_of?(self)
+      Factory.default.currency = x
+    end
+
+
+    # If selector is [A-Z][A-Z][A-Z], load the currency via Factory.default.
+    #
+    #   Currency::Currency.USD
+    #   => #<Currency::Currency:0xb7d0917c @formatter=nil, @scale_exp=2, @scale=100, @symbol="$", @format_left=-3, @code=:USD, @parser=nil, @format_right=-2>
+    #
+    def self.method_missing(sel, *args, &blk)
+      if args.size == 0 && (! block_given?) && /^[A-Z][A-Z][A-Z]$/.match(sel.to_s)
+        Factory.default.get_by_code(sel)
+      else
+        super
+      end
+    end
+
+end # class
+  
+

data/lib/currency/currency/factory.rb

@@ -0,0 +1,121 @@
+# Copyright (C) 2006-2007 Kurt Stephens <ruby-currency(at)umleta.com>
+# See LICENSE.txt for details.
+
+
+# Responsible for creating Currency::Currency objects on-demand.
+class Currency::Currency::Factory
+    @@default = nil
+
+    # Returns the default Currency::Factory.
+    def self.default
+      @@default ||= self.new
+    end
+    # Sets the default Currency::Factory.
+    def self.default=(x)
+      @@default = x
+    end
+
+
+    def initialize(*opts)
+      @currency_by_code = { }
+      @currency_by_symbol = { }
+      @currency = nil
+    end
+
+
+    # Lookup Currency by code.
+    def get_by_code(x)
+      x = ::Currency::Currency.cast_code(x)
+      # $stderr.puts "get_by_code(#{x})"
+      @currency_by_code[x] ||= install(load(::Currency::Currency.new(x)))
+    end
+
+
+    # Lookup Currency by symbol.
+    def get_by_symbol(symbol)
+      @currency_by_symbol[symbol] ||= install(load(::Currency::Currency.new(nil, symbol)))
+    end
+
+
+    # This method initializes a Currency object as
+    # requested from #get_by_code or #get_by_symbol.
+    #
+    # This method must initialize:
+    #
+    #    currency.code
+    #    currency.scale
+    # 
+    # Optionally:
+    #
+    #    currency.symbol
+    #    currency.symbol_html
+    #
+    # Subclasses that provide Currency metadata should override this method.
+    # For example, loading Currency metadata from a database or YAML file.
+    def load(currency)
+      # $stderr.puts "BEFORE: load(#{currency.code})"
+
+      # Basic
+      if currency.code == :USD || currency.symbol == '$'
+	# $stderr.puts "load('USD')"
+        currency.code = :USD
+        currency.symbol = '$'
+        currency.scale = 1000000
+      elsif currency.code == :CAD
+        # $stderr.puts "load('CAD')"
+        currency.symbol = '$'
+        currency.scale = 1000000
+      elsif currency.code == :EUR
+        # $stderr.puts "load('CAD')"
+        currency.symbol = nil
+        currency.symbol_html = '&#8364;'
+        currency.scale = 1000000
+      else
+        currency.symbol = nil
+        currency.scale = 1000000
+      end
+  
+      # $stderr.puts "AFTER: load(#{currency.inspect})"
+
+      currency
+    end
+
+
+    # Installs a new Currency for #get_by_symbol and #get_by_code.
+    def install(currency)
+      raise ::Currency::Exception::UnknownCurrency unless currency
+      @currency_by_symbol[currency.symbol] ||= currency unless currency.symbol.nil?
+      @currency_by_code[currency.code] = currency
+    end
+
+
+    # Returns the default Currency.
+    # Defaults to self.get_by_code(:USD).
+    def currency
+      @currency ||= self.get_by_code(:USD)
+    end
+
+
+    # Sets the default Currency.
+    def currency=(x)
+      @currency = x
+    end
+
+
+    # If selector is [A-Z][A-Z][A-Z], load the currency.
+    #
+    #   factory.USD
+    #   => #<Currency::Currency:0xb7d0917c @formatter=nil, @scale_exp=2, @scale=100, @symbol="$", @format_left=-3, @code=:USD, @parser=nil, @format_right=-2>
+    #
+    def method_missing(sel, *args, &blk)
+      if args.size == 0 && (! block_given?) && /^[A-Z][A-Z][A-Z]$/.match(sel.to_s)
+        self.get_by_code(sel)
+      else
+        super
+      end
+    end
+
+end # class
+
+
+

data/lib/currency/currency_version.rb

@@ -0,0 +1,6 @@
+module Currency
+  CurrencyVersion = '0.4.11'
+end
+# DO NOT EDIT
+# This file is auto-generated by build scripts.
+# See:  rake update_version

data/lib/currency/exception.rb

@@ -0,0 +1,119 @@
+# Copyright (C) 2006-2007 Kurt Stephens <ruby-currency(at)umleta.com>
+# See LICENSE.txt for details.
+
+module Currency::Exception
+    # Base class for all Currency::Exception objects.
+    #
+    #   raise Currency::Exception [ "msg", :opt1, 1, :opt2, 2 ]
+    #
+    class Base < ::Exception
+      EMPTY_HASH = { }.freeze
+
+      def initialize(arg1, *args)
+        case arg1
+        # [ description, ... ]
+        when Array
+          @opts = arg1
+          arg1 = arg1.shift
+        else
+          @opts = nil
+        end
+
+        case @opts
+        when Array
+          if @opts.size == 1 && @opts.first.kind_of?(Hash)
+            # [ description, { ... } ]
+            @opts = @opts.first
+          else
+            # [ description, :key, value, ... ]
+            @opts = Hash[*@opts]
+          end
+        end
+
+        case @opts
+        when Hash
+          @opts = @opts.dup.freeze
+        else
+          @opts = { :info => @opts }.freeze
+        end
+
+        @opts ||= EMPTY_HASH
+
+        super(arg1, *args)
+      end
+
+
+      def method_missing(sel, *args, &blk)
+        sel = sel.to_sym
+        if args.empty? && ! block_given? && @opts.key?(sel) 
+          return @opts[sel]
+        end
+        super
+      end
+
+      def to_s
+        super + ": #{@opts.inspect}"
+      end
+
+    end
+
+    # Generic Error.
+    class Generic < Base
+    end
+
+    # Error during parsing of Money values from String.
+    class InvalidMoneyString < Base
+    end
+
+    # Error during coercion of external Money values.
+    class InvalidMoneyValue < Base
+    end
+  
+    # Error in Currency code formeat.
+    class InvalidCurrencyCode < Base
+    end
+    
+    # Error during conversion between currencies.
+    class IncompatibleCurrency < Base
+    end
+
+    # Error during locating currencies.
+    class MissingCurrency < Base
+    end
+
+    # Error if an Exchange is not defined.
+    class UndefinedExchange < Base
+    end
+
+    # Error if a Currency is unknown.
+    class UnknownCurrency < Base
+    end
+
+    # Error if an Exchange Rate Source cannot provide an Exchange::Rate.
+    class UnknownRate < Base
+    end
+
+    # Error if an Exchange Rate Source.
+    class RateSourceError < Base
+    end
+
+    # Error if an Exchange Rate Source cannot supply any rates.
+    class UnavailableRates < Base
+    end
+
+    # Error if an Exchange::Rate is not valid.
+    class InvalidRate < Base
+    end
+    
+    # Error if a subclass is responsible for implementing a method.
+    class SubclassResponsibility < Base
+    end
+
+    # Error if some functionality is unimplemented
+    class Unimplemented < Base
+    end
+  
+    # Error if reentrantancy is d
+    class InvalidReentrancy < Base
+    end
+end # module