currency 0.1.0

data/lib/currency/active_record.rb

@@ -0,0 +1,70 @@
+require 'active_record/base'
+require File.join(File.dirname(__FILE__), '..', 'currency')
+
+module Currency
+  module ActiveRecord
+    def self.append_features(base) # :nodoc:
+      # $stderr.puts "  Currency::ActiveRecord#append_features(#{base})"
+      super
+      base.extend(ClassMethods)
+    end
+      
+    module ClassMethods
+      def money(attr_name, *opts)
+        opts = Hash.[](*opts)
+
+        attr_name = attr_name.to_s
+
+        currency = opts[:currency]
+
+        currency_field = opts[:currency_field]
+        if currency_field
+          currency = "read_attribute(:#{currency_field})"
+        end
+
+        currency ||= ':USD'
+
+        validate = ''
+        validate = "validates_numericality_of :#{attr_name}" unless opts[:allow_nil]
+
+        module_eval (x = <<-"end_eval"), __FILE__, __LINE__
+#{validate}
+def #{attr_name}
+  # $stderr.puts "  \#{self.class.name}##{attr_name}"
+  unless @#{attr_name}
+    #{attr_name}_rep = read_attribute(:#{attr_name})
+    @#{attr_name} = Money.new_rep(#{attr_name}_rep, #{currency}) unless #{attr_name}_rep.nil?
+  end
+  @#{attr_name}
+end
+def #{attr_name}=(value)
+  if value.nil?
+    ;
+  elsif value.kind_of?(Integer) || value.kind_of?(String) || value.kind_of?(Float)
+    #{attr_name}_money = Money.new(value, #{currency})
+  elsif value.kind_of?(Money)
+    #{attr_name}_money = value.convert(#{currency})
+  else
+    throw "Bad money format \#{value.inspect}"
+  end
+  @#{attr_name} = #{attr_name}_money
+  #{currency_field ? 'write_attribute(:#{currency_field}, #{attr_name}_money.nil? ? nil : #{attr_name}_money.currency.name)' : ''}
+  write_attribute(:#{attr_name}, #{attr_name}_money.nil? ? nil : #{attr_name}_money.rep)
+  value
+end
+def #{attr_name}_before_type_cast
+  x = #{attr_name}
+  x &&= x.format(:no_symbol, :no_currency, :no_thousands)
+  x
+end
+end_eval
+        # $stderr.puts "   CODE = #{x}"
+      end
+    end
+  end
+end
+
+
+ActiveRecord::Base.class_eval do
+  include Currency::ActiveRecord
+end

data/lib/currency/core_extensions.rb

@@ -0,0 +1,25 @@
+#  
+# External representation mixins
+#
+class Integer # Exact
+  def Money_rep(currency)
+    Integer(self * currency.scale)
+  end
+end
+
+
+class Float # Inexact
+  def Money_rep(currency)  
+    Integer(self * currency.scale) 
+  end
+end
+
+
+class String # Exact
+  def Money_rep(currency)
+    x = currency.parse(self, :currency => currency)
+    x.rep if x.kind_of?(Currency::Money)
+    x
+  end
+end
+

data/lib/currency/currency.rb

@@ -0,0 +1,203 @@
+module Currency
+  #include Currency::Exceptions
+
+  class Currency
+    # Create a new currency
+    def initialize(code, symbol = nil, scale = 100)
+      self.code= code
+      self.symbol= symbol
+      self.scale= scale
+    end
+
+    def self.get(code)
+      CurrencyFactory.default.get_by_code(code)
+    end
+
+    def self.cast_code(x)
+     x = x.upcase.intern if x.kind_of?(String)
+     raise InvalidCurrencyCode.new(x) unless x.kind_of?(Symbol)
+     x
+    end
+
+    # Accessors
+    def code
+      @code
+    end
+    def code=(x)
+      x = self.class.cast_code(x) unless x.nil?
+      @code = x
+      #$stderr.puts "#{self}.code = #{@code}"; x
+    end
+
+    def scale
+      @scale
+    end
+    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
+
+    def scale_exp
+      @scale_exp
+    end
+
+    def symbol
+      @symbol
+    end
+    def symbol=(x)
+      @symbol = x
+    end
+
+    # Parse a Money string
+    def parse(str, *opt)
+      x = str
+      opt = Hash.[](*opt)
+
+      md = nil # match data
+
+      # $stderr.puts "'#{x}'.Money_rep(#{self})"
+      
+      # Handle currency code at front of string.
+      if (md = /^([A-Z][A-Z][A-Z])\s*(.*)$/.match(x)) != nil 
+        curr = CurrencyFactory.default.get_by_code(md[1])
+        x = md[2]
+        if curr != self
+          if opt[:currency] && opt[:currency] != curr
+            raise IncompatibleCurrency.new("#{str} #{opt[:currency].code}")
+          end
+          return Money.new(x, curr);
+        end
+        # Handle currency code at end of string.
+      elsif (md = /^(.*)\s*([A-Z][A-Z][A-Z])$/.match(x)) != nil 
+        curr = CurrencyFactory.default.get_by_code(md[2])
+        x = md[1]
+        if curr != self
+          if opt[:currency] && opt[:currency] != curr
+            raise IncompatibleCurrency.new("#{str} #{opt[:currency].code}")
+          end
+          return Money.new(x, curr);
+        end
+      end
+
+      # Remove placeholders and symbol.
+      x = x.gsub(/[, ]/, '')
+      x = x.sub(@symbol, '') if @symbol
+
+      # Match: whole Currency value.
+      if x =~ /^[-+]?(\d+)\.?$/
+        # $stderr.puts "'#{self}'.parse(#{str}) => EXACT"
+        x.to_i.Money_rep(self)
+        
+        # Match: fractional Currency value.
+      elsif (md = /^([-+]?)(\d*)\.(\d+)$/.match(x)) != nil
+        sign = md[1]
+        whole = md[2]
+        part = md[3]
+        
+        # $stderr.puts "'#{self}'.parse(#{str}) => DECIMAL (#{sign} #{whole} . #{part})"
+        
+        if part.length != self.scale
+          
+          # Pad decimal places with additional '0'
+          while part.length < self.scale_exp
+            part << '0'
+          end
+          
+          # Truncate to Currency's decimal size. 
+          part = part[0..(self.scale_exp - 1)]
+          
+          # $stderr.puts "  => INEXACT DECIMAL '#{whole}'"
+        end
+        
+        # Put the string back together:
+        #   #{sign}#{whole}#{part}
+        whole = sign + whole + part
+        # $stderr.puts "  => REP = #{whole}"
+        
+        x = whole.to_i
+
+        x = Money.new_rep(x, opt[:currency])
+      else
+        # $stderr.puts "'#{self}'.parse(#{str}) => ??? '#{x}'"
+        #x.to_f.Money_rep(self)
+        raise InvalidMoneyString.new("#{str} #{self}")
+      end
+    end
+
+    # Format a Money object.
+    def format(m, *opt)
+      opt = opt.flatten
+
+      # Get scaled integer representation for this Currency.
+      x = m.Money_rep(self)
+
+      # Remove sign.
+      x = - x if ( neg = x < 0 )
+
+      # Convert to String.
+      x = x.to_s
+
+      # Keep prefixing "0" until filled to scale.
+      while ( x.length <= @scale_exp )
+        x = "0" + x
+      end
+
+      # Insert decimal place
+      whole = x[0..@format_left] 
+      decimal = x[@format_right..-1]
+
+      # Do commas
+      x = whole
+      unless opt.include?(:no_thousands)
+        x.reverse!
+        x.gsub!(/(\d\d\d)/) {|y| y + ','}
+        x.sub!(/,$/,'')
+        x.reverse!
+      end
+
+      x << '.' + decimal unless opt.include?(:no_cents) || opt.include?(:no_decimal)
+
+      # Put sign back.
+      x = "-" + x if neg
+
+      # Add symbol?
+      x = @symbol + x unless opt.include?(:no_symbol)
+
+      # Suffix currency code.
+      if opt.include?(:with_currency)
+        x << ' '
+        x << '<span class="currency">' if opt.include?(:html)
+        x << @code.to_s
+        x << '</span>' if opt.include?(:html)
+      end
+
+      x
+    end
+
+    #def to_s
+    #  @code.to_s
+    #end
+
+    # Convience
+    # Default currency
+    def self.default
+      CurrencyFactory.default.currency
+    end
+
+    def self.USD
+      CurrencyFactory.default.USD
+    end
+
+    def self.CAD
+      CurrencyFactory.default.CAD
+    end
+  end
+
+
+  # END MODULE
+end
+

data/lib/currency/currency_exchange.rb

@@ -0,0 +1,50 @@
+module Currency
+  # Represents a method of converting between two currencies
+  # TODO: 
+  #  Create an ExchangeRateLoader class.
+  #  Create an ExchangeRateLoader subclass that interfaces to xe.com or other FX quote source.
+  class CurrencyExchange
+    @@default = nil
+    def self.default 
+      @@default ||= self.new
+    end
+    def self.default=(x)
+      @@default = x
+    end
+
+    def initialize(*opt)
+      @exchange_rate = { }
+    end 
+
+    def convert(m, c2, c1 = nil)
+      c1 = m.currency if c1 == nil
+      if ( c1 == c2 )
+        m
+      else
+        Money.new(exchange_rate(c1, c2).convert(m, c1), c2)
+      end
+    end
+
+    def clear_exchange_rates
+      @exchange_rate.empty!
+    end
+
+    def clear_exchange_rate(c1, c2, recip = true)
+      @exchange_rate[c1.code.to_s + c2.code.to_s] = nil
+      @exchange_rate[c2.code.to_s + c1.code.to_s] = nil if recip
+    end
+
+    def exchange_rate(c1, c2)
+      (@exchange_rate[c1.code.to_s + c2.code.to_s] ||= load_exchange_rate(c1, c2)) ||
+      (@exchange_rate[c2.code.to_s + c1.code.to_s] ||= load_exchange_rate(c2, c1))
+    end
+
+    
+    def load_exchange_rate(c1, c2)
+      raise "Subclass responsibility: load_exchange_rate"
+    end
+  end
+
+  # END MODULE
+end
+

data/lib/currency/currency_exchange_test.rb

@@ -0,0 +1,27 @@
+module Currency
+  # This can convert only between USD and CAD
+  class CurrencyExchangeTest < CurrencyExchange
+    @@instance = nil
+    def self.instance(*opts)
+      @@instance ||= self.new(*opts)
+    end
+
+    # Sample constant.
+    def self.USD_CAD; 1.1708; end
+
+    def load_exchange_rate(c1, c2)
+      # $stderr.puts "load_exchange_rate(#{c1}, #{c2})"
+      rate = 0.0
+      if ( c1.code == :USD && c2.code == :CAD )
+        rate = self.class.USD_CAD
+      end
+      rate > 0 ? ExchangeRate.new(c1, c2, rate, self.class.name) : nil
+    end
+  end
+
+  # END MODULE
+end
+
+# Install as current
+Currency::CurrencyExchange.default = Currency::CurrencyExchangeTest.instance
+

data/lib/currency/currency_exchange_xe.rb

@@ -0,0 +1,140 @@
+require 'net/http'
+require 'open-uri'
+
+module Currency
+  # Represents connects to http://xe.com and groks "XE.com Quick Cross Rates"
+
+  class CurrencyExchangeXe < CurrencyExchange
+    @@instance = nil
+    def self.instance(*opts)
+      @@instance ||= self.new(*opts)
+    end
+
+    attr_accessor :uri
+
+    def initialize(*opt)
+      super(*opt)
+      self.uri = 'http://xe.com/'
+      @rates = nil
+    end
+
+    def rates
+      return @rates if @rates
+
+      @rates = parse_page_rates
+      return @rates unless @rates
+
+      @rates_usd_cur = @rates[:USD]
+      @rate_timestamp = Time.now
+      
+      @rates
+    end
+
+    def get_page
+      data = open(uri) { |data| data.read }
+      
+      data = data.split(/[\r\n]/)
+
+      data
+    end
+
+    def parse_page_rates(data = nil)
+      data = get_page unless data
+      
+      # Chomp after
+      until data.empty?
+        line = data.pop
+        break if line =~ /Need More currencies\?/
+      end
+
+      # Chomp before
+      until data.empty?
+        line = data.shift
+        break if line =~ /XE.com Quick Cross Rates/
+      end
+
+      until data.empty?
+        line = data.shift
+        break if line =~ /Confused about how to use the rates/i
+      end
+
+      until data.empty?
+        line = data.shift
+        break if line =~ /^\s*<\/tr>/i
+      end
+      # $stderr.puts "#{data[0..4].inspect}"
+
+      # Read first table row to get position for each currency
+      currency = [ ]
+      until data.empty?
+        line = data.shift
+        break if line =~ /^\s*<\/tr>/i
+        if md = /<td><IMG .+ ALT="([A-Z][A-Z][A-Z])"/i.match(line) #"
+          cur = md[1].intern
+          cur_i = currency.size
+          currency.push(cur)
+          # $stderr.puts "Found currency header: #{cur.inspect} at #{cur_i}"
+        end
+      end
+
+      # $stderr.puts "#{data[0..4].inspect}"
+      
+      # Skip blank <tr>
+      until data.empty?
+        line = data.shift
+        break if line =~ /^\s*<td>.+1.+USD.+=/
+      end
+
+      until data.empty?
+        line = data.shift
+        break if line =~ /^\s*<\/tr>/i
+      end
+
+      # $stderr.puts "#{data[0..4].inspect}"
+
+      # Read first row of 1 USD = ...
+      
+      rate = { }
+      cur_i = -1
+      until data.empty?
+        line = data.shift
+        break if cur_i < 0 && line =~ /^\s*<\/tr>/i  
+        if md = /<td>\s+(\d+\.\d+)\s+<\/td>/.match(line)
+          usd_to_cur = md[1].to_f
+          cur_i = cur_i + 1
+          cur = currency[cur_i]
+          (rate[:USD] ||= {})[cur] = usd_to_cur
+        end
+      end
+
+      rate
+    end
+
+    def load_exchange_rate(c1, c2)
+      rates # Load rates
+
+      # $stderr.puts "load_exchange_rate(#{c1}, #{c2})"
+      rate = 0.0
+      r1 = nil
+      r2 = nil
+
+      if ( c1.code == :USD && (r2 = @rates_usd_cur[c2.code]) )
+        rate = r2
+      elsif ( c2.code == :USD && (r1 = @rates_usd_cur[c2.code]) )
+        rate = 1.0 / r1
+      elsif ( (r1 = @rates_usd_cur[c1.code]) && (r2 = @rates_usd_cur[c2.code]) )
+        rate = r2 / r1
+      end
+
+      # $stderr.puts "XE Rate: #{c1.code} / #{c2.code} = #{rate}"
+
+      rate > 0 ? ExchangeRate.new(c1, c2, rate, self.class.name, @rate_timestamp) : nil
+    end
+  end
+
+  # END MODULE
+end
+
+# Install as current
+Currency::CurrencyExchange.default = Currency::CurrencyExchangeXe.instance
+