currency-rate 1.7.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: db91dd121b519bd89adba8d9576c0746792e5a9e40206347284ed4fc9acc3089
-  data.tar.gz: ae3c3b6b260e4e202d25e602fc215ff7f2f55837a8b0e355da6d8e3c565961b6
+  metadata.gz: e33cf57e2389c7faea732bc6a2c1005d1373daa26622d77d07058a157cb408b4
+  data.tar.gz: ecdcdf02e7478deb612bebe5fed48c3d46d99916f9f25b4e0666bcf88ed4c1f9
 SHA512:
-  metadata.gz: 6dbceacbf49cfb2d1f06174e443748ae6fced938b1ab2504e2a213d437afad3bf0cb822cd08041675e69fb55b9abc7e108c7433ed0c9e19621c9a17ab9f1da0c
-  data.tar.gz: 7fa1c6d94d9c34f9fd3ce672e044b24ee30ca081bda69bd19354902bd8df902bb6f5e073aac0525714f30d6d01bad1c7bb2cf21c835ebe278d457277e3760588
+  metadata.gz: d6d71b129e93052a97d6e27749531c16818e19eeb1f7b44b6889d67683543094eea7c9cf59f7dc6dae01e1e6e0f570c0709c06d3c786b7c7d275f1b4e60c6e65
+  data.tar.gz: 21cd15e77e63eb8df45f4b52904b7c9ac3fb0e0a93838a3373c31165af5a7d115c6982b2e8cdf869898ed24dbe07008bcc817b9464ca0510717cf5a92e359844

data/.gitignore

@@ -17,4 +17,4 @@ pkg
 .byebug_history
 
 # Private API keys for adapters
-api_keys.yml
+spec/api_keys.yml

data/lib/adapter.rb

@@ -4,28 +4,41 @@ module CurrencyRate
 
     SUPPORTED_CURRENCIES = []
     FETCH_URL = nil
-    API_KEY_PARAM = nil
 
-    def name
-      self.class.name.gsub /^.*::/, ""
+    attr_reader   :rates
+    attr_accessor :container
+    attr_accessor :api_key
+
+    def name(format=:snake_case)
+      @camel_case_name ||= self.class.name.gsub(/^.*::/, "").sub("Adapter", "")
+      @snake_case_name ||= @camel_case_name.to_snake_case
+      format == :camel_case ? @camel_case_name : @snake_case_name
+    end
+
+    def get_rate(from, to)
+      @rates = @container.storage.read(self.name) if @rates.nil? && @container.storage.exists?(self.name)
+      return BigDecimal(rates[to])                if ANCHOR_CURRENCY == from && rates[to]
+      return BigDecimal(1 / rates[from])          if ANCHOR_CURRENCY == to && rates[from]
+      return BigDecimal(rates[to] / rates[from])  if rates[from] && rates[to]
+      nil
     end
 
     def fetch_rates
       begin
-        normalize exchange_data
+        @rates = normalize(exchange_data)
       rescue StandardError => e
-        CurrencyRate.logger.error("Error in #{self.name}#fetch_rates")
-        CurrencyRate.logger.error(e)
+        @container.log(:error, e)
         nil
       end
     end
 
     def normalize(data)
-      if data.nil?
-        CurrencyRate.logger.warn("#{self.name}#normalize: data is nil")
+      @rates = if data.nil?
+        @container.log(:warn, "#{self.name}#normalize: data is nil")
         return nil
+      else
+        parse_raw_data(data)
       end
-      true
     end
 
     def exchange_data
@@ -37,34 +50,50 @@ module CurrencyRate
             result[name] = request url
           end
         else
-          request self.class::FETCH_URL
+          result = request self.class::FETCH_URL
         end
       rescue StandardError => e
-        CurrencyRate.logger.error("Error in #{self.name}#exchange_data")
-        CurrencyRate.logger.error(e)
+        @container.log(:error, e)
         nil
       end
     end
 
-    def request(url)
-      fetch_url = url
-      if self.class::API_KEY_PARAM
-        api_key = CurrencyRate.configuration.api_keys[self.name]
+    def url_with_api_key(url)
+      if url.include?("__API_KEY__")
         if api_key.nil?
-          CurrencyRate.logger.error("API key for #{self.name} not defined")
+          @container.log(:error, "API key for #{self.name} is not set")
           return nil
+        else
+          url.sub("__API_KEY__", api_key.strip)
         end
-        param_symbol = fetch_url.split("/").last.include?("?") ? "&" : "?"
-        fetch_url << "#{param_symbol}#{self.class::API_KEY_PARAM}=#{api_key}" if api_key
+      else
+        url
+      end
+    end
+
+    def request(url)
+      unless url = url_with_api_key(url)
+        return nil
       end
-      http_client = HTTP.timeout(connect: CurrencyRate.configuration.connect_timeout, read: CurrencyRate.configuration.read_timeout)
-      JSON.parse(
-        http_client
+      http_client = HTTP.timeout(connect: @container.connect_timeout, read: @container.read_timeout)
+      http_client
         .headers("Accept" => "application/json; version=1")
         .headers("Content-Type" => "text/plain")
-        .get(fetch_url)
+        .get(url)
         .to_s
-      )
+    end
+
+    def parse_raw_data(data)
+      if data.kind_of?(Hash)
+        data.each { |k,v| data[k] = parse_raw_data(v) }
+        data
+      else
+        begin
+          return JSON.parse(data)
+        rescue JSON::ParserError
+          return data
+        end
+      end
     end
 
   end

