currency-rate 0.4.1 → 1.0.0

data/lib/adapters/crypto/bitfinex_adapter.rb

@@ -0,0 +1,17 @@
+module CurrencyRate
+  class BitfinexAdapter < Adapter
+    FETCH_URL = {
+      "BTC_USD" => "https://api.bitfinex.com/v1/pubticker/btcusd",
+      "LTC_USD" => "https://api.bitfinex.com/v1/pubticker/ltcusd",
+    }
+
+    def normalize(data)
+      return nil unless super
+      data.reduce({}) do |result, (pair, value)|
+        result[pair] = BigDecimal.new(value["last_price"].to_s)
+        result
+      end
+    end
+
+  end
+end

data/lib/adapters/crypto/bitpay_adapter.rb

@@ -0,0 +1,14 @@
+module CurrencyRate
+  class BitpayAdapter < Adapter
+    FETCH_URL = "https://bitpay.com/api/rates"
+
+    def normalize(data)
+      return nil unless super
+      data.reject { |rate| rate["code"] == "BTC" }.reduce({}) do |result, rate|
+        result["BTC_#{rate['code'].upcase}"] = BigDecimal.new(rate["rate"].to_s)
+        result
+      end
+    end
+
+  end
+end

data/lib/adapters/crypto/bitstamp_adapter.rb

@@ -0,0 +1,19 @@
+module CurrencyRate
+  class BitstampAdapter < Adapter
+    FETCH_URL = {
+      'BTC_USD' => 'https://www.bitstamp.net/api/v2/ticker/btcusd/',
+      'BTC_EUR' => 'https://www.bitstamp.net/api/v2/ticker/btceur/',
+      'LTC_USD' => 'https://www.bitstamp.net/api/v2/ticker/ltcusd/',
+      'LTC_EUR' => 'https://www.bitstamp.net/api/v2/ticker/ltceur/',
+    }
+
+    def normalize(data)
+      return nil unless super
+      data.reduce({}) do |result, (pair, value)|
+        result[pair] = BigDecimal.new(value["last"].to_s)
+        result
+      end
+    end
+
+  end
+end

data/lib/adapters/crypto/btc_china_adapter.rb

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

data/lib/adapters/crypto/btc_e_adapter.rb

@@ -0,0 +1,18 @@
+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.new(value["ticker"]["last"].to_s)
+        result
+      end
+    end
+
+  end
+end

data/lib/adapters/crypto/coinbase_adapter.rb

@@ -0,0 +1,14 @@
+module CurrencyRate
+  class CoinbaseAdapter < Adapter
+    FETCH_URL = 'https://coinbase.com/api/v1/currencies/exchange_rates'
+
+    def normalize(data)
+      return nil unless super
+      data.reduce({}) do |result, (pair, value)|
+        result[pair.gsub("_to_", "_").upcase] = BigDecimal.new(value.to_s)
+        result
+      end
+    end
+
+  end
+end

data/lib/adapters/crypto/huobi_adapter.rb

@@ -0,0 +1,17 @@
+module CurrencyRate
+  class HuobiAdapter < Adapter
+    FETCH_URL = {
+      "BTC_CNY" => "http://api.huobi.com/staticmarket/ticker_btc_json.js",
+      "LTC_CNY" => "http://api.huobi.com/staticmarket/ticker_ltc_json.js"
+    }
+
+    def normalize(data)
+      return nil unless super
+      data.reduce({}) do |result, (pair, value)|
+        result[pair] = BigDecimal.new(value["ticker"]["last"].to_s)
+        result
+      end
+    end
+
+  end
+end

data/lib/adapters/crypto/kraken_adapter.rb

@@ -0,0 +1,29 @@
+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",
+    }
+
+    ASSET_MAP = {
+      "BTC" => "XBT",
+    }
+
+    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)
+        result
+      end
+    end
+
+    def translate_asset(asset)
+      ASSET_MAP[asset] || asset
+    end
+    alias_method :ta, :translate_asset
+
+  end
+end

data/lib/adapters/crypto/localbitcoins_adapter.rb

@@ -0,0 +1,14 @@
+module CurrencyRate
+  class LocalbitcoinsAdapter < Adapter
+    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)
+        result
+      end
+    end
+
+  end
+end

data/lib/adapters/crypto/okcoin_adapter.rb

@@ -0,0 +1,19 @@
+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'
+    }
+
+    def normalize(data)
+      return nil unless super
+      data.reduce({}) do |result, (pair, value)|
+        result[pair] = BigDecimal.new(value["ticker"]["last"].to_s)
+        result
+      end
+    end
+
+  end
+end

data/lib/adapters/fiat/fixer_adapter.rb

@@ -0,0 +1,16 @@
+module CurrencyRate
+  class FixerAdapter < Adapter
+    ANCHOR_CURRENCY = "USD"
+    FETCH_URL = "http://api.fixer.io/latest?base=usd"
+
+    def normalize(data)
+      return nil unless super
+      rates = { "anchor" => ANCHOR_CURRENCY }
+      data["rates"].each do |k, v|
+        rates[k] = BigDecimal.new(v.to_s)
+      end
+      rates
+    end
+
+  end
+end

data/lib/adapters/fiat/forge_adapter.rb

@@ -0,0 +1,23 @@
+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.new(rate["price"].to_s)
+      end
+      rates
+    end
+
+  end
+end

data/lib/adapters/fiat/yahoo_adapter.rb

@@ -0,0 +1,35 @@
+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.new(rate["Rate"].to_s)
+      end
+      rates
+    end
+
+  end
+end

