currency-rate 1.2.0 → 1.4.1

data/lib/adapters/crypto/coinbase_adapter.rb

@@ -1,11 +1,27 @@
 module CurrencyRate
   class CoinbaseAdapter < Adapter
-    FETCH_URL = 'https://coinbase.com/api/v1/currencies/exchange_rates'
+    # 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 BAT BBD BCH BDT BGN BHD BIF BMD
+      BND BOB BRL BSD BTC BTN BWP BYN BYR BZD CAD CDF CHF CLF CLP CNH CNY COP CRC
+      CUC CVE CZK DJF DKK DOP DZD EEK EGP ERN ETB ETC ETH EUR FJD FKP GBP GEL GGP
+      GHS GIP GMD GNF GTQ GYD HKD HNL HRK HTG HUF IDR ILS IMP INR IQD ISK JEP JMD
+      JOD JPY KES KGS KHR KMF KRW KWD KYD KZT LAK LBP LKR LRD LSL LTC LTL LVL LYD
+      MAD MDL MGA MKD MMK MNT MOP MRO MTL 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 SEK
+      SGD SHP SLL SOS SRD SSP STD SVC SZL THB TJS TMT TND TOP TRY TTD TWD TZS UAH
+      UGX USD SDC UYU UZS VEF VND VUV WST XAF XAG XAU XCD XDR XOF XPD XPF XPT YER
+      ZAR ZEC ZMK ZMW ZRX ZWL
+    )
 
-    def normalize(data)
+    ANCHOR_CURRENCY = "BTC"
+
+    FETCH_URL = "https://api.coinbase.com/v2/exchange-rates?currency=#{ANCHOR_CURRENCY}"
+
+    def normalize(response)
       return nil unless super
-      data.reduce({}) do |result, (pair, value)|
-        result[pair.gsub("_to_", "_").upcase] = BigDecimal.new(value.to_s)
+      response["data"]["rates"].reduce({ "anchor" => ANCHOR_CURRENCY }) do |result, (currency, rate)|
+        result[currency] = BigDecimal.new(rate.to_s)
         result
       end
     end

data/lib/adapters/crypto/exmo_adapter.rb

@@ -0,0 +1,27 @@
+module CurrencyRate
+  class ExmoAdapter < Adapter
+    # No need to use it for fetching, just additional information about supported currencies
+    SUPPORTED_CURRENCIES = %w(
+      ADA BCH BTC BTCZ BTG DASH DOGE DXT EOS ETC ETH EUR GAS GNT GUSD HB
+      HBZ INK KICK LSK LTC MNX NEO OMG PLN QTUM RUB SMART STQ TRX TRY UAH
+      USD USDT WAVES XEM XLM XMR XRP ZEC ZRX
+    )
+
+    ANCHOR_CURRENCY = "BTC"
+
+    FETCH_URL = "https://api.exmo.com/v1/ticker/"
+
+    def normalize(data)
+      return nil unless super
+      data.reduce({ "anchor" => ANCHOR_CURRENCY }) do |result, (key, value)|
+        if key.split("_")[0] == ANCHOR_CURRENCY
+          result[key.sub("#{self.class::ANCHOR_CURRENCY}_", "")] = BigDecimal.new(value["avg"].to_s)
+        elsif key.split("_")[1] == ANCHOR_CURRENCY
+          result[key.sub("_#{self.class::ANCHOR_CURRENCY}", "")] = 1 / BigDecimal.new(value["avg"].to_s)
+        end
+        result
+      end
+    end
+
+  end
+end

data/lib/adapters/crypto/kraken_adapter.rb

@@ -1,21 +1,32 @@
 module CurrencyRate
   class KrakenAdapter < Adapter