data/lib/adapters/crypto/binance_adapter.rb

@@ -20,7 +20,7 @@ module CurrencyRate
                 }
 
     def normalize(data)
-      return nil unless super
+      return nil unless data = super
       binance_result = data["Binance"].reduce({ "anchor" => ANCHOR_CURRENCY }) do |result, hash|
         if hash["symbol"].index(ANCHOR_CURRENCY) == 0
           result[hash["symbol"].sub(ANCHOR_CURRENCY, "")] = BigDecimal(hash["price"].to_s)

data/lib/adapters/crypto/bitfinex_adapter.rb

@@ -21,7 +21,7 @@ module CurrencyRate
     FETCH_URL = "https://api.bitfinex.com/v2/tickers?symbols=ALL"
 
     def normalize(data)
-      return nil unless super
+      return nil unless data = super
       data.reduce({ "anchor" => ANCHOR_CURRENCY }) do |result, pair_info|
         pair_name = pair_info[0].sub("t", "")
         key = pair_name.sub(ANCHOR_CURRENCY, "")

data/lib/adapters/crypto/bitpay_adapter.rb

@@ -18,7 +18,7 @@ module CurrencyRate
     FETCH_URL = "https://bitpay.com/api/rates"
 
     def normalize(data)
-      return nil unless super
+      return nil unless data = super
       data.reject { |rate| rate["code"] == ANCHOR_CURRENCY }.reduce({ "anchor" => ANCHOR_CURRENCY }) do |result, rate|
         result["#{rate['code'].upcase}"] = BigDecimal(rate["rate"].to_s)
         result

data/lib/adapters/crypto/bitstamp_adapter.rb

@@ -10,7 +10,7 @@ module CurrencyRate
     FETCH_URL["USD"] = "https://www.bitstamp.net/api/ticker/"
 
     def normalize(data)
-      return nil unless super
+      return nil unless data = super
       data.reduce({ "anchor" => ANCHOR_CURRENCY }) do |result, (key, value)|
         if key == "USD"
           result[key] =  BigDecimal(value["last"].to_s)

data/lib/adapters/crypto/coin_market_cap_adapter.rb

@@ -12,12 +12,10 @@ module CurrencyRate
     )
 
     ANCHOR_CURRENCY = "BTC"
-
-    FETCH_URL = "https://pro-api.coinmarketcap.com/v1/cryptocurrency/listings/latest"
-    API_KEY_PARAM = "CMC_PRO_API_KEY"
+    FETCH_URL = "https://pro-api.coinmarketcap.com/v1/cryptocurrency/listings/latest?CMC_PRO_API_KEY=__API_KEY__"
 
     def normalize(data)
-      return nil unless super
+      return nil unless data = super
       data["data"].each_with_object({ "anchor" => ANCHOR_CURRENCY }) do |payload, result|
         if payload["symbol"] == ANCHOR_CURRENCY
           result["USD"] = BigDecimal(payload["quote"]["USD"]["price"].to_s)

data/lib/adapters/crypto/coinbase_adapter.rb

@@ -18,9 +18,9 @@ module CurrencyRate
 
     FETCH_URL = "https://api.coinbase.com/v2/exchange-rates?currency=#{ANCHOR_CURRENCY}"
 
-    def normalize(response)
-      return nil unless super
-      response["data"]["rates"].reduce({ "anchor" => ANCHOR_CURRENCY }) do |result, (currency, rate)|
+    def normalize(data)
+      return nil unless data = super
+      data["data"]["rates"].reduce({ "anchor" => ANCHOR_CURRENCY }) do |result, (currency, rate)|
         result[currency] = BigDecimal(rate.to_s)
         result
       end

data/lib/adapters/crypto/exmo_adapter.rb

@@ -12,7 +12,7 @@ module CurrencyRate
     FETCH_URL = "https://api.exmo.com/v1/ticker/"
 
     def normalize(data)
-      return nil unless super
+      return nil unless data = super
       data.reduce({ "anchor" => ANCHOR_CURRENCY }) do |result, (key, value)|
         if key.split("_")[0] == ANCHOR_CURRENCY
           result[key.sub("#{self.class::ANCHOR_CURRENCY}_", "")] = BigDecimal(value["avg"].to_s)

data/lib/adapters/crypto/hit_BTC_adapter.rb

