currency-rate 2.0.0 → 2.0.3

data/lib/adapters/crypto/localbitcoins_adapter.rb

@@ -1,25 +0,0 @@
-module CurrencyRate
-  class LocalbitcoinsAdapter < Adapter
-    # No need to use it for fetching, just additional information about supported currencies
-    SUPPORTED_CURRENCIES = %w(
-      AED AOA ARS AUD BDT BRL BYN CAD CHF CLP CNY COP CRC CZK DKK DOP EGP ETH
-      EUR GBP GEL GHS HKD HUF IDR ILS INR IRR JOD JPY KES KRW KWD KZT LKR LTC
-      MAD MWK MXN MYR NGN NOK NZD OMR PAB PEN PHP PKR PLN QAR RON RSD RUB RWF
-      SAR SEK SGD SZL THB TRY TWD TZS UAH UGX USD UYU VES VND XAF XMR XOF XRP
-      ZAR ZMW
-    )
-
-    ANCHOR_CURRENCY = "BTC"
-
-    FETCH_URL = 'https://localbitcoins.com/bitcoinaverage/ticker-all-currencies/'
-
-    def normalize(data)
-      return nil unless data = super
-      data.reduce({ "anchor" => ANCHOR_CURRENCY }) do |result, (fiat, value)|
-        result["#{fiat.upcase}"] = BigDecimal(value["rates"]["last"].to_s)
-        result
-      end
-    end
-
-  end
-end

data/lib/adapters/crypto/okcoin_adapter.rb

@@ -1,17 +0,0 @@
-module CurrencyRate
-  class OkcoinAdapter < Adapter
-    FETCH_URL = {
-      'LTC_USD' => 'https://www.okcoin.com/api/spot/v3/instruments/LTC-USD/ticker',
-      'BTC_USD' => 'https://www.okcoin.com/api/spot/v3/instruments/BTC-USD/ticker',
-    }
-
-    def normalize(data)
-      return nil unless data = super
-      data.reduce({}) do |result, (pair, value)|
-        result[pair] = BigDecimal(value["last"].to_s)
-        result
-      end
-    end
-
-  end
-end

data/lib/adapters/crypto/paxful_adapter.rb

@@ -1,18 +0,0 @@
-module CurrencyRate
-  class PaxfulAdapter < Adapter
-    SUPPORTED_CURRENCIES = %w(USD)
-
-    ANCHOR_CURRENCY = "BTC"
-
-    FETCH_URL = "https://paxful.com/api/currency/btc"
-
-    def normalize(data)
-      return nil unless data = super
-
-      {
-        "anchor" => ANCHOR_CURRENCY,
-        "USD" => BigDecimal(data["price"].to_s)
-      }
-    end
-  end
-end

data/lib/adapters/crypto/poloniex_adapter.rb

@@ -1,33 +0,0 @@
-module CurrencyRate
-  class PoloniexAdapter < Adapter
-    SUPPORTED_CURRENCIES = %w(BTS DASH DOGE LTC NXT STR XEM XMR XRP USDT
-                              ETH SC DCR LSK STEEM ETC REP ARDR ZEC STRAT
-                              GNT ZRX CVC OMG GAS STORJ EOS SNT KNC BAT
-                              LOOM QTUM USDC MANA BNT BCHABC BCHSV FOAM
-                              NMR POLY LPT ATOM TRX ETHBNT LINK XTZ PAX
-                              USDJ SNX MATIC MKR DAI NEO SWFTC FXC AVA
-                              CHR BNB BUSD MDT XFIL LEND REN LRC WRX SXP
-                              STPT SWAP EXE).freeze
-
-    ANCHOR_CURRENCY = "BTC".freeze
-
-    FETCH_URL = "https://poloniex.com/public?command=returnTicker".freeze
-
-    def normalize(data)
-      return nil unless data = super
-
-      data.each_with_object({ "anchor" => ANCHOR_CURRENCY }) do |(pair_name, pair_info), result|
-        next unless pair_name.include?(ANCHOR_CURRENCY)
-
-        key = pair_name.sub(ANCHOR_CURRENCY, "").sub("_", "")
-
-        result[key] =
-          if pair_name.index(ANCHOR_CURRENCY) == 0
-            1 / BigDecimal(pair_info["last"])
-          else
-            BigDecimal(pair_info["last"])
-          end
-      end
-    end
-  end
-end

data/lib/adapters/crypto/yadio_adapter.rb

