tiny-sharp-rb 0.0.1

data/money-7.0.2/config/currency_non_iso.json

@@ -0,0 +1,146 @@
+{
+  "bch": {
+    "priority": 100,
+    "iso_code": "BCH",
+    "name": "Bitcoin Cash",
+    "symbol": "₿",
+    "disambiguate_symbol": "₿CH",
+    "alternate_symbols": ["BCH"],
+    "subunit": "Satoshi",
+    "subunit_to_unit": 100000000,
+    "symbol_first": false,
+    "format": "%n %u",
+    "html_entity": "₿",
+    "decimal_mark": ".",
+    "thousands_separator": ",",
+    "iso_numeric": "",
+    "smallest_denomination": 1
+  },
+  "btc": {
+    "priority": 100,
+    "iso_code": "BTC",
+    "name": "Bitcoin",
+    "symbol": "₿",
+    "alternate_symbols": [],
+    "subunit": "Satoshi",
+    "subunit_to_unit": 100000000,
+    "symbol_first": true,
+    "html_entity": "₿",
+    "decimal_mark": ".",
+    "thousands_separator": ",",
+    "iso_numeric": "",
+    "smallest_denomination": 1
+  },
+  "jep": {
+    "priority": 100,
+    "iso_code": "JEP",
+    "name": "Jersey Pound",
+    "symbol": "£",
+    "disambiguate_symbol": "JEP",
+    "alternate_symbols": [],
+    "subunit": "Penny",
+    "subunit_to_unit": 100,
+    "symbol_first": true,
+    "html_entity": "£",
+    "decimal_mark": ".",
+    "thousands_separator": ",",
+    "iso_numeric": "",
+    "smallest_denomination": 1
+  },
+  "ggp": {
+    "priority": 100,
+    "iso_code": "GGP",
+    "name": "Guernsey Pound",
+    "symbol": "£",
+    "disambiguate_symbol": "GGP",
+    "alternate_symbols": [],
+    "subunit": "Penny",
+    "subunit_to_unit": 100,
+    "symbol_first": true,
+    "html_entity": "£",
+    "decimal_mark": ".",
+    "thousands_separator": ",",
+    "iso_numeric": "",
+    "smallest_denomination": 1
+  },
+  "imp": {
+    "priority": 100,
+    "iso_code": "IMP",
+    "name": "Isle of Man Pound",
+    "symbol": "£",
+    "disambiguate_symbol": "IMP",
+    "alternate_symbols": ["M£"],
+    "subunit": "Penny",
+    "subunit_to_unit": 100,
+    "symbol_first": true,
+    "html_entity": "£",
+    "decimal_mark": ".",
+    "thousands_separator": ",",
+    "iso_numeric": "",
+    "smallest_denomination": 1
+  },
+  "xfu": {
+    "priority": 100,
+    "iso_code": "XFU",
+    "name": "UIC Franc",
+    "symbol": "",
+    "disambiguate_symbol": "XFU",
+    "alternate_symbols": [],
+    "subunit": "",
+    "subunit_to_unit": 100,
+    "symbol_first": true,
+    "html_entity": "",
+    "decimal_mark": ".",
+    "thousands_separator": ",",
+    "iso_numeric": "",
+    "smallest_denomination": ""
+  },
+  "gbx": {
+    "priority": 100,
+    "iso_code": "GBX",
+    "name": "British Penny",
+    "symbol": "",
+    "disambiguate_symbol": "GBX",
+    "alternate_symbols": [],
+    "subunit": "",
+    "subunit_to_unit": 1,
+    "symbol_first": true,
+    "html_entity": "",
+    "decimal_mark": ".",
+    "thousands_separator": ",",
+    "iso_numeric": "",
+    "smallest_denomination": 1
+  },
+  "cnh": {
+    "priority": 100,
+    "iso_code": "CNH",
+    "name": "Chinese Renminbi Yuan Offshore",
+    "symbol": "¥",
+    "disambiguate_symbol": "CNH",
+    "alternate_symbols": ["CN¥", "元", "CN元"],
+    "subunit": "Fen",
+    "subunit_to_unit": 100,
+    "symbol_first": true,
+    "html_entity": "￥",
+    "decimal_mark": ".",
+    "thousands_separator": ",",
+    "iso_numeric": "",
+    "smallest_denomination": 1
+  },
+  "usdc": {
+    "priority": 100,
+    "iso_code": "USDC",
+    "name": "USD Coin",
+    "symbol": "USDC",
+    "disambiguate_symbol": "USDC",
+    "alternate_symbols": [],
+    "subunit": "Cent",
+    "subunit_to_unit": 1000000,
+    "symbol_first": false,
+    "html_entity": "$",
+    "decimal_mark": ".",
+    "thousands_separator": ",",
+    "iso_numeric": "",
+    "smallest_denomination": 1
+  }
+}