-    FETCH_URL = {
-      "BTC_USD" => "https://api.kraken.com/0/public/Ticker?pair=xbtusd",
-      "BTC_EUR" => "https://api.kraken.com/0/public/Ticker?pair=xbteur",
-      "LTC_USD" => "https://api.kraken.com/0/public/Ticker?pair=ltcusd",
-      "LTC_EUR" => "https://api.kraken.com/0/public/Ticker?pair=ltceur",
-    }
+    SUPPORTED_CURRENCIES = %w(
+      ADA BCH BSV BTC DASH EOS ETC ETH GNO LTC MLN
+      NMC QTUM REP USDT XDG XLM XMR XRP XTZ ZEC
+    )
 
     ASSET_MAP = {
-      "BTC" => "XBT",
-    }
+                  "XXBTZ" => "BTC",
+                  "XETCZ" => "ETC",
+                  "XETHZ" => "ETH",
+                  "XLTCZ" => "LTC",
+                  "XREPZ" => "REP",
+                  "XXLMZ" => "XLM",
+                  "XXMRZ" => "XMR",
+                  "XXRPZ" => "XRP",
+                  "XZECZ" => "ZEC",
+                  "USDTZ" => "USDT",
+                  "TZUSD" => "USDT",
+                }
+
+    ANCHOR_CURRENCY = "USD"
+
+    FETCH_URL = "https://api.kraken.com/0/public/Ticker?pair=#{ %w(ADAUSD BCHUSD BSVUSD DASHUSD EOSUSD GNOUSD QTUMUSD XTZUSD USDTZUSD XETCZUSD XETHZUSD XLTCZUSD XREPZUSD XXLMZUSD XXMRZUSD XXRPZUSD XZECZUSD XXBTZUSD).join(",") }"
 
     def normalize(data)
       return nil unless super
-      data.reduce({}) do |result, (pair, value)|
-        crypto, fiat = pair.split("_")
-        result[pair] = BigDecimal.new(value["result"]["X#{ta(crypto)}Z#{ta(fiat)}"]["c"].first.to_s)
+      data["result"].reduce({ "anchor" => ANCHOR_CURRENCY, ANCHOR_CURRENCY => BigDecimal.new("1") }) do |result, (pair, value)|
+        result[ta(pair.sub(ANCHOR_CURRENCY, ""))] = 1 / BigDecimal.new(value["c"].first.to_s)
         result
       end
     end

data/lib/adapters/crypto/localbitcoins_adapter.rb

@@ -1,11 +1,22 @@
 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 super
-      data.reduce({}) do |result, (fiat, value)|
-        result["BTC_#{fiat.upcase}"] = BigDecimal.new(value["rates"]["last"].to_s)
+      data.reduce({ "anchor" => ANCHOR_CURRENCY }) do |result, (fiat, value)|
+        result["#{fiat.upcase}"] = BigDecimal.new(value["rates"]["last"].to_s)
         result
       end
     end

data/lib/adapters/fiat/currency_layer_adapter.rb

@@ -1,18 +1,20 @@
 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)
+    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://www.apilayer.net/api/live"

data/lib/adapters/fiat/fixer_adapter.rb

@@ -1,7 +1,9 @@
 module CurrencyRate
   class FixerAdapter < Adapter
-    ANCHOR_CURRENCY = "USD"
-    FETCH_URL = "http://api.fixer.io/latest?base=usd"
+    # 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"
 
     def normalize(data)
       return nil unless super

data/lib/adapters/fiat/forge_adapter.rb

@@ -1,9 +1,11 @@
 module CurrencyRate
   class ForgeAdapter < Adapter
-    SUPPORTED_CURRENCIES = %w(JPY CHF CAD SEK NOK MXN ZAR TRY CNH EUR GBP AUD NZD XAU XAG)
+    SUPPORTED_CURRENCIES = %w(
+      JPY CHF CAD SEK NOK MXN ZAR TRY CNH EUR GBP AUD NZD XAU XAG
+    )
+
     ANCHOR_CURRENCY = "USD"
-    FETCH_URL = "https://forex.1forge.com/1.0.2/quotes?pairs=" +
-      SUPPORTED_CURRENCIES.map { |c| "#{ANCHOR_CURRENCY}#{c}" }.join(",")
+    FETCH_URL = "https://forex.1forge.com/1.0.2/quotes?pairs=" + SUPPORTED_CURRENCIES.map { |c| "#{ANCHOR_CURRENCY}#{c}" }.join(",")
     API_KEY_PARAM = "api_key"
 
     def normalize(data)

data/lib/adapters/fiat/free_forex_adapter.rb

