cointools 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0e581465b03a85e017f097f09f991294a9d87676
-  data.tar.gz: f9e6d0cfeab51850d8d858a50990838305b5a13c
+  metadata.gz: 652a3663b1f2a32c461ddf19bb73f95cdadf155c
+  data.tar.gz: 9cd0d5c8891c59fcfebd24dfd038da884a8495f4
 SHA512:
-  metadata.gz: 0f3237529fa8ad91074c3564ca1268bdbf52d2904e016e2744b4d714f829d3e37feb48614eb5fad7aa2833727f9168c5aa1f731ede1a71330b810f336215612d
-  data.tar.gz: 81833105049ee6fcc85a3ecd323fce79087fd75d25300486922e60031e102f997df4153db3696bbdbdbbe5fb9c64c8d23ac17a5efb0a3b613376a5116e13f5fa
+  metadata.gz: 36720bdfcb1f20d8727684fadd4f61cb28e5cb574eb59cb60db1f2ac8d9017f0b3010db97f3e601d4fd027de0a512f4cca4819125b1dfa3f2066ad717f35c56f
+  data.tar.gz: af00dbb857cbc28ff07bfc84895e044d0f2cfcebef8b2c9e083ef1d58014567a1c47aa29eb7eef70c2c5d7b1f7f4e5ce5c252b4e4381eab9c4794d29b0d0f420

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+#### Version 0.5.0 (12.07.2018)
+
+* switched to CoinMarketCap API v2, CMC's `get_price` and `get_price_by_symbol` calls now return data like coin name/symbol, rank and market cap
+* new `get_all_prices` method in CMC that returns all 1600+ coins sorted by rank
+* renamed `--list-exchanges` to `--exchanges`, `--list-markets` to `--markets`, `--list-fiat-currencies` to `--fiat-currencies`, `--fiat-currency` to `--convert-to`
+* all commands print verbose output by default, use `--quiet/-q` to print only the price
+* time can be passed as a string to `get_price` methods
+* improved error handling
+* added a huge amount of tests
+
 #### Version 0.4.0 (23.05.2018)
 
 * added CoinCap.io class and `coincap` command

data/README.md

@@ -37,11 +37,13 @@ To check the current price, skip the timestamp:
 cryptowatch bitfinex btcusd
 ```
 
+By default the price is printed in a verbose format that includes the requested market name and the time of the returned price. Add a `-q/--quiet` option to only print the price as a single number (e.g. to pass it further to another script).
+
 You can fetch a list of available exchanges and markets using these commands:
 
 ```
-cryptowatch --list-exchanges
-cryptowatch --list-markets bithumb
+cryptowatch --exchanges
+cryptowatch --markets bithumb
 ```
 
 In code:
@@ -85,7 +87,9 @@ Alternatively, you can pass the cryptocurrency's symbol using the `-s` or `--sym
 cmcap -s powr
 ```
 
-However, this operation needs to download a complete ticker for all currencies and scan through the list, so it's recommended to use the name as in the example above.
+However, be aware that coin symbols are not unique on CoinMarketCap - there are at least a few examples of duplicates. In such case, the first coin that matches (probably the older one) will be returned.
+
+By default the price is printed in a verbose format that includes the requested coin symbol and the time of the returned price. Add a `-q/--quiet` option to only print the price as a single number (e.g. to pass it further to another script).
 
 You can also use the `-b` or `--btc-price` flag to request a price in BTC instead of USD:
 
@@ -93,13 +97,13 @@ You can also use the `-b` or `--btc-price` flag to request a price in BTC instea
 cmcap power-ledger -b
 ```
 
-Or you can request the price in one of the ~30 other supported fiat currencies with `-f` or `--fiat-currency`:
+Or you can request the price in one of the ~30 other supported fiat currencies with `-c` or `--convert-to`:
 
 ```
-cmcap request-network -fEUR
+cmcap request-network -cEUR
 ```
 
-You can print a list of supported fiat currencies with `cmcap --list-fiat-currencies`.
+You can print a list of supported fiat currencies with `cmcap --fiat-currencies`.
 
 Same things in code:
 
@@ -109,17 +113,40 @@ cmc = CoinTools::CoinMarketCap.new
 
 p CoinTools::CoinMarketCap::FIAT_CURRENCIES
 
-ltc = cryptowatch.get_price('litecoin')
+ltc = cmc.get_price('litecoin')
 puts "LTC: #{ltc.usd_price} USD / #{ltc.btc_price} BTC"
 
-xmr = cryptowatch.get_price_by_symbol('xmr')
+xmr = cmc.get_price_by_symbol('xmr')
 puts "XMR: #{xmr.usd_price} USD / #{xmr.btc_price} BTC"
 
-eth = cryptowatch.get_price('ethereum', convert_to: 'EUR')
+eth = cmc.get_price('ethereum', convert_to: 'EUR')
 puts "ETH: #{eth.converted_price} EUR"
 ```
 
-The soft rate limit for the API is 10 requests per minute (for the currently used v1 API).
+The soft rate limit for the API is 30 requests per minute (for API v2).
+
+Note: since in the v2 API specific coin tickers can only be looked up using CoinMarketCap's internal numeric ids (e.g. Ethereum = 1027), both lookup methods available here - by the coin name ("slug") and symbol - have to first download a `/listings` JSON with a mapping of all coins on the site. The result of that call is cached in a `CoinTools::CoinMarketCap` object, so if you do many lookups in code, in one go or over some period of time, it's recommended to reuse the object instead of recreating it each time.
+
+The API only allows one additional currency apart from USD, so if you pass a `convert_to` parameter, `btc_price` will not be returned, only `converted_price`.
+
+
+### Getting all coin prices
+
+You can also download the whole table of 1600+ coins listed on CoinMarketCap using the `get_all_prices` method. The method also takes a `convert_to` parameter, which works as described above. This method has to use paging to download data in batches and currently makes around 16 calls (which takes about half a minute), so do not call it repeatedly or you might go over the rate limit.
+
+You can pass a block to this method to receive each batch of coins as they arrive. Take into account however that coins are not sorted by rank, but by numeric id (or roughly by creation date), so if you want e.g. top 100 coins, you still need to download the whole list. This is mostly intended to let you track progress in some way, e.g.:
+
+```ruby
+require 'cointools/coinmarketcap'
+cmc = CoinTools::CoinMarketCap.new
+
+coins = cmc.get_all_prices { |l| print '.' }
+puts
+
+coins.first(50).each do |c|
+  puts c.symbol.ljust(5) + c.market_cap.to_i.to_s.rjust(15)
+end
+```
 
 
 ## CoinCap
@@ -138,6 +165,8 @@ To check the current price, skip the timestamp:
 coincap xmr
 ```
 