@@ -0,0 +1,64 @@
+module CurrencyRate
+  class HitBTCAdapter < Adapter
+    SUPPORTED_CURRENCIES = %w(
+      ZRC EDG IHT AEON SOC HBAR ZRX OPT APPC DRGN PTOY
+      XDN OKB CHSB NCT GUSD GET FUN EXP EMRX REV GHOST
+      BMH SNC DTR ERD SCL HMQ ACT ETC QTUM MTX SBTC
+      KIND SMT BTB SWFTC 1ST UTT AXPR NMR EVX IOTA XPRM
+      STMX SALT DGB NTK AMM ALGO ORMEUS BDG BQX EKO FYP
+      IPX HOT MG BTS ADX CRPT WAXP POA PLBT SHIP HTML
+      BOX GNO UBT BTT ZEN VEO POA20 BCPT SRN XPR ETHBNT
+      MANA QKC MLN FLP SOLO TRUE VSYS JST GNT BOS PHB
+      ZEC ESH SWM NANO VIBE HVN SOLVE ELEC LRC AGI LNC
+      WAVES WTC ONT STRAT GNX NEU BCN XPNT ECA ARDR KIN
+      LSK USE IOTX CRO IDH LINK OAX CPT NGC XNS KEY TKY
+      HSR TNT SMART TRST DCR WINGS GT MKR ONE DOGE ARN
+      ACAT BMC RAISE EXM TIME REX FDZ HT MTH SCC BET
+      DENT IDRT IPL ZAP CMCT TDP XAUR MTL NEBL SUSDT BAT
+      STEEM CUR BYTZ PRO LOOM USD DRG DICE ADK COMP DRT
+      XTZ WETH EURS CHZ NEO NPLC XCON LEVL PAX AIM PART
+      PRE ERK HEDG FET PAXG DAG AVA CUTE NEXO DAY PITCH
+      MITX NXT POWR PLR CVCOIN TUSD MYST DLT REM RLC DNA
+      FOTA SBD ELF TEL C20 PNT CND UTK ASI CVC ETP ETH
+      ZIL ARPA INK NPXS LEO MESH NIM DATX FXT PBT GST
+      BSV GAS CBC MCO SENT GBX XRC POE SUR LOC WIKI PPT
+      CVT APM LEND NUT DOV KMD AYA LUN XEM RVN BCD XMR
+      NWC USG CLO NLC2 BBTC BERRY ART GRIN VITAE XBP OMG
+      MDA KRL BCH POLY PLA BANCA ENJ TRIGX UUU PASS ANT
+      LAMB BIZZ RFR AMB ROOBEE BST LCC RCN MIN BUSD DIT
+      PPC AE IQ BNK CENNZ SUB OCN DGD VRA STX AERGO HGT
+      TRAD IGNIS REP DAPP DNT CDT YCC SNGLS ICX PKT COV
+      PAY ABYSS BLZ DAV TKN ERT SPC SEELE XZC MAID AUTO
+      REN DATA AUC TV LAVA KAVA DAI DAPS ADA COCOS MITH
+      SETH NRG PHX DASH VLX CHAT VET EOSDT ZSC KNC DGTX
+      CEL SHORTUSD IOST BNB PBTT XMC EMC VIB BNT STORJ
+      ATOM LCX SC FTT BTM XLM TRX CELR BRD DBIX ETN SNT
+      MOF HEX XUC PLU FACE TNC SIG PXG BDP BTX TAU DCT
+      YOYOW SYBC SWT MAN GLEEC EOS XVG NAV CURE XRP KICK
+      BRDG LTC USDC MATIC FTX BTG PMA
+    ).freeze
+
+    ANCHOR_CURRENCY = "BTC".freeze
+
+    FETCH_URL = "https://api.hitbtc.com/api/2/public/ticker".freeze
+
+    def normalize(data)
+      return nil unless data = super
+
+      data.each_with_object({ "anchor" => ANCHOR_CURRENCY }) do |pair_info, result|
+        pair_name = pair_info["symbol"]
+        next unless pair_name.include?(ANCHOR_CURRENCY)
+        next unless pair_info["last"]
+
+        key = pair_name.sub(ANCHOR_CURRENCY, "")
+
+        result[key] =
+          if pair_name.index(ANCHOR_CURRENCY) == 0
+            BigDecimal(pair_info["last"])
+          else
+            1 / BigDecimal(pair_info["last"])
+          end
+      end
+    end
+  end
+end

data/lib/adapters/crypto/huobi_adapter.rb

@@ -5,7 +5,7 @@ module CurrencyRate
     ANCHOR_CURRENCY = "BTC"
 
     def normalize(data)
-      return nil unless super
+      return nil unless data = super
 
       data["data"].each_with_object({ "anchor" => ANCHOR_CURRENCY }) do |pair_info, result|
         pair_name = pair_info["symbol"].upcase

data/lib/adapters/crypto/kraken_adapter.rb

@@ -24,7 +24,7 @@ module CurrencyRate
     FETCH_URL = "https://api.kraken.com/0/public/Ticker?pair=#{ %w(ADAXBT BCHXBT BSVXBT DASHXBT EOSXBT GNOXBT QTUMXBT XTZXBT XETCXXBT XETHXXBT XLTCXXBT XREPXXBT XXLMXXBT XXMRXXBT XXRPXXBT XZECXXBT XXBTZUSD XBTDAI XBTUSDC).join(",") }"
 
     def normalize(data)
-      return nil unless super
+      return nil unless data = super
       data["result"].reduce({ "anchor" => ANCHOR_CURRENCY }) do |result, (pair, value)|
         key = ta(pair.sub(ta(ANCHOR_CURRENCY), ""))
 

data/lib/adapters/crypto/localbitcoins_adapter.rb

@@ -14,7 +14,7 @@ module CurrencyRate
     FETCH_URL = 'https://localbitcoins.com/bitcoinaverage/ticker-all-currencies/'
 
     def normalize(data)
-      return nil unless super
+      return nil unless data = super
       data.reduce({ "anchor" => ANCHOR_CURRENCY }) do |result, (fiat, value)|
         result["#{fiat.upcase}"] = BigDecimal(value["rates"]["last"].to_s)
         result

data/lib/adapters/crypto/okcoin_adapter.rb

