currency-rate 1.6.1 → 2.0.5

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 super
-
-      {
-        "anchor" => ANCHOR_CURRENCY,
-        "USD" => BigDecimal(data["price"].to_s)
-      }
-    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 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,25 +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:
-        CurrencyRate.configuration.connect_timeout, read:
-        CurrencyRate.configuration.read_timeout
-      )
-      http_client.get(url).to_s
-
-    end
-
-  end
-end

data/lib/adapters/fiat/coinmonitor_adapter.rb

@@ -1,14 +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/api/dolar_ar/"
-
-    def normalize(data)
-      return nil unless super
-
-      { "anchor" => ANCHOR_CURRENCY }.merge({ SUPPORTED_CURRENCIES.first => BigDecimal(data["DOL_blue"].to_s) })
-    end
-  end
-end

data/lib/adapters/fiat/currency_layer_adapter.rb

@@ -1,32 +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://www.apilayer.net/api/live"
-    API_KEY_PARAM = "access_key"
-
-    def normalize(data)
-      return nil unless 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,18 +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/latest"
-    API_KEY_PARAM = "access_key"
-
-    def normalize(data)
-      return nil unless 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,25 +0,0 @@
-module CurrencyRate
-  class ForgeAdapter < Adapter
-    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(",")
-    API_KEY_PARAM = "api_key"
-
-    def normalize(data)
-      return nil unless super
-      rates = { "anchor" => self.class::ANCHOR_CURRENCY }
-      data.each do |rate|
-        if rate["error"]
-          CurrencyRate.logger.error("Forge exchange returned error")
-          return nil
-        end
-        rates[rate["symbol"].sub(self.class::ANCHOR_CURRENCY, "")] = BigDecimal(rate["price"].to_s)
-      end
-      rates
-    end
-
-  end
-end

data/lib/adapters/fiat/free_forex_adapter.rb

@@ -1,32 +0,0 @@
-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(payload["rate"].to_s)
-      end
-      rates
-    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,29 +0,0 @@
-module CurrencyRate
-  class Configuration
-    attr_accessor :api_keys
-    attr_accessor :file_storage
-    attr_accessor :logger
-    attr_accessor :crypto_adapters
-    attr_accessor :fiat_adapters
-    attr_accessor :connect_timeout
-    attr_accessor :read_timeout
-    attr_accessor :limit_sources_for_fiat_currencies
-    attr_accessor :crypto_currencies
-
-    def initialize
-      @api_keys         = { }
-      @file_storage     = { path: "" }
-      @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/currency_rate.rb

@@ -1,84 +0,0 @@
-require "bigdecimal"
-require "logger"
-require "singleton"
-require "json"
-require "http"
-
-require_relative "configuration"
-require_relative "adapter"
-require_relative "fetcher"
-require_relative "synchronizer"
-
-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
-    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
-    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
-    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 self.sync!
-    synchronizer.sync!
-  end
-
-  def self.root
-    File.expand_path("../", File.dirname(__FILE__))
-  end
-end

data/lib/currency_rate/version.rb

@@ -1,3 +0,0 @@
-module CurrencyRate
-  VERSION = "1.6.1"
-end

data/lib/fetcher.rb

@@ -1,78 +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 || FileStorage.new
-      @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/storage/file_storage.rb

@@ -1,29 +0,0 @@
-module CurrencyRate
-  class FileStorage
-    attr_reader   :path
-    attr_accessor :serializer
-
-    def initialize(path = nil, serializer: nil)
-      @path       = path || CurrencyRate.configuration.file_storage[:path]
-      @serializer = serializer || Storage::YAMLSerializer.new
-    end
-
-    def read(exchange_name)
-      path = path_for exchange_name.downcase
-      @serializer.deserialize File.read(path)
-    rescue StandardError => e
-      CurrencyRate.logger.error(e)
-      nil
-    end
-
-    def write(exchange_name, data = "")
-      File.write path_for(exchange_name.downcase), @serializer.serialize(data)
-    rescue StandardError => e
-      CurrencyRate.logger.error(e)
-    end
-
-    def path_for(exchange_name)
-      File.join @path, "#{exchange_name}_rates.yml"
-    end
-  end
-end