@@ -1,19 +0,0 @@
-module CurrencyRate
-  class YadioAdapter < Adapter
-    SUPPORTED_CURRENCIES = %w(VES)
-
-    ANCHOR_CURRENCY = "BTC"
-
-    FETCH_URL = "https://api.yadio.io/rate/BTC"
-
-    def normalize(data)
-      return nil unless data = super
-
-      {
-        "anchor" => ANCHOR_CURRENCY,
-        "USD" => BigDecimal(data["usd"].to_s),
-        "VES" => BigDecimal(data["rate"].to_s),
-      }
-    end
-  end
-end

data/lib/adapters/fiat/bonbast_adapter.rb

@@ -1,23 +0,0 @@
-module CurrencyRate
-  class BonbastAdapter < Adapter
-    # No need to use it for fetching, just additional information about supported currencies
-    SUPPORTED_CURRENCIES = %w(USD IRR)
-    ANCHOR_CURRENCY = "USD"
-    FETCH_URL = "https://www.bonbast.com/"
-
-    def normalize(data)
-      sell = data.match(/<td id="usd1"[^>]*>(\d+)<\/td>/)[1].to_f
-      buy  = data.match(/<td id="usd2"[^>]*>(\d+)<\/td>/)[1].to_f
-      { "anchor" => self.class::ANCHOR_CURRENCY, "IRR" => BigDecimal(([buy, sell].reduce(:+).fdiv(2)*10).to_s) }
-    end
-
-    def request(url)
-      http_client = HTTP.timeout(
-        connect: @container.connect_timeout,
-        read:    @container.read_timeout
-      )
-      http_client.get(url).to_s
-    end
-
-  end
-end

data/lib/adapters/fiat/coinmonitor_adapter.rb

@@ -1,13 +0,0 @@
-module CurrencyRate
-  class CoinmonitorAdapter < Adapter
-    # No need to use it for fetching, just additional information about supported currencies
-    SUPPORTED_CURRENCIES = %w(ARS)
-    ANCHOR_CURRENCY = "USD"
-    FETCH_URL = "https://ar.coinmonitor.info/data_ar.json"
-
-    def normalize(data)
-      return nil unless data = super
-      { "anchor" => ANCHOR_CURRENCY }.merge({ SUPPORTED_CURRENCIES.first => BigDecimal(data["BTC_avr_ars"].to_s) })
-    end
-  end
-end

data/lib/adapters/fiat/currency_layer_adapter.rb

@@ -1,31 +0,0 @@
-module CurrencyRate
-  class CurrencyLayerAdapter < Adapter
-    # No need to use it for fetching, just additional information about supported currencies
-    SUPPORTED_CURRENCIES = %w(
-      AED AFN ALL AMD ANG AOA ARS AUD AWG AZN BAM BBD BDT BGN
-      BHD BIF BMD BND BOB BRL BSD BTC BTN BWP BYN BYR BZD CAD
-      CDF CHF CLF CLP CNY COP CRC CUC CUP CVE CZK DJF DKK DOP
-      DZD EGP ERN ETB EUR FJD FKP GBP GEL GGP GHS GIP GMD GNF
-      GTQ GYD HKD HNL HRK HTG HUF IDR ILS IMP INR IQD IRR ISK
-      JEP JMD JOD JPY KES KGS KHR KMF KPW KRW KWD KYD KZT LAK
-      LBP LKR LRD LSL LTL LVL LYD MAD MDL MGA MKD MMK MNT MOP
-      MRO MUR MVR MWK MXN MYR MZN NAD NGN NIO NOK NPR NZD OMR
-      PAB PEN PGK PHP PKR PLN PYG QAR RON RSD RUB RWF SAR SBD
-      SCR SDG SEK SGD SHP SLL SOS SRD STD SVC SYP SZL THB TJS
-      TMT TND TOP TRY TTD TWD TZS UAH UGX USD UYU UZS VEF VND
-      VUV WST XAF XAG XAU XCD XDR XOF XPF YER ZAR ZMK ZMW ZWL
-    )
-
-    ANCHOR_CURRENCY = "USD"
-    FETCH_URL = "http://apilayer.net/api/live?access_key=__API_KEY__"
-
-    def normalize(data)
-      return nil unless data = super
-      rates = { "anchor" => self.class::ANCHOR_CURRENCY }
-      data["quotes"].each do |key, value|
-        rates[key.sub(self.class::ANCHOR_CURRENCY, "")] = BigDecimal(value.to_s)
-      end
-      rates
-    end
-  end
-end

data/lib/adapters/fiat/fixer_adapter.rb

