currency-rate 1.7.0 → 2.0.6

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/storage/file_storage.rb

@@ -1,29 +0,0 @@
-module CurrencyRate
-  class FileStorage
-    attr_reader   :path
-    attr_accessor :serializer
-
-    def initialize(path:, serializer: nil)
-      @path       = 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

data/lib/storage/serializers/yaml_serializer.rb

@@ -1,15 +0,0 @@
-require "yaml"
-
-module CurrencyRate
-  module Storage
-    class YAMLSerializer
-      def serialize(data)
-        YAML.dump(data)
-      end
-
-      def deserialize(data)
-        YAML.load(data)
-      end
-    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