@@ -1,16 +1,14 @@
 module CurrencyRate
   class OkcoinAdapter < Adapter
     FETCH_URL = {
-      'LTC_USD' => 'https://www.okcoin.com/api/v1/ticker.do?symbol=ltc_usd',
-      'BTC_USD' => 'https://www.okcoin.com/api/v1/ticker.do?symbol=btc_usd',
-      'LTC_CNY' => 'https://www.okcoin.cn/api/ticker.do?symbol=ltc_cny',
-      'BTC_CNY' => 'https://www.okcoin.cn/api/ticker.do?symbol=btc_cny'
+      '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 super
+      return nil unless data = super
       data.reduce({}) do |result, (pair, value)|
-        result[pair] = BigDecimal(value["ticker"]["last"].to_s)
+        result[pair] = BigDecimal(value["last"].to_s)
         result
       end
     end

data/lib/adapters/crypto/paxful_adapter.rb

@@ -7,7 +7,7 @@ module CurrencyRate
     FETCH_URL = "https://paxful.com/api/currency/btc"
 
     def normalize(data)
-      return nil unless super
+      return nil unless data = super
 
       {
         "anchor" => ANCHOR_CURRENCY,

data/lib/adapters/crypto/poloniex_adapter.rb

@@ -14,7 +14,7 @@ module CurrencyRate
     FETCH_URL = "https://poloniex.com/public?command=returnTicker".freeze
 
     def normalize(data)
-      return nil unless super
+      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)

data/lib/adapters/crypto/yadio_adapter.rb

@@ -7,7 +7,7 @@ module CurrencyRate
     FETCH_URL = "https://api.yadio.io/rate/BTC"
 
     def normalize(data)
-      return nil unless super
+      return nil unless data = super
 
       {
         "anchor" => ANCHOR_CURRENCY,

data/lib/adapters/fiat/bonbast_adapter.rb

@@ -12,13 +12,11 @@ module CurrencyRate
     end
 
     def request(url)
-
-      http_client = HTTP.timeout(connect:
-        CurrencyRate.configuration.connect_timeout, read:
-        CurrencyRate.configuration.read_timeout
+      http_client = HTTP.timeout(
+        connect: @container.connect_timeout,
+        read:    @container.read_timeout
       )
       http_client.get(url).to_s
-
     end
 
   end

data/lib/adapters/fiat/coinmonitor_adapter.rb

@@ -3,12 +3,11 @@ module CurrencyRate
     # 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/api/dolar_ar/"
+    FETCH_URL = "https://ar.coinmonitor.info/data_ar.json"
 
     def normalize(data)
-      return nil unless super
-
-      { "anchor" => ANCHOR_CURRENCY }.merge({ SUPPORTED_CURRENCIES.first => BigDecimal(data["DOL_blue"].to_s) })
+      return nil unless data = super
+      { "anchor" => ANCHOR_CURRENCY }.merge({ SUPPORTED_CURRENCIES.first => BigDecimal(data["BTC_avr_ars"].to_s) })
     end
   end
-end
+end

data/lib/adapters/fiat/currency_layer_adapter.rb

@@ -17,11 +17,10 @@ module CurrencyRate
     )
 
     ANCHOR_CURRENCY = "USD"
-    FETCH_URL = "http://www.apilayer.net/api/live"
-    API_KEY_PARAM = "access_key"
+    FETCH_URL = "http://apilayer.net/api/live?access_key=__API_KEY__"
 
     def normalize(data)
-      return nil unless super
+      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)

data/lib/adapters/fiat/fixer_adapter.rb

@@ -2,13 +2,12 @@ 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/latest"
-    API_KEY_PARAM = "access_key"
+    FETCH_URL = "http://data.fixer.io/api/latest?access_key=__API_KEY__&base=#{ANCHOR_CURRENCY}"
 
     def normalize(data)
-      return nil unless super
+      return nil unless data = super
       rates = { "anchor" => ANCHOR_CURRENCY }
-      data["rates"].each do |k, v|
+      data["rates"].each do |k,v|
         rates[k] = BigDecimal(v.to_s)
       end
       rates

data/lib/adapters/fiat/forge_adapter.rb

@@ -1,22 +1,31 @@
 module CurrencyRate
   class ForgeAdapter < Adapter
     SUPPORTED_CURRENCIES = %w(
-      JPY CHF CAD SEK NOK MXN ZAR TRY CNH EUR GBP AUD NZD XAU XAG
+      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"
-    FETCH_URL = "https://forex.1forge.com/1.0.2/quotes?pairs=" + SUPPORTED_CURRENCIES.map { |c| "#{ANCHOR_CURRENCY}#{c}" }.join(",")
-    API_KEY_PARAM = "api_key"
+    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 super
+      return nil unless data = super
       rates = { "anchor" => self.class::ANCHOR_CURRENCY }
       data.each do |rate|
         if rate["error"]
-          CurrencyRate.logger.error("Forge exchange returned error")
+          @container.logger.error("Forge exchange returned error")
           return nil
         end
-        rates[rate["symbol"].sub(self.class::ANCHOR_CURRENCY, "")] = BigDecimal(rate["price"].to_s)
+        rates[rate["s"].sub("#{self.class::ANCHOR_CURRENCY}/", "")] = BigDecimal(rate["p"].to_s) if rate["p"]
       end
       rates
     end

data/lib/adapters/fiat/free_forex_adapter.rb

@@ -1,4 +1,8 @@
 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
@@ -18,10 +22,10 @@ module CurrencyRate
     )
 
     ANCHOR_CURRENCY = "USD"
-    FETCH_URL = "https://www.freeforexapi.com/api/live?pairs=" + SUPPORTED_CURRENCIES.map{|cur| "USD#{cur}"}.join(",")
+    FETCH_URL = "https://www.freeforexapi.com/api/live?pairs=" + SUPPORTED_CURRENCIES.map { |c| "USD#{c}"}.join(",")
 
     def normalize(data)
-      return nil unless super
+      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)
@@ -29,4 +33,4 @@ module CurrencyRate
       rates
     end
   end
