money-joshm1 5.1.2

data/config/currency_non_iso.json

@@ -0,0 +1,30 @@
+{
+  "btc": {
+    "priority": 100,
+    "iso_code": "BTC",
+    "name": "Bitcoin",
+    "symbol": "B⃦",
+    "alternate_symbols": [],
+    "subunit": "Satoshi",
+    "subunit_to_unit": 10000000,
+    "symbol_first": true,
+    "html_entity": "",
+    "decimal_mark": ".",
+    "thousands_separator": ",",
+    "iso_numeric": ""
+  },
+  "jep": {
+    "priority": 100,
+    "iso_code": "JEP",
+    "name": "Jersey Pound",
+    "symbol": "£",
+    "alternate_symbols": [],
+    "subunit": "Penny",
+    "subunit_to_unit": 100,
+    "symbol_first": true,
+    "html_entity": "£",
+    "decimal_mark": ".",
+    "thousands_separator": ",",
+    "iso_numeric": ""
+  }
+}

data/lib/money.rb

@@ -0,0 +1,6 @@
+require "bigdecimal"
+require "bigdecimal/util"
+require "i18n" rescue LoadError
+require "money/currency"
+require "money/money"
+require "money/core_extensions"

data/lib/money/bank/base.rb

@@ -0,0 +1,130 @@
+require 'thread'
+
+class Money
+  # Provides classes that aid in the ability of exchange one currency with
+  # another.
+  module Bank
+
+    # The lowest Money::Bank error class.
+    # All Money::Bank errors should inherit from it.
+    class Error < StandardError
+    end
+
+    # Raised when the bank doesn't know about the conversion rate
+    # for specified currencies.
+    class UnknownRate < Error
+    end
+
+
+    # Money::Bank::Base is the basic interface for creating a money exchange
+    # object, also called Bank.
+    #
+    # A Bank is responsible for storing exchange rates, take a Money object as
+    # input and returns the corresponding Money object converted into an other
+    # currency.
+    #
+    # This class exists for aiding in the creating of other classes to exchange
+    # money between different currencies. When creating a subclass you will
+    # need to implement the following methods to exchange money between
+    # currencies:
+    #
+    # - #exchange_with(Money) #=> Money
+    #
+    # See Money::Bank::VariableExchange for a real example.
+    #
+    # Also, you can extend +Money::Bank::VariableExchange+ instead of
+    # +Money::Bank::Base+ if your bank implementation needs to store rates
+    # internally.
+    #
+    # @abstract Subclass and override +#exchange_with+ to implement a custom
+    #  +Money::Bank+ class. You can also override +#setup+ instead of
+    #  +#initialize+ to setup initial variables, etc.
+    class Base
+
+      # Returns the singleton instance of the Base bank.
+      #
+      # @return [Money::Bank::Base]
+      def self.instance
+        @singleton ||= self.new
+      end
+
+      # The rounding method to use when exchanging rates.
+      #
+      # @return [Proc]
+      attr_reader :rounding_method
+
+      # Initializes a new +Money::Bank::Base+ object. An optional block can be
+      # passed to dictate the rounding method that +#exchange_with+ can use.
+      #
+      # @yield [n] Optional block to use when rounding after exchanging one
+      #  currency for another.
+      # @yieldparam [Float] n The resulting float after exchanging one currency
+      #  for another.
+      # @yieldreturn [Integer]
+      #
+      # @return [Money::Bank::Base]
+      #
+      # @example
+      #   Money::Bank::Base.new #=> #<Money::Bank::Base @rounding_method=nil>
+      #   Money::Bank::Base.new {|n|
+      #     n.floor
+      #   } #=> #<Money::Bank::Base @round_method=#<Proc>>
+      def initialize(&block)
+        @rounding_method = block
+        setup
+      end
+
+      # Called after initialize. Subclasses can use this method to setup
+      # variables, etc that they normally would in +#initialize+.
+      #
+      # @abstract Subclass and override +#setup+ to implement a custom
+      #  +Money::Bank+ class.
+      #
+      # @return [self]
+      def setup
+      end
+
+      # Exchanges the given +Money+ object to a new +Money+ object in
+      # +to_currency+.
+      #
+      # @abstract Subclass and override +#exchange_with+ to implement a custom
+      #  +Money::Bank+ class.
+      #
+      # @raise NotImplementedError
+      #
+      # @param [Money] from The +Money+ object to exchange from.
+      # @param [Money::Currency, String, Symbol] to_currency The currency
+      #  string or object to exchange to.
+      # @yield [n] Optional block to use to round the result after making
+      #  the exchange.
+      # @yieldparam [Float] n The result after exchanging from one currency to
+      #  the other.
+      # @yieldreturn [Integer]
+      #
+      # @return [Money]
+      def exchange_with(from, to_currency, &block)
+        raise NotImplementedError, "#exchange_with must be implemented"
+      end
+
+      # Given two currency strings or object, checks whether they're both the
+      # same currency. Return +true+ if the currencies are the same, +false+
+      # otherwise.
+      #
+      # @param [Money::Currency, String, Symbol] currency1 The first currency
+      #  to compare.
+      # @param [Money::Currency, String, Symbol] currency2 The second currency
+      #  to compare.
+      #
+      # @return [Boolean]
+      #
+      # @example
+      #   same_currency?("usd", "USD")                #=> true
+      #   same_currency?("usd", "EUR")                #=> false
+      #   same_currency?("usd", Currency.new("USD")   #=> true
+      #   same_currency?("usd", "USD")                #=> true
+      def same_currency?(currency1, currency2)
+        Currency.wrap(currency1) == Currency.wrap(currency2)
+      end
+    end
+  end
+end