data/money-7.0.2/lib/money/bank/base.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+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/money-7.0.2/lib/money/bank/single_currency.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'money/bank/base'
+
+class Money
+  module Bank
+    # Raised when trying to exchange currencies
+    class DifferentCurrencyError < Error; end
+
+    # Class to ensure client code is operating in a single currency
+    # by raising if an exchange attempts to happen.
+    #
+    # This is useful when an application uses multiple currencies but
+    # it usually deals with only one currency at a time so any arithmetic
+    # where exchanges happen are erroneous. Using this as the default bank
+    # means that that these mistakes don't silently do the wrong thing.
+    class SingleCurrency < Base
+
+      # Raises a DifferentCurrencyError to remove possibility of accidentally
+      # exchanging currencies
+      def exchange_with(from, to_currency, &block)
+        raise DifferentCurrencyError, "No exchanging of currencies allowed: #{from} #{from.currency} to #{to_currency}"
+      end
+    end
+  end
+end

data/money-7.0.2/lib/money/bank/variable_exchange.rb

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+
+require 'money/bank/base'
+require 'money/rates_store/memory'
+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+.
+    #
+    # Exchange rates are stored in memory using +Money::RatesStore::Memory+ by default.
+    # Pass custom rates stores for other types of storage (file, database, etc)
+    #
+    # @example
+    #   bank = Money::Bank::VariableExchange.new
+    #   bank.add_rate("USD", "CAD", 1.24515)
+    #   bank.add_rate("CAD", "USD", 0.803115)
+    #
+    #   c1 = Money.new(100_00, "USD")
+    #   c2 = Money.new(100_00, "CAD")
+    #
+    #   # Exchange 100 USD to CAD:
+    #   bank.exchange_with(c1, "CAD") #=> #<Money fractional:12451 currency:CAD>
+    #
+    #   # Exchange 100 CAD to USD:
+    #   bank.exchange_with(c2, "USD") #=> #<Money fractional:8031 currency:USD>
+    #
+    #   # With custom exchange rates storage
+    #   redis_store = MyCustomRedisStore.new(host: 'localhost:6379')
+    #   bank = Money::Bank::VariableExchange.new(redis_store)
+    #   # Store rates in redis
+    #   bank.add_rate 'USD', 'CAD', 0.98
+    #   # Get rate from redis
+    #   bank.get_rate 'USD', 'CAD'
+    class VariableExchange < Base
+
+      attr_reader :mutex
+
+      # Available formats for importing/exporting rates.
+      RATE_FORMATS = [:json, :ruby, :yaml].freeze
+      SERIALIZER_SEPARATOR = '_TO_'.freeze
+      FORMAT_SERIALIZERS = {json: JSON, ruby: Marshal, yaml: YAML}.freeze
+
+      # Initializes a new +Money::Bank::VariableExchange+ object.
+      # It defaults to using an in-memory, thread safe store instance for
+      # storing exchange rates.
+      #
+      # @param [RateStore] st An exchange rate store, used to persist exchange rate pairs.
+      # @yield [n] Optional block to use when rounding after exchanging one
+      #  currency for another. See +Money::bank::base+
+      def initialize(st = Money::RatesStore::Memory.new, &block)
+        @store = st
+        super(&block)
+      end
+
+      def store
+        @store.is_a?(String) ? Object.const_get(@store) : @store
+      end
+
+      def marshal_dump
+        [store.marshal_dump, @rounding_method]
+      end
+
+      def marshal_load(arr)
+        store_info = arr[0]
+        @store = store_info.shift.new(*store_info)
+        @rounding_method = arr[1]
+      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 = Money.new(100_00, "USD")
+      #   c2 = Money.new(100_00, "CAD")
+      #
+      #   # Exchange 100 USD to CAD:
+      #   bank.exchange_with(c1, "CAD") #=> #<Money fractional:12451 currency:CAD>
+      #
+      #   # Exchange 100 CAD to USD:
+      #   bank.exchange_with(c2, "USD") #=> #<Money fractional:8031 currency:USD>
+      def exchange_with(from, to_currency, &block)
+        to_currency = Currency.wrap(to_currency)
+        if from.currency == to_currency
+          from
+        else
+          if rate = get_rate(from.currency, to_currency)
+            fractional = calculate_fractional(from, to_currency)
+            from.dup_with(
+              fractional: exchange(fractional, rate, &block),
+              currency: to_currency,
+              bank: self
+            )
+          else
+            raise UnknownRate, "No conversion rate known for '#{from.currency.iso_code}' -> '#{to_currency}'"
+          end
+        end
+      end
+
+      def calculate_fractional(from, to_currency)
+        BigDecimal(from.fractional.to_s) / (
+          BigDecimal(from.currency.subunit_to_unit.to_s) /
+          BigDecimal(to_currency.subunit_to_unit.to_s)
+        )
+      end
+
+      def exchange(fractional, rate, &block)
+        ex = fractional * BigDecimal(rate.to_s)
+        if block_given?
+          yield ex
+        elsif @rounding_method
+          @rounding_method.call(ex)
+        else
+          ex
+        end
+      end
+
+      # Registers a conversion rate and returns it (uses +#set_rate+).
+      # Delegates to +Money::RatesStore::Memory+
+      #
+      # @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.
+      # access.
+      # Delegates to +Money::RatesStore::Memory+
+      #
+      # @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.
+      # @param [Hash] opts Options hash to set special parameters. Backwards compatibility only.
+      #
+      # @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, opts = {})
+        store.add_rate(Currency.wrap(from).iso_code, Currency.wrap(to).iso_code, rate)
+      end
+
+      # Retrieve the rate for the given currencies.
+      # data access.
+      # Delegates to +Money::RatesStore::Memory+
+      #
+      # @param [Currency, String, Symbol] from Currency to exchange from.
+      # @param [Currency, String, Symbol] to Currency to exchange to.
+      # @param [Hash] opts Options hash to set special parameters. Backwards compatibility only.
+      #
+      # @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, opts = {})
+        store.get_rate(Currency.wrap(from).iso_code, Currency.wrap(to).iso_code)
+      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.
+      # @param [Hash] opts Options hash to set special parameters. Backwards compatibility only.
+      #
+      # @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, opts = {})
+        raise Money::Bank::UnknownRateFormat unless RATE_FORMATS.include?(format)
+
+        store.transaction do
+          s = FORMAT_SERIALIZERS[format].dump(rates)
+
+          unless file.nil?
+            File.open(file, "w") {|f| f.write(s) }
+          end
+
+          s
+        end
+      end
+
+      # This should be deprecated.
+      def rates
+        store.each_rate.each_with_object({}) do |(from,to,rate),hash|
+          hash[[from, to].join(SERIALIZER_SEPARATOR)] = rate
+        end
+      end
+
+      # Loads rates provided in +s+ given the specified format. Available
+      # formats are +:json+, +:ruby+ and +:yaml+.
+      # Delegates to +Money::RatesStore::Memory+
+      #
+      # @param [Symbol] format The format of +s+.
+      # @param [String] s The rates string.
+      # @param [Hash] opts Options hash to set special parameters. Backwards compatibility only.
+      #
+      # @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, opts = {})
+        raise Money::Bank::UnknownRateFormat unless RATE_FORMATS.include?(format)
+
+        if format == :ruby
+          warn '[WARNING] Using :ruby format when importing rates is potentially unsafe and ' \
+            'might lead to remote code execution via Marshal.load deserializer. Consider using ' \
+            'safe alternatives such as :json and :yaml.'
+        end
+
+        store.transaction do
+          data = FORMAT_SERIALIZERS[format].load(s)
+
+          data.each do |key, rate|
+            from, to = key.split(SERIALIZER_SEPARATOR)
+            store.add_rate from, to, rate
+          end
+        end
+
+        self
+      end
+    end
+  end
+end

data/money-7.0.2/lib/money/currency/heuristics.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class Money
+  class Currency
+    module Heuristics
+      def analyze(str)
+        raise StandardError, 'Heuristics deprecated, add `gem "money-heuristics"` to Gemfile'
+      end
+    end
+  end
+end

data/money-7.0.2/lib/money/currency/loader.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class Money
+  class Currency
+    module Loader
+      DATA_PATH = File.expand_path("../../../../config", __FILE__)
+
+      class << self
+        # Loads and returns the currencies stored in JSON files in the config directory.
+        #
+        # @return [Hash]
+        def load_currencies
+          currencies = parse_currency_file("currency_iso.json")
+          currencies.merge! parse_currency_file("currency_non_iso.json")
+          currencies.merge! parse_currency_file("currency_backwards_compatible.json")
+        end
+
+        private
+
+        def parse_currency_file(filename)
+          json = File.read("#{DATA_PATH}/#{filename}")
+          json.force_encoding(::Encoding::UTF_8) if defined?(::Encoding)
+          JSON.parse(json, symbolize_names: true)
+        end
+      end
+    end
+  end
+end