-end
+end

data/lib/container.rb

@@ -0,0 +1,203 @@
+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

data/lib/currency_rate.rb

@@ -5,81 +5,37 @@ require "json"
 require "http"
 
 require_relative "exceptions"
-require_relative "configuration"
 require_relative "adapter"
-require_relative "fetcher"
-require_relative "synchronizer"
+require_relative "container"
+require_relative "utils/string_extensions"
 
 Dir["#{File.expand_path __dir__}/adapters/**/*.rb"].each { |f| require f }
-Dir["#{File.expand_path __dir__}/storage/**/*.rb"].each { |f| require f }
+Dir["#{File.expand_path __dir__}/storage/**/*.rb"].each  { |f| require f }
 
 module CurrencyRate
+
+  @@default_config = {
+    connect_timeout: 10,
+    read_timeout: 10,
+    logger_callbacks: {},
+    logger_settings:  { device: $stdout, level: :info, formatter: nil },
+    storage_settings: { path: __dir__, serializer: CurrencyRate::Storage::YAMLSerializer }
+  }
+
   class << self
-    attr_writer :configuration
-  end
 
-  def self.method_missing(m, *args, &block)
-    if m.to_s.end_with? "_adapters"
-      self.send(:adapters, m[0..-10])
-    else
-      super
+    def default_config
+      @@default_config
     end
-  end
 
-  def self.adapters(type)
-    Dir[File.join self.root, "lib/adapters/#{type}/*"].map do |file|
-      File.basename(file, ".rb").split('_')[0...-1].map {|w| w.capitalize}.join
+    def update_default_config(config_hash)
+      @@default_config.merge!(config_hash)
     end
-  end
-
-  def self.configuration
-    @configuration ||= Configuration.new
-  end
-
-  def self.configure
-    yield(configuration)
-  end
-
-  def self.fetcher
-    @fetcher ||= Fetcher.new(fiat_exchanges: configuration.fiat_adapters,
-                             crypto_exchanges: configuration.crypto_adapters,
-                             limit_sources_for_fiat_currencies: configuration.limit_sources_for_fiat_currencies)
-  end
-
-  def self.fetch_crypto(exchange, from, to)
-    fetcher.fetch_crypto(exchange, from, to)
-  end
-
-  def self.fetch_fiat(from, to)
-    fetcher.fetch_fiat(from, to)
-  end
-
-  def self.logger
-    return @logger if @logger
-    @logger = Logger.new(configuration.logger[:device])
-    @logger.progname = "CurrencyRate"
-    @logger.level = configuration.logger[:level]
-    @logger.formatter = configuration.logger[:formatter] if configuration.logger[:formatter]
-    @logger
-  end
-
-  def self.synchronizer
-    @synchronizer ||= Synchronizer.new
-  end
-
-  def self.sync_crypto!
-    synchronizer.sync_crypto!
-  end
 
-  def self.sync_fiat!
-    synchronizer.sync_fiat!
-  end
+    def root
+      File.expand_path("../", File.dirname(__FILE__))
+    end
 
-  def self.sync!
-    synchronizer.sync!
   end
 
-  def self.root
-    File.expand_path("../", File.dirname(__FILE__))
-  end
 end

data/lib/currency_rate/version.rb

@@ -1,3 +1,3 @@
 module CurrencyRate
-  VERSION = "1.7.0"
+  VERSION = "2.0.0"
 end

data/lib/storage/file_storage.rb

@@ -3,27 +3,32 @@ module CurrencyRate
     attr_reader   :path
     attr_accessor :serializer
 
-    def initialize(path:, serializer: nil)
+    def initialize(path:, container:, serializer: nil)
       @path       = path
+      @container  = container
       @serializer = serializer || Storage::YAMLSerializer.new
     end
 
-    def read(exchange_name)
-      path = path_for exchange_name.downcase
+    def exists?(adapter_name)
+      File.exists? path_for(adapter_name)
+    end
+
+    def read(adapter_name)
+      path = path_for adapter_name
       @serializer.deserialize File.read(path)
     rescue StandardError => e
-      CurrencyRate.logger.error(e)
+      @container.log(:error, e)
       nil
     end
 
-    def write(exchange_name, data = "")
-      File.write path_for(exchange_name.downcase), @serializer.serialize(data)
+    def write(adapter_name, data = "")
+      File.write path_for(adapter_name), @serializer.serialize(data)
     rescue StandardError => e
-      CurrencyRate.logger.error(e)
+      @container.log(:error, e)
     end
 
-    def path_for(exchange_name)
-      File.join @path, "#{exchange_name}_rates.yml"
+    def path_for(adapter_name)
+      File.join @path, "#{adapter_name}.yml"
     end
   end
 end