data/lib/money/bank/variable_exchange.rb

@@ -0,0 +1,252 @@
+require 'money/bank/base'
+require 'json'
+require 'yaml'
+
+class Money
+  module Bank
+    # Thrown when an unknown rate format is requested.
+    class UnknownRateFormat < StandardError; end
+
+    # Class for aiding in exchanging money between different currencies. By
+    # default, the +Money+ class uses an object of this class (accessible
+    # through +Money#bank+) for performing currency exchanges.
+    #
+    # By default, +Money::Bank::VariableExchange+ has no knowledge about
+    # conversion rates. One must manually specify them with +add_rate+, after
+    # which one can perform exchanges with +#exchange_with+.
+    #
+    # @example
+    #   bank = Money::Bank::VariableExchange.new
+    #   bank.add_rate("USD", "CAD", 1.24515)
+    #   bank.add_rate("CAD", "USD", 0.803115)
+    #
+    #   c1 = 100_00.to_money("USD")
+    #   c2 = 100_00.to_money("CAD")
+    #
+    #   # Exchange 100 USD to CAD:
+    #   bank.exchange_with(c1, "CAD") #=> #<Money @fractional=1245150>
+    #
+    #   # Exchange 100 CAD to USD:
+    #   bank.exchange_with(c2, "USD") #=> #<Money @fractional=803115>
+    class VariableExchange < Base
+
+      attr_reader :rates
+
+      # Available formats for importing/exporting rates.
+      RATE_FORMATS = [:json, :ruby, :yaml]
+
+      # Setup rates hash and mutex for rates locking
+      #
+      # @return [self]
+      def setup
+        @rates = {}
+        @mutex = Mutex.new
+        self
+      end
+
+      def marshal_dump
+        [@rates, @rounding_method]
+      end
+
+      def marshal_load(arr)
+        @rates, @rounding_method = arr
+        @mutex = Mutex.new
+      end
+
+      # Exchanges the given +Money+ object to a new +Money+ object in
+      # +to_currency+.
+      #
+      # @param  [Money] from
+      #         The +Money+ object to exchange.
+      # @param  [Currency, String, Symbol] to_currency
+      #         The currency to exchange to.
+      #
+      # @yield [n] Optional block to use when rounding after exchanging one
+      #  currency for another.
+      # @yieldparam [Float] n The resulting float after exchanging one currency
+      #  for another.
+      # @yieldreturn [Integer]
+      #
+      # @return [Money]
+      #
+      # @raise +Money::Bank::UnknownRate+ if the conversion rate is unknown.
+      #
+      # @example
+      #   bank = Money::Bank::VariableExchange.new
+      #   bank.add_rate("USD", "CAD", 1.24515)
+      #   bank.add_rate("CAD", "USD", 0.803115)
+      #
+      #   c1 = 100_00.to_money("USD")
+      #   c2 = 100_00.to_money("CAD")
+      #
+      #   # Exchange 100 USD to CAD:
+      #   bank.exchange_with(c1, "CAD") #=> #<Money @fractional=1245150>
+      #
+      #   # Exchange 100 CAD to USD:
+      #   bank.exchange_with(c2, "USD") #=> #<Money @fractional=803115>
+      def exchange_with(from, to_currency)
+        return from if same_currency?(from.currency, to_currency)
+
+        rate = get_rate(from.currency, to_currency)
+        unless rate
+          raise UnknownRate, "No conversion rate known for '#{from.currency.iso_code}' -> '#{to_currency}'"
+        end
+        _to_currency_  = Currency.wrap(to_currency)
+
+        fractional = BigDecimal.new(from.fractional.to_s) / (BigDecimal.new(from.currency.subunit_to_unit.to_s) / BigDecimal.new(_to_currency_.subunit_to_unit.to_s))
+
+        ex = fractional * BigDecimal.new(rate.to_s)
+        ex = ex.to_f
+        ex = if block_given?
+               yield ex
+             elsif @rounding_method
+               @rounding_method.call(ex)
+             else
+               ex.to_s.to_i
+             end
+        Money.new(ex, _to_currency_)
+      end
+
+      # Registers a conversion rate and returns it (uses +#set_rate+).
+      #
+      # @param [Currency, String, Symbol] from Currency to exchange from.
+      # @param [Currency, String, Symbol] to Currency to exchange to.
+      # @param [Numeric] rate Rate to use when exchanging currencies.
+      #
+      # @return [Numeric]
+      #
+      # @example
+      #   bank = Money::Bank::VariableExchange.new
+      #   bank.add_rate("USD", "CAD", 1.24515)
+      #   bank.add_rate("CAD", "USD", 0.803115)
+      def add_rate(from, to, rate)
+        set_rate(from, to, rate)
+      end
+
+      # Set the rate for the given currencies. Uses +Mutex+ to synchronize data
+      # access.
+      #
+      # @param [Currency, String, Symbol] from Currency to exchange from.
+      # @param [Currency, String, Symbol] to Currency to exchange to.
+      # @param [Numeric] rate Rate to use when exchanging currencies.
+      #
+      # @return [Numeric]
+      #
+      # @example
+      #   bank = Money::Bank::VariableExchange.new
+      #   bank.set_rate("USD", "CAD", 1.24515)
+      #   bank.set_rate("CAD", "USD", 0.803115)
+      def set_rate(from, to, rate)
+        @mutex.synchronize { @rates[rate_key_for(from, to)] = rate }
+      end
+
+      # Retrieve the rate for the given currencies. Uses +Mutex+ to synchronize
+      # data access.
+      #
+      # @param [Currency, String, Symbol] from Currency to exchange from.
+      # @param [Currency, String, Symbol] to Currency to exchange to.
+      #
+      # @return [Numeric]
+      #
+      # @example
+      #   bank = Money::Bank::VariableExchange.new
+      #   bank.set_rate("USD", "CAD", 1.24515)
+      #   bank.set_rate("CAD", "USD", 0.803115)
+      #
+      #   bank.get_rate("USD", "CAD") #=> 1.24515
+      #   bank.get_rate("CAD", "USD") #=> 0.803115
+      def get_rate(from, to)
+        @mutex.synchronize { @rates[rate_key_for(from, to)] }
+      end
+
+      # Return the known rates as a string in the format specified. If +file+
+      # is given will also write the string out to the file specified.
+      # Available formats are +:json+, +:ruby+ and +:yaml+.
+      #
+      # @param [Symbol] format Request format for the resulting string.
+      # @param [String] file Optional file location to write the rates to.
+      #
+      # @return [String]
+      #
+      # @raise +Money::Bank::UnknownRateFormat+ if format is unknown.
+      #
+      # @example
+      #   bank = Money::Bank::VariableExchange.new
+      #   bank.set_rate("USD", "CAD", 1.24515)
+      #   bank.set_rate("CAD", "USD", 0.803115)
+      #
+      #   s = bank.export_rates(:json)
+      #   s #=> "{\"USD_TO_CAD\":1.24515,\"CAD_TO_USD\":0.803115}"
+      def export_rates(format, file=nil)
+        raise Money::Bank::UnknownRateFormat unless
+          RATE_FORMATS.include? format
+
+        s = ""
+        @mutex.synchronize {
+          s = case format
+              when :json
+                JSON.dump(@rates)
+              when :ruby
+                Marshal.dump(@rates)
+              when :yaml
+                YAML.dump(@rates)
+              end
+
+          unless file.nil?
+            File.open(file, "w") {|f| f.write(s) }
+          end
+        }
+        s
+      end
+
+      # Loads rates provided in +s+ given the specified format. Available
+      # formats are +:json+, +:ruby+ and +:yaml+.
+      #
+      # @param [Symbol] format The format of +s+.
+      # @param [String] s The rates string.
+      #
+      # @return [self]
+      #
+      # @raise +Money::Bank::UnknownRateFormat+ if format is unknown.
+      #
+      # @example
+      #   s = "{\"USD_TO_CAD\":1.24515,\"CAD_TO_USD\":0.803115}"
+      #   bank = Money::Bank::VariableExchange.new
+      #   bank.import_rates(:json, s)
+      #
+      #   bank.get_rate("USD", "CAD") #=> 1.24515
+      #   bank.get_rate("CAD", "USD") #=> 0.803115
+      def import_rates(format, s)
+        raise Money::Bank::UnknownRateFormat unless
+          RATE_FORMATS.include? format
+
+        @mutex.synchronize {
+          @rates = case format
+                   when :json
+                     JSON.load(s)
+                   when :ruby
+                     Marshal.load(s)
+                   when :yaml
+                     YAML.load(s)
+                   end
+        }
+        self
+      end
+
+      private
+
+      # Return the rate hashkey for the given currencies.
+      #
+      # @param [Currency, String, Symbol] from The currency to exchange from.
+      # @param [Currency, String, Symbol] to The currency to exchange to.
+      #
+      # @return [String]
+      #
+      # @example
+      #   rate_key_for("USD", "CAD") #=> "USD_TO_CAD"
+      def rate_key_for(from, to)
+        "#{Currency.wrap(from).iso_code}_TO_#{Currency.wrap(to).iso_code}".upcase
+      end
+    end
+  end
+end