@@ -0,0 +1,32 @@
+module CurrencyRate
+  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{|cur| "USD#{cur}"}.join(",")
+
+    def normalize(data)
+      return nil unless super
+      rates = { "anchor" => self.class::ANCHOR_CURRENCY }
+      data["rates"].each do |pair, payload|
+        rates[pair.sub(self.class::ANCHOR_CURRENCY, "")] = BigDecimal.new(payload["rate"].to_s)
+      end
+      rates
+    end
+  end
+end

data/lib/configuration.rb

@@ -5,17 +5,21 @@ module CurrencyRate
     attr_accessor :logger
     attr_accessor :crypto_adapters
     attr_accessor :fiat_adapters
+    attr_accessor :connect_timeout
+    attr_accessor :read_timeout
 
     def initialize
-      @api_keys     = { }
-      @file_storage = { path: "" }
-      @logger       = {
-        device: $stdout,
-        level:  :info,
-        formatter: nil,
-       }
+      @api_keys         = { }
+      @file_storage     = { path: "" }
+      @logger           = {
+                            device: $stdout,
+                            level:  :info,
+                            formatter: nil,
+                          }
        @crypto_adapters = CurrencyRate.adapters :crypto
-       @fiat_adapters =   CurrencyRate.adapters :fiat
+       @fiat_adapters   = CurrencyRate.adapters :fiat
+       @connect_timeout = 4
+       @read_timeout    = 4
     end
   end
 end

data/lib/currency_rate.rb

@@ -4,12 +4,13 @@ require "singleton"
 require "json"
 require "http"
 
-require "configuration"
-require "adapter"
-require "fetcher"
-require "synchronizer"
+require_relative "configuration"
+require_relative "adapter"
+require_relative "fetcher"
+require_relative "synchronizer"
 
-Dir["#{File.expand_path File.dirname(__FILE__)}/**/*.rb"].each { |f| require f }
+Dir["#{File.expand_path __dir__}/adapters/**/*.rb"].each { |f| require f }
+Dir["#{File.expand_path __dir__}/storage/**/*.rb"].each { |f| require f }
 
 module CurrencyRate
   class << self
@@ -26,7 +27,7 @@ module CurrencyRate
 
   def self.adapters(type)
     Dir[File.join self.root, "lib/adapters/#{type}/*"].map do |file|
-      File.basename(file, ".rb").split('_').map {|w| w.capitalize}.join
+      File.basename(file, ".rb").split('_')[0...-1].map {|w| w.capitalize}.join
     end
   end
 
@@ -39,7 +40,7 @@ module CurrencyRate
   end
 
   def self.fetcher
-    @fetcher ||= Fetcher.new
+    @fetcher ||= Fetcher.new(fiat_exchanges: configuration.fiat_adapters)
   end
 
   def self.fetch_crypto(exchange, from, to)
@@ -63,6 +64,14 @@ module CurrencyRate
     @synchronizer ||= Synchronizer.new
   end
 
+  def self.sync_crypto!
+    synchronizer.sync_crypto!
+  end
+
+  def self.sync_fiat!
+    synchronizer.sync_fiat!
+  end
+
   def self.sync!
     synchronizer.sync!
   end

data/lib/fetcher.rb

@@ -3,69 +3,56 @@ module CurrencyRate
     attr_accessor :storage
     attr_accessor :fiat_exchanges
 
-    def initialize(storage: nil)
+    def initialize(fiat_exchanges: nil, storage: nil)
       @storage = storage || FileStorage.new
-      @fiat_exchanges = ["Yahoo", "Fixer", "Forge"]
+      @fiat_exchanges = fiat_exchanges || ["Yahoo", "Fixer", "Forge"]
     end
 
     def fetch_crypto(exchange, from, to)
-      crypto = from.upcase
-      fiat = to.upcase
-      pair = "#{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
-      return BigDecimal.new(rates[pair]) if rates[pair]
 
-      supported_crypto, supported_fiat = rates.keys.reduce([[], []]) do |result, rate|
-        c, f = rate.split("_")
-        result[0] << c
-        result[1] << f
-        result
-      end.map { |x| x.uniq }
+      rate = calculate_rate(rates, from, to)
+      return rate unless rate.nil?
 
