mumboe-currency 0.5

data/bin/currency_historical_rate_load

@@ -0,0 +1,105 @@
+#!/usr/bin/env ruby
+# -*- ruby -*-
+
+# Dependencies
+bin_dir = File.dirname(__FILE__)
+$:.unshift File.expand_path(bin_dir + "/../lib")
+
+require 'rubygems'
+
+gem 'activesupport'
+gem 'activerecord'
+
+require 'active_record'
+
+require 'currency'
+require 'currency/exchange/rate/source/historical/rate_loader'
+require 'optparse'
+require 'ostruct'
+require 'yaml'
+
+
+# Parse command line arguments.
+opts = { }
+opts[:db_config] = bin_dir + '/.db_config.yml'
+opts[:rate_sources] = [ ]
+opts[:required_currencies] = 
+  [
+   :USD,
+   :GBP,
+   :CAD,
+   :EUR,
+  ]
+opts[:RAILS_ENV] = ENV["RAILS_ENV"] || 'development'
+
+
+op = OptionParser.new do | op |
+  op.banner = "currency_historical_rate_load - loads currency rates from sources into historical rates table"
+  op.separator "Usage:"
+  op.on("--deploy-table",
+        TrueClass,
+        "If true the database table will be created."
+        ) do | v |
+    opts[:deploy_table] = v
+  end
+  op.on("-d",
+        "--db-config FILE",
+        String,
+        "The YAML file containing the ActiveRecord::Base database configuration."
+        ) do | v |
+    opts[:db_config] = v
+  end
+  op.on("-e",
+        "--rails-env ENV",
+        String,
+        "The configuration key to use from the --db-config file; default #{opts[:RAILS_ENV].inspect}."
+        ) do | v |
+    opts[:RAILS_ENV] = v
+  end
+  op.on("-s",
+        "--rate-source RATE_SOURCE",
+        String,
+        "The rate source to be queried."
+        ) do | v |
+    opts[:rate_sources] += v.split(/[\s,]+/)
+  end
+  op.on("-c",
+        "--currencies CURRENCY",
+        String,
+        "The required currencies; default: #{opts[:required_currencies].inspect}."
+        ) do | v |
+    opts[:required_currencies] = v.split(/[\s,]+/)
+  end
+  op.on("-h",
+        "--help",
+        "Show this message") do 
+    STDERR.puts op.to_s
+    exit(1)
+  end
+end
+
+args = ARGV.dup
+op.parse!(args)
+
+# Setup the database environment.
+db_config = File.open(opts[:db_config]) do | fh | 
+  YAML::load(fh)
+end
+db_config.freeze
+db_config = db_config[opts[:RAILS_ENV]] || raise("Cannot locate #{opts[:RAILS_ENV].inspect} in --db-config; available environments: #{db_config.keys.sort.inspect}")
+db_config.freeze
+ActiveRecord::Base.establish_connection(db_config)
+
+# Deploy table?
+if opts[:deploy_table]
+  require 'active_record/migration'
+  Currency::Exchange::Rate::Source::Historical::Rate.__create_table(ActiveRecord::Migration)
+end
+
+# Start Loading Rates.
+instance = Currency::Exchange::Rate::Source::Historical::RateLoader.new(opts)
+instance.run
+
+# Finished
+exit(0)
+

data/examples/ex1.rb

@@ -0,0 +1,13 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'currency'
+require 'currency/exchange/rate/source/test'
+
+x = Currency.Money("1,203.43", :USD)
+
+puts x.to_s
+puts (x * 10).to_s
+puts (x * 33333).inspect
+
+puts x.currency.code.inspect
+

data/examples/xe1.rb

@@ -0,0 +1,20 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'currency'
+require 'currency/exchange/rate/source/xe'
+
+ex = Currency::Exchange::Rate::Source::Xe.new()
+Currency::Exchange::Rate::Source.current = ex
+
+puts ex.inspect
+puts ex.parse_page_rates.inspect
+
+usd = Currency.Money("1", 'USD')
+
+puts "usd = #{usd}"
+
+cad = usd.convert(:CAD)
+puts "cad = #{cad}"
+
+
+

data/lib/currency/active_record.rb