+By default the price is printed in a verbose format that includes the requested coin symbol and the time of the returned price. Add a `-q/--quiet` option to only print the price as a single number (e.g. to pass it further to another script).
+
 You can also use the `-b` or `--btc-price` flag to request a price in BTC instead of USD, or `-e` or `--eur-price` for EUR:
 
 ```

data/bin/cmcap

@@ -1,37 +1,37 @@
 #!/usr/bin/env ruby
 
 require 'bundler/setup'
-require 'cointools'
+require 'cointools/coinmarketcap'
 
 require 'optparse'
 require 'time'
 
 def print_help
-  puts "Usage: #{$PROGRAM_NAME} <coin_name> [-b/--btc-price] [-fXXX/--fiat-currency XXX] [-v/--verbose]"
+  puts "Usage: #{$PROGRAM_NAME} <coin_name> [-b/--btc-price] [-cXXX/--convert-to XXX] [-q/--quiet]"
   puts " e.g.: #{$PROGRAM_NAME} litecoin"
   puts
   puts "* To look up the currency by symbol instead of name (slower, downloads more data):"
-  puts "       #{$PROGRAM_NAME} -s/--symbol <symbol> [-b/--btc-price] [-fXXX/--fiat-currency XXX] [-v/--verbose]"
+  puts "       #{$PROGRAM_NAME} -s/--symbol <symbol> [-b/--btc-price] [-cXXX/--convert-to XXX] [-q/--quiet]"
   puts " e.g.: #{$PROGRAM_NAME} -s LTC"
   puts
   puts "* To list supported fiat currencies:"
-  puts "       #{$PROGRAM_NAME} --list-fiat-currences"
+  puts "       #{$PROGRAM_NAME} --fiat-currences"
   puts
   puts "* -b / --btc-price: returns the coin's price in BTC instead of USD"
-  puts "* -fEUR / --fiat-currency EUR: returns the price in a given fiat currency instead of USD"
+  puts "* -cEUR / --convert-to EUR: returns the price in a given fiat currency instead of USD"
 end
 
-verbose = false
+quiet = false
 btc_price = false
 fiat_currency = nil
 symbol = nil
 
 OptionParser.new do |opts|
-  opts.on('-v', '--verbose') { verbose = true }
+  opts.on('-q', '--quiet') { quiet = true }
   opts.on('-b', '--btc-price') { btc_price = true }
-  opts.on('-fXXX', '--fiat-currency XXX') { |f| fiat_currency = f }
+  opts.on('-cXXX', '--convert-to XXX') { |f| fiat_currency = f }
 
-  opts.on('--list-fiat-currencies') do
+  opts.on('--fiat-currencies') do
     puts CoinTools::CoinMarketCap::FIAT_CURRENCIES
     exit 0
   end
@@ -56,7 +56,7 @@ unless symbol
 end
 
 if fiat_currency && btc_price
-  puts "#{$PROGRAM_NAME}: --btc-price and --fiat-currency options cannot be used together"
+  puts "#{$PROGRAM_NAME}: --btc-price and --convert-to options cannot be used together"
   exit 1
 end
 
@@ -78,22 +78,26 @@ begin
     unit = 'USD'
   end
 
-  if verbose
-    puts "#{symbol&.upcase || coin_name} @ #{result.time || Time.now} ==> #{price} #{unit}"
-    puts
-  else
+  if quiet
     puts price
+  else
+    puts "#{symbol&.upcase || coin_name} @ #{result.last_updated || Time.now} ==> #{price} #{unit}"
+    puts
   end
-rescue CoinTools::CoinMarketCap::BadRequestException => e
-  $stderr.puts "Error: Incorrect coin name: #{coin_name} (#{e})"
+rescue CoinTools::InvalidSymbolError => e
+  $stderr.puts "Error: Invalid coin name: '#{symbol}'"
   exit 1
-rescue CoinTools::CoinMarketCap::InvalidResponseException => e
-  $stderr.puts "Error: Something went wrong: #{e}"
+rescue CoinTools::InvalidFiatCurrencyError => e
+  $stderr.puts "Error: Unsupported fiat currency: '#{fiat_currency}'"
   exit 1
-rescue CoinTools::CoinMarketCap::NoDataException => e
-  $stderr.puts "Error: #{e}"
+rescue CoinTools::UnknownCoinError => e
+  if symbol
+    $stderr.puts "Error: No such coin: #{symbol.upcase}"
+  else
+    $stderr.puts "Error: No such coin: #{coin_name} (remember to use CoinMarketCap's IDs, or the -s option)"
+  end
   exit 1
-rescue CoinTools::CoinMarketCap::InvalidFiatCurrencyException => e
-  $stderr.puts "Error: Unsupported fiat currency: #{fiat_currency}"
+rescue CoinTools::ResponseError => e
+  $stderr.puts "Error: Something went wrong: #{e.nice_message}"
   exit 1
 end

data/bin/coincap

@@ -1,25 +1,24 @@
 #!/usr/bin/env ruby
 
 require 'bundler/setup'
-require 'cointools'
+require 'cointools/coincap'
 
 require 'optparse'
-require 'time'
 
 def print_help
-  puts "Usage: #{$PROGRAM_NAME} <symbol> [<date>] [-b/--btc-price | -e/--eur-price] [-v/--verbose]"
+  puts "Usage: #{$PROGRAM_NAME} <symbol> [<date>] [-b/--btc-price | -e/--eur-price] [-q/--quiet]"
   puts " e.g.: #{$PROGRAM_NAME} NANO \"2017-12-20 15:00\""
   puts
   puts "* -b / --btc-price: returns the coin's price in BTC instead of USD (current prices only)"
   puts "* -e / --eur-price: returns the coin's price in EUR (current prices only)"
 end
 
-verbose = false
+quiet = false
 btc_price = false
 eur_price = false
 
 OptionParser.new do |opts|
-  opts.on('-v', '--verbose') { verbose = true }
+  opts.on('-q', '--quiet') { quiet = true }
   opts.on('-b', '--btc-price') { btc_price = true }
   opts.on('-e', '--eur-price') { eur_price = true }
 
@@ -37,19 +36,19 @@ if ARGV.length < 1 || ARGV.length > 2
 end
 
 symbol = ARGV[0]
-date = Time.parse(ARGV[1]) if ARGV[1]
+date = ARGV[1]
 
-if eur_price && btc_price
-  puts "#{$PROGRAM_NAME}: --btc-price and --eur-price options cannot be used together"
-  exit 1
-end
+begin
+  if eur_price && btc_price
+    puts "#{$PROGRAM_NAME}: --btc-price and --eur-price options cannot be used together"
+    exit 1
+  end
 
-if date && (eur_price || btc_price)
-  puts "#{$PROGRAM_NAME}: --btc-price and --eur-price options cannot be used for historical prices"
-  exit 1
-end
+  if date && (eur_price || btc_price)
+    puts "#{$PROGRAM_NAME}: --btc-price and --eur-price options cannot be used for historical prices"
+    exit 1
+  end
 
-begin
   result = CoinTools::CoinCap.new.get_price(symbol, date)
 
   if btc_price
@@ -63,19 +62,22 @@ begin
     unit = 'USD'
   end
 
-  if verbose
+  if quiet
+    puts price
+  else
     puts "#{symbol.upcase} @ #{result.time || Time.now} ==> #{price} #{unit}"
     puts
-  else
-    puts price
   end
-rescue CoinTools::CoinCap::BadRequestException => e
-  $stderr.puts "Error: Incorrect coin name: #{coin_name} (#{e})"
+rescue CoinTools::InvalidSymbolError => e
+  $stderr.puts "Error: Invalid coin name: '#{symbol}'"
+  exit 1
+rescue CoinTools::InvalidDateError => e
+  $stderr.puts "Error: Invalid date format: '#{date}' (#{e})"
   exit 1
-rescue CoinTools::CoinCap::InvalidResponseException => e
-  $stderr.puts "Error: Something went wrong: #{e}"
+rescue CoinTools::UnknownCoinError => e
+  $stderr.puts "Error: No such coin: #{symbol.upcase}"
   exit 1
-rescue CoinTools::CoinCap::NoDataException => e
-  $stderr.puts "Error: #{e}"
+rescue CoinTools::ResponseError => e
+  $stderr.puts "Error: Something went wrong: #{e.nice_message}"
   exit 1
 end

data/bin/cryptowatch

@@ -1,27 +1,26 @@
 #!/usr/bin/env ruby
 
 require 'bundler/setup'
-require 'cointools'
+require 'cointools/cryptowatch'
 
 require 'optparse'
-require 'time'
 
 def print_help
-  puts "Usage: #{$PROGRAM_NAME} <exchange> <market> [<date>] [-v/--verbose] [-f/--fast]"
+  puts "Usage: #{$PROGRAM_NAME} <exchange> <market> [<date>] [-q/--quiet] [-f/--fast]"
   puts " e.g.: #{$PROGRAM_NAME} gdax btcusd \"2017-06-30 15:27\""
   puts
   puts "* --fast: tries to use less API time allowance at the cost of worse reliability"
   puts "* To print a list of available exchanges:"
-  puts "       #{$PROGRAM_NAME} --list-exchanges"
+  puts "       #{$PROGRAM_NAME} --exchanges"
   puts "* To print a list of available markets on an exchange:"
-  puts "       #{$PROGRAM_NAME} --list-markets kraken"
+  puts "       #{$PROGRAM_NAME} --markets kraken"
 end
 
-verbose = false
+quiet = false
 fast = false
 
 OptionParser.new do |opts|
-  opts.on('-v', '--verbose') { verbose = true }
+  opts.on('-q', '--quiet') { quiet = true }
 
   opts.on('-h', '--help') do
     print_help
@@ -30,17 +29,23 @@ OptionParser.new do |opts|
 
   opts.on('-f', '--fast') { fast = true }
 
-  opts.on('--list-exchanges') do
+  opts.on('--exchanges') do
     puts CoinTools::Cryptowatch.new.exchanges
     exit 0
   end
 
-  opts.on('--list-markets EXCHANGE') do |exchange|
+  opts.on('--markets EXCHANGE') do |exchange|
     begin
       puts CoinTools::Cryptowatch.new.get_markets(exchange)
       exit 0
-    rescue CoinTools::Cryptowatch::BadRequestException => e
-      $stderr.puts "Error: Incorrect exchange name: #{e}"
+    rescue CoinTools::InvalidExchangeError => e
+      $stderr.puts "Error: Invalid exchange name: '#{exchange}'"
+      exit 1
+    rescue CoinTools::UnknownExchangeError => e
+      $stderr.puts "Error: Unknown exchange: #{exchange}"
+      exit 1
+    rescue CoinTools::ResponseError => e
+      $stderr.puts "Error: Something went wrong: #{e.nice_message}"
       exit 1
     end
   end
@@ -55,25 +60,32 @@ end
 
 exchange = ARGV[0].downcase
 market = ARGV[1].downcase
-date = Time.parse(ARGV[2]) if ARGV[2]
+date = ARGV[2]
+currency = market[-3..-1].upcase
 
 begin
   method = fast ? :get_price_fast : :get_price
   result = CoinTools::Cryptowatch.new.send(method, exchange, market, date)
 
-  if verbose
-    puts "#{exchange}:#{market} @ #{result.time || Time.now} ==> #{result.price}"
-    puts
-  else
+  if quiet
     puts result.price
+  else
+    puts "#{exchange}:#{market} @ #{result.time || Time.now} ==> #{result.price} #{currency}"
+    puts
   end
-rescue CoinTools::Cryptowatch::InvalidDateException => e
-  $stderr.puts "Error: #{e}"
+rescue CoinTools::InvalidExchangeError => e
+  $stderr.puts "Error: Invalid exchange name: '#{exchange}'"
+  exit 1
+rescue CoinTools::InvalidSymbolError => e
+  $stderr.puts "Error: Invalid market name: '#{market}'"
+  exit 1
+rescue CoinTools::InvalidDateError => e
+  $stderr.puts "Error: Invalid date format: '#{date}' (#{e})"
   exit 1
-rescue CoinTools::Cryptowatch::BadRequestException => e
-  $stderr.puts "Error: Incorrect exchange or market name (#{e})"
+rescue CoinTools::UnknownCoinError => e
+  $stderr.puts "Error: Unknown exchange/market pair: #{exchange}/#{market}"
   exit 1
-rescue CoinTools::Cryptowatch::NoDataException => e
-  $stderr.puts "Error: #{e}: data not ready yet"
+rescue CoinTools::ResponseError => e
+  $stderr.puts "Error: Something went wrong: #{e.nice_message}"
   exit 1
 end

data/lib/cointools/base_struct.rb

@@ -0,0 +1,21 @@
+module CoinTools
+  class BaseStruct
+    def self.make(*fields)
+      struct = Class.new(self)
+
+      fields.each do |f|
+        raise ArgumentError.new("Invalid field name: #{f}") unless f.to_s =~ /[a-z][a-z_]*/
+      end
+
+      struct.class_eval <<-CODE
+        def initialize(#{fields.map { |f| "#{f}:" }.join(', ')})
+          #{fields.map { |f| "@#{f} = #{f}" }.join("\n")}
+        end
+
+        attr_reader #{fields.map { |f| ":#{f}" }.join(', ')}
+      CODE
+
+      struct
+    end
+  end
+end

data/lib/cointools/coincap.rb

@@ -1,38 +1,30 @@
-require_relative 'version'
+require_relative 'base_struct'
+require_relative 'errors'
+require_relative 'request'
+require_relative 'utils'
 
-require 'json'
 require 'net/http'
 require 'uri'
 
 module CoinTools
   class CoinCap
     BASE_URL = "https://coincap.io"
-    USER_AGENT = "cointools/#{CoinTools::VERSION}"
-
-    DataPoint = Struct.new(:time, :usd_price, :eur_price, :btc_price)
-
     PERIODS = [1, 7, 30, 90, 180, 365]
 
-    class InvalidResponseException < StandardError
-      attr_reader :response
+    DataPoint = BaseStruct.make(:time, :usd_price, :eur_price, :btc_price)
 
-      def initialize(response)
-        super("#{response.code} #{response.message}")
-        @response = response
-      end
-    end
-
-    class BadRequestException < InvalidResponseException
-    end
-
-    class InvalidDateException < StandardError
-    end
 
     def get_price(symbol, time = nil)
-      return get_current_price(symbol) if time.nil?
+      raise InvalidSymbolError if symbol.to_s.empty?
+
+      if time.nil?
+        return get_current_price(symbol)
+      elsif time.is_a?(String)
+        time = Utils.parse_time(time)
+      end
 
-      (time <= Time.now) or raise InvalidDateException.new('Future date was passed')
-      (time.year >= 2009) or raise InvalidDateException.new('Too early date was passed')
+      (time <= Time.now) or raise InvalidDateError.new('Future date was passed')
+      (time.year >= 2009) or raise InvalidDateError.new('Too early date was passed')
 
       period = period_for_time(time)
 
@@ -42,59 +34,63 @@ module CoinTools
         url = URI("#{BASE_URL}/history/#{symbol.upcase}")
       end
 
-      unixtime = time.to_i
-
-      response = make_request(url)
+      response = Request.get(url)
 
       case response
       when Net::HTTPSuccess
-        json = JSON.load(response.body)
+        json = Utils.parse_json(response.body)
+        raise UnknownCoinError.new(response) if json.nil? || json.empty?
+        raise JSONError.new(response) unless json.is_a?(Hash)
+
         data = json['price']
+        raise JSONError.new(response) unless data.is_a?(Array)
 
+        unixtime = time.to_i
         timestamp, price = best_matching_record(data, unixtime)
+        raise NoDataError.new(response) if timestamp.nil? || price.nil?
+
         actual_time = Time.at(timestamp / 1000)
 
-        return DataPoint.new(actual_time, price, nil, nil)
-      when Net::HTTPBadRequest
-        raise BadRequestException.new(response)
+        return DataPoint.new(time: actual_time, usd_price: price, eur_price: nil, btc_price: nil)
+      when Net::HTTPClientError
+        raise BadRequestError.new(response)
       else
-        raise InvalidResponseException.new(response)
+        raise ServiceUnavailableError.new(response)
       end
     end
 
     def get_current_price(symbol)
+      raise InvalidSymbolError if symbol.to_s.empty?
+
       url = URI("#{BASE_URL}/page/#{symbol.upcase}")
 
-      response = make_request(url)
+      response = Request.get(url)
 
       case response
       when Net::HTTPSuccess
-        json = JSON.load(response.body)
+        json = Utils.parse_json(response.body)
+        raise UnknownCoinError.new(response) if json.nil? || json.empty?
+        raise JSONError.new(response) unless json.is_a?(Hash)
 
         usd_price = json['price_usd']
         eur_price = json['price_eur']
         btc_price = json['price_btc']
 
-        return DataPoint.new(nil, usd_price, eur_price, btc_price)
-      when Net::HTTPBadRequest
-        raise BadRequestException.new(response)
+        if usd_price || eur_price || btc_price
+          return DataPoint.new(time: nil, usd_price: usd_price, eur_price: eur_price, btc_price: btc_price)
+        else
+          raise NoDataError.new(response)
+        end
+      when Net::HTTPClientError
+        raise BadRequestError.new(response)
       else
-        raise InvalidResponseException.new(response)
+        raise ServiceUnavailableError.new(response)
       end
     end
 
 
     private
 
-    def make_request(url)
-      Net::HTTP.start(url.host, url.port, use_ssl: true) do |http|
-        request = Net::HTTP::Get.new(url)
-        request['User-Agent'] = USER_AGENT
-
-        http.request(request)
-      end
-    end
-
     def best_matching_record(data, unixtime)
       millitime = unixtime * 1000
       data.sort_by { |record| (record[0] - millitime).abs }.first

data/lib/cointools/coinmarketcap.rb

@@ -1,13 +1,14 @@
-require_relative 'version'
+require_relative 'base_struct'
+require_relative 'errors'
+require_relative 'request'
+require_relative 'utils'
 
-require 'json'
 require 'net/http'
 require 'uri'
 
 module CoinTools
   class CoinMarketCap
     BASE_URL = "https://api.coinmarketcap.com"
-    USER_AGENT = "cointools/#{CoinTools::VERSION}"
 
     FIAT_CURRENCIES = [
       'AUD', 'BRL', 'CAD', 'CHF', 'CLP', 'CNY', 'CZK', 'DKK', 'EUR', 'GBP',
@@ -16,120 +17,224 @@ module CoinTools
       'ZAR'
     ]
 
-    class DataPoint
-      attr_reader :time, :usd_price, :btc_price, :converted_price
+    class Listing
+      attr_reader :numeric_id, :name, :symbol, :text_id
 
-      def initialize(time, usd_price, btc_price, converted_price = nil)
-        @time = time
-        @usd_price = usd_price
-        @btc_price = btc_price
-        @converted_price = converted_price
+      def initialize(json)
+        [:id, :name, :symbol, :website_slug].each do |key|
+          raise ArgumentError.new("Missing #{key} field") unless json[key.to_s]
+        end
+
+        @numeric_id = json['id']
+        @name = json['name']
+        @symbol = json['symbol']
+        @text_id = json['website_slug']
       end
     end
 
-    class InvalidResponseException < StandardError
-      attr_reader :response
+    class CoinData < Listing
+      attr_reader :last_updated, :usd_price, :btc_price, :converted_price, :rank, :market_cap
+
+      def initialize(json, convert_to = nil)
+        super(json)
+
+        raise ArgumentError.new('Missing rank field') unless json['rank']
+        raise ArgumentError.new('Invalid rank field') unless json['rank'].is_a?(Integer) && json['rank'] > 0
+        @rank = json['rank']
 
-      def initialize(response)
-        super("#{response.code} #{response.message}")
-        @response = response
+        quotes = json['quotes']
+        raise ArgumentError.new('Missing quotes field') unless quotes
+        raise ArgumentError.new('Invalid quotes field') unless quotes.is_a?(Hash)
+
+        usd_quote = quotes['USD']
+        raise ArgumentError.new('Missing USD quote info') unless usd_quote
+        raise ArgumentError.new('Invalid USD quote info') unless usd_quote.is_a?(Hash)
+
+        @usd_price = usd_quote['price']&.to_f
+        @market_cap = usd_quote['market_cap']&.to_f
+
+        if convert_to
+          converted_quote = quotes[convert_to.upcase]
+
+          if converted_quote
+            raise ArgumentError.new("Invalid #{convert_to.upcase} quote info") unless converted_quote.is_a?(Hash)
+            @converted_price = converted_quote['price']&.to_f
+          end
+        else
+          btc_quote = quotes['BTC']
+
+          if btc_quote
+            raise ArgumentError.new("Invalid BTC quote info") unless btc_quote.is_a?(Hash)
+            @btc_price = btc_quote['price']&.to_f
+          end
+        end
+
+        timestamp = json['last_updated']
+        @last_updated = Time.at(timestamp) if timestamp
       end
     end
 
-    class BadRequestException < InvalidResponseException
+    def symbol_map
+      load_listings if @symbol_map.nil?
+      @symbol_map
     end
 
-    class NoDataException < StandardError
+    def id_map
+      load_listings if @id_map.nil?
+      @id_map
     end
 
-    class InvalidFiatCurrencyException < StandardError
-    end
+    def load_listings
+      url = URI("#{BASE_URL}/v2/listings/")
+
+      response = Request.get(url)
+
+      case response
+      when Net::HTTPSuccess
+        data = parse_response(response, Array)
 
-    class InvalidDateException < StandardError
+        @id_map = {}
+        @symbol_map = {}
+
+        begin
+          data.each do |record|
+            listing = Listing.new(record)
+
+            @id_map[listing.text_id] = listing
+            @symbol_map[listing.symbol] = listing
+          end
+        rescue ArgumentError => e
+          # TODO: JSONError vs. NoDataError? + error class docs
+          raise JSONError.new(response, e.message)
+        end
+
+        data.length
+      when Net::HTTPClientError
+        raise BadRequestError.new(response)
+      else
+        raise ServiceUnavailableError.new(response)
+      end
     end
 
     def get_price(coin_name, convert_to: nil)
-      url = URI("#{BASE_URL}/v1/ticker/#{coin_name}/")
+      raise InvalidSymbolError if coin_name.to_s.empty?
+
+      validate_fiat_currency(convert_to) if convert_to
+
+      listing = id_map[coin_name.to_s]
+      raise InvalidSymbolError if listing.nil?
+
+      get_price_for_listing(listing, convert_to: convert_to)
+    end
+
+    def get_price_by_symbol(coin_symbol, convert_to: nil)
+      raise InvalidSymbolError if coin_symbol.to_s.empty?
+
+      validate_fiat_currency(convert_to) if convert_to
+
+      listing = symbol_map[coin_symbol.to_s]
+      raise InvalidSymbolError if listing.nil?
+
+      get_price_for_listing(listing, convert_to: convert_to)
+    end
+
+    def get_price_for_listing(listing, convert_to: nil)
+      url = URI("#{BASE_URL}/v2/ticker/#{listing.numeric_id}/")
 
       if convert_to
-        validate_fiat_currency(convert_to)
-        url += "?convert=#{convert_to}"
+        url.query = "convert=#{convert_to.upcase}"
+      else
+        url.query = "convert=BTC"
       end
 
-      response = make_request(url)
+      response = Request.get(url)
 
       case response
       when Net::HTTPSuccess
-        json = JSON.load(response.body)
-        record = json[0]
-
-        usd_price = record['price_usd']&.to_f
-        btc_price = record['price_btc']&.to_f
-        timestamp = Time.at(record['last_updated'].to_i)
+        record = parse_response(response, Hash)
 
-        if convert_to
-          converted_price = record["price_#{convert_to.downcase}"]&.to_f
-          raise NoDataException.new('Conversion to chosen fiat currency failed') if converted_price.nil?
+        begin
+          return CoinData.new(record, convert_to)
+        rescue ArgumentError => e
+          raise JSONError.new(response, e.message)
         end
-
-        return DataPoint.new(timestamp, usd_price, btc_price, converted_price)
       when Net::HTTPNotFound
-        raise BadRequestException.new(response)
+        raise UnknownCoinError.new(response)
+      when Net::HTTPClientError
+        raise BadRequestError.new(response)
       else
-        raise InvalidResponseException.new(response)
+        raise ServiceUnavailableError.new(response)
       end
     end
 
-    def get_price_by_symbol(coin_symbol, convert_to: nil)
-      url = URI("#{BASE_URL}/v1/ticker/?limit=0")
-      symbol = coin_symbol.downcase
+    def get_all_prices(convert_to: nil, &block)
+      url = URI("#{BASE_URL}/v2/ticker/?structure=array&sort=id&limit=100")
 
       if convert_to
         validate_fiat_currency(convert_to)
-        url.query += "&convert=#{convert_to}"
+        url.query += "&convert=#{convert_to.upcase}"
+      else
+        url.query += "&convert=BTC"
       end
 
-      response = make_request(url)
+      start = 0
+      coins = []
+
+      loop do
+        new_batch = fetch_full_ticker_page(url, convert_to, coins.length, &block)
+
+        if new_batch.empty?
+          break
+        else
+          coins.concat(new_batch)
+        end
+      end
+
+      coins.sort_by(&:rank)
+    end
+
+
+    private
+
+    def fetch_full_ticker_page(base_url, convert_to, start)
+      url = base_url.clone
+      url.query += "&start=#{start}"
+      response = Request.get(url)
 
       case response
       when Net::HTTPSuccess
-        json = JSON.load(response.body)
-        record = json.detect { |r| r['symbol'].downcase == symbol }
-        raise NoDataException.new('No coin found with given symbol') if record.nil?
-
-        usd_price = record['price_usd']&.to_f
-        btc_price = record['price_btc']&.to_f
-        timestamp = Time.at(record['last_updated'].to_i)
+        data = parse_response(response, Array)
 
-        if convert_to
-          converted_price = record["price_#{convert_to.downcase}"]&.to_f
-          raise NoDataException.new('Conversion to chosen fiat currency failed') if converted_price.nil?
+        begin
+          new_batch = data.map { |record| CoinData.new(record, convert_to) }
+        rescue ArgumentError => e
+          raise JSONError.new(response, e.message)
         end
 
-        return DataPoint.new(timestamp, usd_price, btc_price, converted_price)
+        yield new_batch if block_given? && !new_batch.empty?
+
+        new_batch
       when Net::HTTPNotFound
-        raise BadRequestException.new(response)
+        []
+      when Net::HTTPClientError
+        raise BadRequestError.new(response)
       else
-        raise InvalidResponseException.new(response)
+        raise ServiceUnavailableError.new(response)
       end
     end
 
-
-    private
-
     def validate_fiat_currency(fiat_currency)
-      unless FIAT_CURRENCIES.include?(fiat_currency.upcase)
-        raise InvalidFiatCurrencyException
-      end
+      raise InvalidFiatCurrencyError unless FIAT_CURRENCIES.include?(fiat_currency.upcase)
     end
 
-    def make_request(url)
-      Net::HTTP.start(url.host, url.port, use_ssl: true) do |http|
-        request = Net::HTTP::Get.new(url)
-        request['User-Agent'] = USER_AGENT
+    def parse_response(response, expected_data_type)
+      json = Utils.parse_json(response.body)
 
-        http.request(request)
-      end
+      raise JSONError.new(response) unless json.is_a?(Hash) && json['metadata']
+      raise BadRequestError.new(response, json['metadata']['error']) if json['metadata']['error']
+      raise JSONError.new(response) unless json['data'].is_a?(expected_data_type)
+
+      json['data']
     end
   end
 end

data/lib/cointools/cryptowatch.rb

@@ -1,15 +1,14 @@
-require_relative 'version'
+require_relative 'base_struct'
+require_relative 'errors'
+require_relative 'request'
+require_relative 'utils'
 
-require 'json'
 require 'net/http'
 require 'uri'
 
 module CoinTools
   class Cryptowatch
     BASE_URL = "https://api.cryptowat.ch"
-    USER_AGENT = "cointools/#{CoinTools::VERSION}"
-
-    DataPoint = Struct.new(:price, :time, :api_time_spent, :api_time_remaining)
 
     # we expect this many days worth of data for a given period precision (in seconds); NOT guaranteed by the API
     DAYS_FOR_PERIODS = {
@@ -17,96 +16,130 @@ module CoinTools
       7200 => 365, 14400 => 1.5 * 365, 21600 => 2 * 365, 43200 => 3 * 365, 86400 => 4 * 365
     }
 
-    class InvalidResponseException < StandardError
-      attr_reader :response
-
-      def initialize(response)
-        super("#{response.code} #{response.message}")
-        @response = response
-      end
-    end
-
-    class BadRequestException < InvalidResponseException
-    end
+    DataPoint = BaseStruct.make(:price, :time, :api_time_spent, :api_time_remaining)
 
-    class NoDataException < StandardError
-    end
-
-    class InvalidDateException < StandardError
-    end
 
     def exchanges
       @exchanges ||= get_exchanges
     end
 
     def get_markets(exchange)
+      raise InvalidExchangeError if exchange.to_s.empty?
+
       url = URI("#{BASE_URL}/markets/#{exchange}")
 
-      response = make_request(url)
+      response = Request.get(url)
 
       case response
       when Net::HTTPSuccess
-        json = JSON.load(response.body)
+        json = Utils.parse_json(response.body)
+        raise JSONError.new(response) unless json.is_a?(Hash) && json['result'].is_a?(Array)
+
         return json['result'].select { |m| m['active'] == true }.map { |m| m['pair'] }.sort
-      when Net::HTTPBadRequest
-        raise BadRequestException.new(response)
+      when Net::HTTPNotFound
+        raise UnknownExchangeError.new(response)
+      when Net::HTTPClientError
+        raise BadRequestError.new(response)
       else
-        raise InvalidResponseException.new(response)
+        raise ServiceUnavailableError.new(response)
       end
     end
 
     def get_price(exchange, market, time = nil)
-      return get_current_price(exchange, market) if time.nil?
+      raise InvalidExchangeError if exchange.to_s.empty?
+      raise InvalidSymbolError if market.to_s.empty?
 
-      (time <= Time.now) or raise InvalidDateException.new('Future date was passed')
-      (time.year >= 2009) or raise InvalidDateException.new('Too early date was passed')
+      if time.nil?
+        return get_current_price(exchange, market)
+      elsif time.is_a?(String)
+        time = Utils.parse_time(time)
+      end
+
+      (time <= Time.now) or raise InvalidDateError.new('Future date was passed')
+      (time.year >= 2009) or raise InvalidDateError.new('Too early date was passed')
 
       unixtime = time.to_i
       current_time = Time.now.to_i
       url = URI("#{BASE_URL}/markets/#{exchange}/#{market}/ohlc?after=#{unixtime}")
 
-      response = make_request(url)
+      response = Request.get(url)
 
       case response
       when Net::HTTPSuccess
-        json = JSON.load(response.body)
+        json = Utils.parse_json(response.body)
+        raise JSONError.new(response) unless json.is_a?(Hash)
+
         data = json['result']
         allowance = json['allowance']
+        raise JSONError.new(response) unless data.is_a?(Hash) && allowance.is_a?(Hash)
 
         timestamp, o, h, l, c, volume = best_matching_record(data, unixtime, current_time)
-        raise NoDataException.new('No data found for a given time') if timestamp.nil?
+        raise NoDataError.new(response, 'No price data returned') unless timestamp && o
 
         actual_time = Time.at(timestamp)
-        return DataPoint.new(o, actual_time, allowance['cost'], allowance['remaining'])
-      when Net::HTTPBadRequest
-        raise BadRequestException.new(response)
+
+        return DataPoint.new(
+          price: o,
+          time: actual_time,
+          api_time_spent: allowance['cost'],
+          api_time_remaining: allowance['remaining']
+        )
+      when Net::HTTPNotFound
+        raise UnknownCoinError.new(response)
+      when Net::HTTPClientError
+        raise BadRequestError.new(response)
       else
-        raise InvalidResponseException.new(response)
+        raise ServiceUnavailableError.new(response)
       end
     end
 
     def get_current_price(exchange, market)
+      raise InvalidExchangeError if exchange.to_s.empty?
+      raise InvalidSymbolError if market.to_s.empty?
+
       url = URI("#{BASE_URL}/markets/#{exchange}/#{market}/price")
 
-      response = make_request(url)
+      response = Request.get(url)
 
       case response
       when Net::HTTPSuccess
-        json = JSON.load(response.body)
-        price = json['result']['price']
-        allowance = json['allowance']
+        json = Utils.parse_json(response.body)
+        raise JSONError.new(response) unless json.is_a?(Hash)
 
-        return DataPoint.new(price, nil, allowance['cost'], allowance['remaining'])
-      when Net::HTTPBadRequest
-        raise BadRequestException.new(response)
+        data = json['result']
+        allowance = json['allowance']
+        raise JSONError.new(response) unless data.is_a?(Hash) && allowance.is_a?(Hash)
+
+        price = data['price']
+        raise NoDataError.new(response) unless price
+
+        return DataPoint.new(
+          price: price,
+          time: nil,
+          api_time_spent: allowance['cost'],
+          api_time_remaining: allowance['remaining']
+        )
+      when Net::HTTPNotFound
+        raise UnknownCoinError.new(response)
+      when Net::HTTPClientError
+        raise BadRequestError.new(response)
       else
-        raise InvalidResponseException.new(response)
+        raise ServiceUnavailableError.new(response)
       end
     end
 
-    def get_price_fast(exchange, market, time)
-      (time <= Time.now) or raise InvalidDateException.new('Future date was passed')
-      (time.year >= 2009) or raise InvalidDateException.new('Too early date was passed')
+    def get_price_fast(exchange, market, time = nil)
+      raise InvalidExchangeError if exchange.to_s.empty?
+      raise InvalidSymbolError if market.to_s.empty?
+
+      if time.nil?
+        return get_current_price(exchange, market)
+      elsif time.is_a?(String)
+        time = Utils.parse_time(time)
+      end
+
+      (time <= Time.now) or raise InvalidDateError.new('Future date was passed')
+      (time.year >= 2009) or raise InvalidDateError.new('Too early date was passed')
 
       period = precision_for_time(time)
 
@@ -118,43 +151,45 @@ module CoinTools
       current_time = Time.now.to_i
       url = URI("#{BASE_URL}/markets/#{exchange}/#{market}/ohlc?after=#{unixtime}&periods=#{period}")
 
-      response = make_request(url)
+      response = Request.get(url)
 
       case response
       when Net::HTTPSuccess
-        json = JSON.load(response.body)
+        json = Utils.parse_json(response.body)
+        raise JSONError.new(response) unless json.is_a?(Hash)
+
         data = json['result']
         allowance = json['allowance']
+        raise JSONError.new(response) unless data.is_a?(Hash) && allowance.is_a?(Hash)
 
         timestamp, o, h, l, c, volume = best_matching_record(data, unixtime, current_time)
-        raise NoDataException.new('No data found for a given time') if timestamp.nil?
+        raise NoDataError.new(response, 'No price data returned') unless timestamp && o
 
         actual_time = Time.at(timestamp)
-        return DataPoint.new(o, actual_time, allowance['cost'], allowance['remaining'])
-      when Net::HTTPBadRequest
-        raise BadRequestException.new(response)
+
+        return DataPoint.new(
+          price: o,
+          time: actual_time,
+          api_time_spent: allowance['cost'],
+          api_time_remaining: allowance['remaining']
+        )
+      when Net::HTTPNotFound
+        raise UnknownCoinError.new(response)
+      when Net::HTTPClientError
+        raise BadRequestError.new(response)
       else
-        raise InvalidResponseException.new(response)
+        raise ServiceUnavailableError.new(response)
       end
     end
 
 
     private
 
-    def make_request(url)
-      Net::HTTP.start(url.host, url.port, use_ssl: true) do |http|
-        request = Net::HTTP::Get.new(url)
-        request['User-Agent'] = USER_AGENT
-
-        http.request(request)
-      end
-    end
-
     def best_matching_record(data, unixtime, request_time)
       candidates = []
 
       data.keys.sort_by { |k| k.to_i }.each do |k|
-        records = data[k]
+        records = data[k] || []
         previous = nil
 
         records.each do |record|
@@ -192,14 +227,18 @@ module CoinTools
     def get_exchanges
       url = URI("#{BASE_URL}/exchanges")
 
-      response = make_request(url)
+      response = Request.get(url)
 
       case response
       when Net::HTTPSuccess
-        json = JSON.load(response.body)
+        json = Utils.parse_json(response.body)
+        raise JSONError.new(response) unless json.is_a?(Hash) && json['result'].is_a?(Array)
+
         return json['result'].select { |e| e['active'] == true }.map { |e| e['symbol'] }.sort
+      when Net::HTTPClientError
+        raise BadRequestError.new(response)
       else
-        raise InvalidResponseException.new(response)
+        raise ServiceUnavailableError.new(response)
       end
     end
   end

data/lib/cointools/errors.rb

@@ -0,0 +1,57 @@
+module CoinTools
+  class Error < StandardError
+    def nice_message
+      "#{self.class}: #{message}"
+    end
+  end
+
+
+  class UserError < Error
+  end
+
+  class InvalidDateError < UserError
+  end
+
+  class InvalidExchangeError < UserError
+  end
+
+  class InvalidFiatCurrencyError < UserError
+  end
+
+  class InvalidSymbolError < UserError
+  end
+
+
+  class ResponseError < Error
+    attr_reader :response
+
+    def initialize(response, message = nil)
+      super(message || "#{response.code} #{response.message}")
+      @response = response
+    end
+  end
+
+  class JSONError < ResponseError
+    def initialize(response, message = nil)
+      super(response, message || "Incorrect JSON structure")
+    end
+  end
+
+  class NoDataError < ResponseError
+    def initialize(response, message = nil)
+      super(response, message || "Missing data in the response")
+    end
+  end
+
+  class BadRequestError < ResponseError
+  end
+
+  class UnknownCoinError < BadRequestError
+  end
+
+  class UnknownExchangeError < BadRequestError
+  end
+
+  class ServiceUnavailableError < ResponseError
+  end
+end

data/lib/cointools/request.rb

@@ -0,0 +1,21 @@
+require 'net/http'
+require 'uri'
+
+require_relative 'version'
+
+module CoinTools
+  module Request
+    USER_AGENT = "cointools/#{CoinTools::VERSION}"
+
+    def self.get(url)
+      url = URI(url) if url.is_a?(String)
+
+      Net::HTTP.start(url.host, url.port, use_ssl: true) do |http|
+        request = Net::HTTP::Get.new(url)
+        request['User-Agent'] = USER_AGENT
+
+        http.request(request)
+      end
+    end
+  end
+end

data/lib/cointools/utils.rb

@@ -0,0 +1,20 @@
+require_relative 'errors'
+
+require 'json'
+require 'time'
+
+module CoinTools
+  module Utils
+    class << self
+      def parse_json(text)
+        JSON.parse(text, quirks_mode: true)
+      end
+
+      def parse_time(text)
+        Time.parse(text)
+      rescue ArgumentError => e
+        raise InvalidDateError.new(e.message)
+      end
+    end
+  end
+end

data/lib/cointools/version.rb

@@ -1,3 +1,3 @@
 module CoinTools
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cointools
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Kuba Suder
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-23 00:00:00.000000000 Z
+date: 2018-07-12 00:00:00.000000000 Z
 dependencies: []
 description: 
 email:
@@ -27,9 +27,13 @@ files:
 - bin/coincap
 - bin/cryptowatch
 - lib/cointools.rb
+- lib/cointools/base_struct.rb
 - lib/cointools/coincap.rb
 - lib/cointools/coinmarketcap.rb
 - lib/cointools/cryptowatch.rb
+- lib/cointools/errors.rb
+- lib/cointools/request.rb
+- lib/cointools/utils.rb
 - lib/cointools/version.rb
 homepage: https://github.com/mackuba/cointools
 licenses:
@@ -51,7 +55,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.5.2.3
 signing_key: 
 specification_version: 4
 summary: A collection of scripts for checking cryptocurrency prices.