-      unless supported_crypto.include?(crypto)
-        CurrencyRate.logger.warn("Fetcher#fetch_crypto: #{exchange} doesn't support #{crypto}")
-        return nil
-      end
-
-      # If requested pair not found and exchange supports requested cryptocurrency
-      # then we can convert using another supported fiat currency as an anchor
-      # USD has first priority since it's the most popular world currency
-      if fiat != "USD" && supported_fiat.delete("USD")
-        usd_fiat = fetch_fiat("USD", fiat)
-        return BigDecimal.new(rates["#{crypto}_USD"]) * BigDecimal.new(usd_fiat) if usd_fiat
-      end
-
-      # We don't have usd_fiat pair so try other supported currencies as convertation anchor
-      supported_fiat.each do |anchor|
-        anchor_fiat = fetch_fiat(anchor, fiat)
-        return BigDecimal.new(rates["#{crypto}_#{anchor}"]) * BigDecimal.new(anchor_fiat) if anchor_fiat
+      if to != "USD"
+        usd_fiat = fetch_fiat("USD", to)
+        return BigDecimal.new(rates["USD"] * usd_fiat) if usd_fiat && rates["USD"]
       end
-
-      # We didn't find a way to fetch rate for requested pair
-      CurrencyRate.logger.warn("Fetcher#fetch_crypto: cannot fetch #{from}_#{to} from #{exchange}")
-      nil
     end
 
     def fetch_fiat(from, to)
+      from = from.strip.upcase
+      to = to.strip.upcase
+
       @fiat_exchanges.each do |exchange|
-        left = from.upcase
-        right = to.upcase
         rates = @storage.read(exchange)
         next if rates.nil?
-        anchor = rates.delete("anchor")
-        return BigDecimal.new(rates[right]) if anchor == left && rates[right]
-        return BigDecimal.new(1) / BigDecimal.new(rates[left]) if anchor == right && rates[left]
-        return BigDecimal.new(rates[left]) / BigDecimal.new(rates[right]) if rates[left] && rates[right]
+
+        rate = calculate_rate(rates, from, to)
+        return rate unless rate.nil?
       end
-      CurrencyRate.logger.warn("Fetcher#fetch_fiat: rate for #{from}_#{to} not found")
-      nil
     end
 
+    private
+
+      def calculate_rate(rates, from, to)
+        anchor = rates.delete("anchor")
+
+        return BigDecimal.new(rates[to]) if anchor == from && rates[to]
+        return BigDecimal.new(1 / rates[from]) if anchor == to && rates[from]
+        return BigDecimal.new(rates[to] / rates[from]) if rates[from] && rates[to]
+
+        CurrencyRate.logger.warn("Fetcher: rate for #{from}_#{to} not found.")
+        nil
+      end
+
   end
 end
 

data/lib/storage/file_storage.rb

@@ -4,8 +4,8 @@ module CurrencyRate
     attr_accessor :serializer
 
     def initialize(path = nil, serializer: nil)
-      @path       ||= CurrencyRate.configuration.file_storage[:path]
-      @serializer ||= Storage::YAMLSerializer.new
+      @path       = path || CurrencyRate.configuration.file_storage[:path]
+      @serializer = serializer || Storage::YAMLSerializer.new
     end
 
     def read(exchange_name)

data/lib/synchronizer.rb

@@ -6,28 +6,42 @@ module CurrencyRate
       @storage = storage || FileStorage.new
     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 = []
-      [CurrencyRate.configuration.fiat_adapters, CurrencyRate.configuration.crypto_adapters].each do |adapters|
-        adapters.each do |adapter_name|
-          adapter_name = "#{adapter_name}Adapter" unless adapter_name.include? "Adapter"
-          begin
-            adapter = CurrencyRate::const_get(adapter_name).instance
-            rates = adapter.fetch_rates
-            unless rates
-              CurrencyRate.logger.warn("Synchronizer#sync!: rates for #{adapter_name} not found")
-              failed.push(adapter_name)
-              next
-            end
-            exchange_name = adapter_name[0..-8].downcase
-            @storage.write(exchange_name, rates)
-            successfull.push(adapter_name)
-          rescue StandardError => e
-            failed.push(adapter_name)
-            CurrencyRate.logger.error(e)
+      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.downcase
+          @storage.write(exchange_name, rates)
+          successfull.push(provider)
+        rescue StandardError => e
+          failed.push(provider)
+          CurrencyRate.logger.error(e)
+          next
         end
       end
       [successfull, failed]