@@ -0,0 +1,265 @@
+# Copyright (C) 2006-2007 Kurt Stephens <ruby-currency(at)umleta.com>
+# See LICENSE.txt for details.
+
+require 'active_record/base'
+require File.join(File.dirname(__FILE__), '..', 'currency')
+
+# See Currency::ActiveRecord::ClassMethods
+class ActiveRecord::Base
+    @@money_attributes = { }
+
+    # Called by money macro when a money attribute
+    # is created.
+    def self.register_money_attribute(attr_opts)
+      (@@money_attributes[attr_opts[:class]] ||= { })[attr_opts[:attr_name]] = attr_opts
+    end
+
+    # Returns an array of option hashes for all the money attributes of
+    # this class.
+    #
+    # Superclass attributes are not included.
+    def self.money_attributes_for_class(cls)
+      (@@money_atttributes[cls] || { }).values
+    end
+
+
+    # Iterates through all known money attributes in all classes.
+    #
+    # each_money_attribute { | money_opts |
+    #   ...
+    # }
+    def self.each_money_attribute(&blk)
+      @@money_attributes.each do | cls, hash |
+        hash.each do | attr_name, attr_opts |
+          yield attr_opts
+        end
+      end
+    end
+
+end # class
+
+
+# See Currency::ActiveRecord::ClassMethods
+module Currency::ActiveRecord
+    
+    def self.append_features(base) # :nodoc:
+      # $stderr.puts "  Currency::ActiveRecord#append_features(#{base})"
+      super
+      base.extend(ClassMethods)
+    end
+
+
+
+# == ActiveRecord Suppport
+#
+# Support for Money attributes in ActiveRecord::Base subclasses:
+#
+#    require 'currency'
+#    require 'currency/active_record'
+#    
+#    class Entry < ActiveRecord::Base
+#       attr_money :amount
+#    end
+# 
+    module ClassMethods
+
+      # Deprecated: use attr_money.
+      def money(*args)
+        $stderr.puts "WARNING: money(#{args.inspect}) deprecated, use attr_money: in #{caller(1)[0]}"
+        attr_money(*args)
+      end
+
+
+      # Defines a Money object attribute that is bound
+      # to a database column.  The database column to store the
+      # Money value representation is assumed to be
+      # INTEGER and will store Money#rep values.
+      #
+      # Options:
+      #
+      #    :column => undef
+      #
+      # Defines the column to use for storing the money value.
+      # Defaults to the attribute name.
+      #
+      # If this column is different from the attribute name,
+      # the money object will intercept column=(x) to flush
+      # any cached Money object.
+      #
+      #    :currency => currency_code (e.g.: :USD)
+      #
+      # Defines the Currency to use for storing a normalized Money 
+      # value.
+      #
+      # All Money values will be converted to this Currency before
+      # storing.  This allows SQL summary operations, 
+      # like SUM(), MAX(), AVG(), etc., to produce meaningful results,
+      # regardless of the initial currency specified.  If this
+      # option is used, subsequent reads will be in the specified
+      # normalization :currency.
+      #
+      #    :currency_column => undef
+      #
+      # Defines the name of the CHAR(3) column used to store and
+      # retrieve the Money's Currency code.  If this option is used, each
+      # record may use a different Currency to store the result, such
+      # that SQL summary operations, like SUM(), MAX(), AVG(), 
+      # may return meaningless results.
+      #
+      #    :currency_preferred_column => undef
+      #
+      # Defines the name of a CHAR(3) column used to store and
+      # retrieve the Money's Currency code.  This option can be used
+      # with normalized Money values to retrieve the Money value 
+      # in its original Currency, while
+      # allowing SQL summary operations on the normalized Money values
+      # to still be valid.
+      #
+      #    :time => undef
+      #
+      # Defines the name of attribute used to 
+      # retrieve the Money's time.  If this option is used, each
+      # Money value will use this attribute during historical Currency
+      # conversions.
+      #
+      # Money values can share a time value with other attributes
+      # (e.g. a created_on column).
+      #
+      # If this option is true, the money time attribute will be named
+      # "#{attr_name}_time" and :time_update will be true.
+      #
+      #    :time_update => undef
+      #
+      # If true, the Money time value is updated upon setting the
+      # money attribute.  
+      #
+      def attr_money(attr_name, *opts)
+        opts = Hash[*opts]
+
+        attr_name = attr_name.to_s
+        opts[:class] = self
+        opts[:table] = self.table_name
+        opts[:attr_name] = attr_name.intern
+        ::ActiveRecord::Base.register_money_attribute(opts)
+
+        column = opts[:column] || opts[:attr_name]
+        opts[:column] = column
+
+        if column.to_s != attr_name.to_s
+          alias_accessor = <<-"end_eval"
+alias :before_money_#{column}=, :#{column}=
+
+def #{column}=(__value)
+  @{attr_name} = nil # uncache
+  before_money#{column} = __value
+end
+
+end_eval
+        end
+
+        currency = opts[:currency]
+
+        currency_column = opts[:currency_column]
+        if currency_column && ! currency_column.kind_of?(String)
+          currency_column = currency_column.to_s
+          currency_column = "#{column}_currency"
+        end
+        if currency_column
+          read_currency = "read_attribute(:#{currency_column.to_s})"
+          write_currency = "write_attribute(:#{currency_column}, #{attr_name}_money.nil? ? nil : #{attr_name}_money.currency.code.to_s)"
+        end
+        opts[:currency_column] = currency_column
+
+        currency_preferred_column = opts[:currency_preferred_column]
+        if currency_preferred_column
+          currency_preferred_column = currency_preferred_column.to_s
+          read_preferred_currency = "@#{attr_name} = @#{attr_name}.convert(read_attribute(:#{currency_preferred_column}))"
+          write_preferred_currency = "write_attribute(:#{currency_preferred_column}, @#{attr_name}_money.currency.code)"
+        end
+
+        time = opts[:time]
+        write_time = ''
+        if time
+          if time == true
+            time = "#{attr_name}_time"
+            opts[:time_update] = true
+          end
+          read_time = "self.#{time}"
+        end
+        opts[:time] = time
+        if opts[:time_update]
+          write_time = "self.#{time} = #{attr_name}_money && #{attr_name}_money.time"
+        end
+
+        currency ||= ':USD'
+        time ||= 'nil'
+
+        read_currency ||= currency
+        read_time ||= time
+
+        money_rep ||= "#{attr_name}_money.rep"
+
+        validate_allow_nil = opts[:allow_nil] ? ', :allow_nil => true' : ''
+        validate = "# Validation\n"
+        validate << "\nvalidates_numericality_of :#{attr_name}#{validate_allow_nil}\n"
+        validate << "\nvalidates_format_of :#{currency_column}, :with => /^[A-Z][A-Z][A-Z]$/#{validate_allow_nil}\n" if currency_column
+
+ 
+        alias_accessor ||= ''
+
+        module_eval (opts[:module_eval] = x = <<-"end_eval"), __FILE__, __LINE__
+#{validate}
+
+#{alias_accessor}
+
+def #{attr_name}
+  # $stderr.puts "  \#{self.class.name}##{attr_name}"
+  unless @#{attr_name}
+    #{attr_name}_rep = read_attribute(:#{column})
+    unless #{attr_name}_rep.nil?
+      @#{attr_name} = ::Currency::Money.new_rep(#{attr_name}_rep, #{read_currency} || #{currency}, #{read_time} || #{time})
+      #{read_preferred_currency}
+    end
+  end
+  @#{attr_name}
+end
+
+def #{attr_name}=(value)
+  if value.nil?
+    #{attr_name}_money = nil
+  elsif value.kind_of?(Integer) || value.kind_of?(String) || value.kind_of?(Float)
+    #{attr_name}_money = ::Currency::Money(value, #{currency})
+    #{write_preferred_currency}
+  elsif value.kind_of?(::Currency::Money)
+    #{attr_name}_money = value
+    #{write_preferred_currency}
+    #{write_currency ? write_currency : "#{attr_name}_money = #{attr_name}_money.convert(#{currency})"}
+  else
+    raise ::Currency::Exception::InvalidMoneyValue, value
+  end
+
+  @#{attr_name} = #{attr_name}_money
+  
+  write_attribute(:#{column}, #{attr_name}_money.nil? ? nil : #{money_rep})
+  #{write_time}
+
+  value
+end
+
+def #{attr_name}_before_type_cast
+  # FIXME: User cannot specify Currency
+  x = #{attr_name}
+  x &&= x.format(:symbol => false, :currency => false, :thousands => false)
+  x
+end
+
+end_eval
+        # $stderr.puts "   CODE = #{x}"
+      end
+    end
+end
+
+
+ActiveRecord::Base.class_eval do
+  include Currency::ActiveRecord
+end

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,41 @@
+# 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
+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
+