@@ -1,17 +0,0 @@
-module CurrencyRate
-  class FixerAdapter < Adapter
-    # EUR is the only currency available as a base on free plan
-    ANCHOR_CURRENCY = "EUR"
-    FETCH_URL = "http://data.fixer.io/api/latest?access_key=__API_KEY__&base=#{ANCHOR_CURRENCY}"
-
-    def normalize(data)
-      return nil unless data = super
-      rates = { "anchor" => ANCHOR_CURRENCY }
-      data["rates"].each do |k,v|
-        rates[k] = BigDecimal(v.to_s)
-      end
-      rates
-    end
-
-  end
-end

data/lib/adapters/fiat/forge_adapter.rb

@@ -1,34 +0,0 @@
-module CurrencyRate
-  class ForgeAdapter < Adapter
-    SUPPORTED_CURRENCIES = %w(
-      AED AFN ALL AMD ANG AOA ARE ARS AUD AUN AWG BAM BBD BDT BGN BHD BIF BMD
-      BND BOB BRI BRL BSD BTN BWP BYN BZD CAD CDF CHF CLF CLP CLY CNH CNY COP
-      CRC CUP CVE CYP CZK DJF DKK DOE DOP DZD EGP ETB EUR FJD FRN GBP GEL GHS
-      GMD GNF GTQ GYD HKD HNL HRK HTG HUF IDR ILS INR IQD IRR ISK JMD JOD JPY
-      KES KHR KMF KRU KRW KWD KYD KZT LAK LBP LFX LKR LRD LSL LTL LYD M5P MAD
-      MAL MDL MGA MKD MMK MOP MRU MTL MUR MVR MWK MXN MYR MZN NAD NBL NGN NIO
-      NOK NPR NSO NZD OMR OSO PAB PEN PGK PHP PKR PLN PYG QAR RON RSD RUB RWF
-      SAR SBD SCR SDG SEK SGD SHP SLL SOS SRD STN SVC SZL THB TJS TMT TND TOP
-      TRY TTD TWD TZS UAH UGX USD UYU UZS VES VND VRL VRN XAG XAGK XAU XAUK XCD
-      XDR XOF XPD XPDK XPF XPT XPTK YER ZAR ZMW ZWD
-    )
-
-    ANCHOR_CURRENCY = "USD"
-    currency_pairs_request = SUPPORTED_CURRENCIES.map { |c| "#{ANCHOR_CURRENCY}/#{c}" }.join(",")
-    FETCH_URL = "https://api.1forge.com/quotes?pairs=#{currency_pairs_request}&api_key=__API_KEY__"
-
-    def normalize(data)
-      return nil unless data = super
-      rates = { "anchor" => self.class::ANCHOR_CURRENCY }
-      data.each do |rate|
-        if rate["error"]
-          @container.logger.error("Forge exchange returned error")
-          return nil
-        end
-        rates[rate["s"].sub("#{self.class::ANCHOR_CURRENCY}/", "")] = BigDecimal(rate["p"].to_s) if rate["p"]
-      end
-      rates
-    end
-
-  end
-end

data/lib/adapters/fiat/free_forex_adapter.rb

@@ -1,36 +0,0 @@
-module CurrencyRate
-
-  # Beware, freeforexapi.com doesn't normally work and you need to place
-  # a small banner on your website so they'd list your websites IP address.
-  # More info here: http://freeforexapi.com/Home/Api
-  class FreeForexAdapter < Adapter
-    SUPPORTED_CURRENCIES = %w(
-      AED AFN ALL AMD ANG AOA ARS ATS AUD AWG AZM AZN BAM BBD BDT
-      BEF BGN BHD BIF BMD BND BOB BRL BSD BTN BWP BYN BYR BZD CAD
-      CDF CLP CNH CNY COP CRC CUC CUP CVE CYP CZK DEM DJF DKK DOP
-      DZD EEK EGP ERN ESP ETB EUR FIM FJD FKP FRF GBP GEL GGP GHC
-      GHS GIP GMD GNF GRD GTQ GYD HKD HNL HRK HTG HUF IDR IEP ILS
-      IMP INR IQD IRR ISK ITL JEP JMD JOD KES KGS KHR KMF KPW KRW
-      KWD KYD KZT LAK LBP LKR LRD LSL LTL LUF LVL LYD MAD MDL MGA
-      MGF MKD MMK MNT MOP MRO MRU MTL MUR MVR MWK MXN MYR MZM MZN
-      NAD NGN NIO NLG NOK NPR NZD OMR PAB PEN PGK PHP PKR PLN PTE
-      PYG QAR ROL RON RSD RUB RWF SAR SBD SCR SDD SDG SEK SGD SHP
-      SIT SKK SLL SOS SPL SRD SRG STD STN SVC SYP SZL THB TJS TMM
-      TMT TND TOP TRL TRY TTD TVD TWD TZS UAH UGX UYU UZS VAL VEB
-      VEF VES VND VUV WST XAF XAG XAU XBT XCD XDR XOF XPD XPF XPT
-      YER ZAR ZMK ZMW ZWD
-    )
-
-    ANCHOR_CURRENCY = "USD"
-    FETCH_URL = "https://www.freeforexapi.com/api/live?pairs=" + SUPPORTED_CURRENCIES.map { |c| "USD#{c}"}.join(",")
-
-    def normalize(data)
-      return nil unless data = super
-      rates = { "anchor" => self.class::ANCHOR_CURRENCY }
-      data["rates"].each do |pair, payload|
-        rates[pair.sub(self.class::ANCHOR_CURRENCY, "")] = BigDecimal(payload["rate"].to_s)
-      end
-      rates
-    end
-  end
-end