data/lib/utils/string_extensions.rb

@@ -0,0 +1,19 @@
+module StringExtensions
+
+  def to_snake_case
+    self.to_s.gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
+
+  def to_camel_case
+    words = self.to_s.split('_')
+    words.map { |w| w[0].capitalize + w[1..-1] }.join
+  end
+
+end
+
+class String; include StringExtensions; end
+class Symbol; include StringExtensions; end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: currency-rate
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Roman Snitko
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-08-18 00:00:00.000000000 Z
+date: 2020-12-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http
@@ -94,19 +94,16 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- api_keys.yml.sample
 - currency-rate.gemspec
 - lib/adapter.rb
 - lib/adapters/crypto/binance_adapter.rb
 - lib/adapters/crypto/bitfinex_adapter.rb
 - lib/adapters/crypto/bitpay_adapter.rb
 - lib/adapters/crypto/bitstamp_adapter.rb
-- lib/adapters/crypto/btc_china_adapter.rb
-- lib/adapters/crypto/btc_e_adapter.rb
 - lib/adapters/crypto/coin_market_cap_adapter.rb
 - lib/adapters/crypto/coinbase_adapter.rb
 - lib/adapters/crypto/exmo_adapter.rb
-- lib/adapters/crypto/hit_btc_adapter.rb
+- lib/adapters/crypto/hit_BTC_adapter.rb
 - lib/adapters/crypto/huobi_adapter.rb
 - lib/adapters/crypto/kraken_adapter.rb
 - lib/adapters/crypto/localbitcoins_adapter.rb
@@ -120,15 +117,13 @@ files:
 - lib/adapters/fiat/fixer_adapter.rb
 - lib/adapters/fiat/forge_adapter.rb
 - lib/adapters/fiat/free_forex_adapter.rb
-- lib/adapters/fiat/yahoo_adapter.rb
-- lib/configuration.rb
+- lib/container.rb
 - lib/currency_rate.rb
 - lib/currency_rate/version.rb
 - lib/exceptions.rb
-- lib/fetcher.rb
 - lib/storage/file_storage.rb
 - lib/storage/serializers/yaml_serializer.rb
-- lib/synchronizer.rb
+- lib/utils/string_extensions.rb
 homepage: https://gitlab.com/hodlhodl-public/currency-rate
 licenses: []
 metadata:
@@ -150,7 +145,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Converter for fiat and crypto currencies

data/api_keys.yml.sample

@@ -1,4 +0,0 @@
-ForgeAdapter: "<your_key>"
-CurrencyLayerAdapter: "<your_key>"
-FixerAdapter: "<your_key>"
-CoinMarketCapAdapter: "<your_key>"

data/lib/adapters/crypto/btc_china_adapter.rb

@@ -1,11 +0,0 @@
-module CurrencyRate
-  class BtcChinaAdapter < Adapter
-    FETCH_URL = 'https://data.btcchina.com/data/ticker'
-
-    def normalize(data)
-      return nil unless super
-      { "BTC_CNY" => BigDecimal(data["ticker"]["last"].to_s) }
-    end
-
-  end
-end

data/lib/adapters/crypto/btc_e_adapter.rb

@@ -1,18 +0,0 @@
-module CurrencyRate
-  class BtcEAdapter < Adapter
-    FETCH_URL = {
-      'BTC_USD' => 'https://wex.nz/api/2/btc_usd/ticker',
-      'BTC_EUR' => 'https://wex.nz/api/2/btc_eur/ticker',
-      'BTC_RUB' => 'https://wex.nz/api/2/btc_rur/ticker',
-    }
-
-    def normalize(data)
-      return nil unless super
-      data.reduce({}) do |result, (pair, value)|
-        result[pair] = BigDecimal(value["ticker"]["last"].to_s)
-        result
-      end
-    end
-
-  end
-end

data/lib/adapters/crypto/hit_btc_adapter.rb

