currency 0.3.3 → 0.4.0

data/lib/currency/core_extensions.rb

@@ -1,3 +1,5 @@
+# Copyright (C) 2006-2007 Kurt Stephens <ruby-currency(at)umleta.com>
+# See LICENSE.txt for details.
 
 
 # External representation mixin
@@ -12,7 +14,7 @@ end
 # External representation mixin
 class Integer 
   # Exact conversion to Money representation value.
-  def Money_rep(currency)
+  def Money_rep(currency, time = nil)
     Integer(self * currency.scale)
   end
 end
@@ -21,7 +23,7 @@ end
 # External representation mixin
 class Float 
   # Inexact conversion to Money representation value.
-  def Money_rep(currency)  
+  def Money_rep(currency, time = nil)  
     Integer(self * currency.scale) 
   end
 end
@@ -30,9 +32,9 @@ end
 # External representation mixin
 class String
   # Exact conversion to Money representation value.
-  def Money_rep(currency)
-    x = currency.parse(self, :currency => currency)
-    x.rep if x.kind_of?(Currency::Money)
+  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

@@ -1,73 +1,103 @@
-# -*- ruby -*-
-#
-# = Currency::Currency
-#
+# 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
 
-module Currency
-  #include Currency::Exceptions
 
-  class Currency
     # Create a new currency.
-    # This should only be called from Currency::CurrencyFactory.
+    # This should only be called from Currency::Currency::Factory.
     def initialize(code, symbol = nil, scale = 100)
       self.code = code
       self.symbol = symbol
       self.scale = scale
     end
 
-    # Returns the Currency object from the default CurrencyFactory
-    # by its 3-letter uppercase Symbol name, such as :USD, or :CAD.
+
+    # 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)
-      CurrencyFactory.default.get_by_code(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 Exception::InvalidCurrencyCode.new(x) unless x.kind_of?(Symbol)
-     raise Exception::InvalidCurrencyCode.new(x) unless x.to_s.length == 3
-     x
+      x = x.upcase.intern if x.kind_of?(String)
+      raise ::Currency::Exception::InvalidCurrencyCode.new(x) unless x.kind_of?(Symbol)
+      raise ::Currency::Exception::InvalidCurrencyCode.new(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
 
-    # Get the Currency's code.
-    def code
-      @code
-    end
 
-
-    # Client should never call this directly.
+    # 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
 
-    # Get the Currency's scale factor.  
-    # E.g: the :USD scale factor is 100.
-    def scale
-      @scale
-    end
 
-    # Client should never call this directly.
+    # Clients should never call this directly.
     def scale=(x)
       @scale = x
       return x if x.nil?
@@ -77,178 +107,65 @@ module Currency
       x
     end
 
-    # Get the Currency's scale factor.  
-    # E.g: the :USD scale factor is 2, where 10 ^ 2 == 100.
-    def scale_exp
-      @scale_exp
-    end
-
-    # Get the Currency's symbol. 
-    # E.g. :USD, :CAD, etc.
-    def symbol
-      @symbol
-    end
 
-    # Client should never call this directly.
-    def symbol=(x)
-      @symbol = x
-    end
-
-    # Parse a Money string.
-    # Options:
-    #   :currency => Currency object.
-    # Look for a matching currency code at the beginning or end of the string.
-    # If the currency does not match IncompatibleCurrency is raised.
+    # Parse a Money string in this Currency.
+    #
+    # See Currency::Parser#parse.
     #
     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 Exception::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 Exception::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 Exception::InvalidMoneyString.new("#{str} #{self}")
-      end
+      parser_or_default.parse(str, *opt)
     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
+    def parser_or_default
+      (@parser || ::Currency::Parser.default)
+    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)
+    # 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
 
-      # Put sign back.
-      x = "-" + x if neg
 
-      # Add symbol?
-      x = (@symbol || '') + x unless opt.include?(:no_symbol)
+    def formatter_or_default
+      (@formatter || ::Currency::Formatter.default)
+    end
 
-      # 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
+    # Returns the Currency code as a String.
+    def to_s
+      @code.to_s
     end
 
-    #def to_s
-    #  @code.to_s
-    #end
 
-    # Returns the default CurrencyFactory's currency.
+    # Returns the default Factory's currency.
     def self.default
-      CurrencyFactory.default.currency
+      Factory.default.currency
     end
-    # Sets the default CurrencyFactory's currency.
+
+
+    # Sets the default Factory's currency.
     def self.default=(x)
-      CurrencyFactory.default.currency = x
+      x = self.get(x) unless x.kind_of?(self)
+      Factory.default.currency = x
     end
 
-    # Returns the USD Currency.
-    def self.USD
-      CurrencyFactory.default.USD
-    end
 
-    # Returns the CAD Currency.
-    def self.CAD
-      CurrencyFactory.default.CAD
+    # 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
+end # class
   
-end # module
 

data/lib/currency/{currency_factory.rb → currency/factory.rb}

@@ -1,44 +1,54 @@
-module Currency
-  class CurrencyFactory
+# 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 CurrencyFactory.
+    # Returns the default Currency::Factory.
     def self.default
-      @@default ||= CurrencyFactory.new
+      @@default ||= self.new
     end
-    # Sets the default CurrencyFactory.
+    # Sets the default Currency::Factory.
     def self.default=(x)
       @@default = x
     end
 
+
     def initialize(*opts)
       @currency_by_code = { }
       @currency_by_symbol = { }
       @currency = nil
-      @USD = nil    
-      @CAD = nil
     end
 
+
     # Lookup Currency by code.
     def get_by_code(x)
-      x = Currency.cast_code(x)
+      x = ::Currency::Currency.cast_code(x)
       # $stderr.puts "get_by_code(#{x})"
-      @currency_by_code[x] ||= install(load(Currency.new(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.new(nil, 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.symbol
     #    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.
@@ -55,6 +65,11 @@ module Currency
         # $stderr.puts "load('CAD')"
         currency.symbol = '$'
         currency.scale = 100
+      elsif currency.code == :EUR
+        # $stderr.puts "load('CAD')"
+        currency.symbol = nil
+        currency.symbol_html = '&#8364;'
+        currency.scale = 100
       else
         currency.symbol = nil
         currency.scale = 100
@@ -65,36 +80,42 @@ module Currency
       currency
     end
 
+
     # Installs a new Currency for #get_by_symbol and #get_by_code.
     def install(currency)
-      raise Exception::UnknownCurrency.new() unless currency
+      raise ::Currency::Exception::UnknownCurrency.new() unless currency
       @currency_by_symbol[currency.symbol] ||= currency unless currency.symbol.nil?
       @currency_by_code[currency.code] = currency
     end
 
-    # Standard Currency: US Dollars, :USD.
-    def USD
-      @USD ||= self.get_by_code(:USD)
-    end
-
-    # Standard Currency: Canadian Dollars, :CAD.
-    def CAD
-      @CAD ||= self.get_by_code(:CAD)
-    end
 
     # Returns the default Currency.
-    # Defaults to self.USD.
+    # Defaults to self.get_by_code(:USD).
     def currency
-      @currency ||= self.USD
+      @currency ||= self.get_by_code(:USD)
     end
 
+
     # Sets the default Currency.
     def currency=(x)
       @currency = x
     end
 
-  end # class
-end # module
+
+    # 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