data/lib/container.rb

@@ -1,203 +0,0 @@
-class CurrencyRate::Container
-
-  attr_accessor :api_keys
-  attr_accessor :logger
-  attr_accessor :adapters
-  attr_accessor :connect_timeout
-  attr_accessor :read_timeout
-  attr_accessor :storage
-  attr_accessor :logger_callbacks
-  attr_accessor :limit_adapters_for_pairs
-
-  def initialize(
-    api_keys: {},
-    adapter_type: nil,
-    adapter_names: nil,
-    limit_adapters_for_pairs: {},
-    storage_settings: CurrencyRate.default_config[:storage_settings],
-    connect_timeout: CurrencyRate.default_config[:connect_timeout],
-    read_timeout: CurrencyRate.default_config[:read_timeout],
-    logger_settings: CurrencyRate.default_config[:logger_settings],
-    logger_callbacks: CurrencyRate.default_config[:logger_callbacks]
-  )
-
-    logger_settigns = CurrencyRate.default_config[:logger_settings].merge(logger_settings)
-    storage_settigns = CurrencyRate.default_config[:storage_settings].merge(storage_settings)
-
-    method(__method__).parameters.map do |_, name|
-      value = binding.local_variable_get(name)
-      instance_variable_set("@#{name}", value)
-    end
-
-    _logger_callbacks = {}
-    @logger_callbacks.each do |k,v|
-      _logger_callbacks[Logger::Severity.const_get(k.to_s.upcase)] = v
-    end
-    @logger_callbacks = _logger_callbacks
-
-    _limit_adapters_for_pairs = {}
-    @limit_adapters_for_pairs.each do |k,v|
-      _limit_adapters_for_pairs[k] = CurrencyRate.const_get(v.to_s.to_camel_case + "Adapter").instance
-    end
-    @limit_adapters_for_pairs = _limit_adapters_for_pairs
-
-    @storage = CurrencyRate.const_get(storage_settigns[:type].to_s.to_camel_case + "Storage").new(
-      path: storage_settings[:path],
-      container: self,
-      serializer: storage_settings[:serializer]
-    )
-
-    load_adapters!(names: adapter_names, type: adapter_type)
-  end
-
-  def method_missing(m, *args, &block)
-    if m.to_s.end_with? "_adapters"
-      self.send(:adapters, m[0..-10])
-    else
-      super
-    end
-  end
-
-  def logger
-    return @logger if @logger
-    @logger = Logger.new(@logger_settings[:device])
-    @logger.progname  = "CurrencyRate"
-    @logger.level     = @logger_settings[:level]
-    @logger.formatter = @logger_settings[:formatter] if @logger_settings[:formatter]
-    @logger
-  end
-
-  # This method doesn't make any requests. It merely reads normalized data 
-  # from the selected storage. Contrary to what one might assume,
-  # it doesn't call CurrencyRate::Container.sync! if storage for a particular
-  # adapter doesn't exist - that's because those are two separate tasks
-  # and you might not want to make that external http(s) request even if
-  # the rates in storage are not found.
-  #
-  # It also uses a 3 different strategies to calculate rates before they are returned:
-  #
-  # 1. If only one adapter is specified and/or available, it will return the rate for the
-  #    pair using the data from the storage for this particular adapter.
-  #
-  # 2. If two or more adapters are specified and available, it will return the average rate
-  #    based on the the rates from all of those adapters.
-  #
-  # 3. If `strategy: :majority` flag is set and an odd number of adapters (say, 3) 
-  #    is passed and/or available it will look at the rates from all, separate them
-  #    into two groups based on how close their rates are and return the average of the rates
-  #    that are closest in the group that is the largest.
-  #
-  # It will also check @limit_adapters_for_pairs hash for the request pair
-  # and if the key exists it will exclude adapters that are not listed in the array
-  # under that key.
-  def get_rate(from, to, use_adapters=@adapter_names, strategy: :average)
-    adapters_for_pair = @limit_adapters_for_pairs["#{from}/#{to}"]
-    _adapters = adapters.select { |a| use_adapters.include?(a.name(:camel_case))       }
-    _adapters = _adapters.select { |a| adapters_for_pair.include?(a.name(:camel_case)) } if adapters_for_pair
-
-    warning_loggers = []
-    rates = _adapters.map do |a|
-      rate = [a.name(:camel_case), a.get_rate(from, to)]
-      warning_loggers.push -> { self.log(:warn, "No rate for pair #{from}/#{to} found in #{a.name(:camel_case)} adapter") if rate[1].nil? }
-      rate
-    end.select { |r| !r[1].nil? }
-
-    if rates.empty?
-      self.log(:error,
-        "No rate for pair #{from}/#{to} is found in any of the available adapters " +
-        "(#{_adapters.map { |a| a.name(:camel_case) }.join(", ")})"
-      )
-    else
-      warning_loggers.each { |wl| wl.call }
-    end
-
-    if rates.size == 1
-      rates[0][1]
-    else
-      if strategy == :majority && rates.size.odd?
-        rates.sort! { |r1, r2| r1[1] <=> r2[1] }
-
-        largest_discrepancy_rate_index = 0
-        last_discrepancy = 0
-
-        rates.each_with_index do |r,i|
-          if i > 0
-            discrepancy = r[1] - rates[i-1][1]
-            if discrepancy > last_discrepancy
-              last_discrepancy = discrepancy
-              largest_discrepancy_rate_index = i
-            end
-          end
-        end
-
-        rates_group_1 = rates[0...largest_discrepancy_rate_index]
-        rates_group_2 = rates[largest_discrepancy_rate_index..rates.size-1]
-        rates = [rates_group_1, rates_group_2].max { |g1,g2| g1.size <=> g2.size }
-      end
-      rates.inject(BigDecimal(0)) { |sum, i| sum + i[1] } / BigDecimal(rates.size)
-    end
-
-  end
-
-  def sync!
-    successfull = []
-    failed      = []
-    @adapters.each do |adapter|
-      adapter_name = adapter.class.to_s.sub("CurrencyRate::", "")
-      begin
-        rates = adapter.fetch_rates
-        unless rates
-          self.log(:warn, "Trying to sync rates for #{adapter_name}, rates not found, but http(s) request did not return any error.")
-          failed << adapter_name
-          next
-        end
-        @storage.write(adapter_name.to_snake_case.sub("_adapter", ""), rates)
-        successfull << adapter_name
-      rescue StandardError => e
-        failed << adapter_name
-        self.log(:error, e)
-        next
-      end
-    end
-    [successfull, failed]
-  end
-
-  def log(level, message)
-    severity = Logger::Severity.const_get(level.to_s.upcase)
-    logger.send(level, message)
-    if @logger_callbacks[severity]
-      @logger_callbacks[severity].call(level, message)
-    else
-      @logger_callbacks.keys.sort.each do |k|
-        @logger_callbacks[k].call(level, message) && break if k < severity
-      end
-    end
-  end
-
-  private
-
-  def load_adapters!(names: nil, type: :all)
-    if names
-      names = [names] if names.kind_of?(String)
-      @adapters = names.map do |name|
-        CurrencyRate.const_get(name + "Adapter").instance
-      end
-    else
-      crypto_adapter_files = Dir[File.join CurrencyRate.root, "lib/adapters/crypto/*"]
-      fiat_adapter_files   = Dir[File.join CurrencyRate.root, "lib/adapters/fiat/*"]
-      adapter_files = case type
-        when :crypto  then crypto_adapter_files
-        when :fiat    then fiat_adapter_files
-        else               crypto_adapter_files + fiat_adapter_files
-      end
-      @adapters = adapter_files.map do |file|
-        CurrencyRate.const_get(File.basename(file, ".rb").to_camel_case).instance
-      end
-    end
-    @adapters.each { |a| a.container = self; a.api_key = @api_keys[a.name] }
-    @adapter_names = @adapters.map { |a| a.name(:camel_case) }
-    @adapters
-  end
-
-
-end