@@ -1,61 +0,0 @@
-module CurrencyRate
-  class HitBTCAdapter < Adapter
-    SUPPORTED_CURRENCIES = %w(ZRC EDG IHT AEON SOC HBAR ZRX OPT APPC DRGN PTOY
-                              XDN OKB CHSB NCT GUSD GET FUN EXP EMRX REV GHOST
-                              BMH SNC DTR ERD SCL HMQ ACT ETC QTUM MTX SBTC
-                              KIND SMT BTB SWFTC 1ST UTT AXPR NMR EVX IOTA XPRM
-                              STMX SALT DGB NTK AMM ALGO ORMEUS BDG BQX EKO FYP
-                              IPX HOT MG BTS ADX CRPT WAXP POA PLBT SHIP HTML
-                              BOX GNO UBT BTT ZEN VEO POA20 BCPT SRN XPR ETHBNT
-                              MANA QKC MLN FLP SOLO TRUE VSYS JST GNT BOS PHB
-                              ZEC ESH SWM NANO VIBE HVN SOLVE ELEC LRC AGI LNC
-                              WAVES WTC ONT STRAT GNX NEU BCN XPNT ECA ARDR KIN
-                              LSK USE IOTX CRO IDH LINK OAX CPT NGC XNS KEY TKY
-                              HSR TNT SMART TRST DCR WINGS GT MKR ONE DOGE ARN
-                              ACAT BMC RAISE EXM TIME REX FDZ HT MTH SCC BET
-                              DENT IDRT IPL ZAP CMCT TDP XAUR MTL NEBL SUSDT BAT
-                              STEEM CUR BYTZ PRO LOOM USD DRG DICE ADK COMP DRT
-                              XTZ WETH EURS CHZ NEO NPLC XCON LEVL PAX AIM PART
-                              PRE ERK HEDG FET PAXG DAG AVA CUTE NEXO DAY PITCH
-                              MITX NXT POWR PLR CVCOIN TUSD MYST DLT REM RLC DNA
-                              FOTA SBD ELF TEL C20 PNT CND UTK ASI CVC ETP ETH
-                              ZIL ARPA INK NPXS LEO MESH NIM DATX FXT PBT GST
-                              BSV GAS CBC MCO SENT GBX XRC POE SUR LOC WIKI PPT
-                              CVT APM LEND NUT DOV KMD AYA LUN XEM RVN BCD XMR
-                              NWC USG CLO NLC2 BBTC BERRY ART GRIN VITAE XBP OMG
-                              MDA KRL BCH POLY PLA BANCA ENJ TRIGX UUU PASS ANT
-                              LAMB BIZZ RFR AMB ROOBEE BST LCC RCN MIN BUSD DIT
-                              PPC AE IQ BNK CENNZ SUB OCN DGD VRA STX AERGO HGT
-                              TRAD IGNIS REP DAPP DNT CDT YCC SNGLS ICX PKT COV
-                              PAY ABYSS BLZ DAV TKN ERT SPC SEELE XZC MAID AUTO
-                              REN DATA AUC TV LAVA KAVA DAI DAPS ADA COCOS MITH
-                              SETH NRG PHX DASH VLX CHAT VET EOSDT ZSC KNC DGTX
-                              CEL SHORTUSD IOST BNB PBTT XMC EMC VIB BNT STORJ
-                              ATOM LCX SC FTT BTM XLM TRX CELR BRD DBIX ETN SNT
-                              MOF HEX XUC PLU FACE TNC SIG PXG BDP BTX TAU DCT
-                              YOYOW SYBC SWT MAN GLEEC EOS XVG NAV CURE XRP KICK
-                              BRDG LTC USDC MATIC FTX BTG PMA).freeze
-
-    ANCHOR_CURRENCY = "BTC".freeze
-
-    FETCH_URL = "https://api.hitbtc.com/api/2/public/ticker".freeze
-
-    def normalize(data)
-      return nil unless super
-
-      data.each_with_object({ "anchor" => ANCHOR_CURRENCY }) do |pair_info, result|
-        pair_name = pair_info["symbol"]
-        next unless pair_name.include?(ANCHOR_CURRENCY)
-
-        key = pair_name.sub(ANCHOR_CURRENCY, "")
-
-        result[key] =
-          if pair_name.index(ANCHOR_CURRENCY) == 0
-            BigDecimal(pair_info["last"])
-          else
-            1 / BigDecimal(pair_info["last"])
-          end
-      end
-    end
-  end
-end

data/lib/adapters/fiat/yahoo_adapter.rb

@@ -1,35 +0,0 @@
-module CurrencyRate
-  class YahooAdapter < Adapter
-    SUPPORTED_CURRENCIES = %w(
-      AED AFN ALL AMD ANG AOA ARS AUD AWG AZN BAM BBD BDT BGN BHD BIF BMD BND
-      BRL BSD BTN BWP BYR BZD CAD CHF CLF CLP CNY COP CRC CUC CUP CVE CZK DEM
-      DJF DKK DOP DZD ECS EGP ERN ETB EUR FJD FKP FRF GBP GEL GHS GIP GMD GNF
-      GTQ GYD HKD HNL HRK HTG HUF IDR IEP ILS INR IQD ISK ITL JMD JOD JPY KES
-      KGS KHR KMF KWD KYD KZT LAK LBP LKR LRD LSL LTL LVL LYD MAD MGA MMK MNT
-      MOP MRO MUR MVR MWK MXN MXV 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 SLL SOS
-      SRD STD SVC SYP SZL THB TJS TMT TND TOP TRY TTD UAH UGX USD UYU UZS VND
-      VUV WST XAF XAG XAU XCD XDR XOF XPD XPF XPT YER ZAR ZMW ZWL
-    )
-
-    ANCHOR_CURRENCY = "USD"
-
-    FETCH_URL = "http://query.yahooapis.com/v1/public/yql?" + URI.encode_www_form(
-      format: 'json',
-      env: "store://datatables.org/alltableswithkeys",
-      q: "SELECT * FROM yahoo.finance.xchange WHERE pair IN" +
-        # The following line is building array string in SQL: '("USDJPY", "USDRUB", ...)'
-        "(#{SUPPORTED_CURRENCIES.map{|x| '"' + ANCHOR_CURRENCY + x.upcase + '"'}.join(',')})"
-    )
-
-    def normalize(data)
-      return nil unless super
-      rates = { "anchor" => self.class::ANCHOR_CURRENCY }
-      data["query"]["results"]["rate"].each do |rate|
-        rates[rate["Name"].split("/")[1]] = BigDecimal(rate["Rate"].to_s)
-      end
-      rates
-    end
-
-  end
-end

data/lib/configuration.rb

