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,83 @@
+# 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
+
+# module Asa
+#   module Rounding
+#     def self.included(base) #:nodoc:
+#       puts "included by #{base.inspect}"
+#       base.class_eval do
+#         alias_method :round_without_precision, :round
+#         alias_method :round, :round_with_precision
+#       end
+#     end
+# 
+#     # Rounds the float with the specified precision.
+#     #
+#     #   x = 1.337
+#     #   x.round    # => 1
+#     #   x.round(1) # => 1.3
+#     #   x.round(2) # => 1.34
+#     def round_with_precision(precision = nil)
+#       precision.nil? ? round_without_precision : (self * (10 ** precision)).round / (10 ** precision).to_f
+#     end
+#     
+#   end
+# end
+# 
+# class Float 
+#   include Asa::Rounding
+#   # Inexact conversion to Money representation value.
+#   def Money_rep(currency, time = nil)  
+#     Integer(Currency::Config.current.float_ref_filter.call(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_awesome_precision(precision = nil)
+  #   # puts "self: #{self.inspect}"
+  #   # puts "precision: #{precision.inspect}"
+  #   # puts "round_without_precision: #{round_without_precision.inspect}"
+  #   # puts "self * (10 ** precision): #{(self * (10 ** precision)).inspect}"
+  #   # puts "(self * (10 ** precision)).round_without_precision: #{((self * (10 ** precision)).round_without_precision).inspect}"
+  #   # self.to_s.to_f.round_without_precision
+  #   precision.nil? ? round_without_awesome_precision : (self * (10 ** precision)).round_without_awesome_precision / (10 ** precision).to_f
+  # end
+  # alias_method :round_without_awesome_precision, :round
+  # alias_method :round, :round_with_awesome_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
+
+
+