data/lib/money/core_extensions.rb

@@ -0,0 +1,82 @@
+# Open +Numeric+ to add new method.
+class Numeric
+
+  # Converts this numeric into a +Money+ object in the given +currency+.
+  #
+  # @param [Currency, String, Symbol] currency
+  #   The currency to set the resulting +Money+ object to.
+  #
+  # @return [Money]
+  #
+  # @example
+  #   100.to_money                   #=> #<Money @fractional=10000>
+  #   100.37.to_money                #=> #<Money @fractional=10037>
+  #   BigDecimal.new('100').to_money #=> #<Money @fractional=10000>
+  #
+  # @see Money.from_numeric
+  #
+  def to_money(currency = nil)
+    Money.from_numeric(self, currency || Money.default_currency)
+  end
+
+end
+
+# Open +String+ to add new methods.
+class String
+
+  # Parses the current string and converts it to a +Money+ object.
+  # Excess characters will be discarded.
+  #
+  # @param [Currency, String, Symbol] currency
+  #   The currency to set the resulting +Money+ object to.
+  #
+  # @return [Money]
+  #
+  # @example
+  #   '100'.to_money                #=> #<Money @fractional=10000>
+  #   '100.37'.to_money             #=> #<Money @fractional=10037>
+  #   '100 USD'.to_money            #=> #<Money @fractional=10000, @currency=#<Money::Currency id: usd>>
+  #   'USD 100'.to_money            #=> #<Money @fractional=10000, @currency=#<Money::Currency id: usd>>
+  #   '$100 USD'.to_money           #=> #<Money @fractional=10000, @currency=#<Money::Currency id: usd>>
+  #   'hello 2000 world'.to_money   #=> #<Money @fractional=200000 @currency=#<Money::Currency id: usd>>
+  #
+  # @see Money.from_string
+  #
+  def to_money(currency = nil)
+    Money.parse(self, currency)
+  end
+
+  # Converts the current string into a +Currency+ object.
+  #
+  # @return [Money::Currency]
+  #
+  # @raise [Money::Currency::UnknownCurrency]
+  #   If this String reference an unknown currency.
+  #
+  # @example
+  #   "USD".to_currency #=> #<Money::Currency id: usd>
+  #
+  def to_currency
+    Money::Currency.new(self)
+  end
+
+end
+
+# Open +Symbol+ to add new methods.
+class Symbol
+
+  # Converts the current symbol into a +Currency+ object.
+  #
+  # @return [Money::Currency]
+  #
+  # @raise [Money::Currency::UnknownCurrency]
+  #   If this String reference an unknown currency.
+  #
+  # @example
+  #   :ars.to_currency #=> #<Money::Currency id: ars>
+  #
+  def to_currency
+    Money::Currency.new(self)
+  end
+
+end