@@ -1,28 +0,0 @@
-module CurrencyRate
-  class Configuration
-    attr_accessor :api_keys
-    attr_accessor :logger
-    attr_accessor :crypto_adapters
-    attr_accessor :fiat_adapters
-    attr_accessor :connect_timeout
-    attr_accessor :read_timeout
-    attr_accessor :storage
-    attr_accessor :limit_sources_for_fiat_currencies
-    attr_accessor :crypto_currencies
-
-    def initialize
-      @api_keys         = { }
-      @logger           = {
-                            device: $stdout,
-                            level:  :info,
-                            formatter: nil,
-                          }
-       @crypto_adapters = CurrencyRate.adapters :crypto
-       @fiat_adapters   = CurrencyRate.adapters :fiat
-       @connect_timeout = 4
-       @read_timeout    = 4
-       @limit_sources_for_fiat_currencies = {}
-       @crypto_currencies = []
-    end
-  end
-end

data/lib/fetcher.rb

@@ -1,80 +0,0 @@
-module CurrencyRate
-  class Fetcher
-    attr_accessor :storage
-    attr_accessor :fiat_exchanges
-    attr_accessor :crypto_exchanges
-    attr_accessor :limit_sources_for_fiat_currencies
-
-    def initialize(fiat_exchanges: nil, crypto_exchanges: nil, storage: nil, limit_sources_for_fiat_currencies: {})
-      @storage = storage || CurrencyRate.configuration.storage
-      raise CurrencyRate::StorageNotDefinedError unless @storage
-
-      @fiat_exchanges = fiat_exchanges || ["Yahoo", "Fixer", "Forge"]
-      @crypto_exchanges = crypto_exchanges || ["Bitstamp", "Binance"]
-      @limit_sources_for_fiat_currencies = limit_sources_for_fiat_currencies
-    end
-
-    def fetch_crypto(exchange, from, to)
-      from = from.strip.upcase
-      to = to.strip.upcase
-      rates = @storage.read(exchange)
-
-      if rates.nil?
-        CurrencyRate.logger.warn("Fetcher#fetch_crypto: rates for #{exchange} not found in storage <#{@storage.class.name}>")
-        return nil
-      end
-
-      rate = calculate_rate(rates, from, to)
-      return rate unless rate.nil?
-
-      if to != "USD"
-        usd_fiat = fetch_fiat("USD", to)
-        return BigDecimal(rates["USD"] * usd_fiat) if usd_fiat && rates["USD"]
-      end
-      nil
-    end
-
-    def fetch_fiat(from, to)
-      from = from.strip.upcase
-      to = to.strip.upcase
-
-      exchanges = @fiat_exchanges.dup
-      exchanges += @crypto_exchanges if is_crypto_currency?(from) || is_crypto_currency?(to)
-
-      if(@limit_sources_for_fiat_currencies[from])
-        exchanges.select! { |ex| @limit_sources_for_fiat_currencies[from].include?(ex) }
-      end
-      if(@limit_sources_for_fiat_currencies[to])
-        exchanges.select! { |ex| @limit_sources_for_fiat_currencies[to].include?(ex) }
-      end
-
-      exchanges.each do |exchange|
-        rates = @storage.read(exchange)
-        next if rates.nil?
-
-        rate = calculate_rate(rates, from, to)
-        return rate unless rate.nil?
-      end
-      nil
-    end
-
-    private
-
-      def calculate_rate(rates, from, to)
-        anchor = rates.delete("anchor")
-
-        return BigDecimal(rates[to])               if anchor == from && rates[to]
-        return BigDecimal(1 / rates[from])         if anchor == to && rates[from]
-        return BigDecimal(rates[to] / rates[from]) if rates[from] && rates[to]
-
-        CurrencyRate.logger.warn("Fetcher: rate for #{from}_#{to} not found.")
-        nil
-      end
-
-      def is_crypto_currency?(currency)
-        CurrencyRate.configuration.crypto_currencies.include?(currency)
-      end
-
-  end
-end
-

data/lib/synchronizer.rb

@@ -1,54 +0,0 @@
-module CurrencyRate
-  class Synchronizer
-    attr_accessor :storage
-
-    def initialize(storage: nil)
-      @storage = storage || CurrencyRate.configuration.storage
-      raise CurrencyRate::StorageNotDefinedError unless @storage
-    end
-
-    def sync_fiat!
-      _sync CurrencyRate.configuration.fiat_adapters
-    end
-
-    def sync_crypto!
-      _sync CurrencyRate.configuration.crypto_adapters
-    end
-
-    def sync!
-      fiat = sync_fiat!
-      crypto = sync_crypto!
-      [fiat[0] | crypto[0], fiat[1] | crypto[1]]
-    end
-
-    private
-
-    def _sync(adapters)
-      successfull = []
-      failed = []
-      adapters.each do |provider|
-        adapter_name = "#{provider}Adapter"
-        begin
-          adapter = CurrencyRate.const_get(adapter_name).instance
-          rates = adapter.fetch_rates
-
-          unless rates
-            CurrencyRate.logger.warn("Synchronizer#sync!: rates for #{provider} not found")
-            failed.push(provider)
-            next
-          end
-
-          exchange_name = provider
-          @storage.write(exchange_name, rates)
-          successfull.push(provider)
-        rescue StandardError => e
-          failed.push({ provider: e })
-          CurrencyRate.logger.error(e)
-          next
-        end
-      end
-      [successfull, failed]
-    end
-
-  end
-end