data/lib/configuration.rb

@@ -0,0 +1,21 @@
+module CurrencyRate
+  class Configuration
+    attr_accessor :api_keys
+    attr_accessor :file_storage
+    attr_accessor :logger
+    attr_accessor :crypto_adapters
+    attr_accessor :fiat_adapters
+
+    def initialize
+      @api_keys     = { }
+      @file_storage = { path: "" }
+      @logger       = {
+        device: $stdout,
+        level:  :info,
+        formatter: nil,
+       }
+       @crypto_adapters = CurrencyRate.adapters :crypto
+       @fiat_adapters =   CurrencyRate.adapters :fiat
+    end
+  end
+end

data/lib/currency_rate.rb

@@ -1,69 +1,73 @@
-require 'singleton'
-require 'bigdecimal'
-require 'satoshi-unit'
-require 'open-uri'
-require 'json'
+require "bigdecimal"
+require "logger"
+require "singleton"
+require "json"
+require "http"
 
+require "configuration"
 require "adapter"
-require "crypto_adapter"
-require "fiat_adapter"
+require "fetcher"
+require "synchronizer"
 
 Dir["#{File.expand_path File.dirname(__FILE__)}/**/*.rb"].each { |f| require f }
 
 module CurrencyRate
+  class << self
+    attr_writer :configuration
+  end
 
-  def self.get(adapter_name, from, to, anchor_currency: nil, try_storage_on_fetching_failed: false)
-
-    a = adapter_instance(adapter_name)
-    a.try_storage_on_fetching_failed = try_storage_on_fetching_failed
-
-    # Setting default values for anchor currency depending on
-    # which adapter type is un use.
-    anchor_currency ||= if a.kind_of?(CryptoAdapter)
-      a.class::SUPPORTED_CRYPTO_CURRENCIES.include?("BTC") ? "BTC" : a.class::SUPPORTED_CRYPTO_CURRENCIES.first
+  def self.method_missing(m, *args, &block)
+    if m.to_s.end_with? "_adapters"
+      self.send(:adapters, m[0..-10])
     else
-      a.class::SUPPORTED_CURRENCIES.include?("USD") ? "USD" : a.class::SUPPORTED_CURRENCIES.first
-    end if anchor_currency.nil?
+      super
+    end
+  end
 
-    # None of the currencies is anchor currency?
-    # No problem, convert the amount given into the anchor currency first.
-    if [to, from].include?(anchor_currency)
-      a.rate_for(from, to)
-    else
-      rate_from = get(adapter_name, anchor_currency, from, try_storage_on_fetching_failed: try_storage_on_fetching_failed)
-      rate_to   = get(adapter_name, anchor_currency, to  , try_storage_on_fetching_failed: try_storage_on_fetching_failed)
-      BigDecimal.new(rate_to.to_s)/BigDecimal.new(rate_from.to_s)
+  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
     end
   end
 
-  def self.convert(adapter_name, amount:, from:, to:, anchor_currency: nil, try_storage_on_fetching_failed: false)
-    a = adapter_instance(adapter_name)
-    result = BigDecimal.new(amount.to_s)*BigDecimal.new(get(a, from, to, anchor_currency: anchor_currency, try_storage_on_fetching_failed: try_storage_on_fetching_failed).to_s)
-    result.round(a.kind_of?(CryptoAdapter) && a.class::SUPPORTED_CRYPTO_CURRENCIES.include?(to) ? a.class::DECIMAL_PRECISION : 2)
+  def self.configuration
+    @configuration ||= Configuration.new
   end
 
-  def self.default_currencies_for(adapter_name)
-    adapter_class(adapter_name)::DEFAULT_CURRENCIES
+  def self.configure
+    yield(configuration)
   end
 
-  private
+  def self.fetcher
+    @fetcher ||= Fetcher.new
+  end
 
-    def self.adapter_instance(s)
-      return s unless s.kind_of?(String) # if we pass class, no need to convert
-      adapter_class(s).instance
-    end
+  def self.fetch_crypto(exchange, from, to)
+    fetcher.fetch_crypto(exchange, from, to)
+  end
 
-    def self.adapter_class(s)
-      classify_string("#{s}_adapter", CurrencyRate)
-    end
+  def self.fetch_fiat(from, to)
+    fetcher.fetch_fiat(from, to)
+  end
 
-    def self.classify_string(s, prefix="")
-      s = if s !~ /[[:upper:]]/ # contains uppercase characters? Must be a class name already!
-        s.split('_').collect(&:capitalize).join
-      else
-        s.sub("_adapter", "Adapter")
-      end
-      Kernel.const_get(prefix.to_s + "::" + s)
-    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!
+    synchronizer.sync!
+  end
+
+  def self.root
+    File.expand_path("../", File.dirname(__FILE__))
+  end
 end

data/lib/fetcher.rb

@@ -0,0 +1,71 @@
+module CurrencyRate
+  class Fetcher
+    attr_accessor :storage
+    attr_accessor :fiat_exchanges
+
+    def initialize(storage: nil)
+      @storage = storage || FileStorage.new
+      @fiat_exchanges = ["Yahoo", "Fixer", "Forge"]
+    end
+
+    def fetch_crypto(exchange, from, to)
+      crypto = from.upcase
+      fiat = to.upcase
+      pair = "#{from}_#{to}"
+      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 }
+
+      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
+      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)
+      @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]
+      end
+      CurrencyRate.logger.warn("Fetcher#fetch_fiat: rate for #{from}_#{to} not found")
+      nil
+    end
+
+  end
+end
+