coinsync 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 59e420867e256a9ed7fef1d87ae08279e7e4dfcc
-  data.tar.gz: 69fbe095ab411e0a0a65223063bb30267af81682
+  metadata.gz: 5ee9560e9255a67e3389a7aa39ca48820dffe803
+  data.tar.gz: e946c4c12142d887c53f50b54c85d4a1d473f5bf
 SHA512:
-  metadata.gz: fa574e1fcecefe950ab83f576754e24ae4a867bf913ff2ea34cdf0673149e6787edc75663d6500500dec5e8e668fb5a6e34163e0ee106395296d6beef721cc11
-  data.tar.gz: 8f60e49910ffc061406cf20f7186f31bd0246e2c663b69753f343daf87c5b155b2a82d0039095c36ebf1ccea0bf559cba4b9c3b2eaacf8cbcbbd273206bc670b
+  metadata.gz: cff97b38cecbc4933545d1f50525ab9aeba5e02ac13474e103e3108174b175bd98b6536097bec5816f4c265504fb155bc8d36081cdfdd6ef3f0987acbd5fd3f3
+  data.tar.gz: c324c154236885613861372a8302582dd80214416eaa3e85690826a0864ee43c610f95869c78c0e174e8ae9d882f176657bb476909a14d5cef808471abfad6d5

data/README.md

@@ -88,7 +88,8 @@ settings:
   time_format: "%Y-%m-%d %H:%M"
   column_separator: ";"
   decimal_separator: ","
-  convert_to: PLN
+  convert_currency:
+    to: PLN
 include:
   - extras.rb
 ```
@@ -119,8 +120,7 @@ See the separate ["Importers"](doc/importers.md) doc file for a full list of sup
 
 - `base_cryptocurrencies`: an array listing which cryptocurrencies might be considered the base currency for a trading pair; if both sides of the pair are included in the list, the one earlier in the list takes priority (default: `['USDT', 'BTC', 'ETH', 'BNB', 'KCS', 'LTC', 'BCH', 'NEO']`)
 - `column_separator`: what character is used to separate columns in saved CSV files (default: `","`)
-- `convert_to`: what fiat currency should fiat amounts be converted to (default: none)
-- `convert_with`: what currency converter module should be used to do the currency conversions (default: `fixer`)
+- `convert_currency`: currency conversion config, see below
 - `decimal_separator`: what character is used to separate decimal digits in numbers (default: `"."`)
 - `time_format`: the [time format string](http://ruby-doc.org/core-2.5.0/Time.html#method-i-strftime) to use when printing dates (default: `"%Y-%m-%d %H:%M:%S"`)
 - `timezone`: an explicit timezone to use for printing dates and currency conversion (default: system timezone)
@@ -132,13 +132,35 @@ If you want to extend the tool with support for additional importers, build task
 
 ### Currency conversion
 
-If you make transactions in multiple fiat currencies (e.g. USD on Bitfinex, EUR on Kraken) and you want to have all values converted to one currency (for example, to calculate profits for tax purposes), use the `convert_to` and `convert_with` options in the settings. Currency conversion is done using pluggable modules that load currency rates from specific sources. Currently, two are available:
+If you make transactions in multiple fiat currencies (e.g. USD on Bitfinex, EUR on Kraken) and you want to have all values converted to one currency (for example, to calculate profits for tax purposes), add a `currency_conversion` section in the settings. Currency conversion is done using pluggable modules that load currency rates from specific sources. Currently, two are available:
 
-- `fixer` loads exchange rates from [fixer.io](http://fixer.io) API (note: they've now decided to deprecate this API in June and the new one requires an API key, let me know if you know any better option)
-- `nbp` loads rates from [Polish National Bank](http://www.nbp.pl/home.aspx?f=/statystyka/kursy.html) (this will be moved to a separate gem)
+- `exchangeratesapi` loads exchange rates from [exchangeratesapi.io](https://exchangeratesapi.io) API
+- `nbp` loads rates from [Polish National Bank](http://www.nbp.pl/home.aspx?f=/statystyka/kursy.html) (this might be moved to a separate gem?)
 
 You can always write another module that connects to your preferred source and plug it in using `include`.
 
+The `currency_conversion` option value should be a hash with keys:
+
+- `using`: name of the currency converter module (default: `exchangeratesapi`)
+- `to`: code of the currency to convert to (required)
+
+
+### Transaction value estimation
+
+In some cases you might want to know the total value of a transaction in a chosen fiat currency. For purchase and sale transactions, this is just the total amount for which you've bought or sold the given asset. However, for swap (crypto-to-crypto) transactions, the total value can't be simply calculated from the available data, and it might not even be obvious *how* it should be calculated at all.
+
+This is where value estimation modules aka price loaders come in. They're another type of pluggable modules that load historical prices of a given coin from a selected source. For simplicity, only the price of the base coin is checked - e.g. when you buy STEEM with BTC, the value of the transaction (i.e. the value of both the sold BTC and the bought STEEM) is set to the price of BTC at that moment times the amount of BTC spent, and the price of STEEM in USD/EUR isn't checked separately.
+
+Currently only one price loader is available: `cryptowatch`, which can load the price of any coin listed on [Cryptowat.ch](https://cryptowat.ch) (requires the [cointools gem](https://github.com/mackuba/cointools)).
+
+To estimate transaction value using Cryptowat.ch, add a `value_estimation` section in the settings:
+
+- `using`: name of the price loader module (required - `cryptowatch`)
+- `exchange`: name of an exchange listed on Cryptowat.ch (default: `bitfinex`)
+- `currency`: code of the fiat currency in which value should be calculated (default: `USD`)
+
+At the moment this feature is only used in the [Split List](#build-split-list) output.
+
 
 ## Using the tool
 
@@ -195,6 +217,15 @@ coinsync build list
 This will just print all your transactions to a single unified CSV file (in `build/list.csv`).
 
 
+#### Build Split List
+
+```
+coinsync build split-list
+```
+
+Builds a list similar to `build list`, but all "swap" transactions (crypto-to-crypto) are split into separate sale and purchase parts (`build/split-list.csv`). This can be useful for some tax-related calculations, and is only really useful if you also enable the [transaction value estimation option](#transaction-value-estimation).
+
+
 #### Build Raw
 
 ```

data/lib/coinsync/build_task.rb

@@ -1,7 +1,7 @@
 require 'fileutils'
 
 require_relative 'builder'
-require_relative 'currency_converter'
+require_relative 'currency_conversion_task'
 require_relative 'outputs/all'
 
 module CoinSync
@@ -31,8 +31,8 @@ module CoinSync
       output = output_class.new(@config, "build/#{output_name}.csv")
 
       if output.requires_currency_conversion?
-        if @config.convert_to_currency
-          converter = CurrencyConverter.new(@config)
+        if options = @config.currency_conversion
+          converter = CurrencyConversionTask.new(options)
           converter.process_transactions(transactions)
         end
       end

data/lib/coinsync/config.rb

@@ -1,5 +1,9 @@
+require 'ostruct'
 require 'yaml'
 
+require_relative 'currencies'
+require_relative 'currency_converters/all'
+require_relative 'price_loaders/all'
 require_relative 'source'
 
 module CoinSync
@@ -71,12 +75,12 @@ module CoinSync
       settings['decimal_separator']
     end
 
-    def convert_to_currency
-      settings['convert_to'] ? FiatCurrency.new(settings['convert_to']) : nil
+    def currency_conversion
+      settings['convert_currency'] && CurrencyConversionOptions.new(settings['convert_currency'])
     end
 
-    def currency_converter
-      settings['convert_with']&.to_sym || :fixer
+    def value_estimation
+      settings['estimate_value'] && ValueEstimationOptions.new(settings['estimate_value'])
     end
 
     def time_format
@@ -90,5 +94,57 @@ module CoinSync
     def translate(label)
       @labels[label] || label
     end
+
+    class CurrencyConversionOptions < OpenStruct
+      DEFAULT_CURRENCY_CONVERTER = :exchangeratesapi
+
+      def initialize(options)
+        super
+
+        if options['using']
+          self.currency_converter_name = options['using'].to_sym
+        else
+          self.currency_converter_name = DEFAULT_CURRENCY_CONVERTER
+        end
+
+        if options['to']
+          self.currency = FiatCurrency.new(options['to'].upcase)
+        else
+          raise "'convert_currency' requires a 'to' field with a currency code"
+        end
+      end
+
+      def currency_converter
+        currency_converter_class = CurrencyConverters.registered[currency_converter_name]
+
+        if currency_converter_class
+          currency_converter_class.new(self)
+        else
+          raise "Unknown currency converter: #{currency_converter_name}"
+        end
+      end
+    end
+
+    class ValueEstimationOptions < OpenStruct
+      def initialize(options)
+        super
+
+        if options['using']
+          self.price_loader_name = options['using'].to_sym
+        else
+          raise "'value_estimation' requires a 'using' field with a name of a price loader"
+        end
+      end
+
+      def price_loader
+        price_loader_class = PriceLoaders.registered[price_loader_name]
+
+        if price_loader_class
+          price_loader_class.new(self)
+        else
+          raise "Unknown price loader: #{price_loader_name}"
+        end
+      end
+    end
   end
 end 

data/lib/coinsync/{currency_converter.rb → currency_conversion_task.rb}

@@ -1,23 +1,14 @@
 require 'bigdecimal'
 require 'time'
 
-require_relative 'currencies'
-require_relative 'currency_converters/all'
 require_relative 'transaction'
 
 module CoinSync
-  class CurrencyConverter
-    def initialize(config)
-      @config = config
-      @target_currency = config.convert_to_currency
-
-      converter_class = CurrencyConverters.registered[config.currency_converter]
-
-      if converter_class
-        @converter = converter_class.new
-      else
-        raise "Unknown currency converter #{config.currency_converter}"
-      end
+  class CurrencyConversionTask
+    def initialize(options)
+      @options = options
+      @target_currency = options.currency
+      @converter = options.currency_converter
     end
 
     def process_transactions(transactions)
@@ -26,16 +17,22 @@ module CoinSync
 
         if tx.bought_currency.fiat? && tx.bought_currency != @target_currency
           tx.converted = Transaction::ConvertedAmounts.new
-          tx.converted.bought_currency = @target_currency
-          tx.converted.exchange_rate = @converter.convert(
-            BigDecimal.new(1),
-            from: tx.bought_currency,
-            to: @target_currency,
-            date: tx.time.to_date
-          )
-          tx.converted.bought_amount = tx.bought_amount * tx.converted.exchange_rate
           tx.converted.sold_currency = tx.sold_currency
           tx.converted.sold_amount = tx.sold_amount
+          tx.converted.bought_currency = @target_currency
+
+          if tx.bought_currency.code
+            tx.converted.exchange_rate = @converter.convert(
+              BigDecimal.new(1),
+              from: tx.bought_currency,
+              to: @target_currency,
+              date: tx.time.to_date
+            )
+            tx.converted.bought_amount = tx.bought_amount * tx.converted.exchange_rate
+          else
+            tx.converted.exchange_rate = nil
+            tx.converted.bought_amount = BigDecimal.new(0)
+          end
         elsif tx.sold_currency.fiat? && tx.sold_currency != @target_currency
           tx.converted = Transaction::ConvertedAmounts.new
           tx.converted.bought_currency = tx.bought_currency

data/lib/coinsync/currency_converters/base.rb

@@ -18,7 +18,8 @@ module CoinSync
         end
       end
 
-      def initialize
+      def initialize(options)
+        @options = options
         @cache = Cache.new(self.class.name.downcase.split('::').last)
       end
 

data/lib/coinsync/currency_converters/cache.rb

@@ -6,7 +6,7 @@ module CoinSync
     class Cache
       def initialize(name)
         @name = name
-        @filename = "caches/#{name}.json"
+        @filename = "cache/#{name}.json"
 
         if File.exist?(@filename)
           @rates = JSON.parse(File.read(@filename))

data/lib/coinsync/currency_converters/{fixer.rb → exchangeratesapi.rb}

@@ -6,10 +6,10 @@ require_relative '../request'
 
 module CoinSync
   module CurrencyConverters
-    class Fixer < Base
-      register_converter :fixer
+    class ExchangeRatesAPI < Base
+      register_converter :exchangeratesapi
 
-      BASE_URL = "https://api.fixer.io"
+      BASE_URL = "https://exchangeratesapi.io/api"
 
       class Exception < StandardError; end
       class NoDataException < Exception; end

data/lib/coinsync/importers/bitbay_api.rb

@@ -22,7 +22,7 @@ module CoinSync
       OP_SALE = '-pay_for_currency'
       OP_FEE = '-fee'
 
-      MAX_TIME_DIFFERENCE = 5.0
+      MAX_TIME_DIFFERENCE = 2.0  # TODO: this breaks too easily (3.0)
       TRANSACTION_TYPES = [OP_PURCHASE, OP_SALE, OP_FEE]
 
       class HistoryEntry
@@ -45,17 +45,23 @@ module CoinSync
 
         def parse_currency(code)
           case code.upcase
-          when 'BTC' then CryptoCurrency.new('BTC')
-          when 'ETH' then CryptoCurrency.new('ETH')
-          when 'LTC' then CryptoCurrency.new('LTC')
-          when 'LSK' then CryptoCurrency.new('LSK')
+
           when 'BCC' then CryptoCurrency.new('BCH')
+          when 'BTC' then CryptoCurrency.new('BTC')
           when 'BTG' then CryptoCurrency.new('BTG')
-          when 'GAME' then CryptoCurrency.new('GAME')
           when 'DASH' then CryptoCurrency.new('DASH')
-          when 'PLN' then FiatCurrency.new('PLN')
+          when 'ETH' then CryptoCurrency.new('ETH')
+          when 'GAME' then CryptoCurrency.new('GAME')
+          when 'KZC' then CryptoCurrency.new('KZC')
+          when 'LSK' then CryptoCurrency.new('LSK')
+          when 'LTC' then CryptoCurrency.new('LTC')
+          when 'XIN' then CryptoCurrency.new('XIN')
+          when 'XRP' then CryptoCurrency.new('XRP')
+
           when 'EUR' then FiatCurrency.new('EUR')
           when 'USD' then FiatCurrency.new('USD')
+          when 'PLN' then FiatCurrency.new('PLN')
+
           else raise "Unknown currency: #{code}"
           end
         end

data/lib/coinsync/outputs/base.rb

@@ -9,10 +9,10 @@ module CoinSync
 
     class Base
       def self.register_output(key)
-        if Outputs.registered[key]
+        if Outputs.registered[key.to_sym]
           raise "Output has already been registered at '#{key}'"
         else
-          Outputs.registered[key] = self
+          Outputs.registered[key.to_sym] = self
         end
       end
 

data/lib/coinsync/outputs/list.rb

@@ -34,10 +34,10 @@ module CoinSync
           'Currency'
         ].map { |l| @config.translate(l) }
 
-        if currency = @config.convert_to_currency
+        if options = @config.currency_conversion
           line += [
-            @config.translate('Total value ($CURRENCY)').gsub('$CURRENCY', currency.code),
-            @config.translate('Price ($CURRENCY)').gsub('$CURRENCY', currency.code),
+            @config.translate('Total value ($CURRENCY)').gsub('$CURRENCY', options.currency.code),
+            @config.translate('Price ($CURRENCY)').gsub('$CURRENCY', options.currency.code),
             @config.translate('Exchange rate')
           ]
         end
@@ -66,7 +66,7 @@ module CoinSync
           tx.fiat_currency.code || '–'
         ]
 
-        if @config.convert_to_currency
+        if @config.currency_conversion
           if tx.converted
             csv += [
               @formatter.format_fiat(tx.converted.fiat_amount),
@@ -112,7 +112,7 @@ module CoinSync
           currency.code
         ]
 
-        if @config.convert_to_currency
+        if @config.currency_conversion
           csv += [nil, nil, nil]
         end
 

data/lib/coinsync/outputs/split_list.rb

@@ -0,0 +1,153 @@
+require 'csv'
+
+require_relative 'base'
+require_relative '../currencies'
+require_relative '../currency_conversion_task'
+require_relative '../transaction'
+
+module CoinSync
+  module Outputs
+    class SplitList < List
+      register_output 'split-list'
+
+      def requires_currency_conversion?
+        false
+      end
+
+      def initialize(config, target_file)
+        super
+
+        if @config.value_estimation
+          @price_loader = @config.value_estimation.price_loader
+        end
+      end
+
+      def process_transactions(transactions, *args)
+        split_list = []
+
+        transactions.each do |tx|
+          if tx.purchase? || tx.sale?
+            split_list << tx
+          else
+            sale, purchase = split_transaction(tx)
+            split_list << sale
+            split_list << purchase
+          end
+        end
+
+        @price_loader&.finalize
+
+        if options = @config.currency_conversion
+          converter = CurrencyConversionTask.new(options)
+          converter.process_transactions(split_list)
+        end
+
+        super(split_list, *args)
+      end
+
+      def split_transaction(tx)
+        if @classifier.is_purchase?(tx)
+          base = tx.sold_currency
+          base_price, fiat_currency = get_coin_price(base, tx.time)
+          total_value = tx.sold_amount * base_price
+        else
+          base = tx.bought_currency
+          base_price, fiat_currency = get_coin_price(base, tx.time)
+          total_value = tx.bought_amount * base_price
+        end
+
+        sale = Transaction.new(
+          number: "#{tx.number}.A",
+          exchange: tx.exchange,
+          time: tx.time,
+          sold_currency: tx.sold_currency,
+          sold_amount: tx.sold_amount,
+          bought_currency: fiat_currency,
+          bought_amount: total_value
+        )
+
+        purchase = Transaction.new(
+          number: "#{tx.number}.B",
+          exchange: tx.exchange,
+          time: tx.time,
+          bought_currency: tx.bought_currency,
+          bought_amount: tx.bought_amount,
+          sold_currency: fiat_currency,
+          sold_amount: total_value
+        )
+
+        [sale, purchase]
+      end
+
+      def fiat_transaction_to_csv(tx)
+        tx_type = @config.translate(tx.type.to_s.capitalize)
+
+        is_split = tx.number.to_s.include?('.')
+        is_incomplete = is_split && tx.bought_amount * tx.sold_amount == 0
+
+        if is_split
+          tx_type = @config.translate(Transaction::TYPE_SWAP.to_s.capitalize) + '/' + tx_type
+        end
+
+        csv = [
+          tx.number || 0,
+          tx.exchange,
+          tx_type,
+          @formatter.format_time(tx.time),
+          @formatter.format_crypto(tx.crypto_amount),
+          tx.crypto_currency.code
+        ]
+
+        if is_incomplete
+          csv += [nil, nil, nil]
+        else
+          csv += [
+            @formatter.format_fiat(tx.fiat_amount),
+            @formatter.format_fiat_price(tx.price),
+            tx.fiat_currency.code || '–'
+          ]
+        end
+
+        if @config.currency_conversion
+          if is_incomplete
+            csv += [nil, nil, nil]
+          elsif tx.converted
+            csv += [
+              @formatter.format_fiat(tx.converted.fiat_amount),
+              @formatter.format_fiat_price(tx.converted.price),
+              tx.converted.exchange_rate && @formatter.format_float(tx.converted.exchange_rate, precision: 4)
+            ]
+          else
+            csv += [
+              @formatter.format_fiat(tx.fiat_amount),
+              @formatter.format_fiat_price(tx.price),
+              nil
+            ]
+          end
+        end
+
+        csv
+      end
+
+      def swap_transaction_to_csv(tx)
+        # sanity check - this should not happen
+        raise "SplitList: unexpected unprocessed swap transaction"
+      end
+
+      def get_coin_price(coin, time)
+        if @price_loader
+          print "$"
+
+          begin
+            @price_loader.get_price(coin, time)
+          rescue Exception => e
+            @price_loader.finalize
+            raise
+          end
+        else
+          [BigDecimal.new(0), FiatCurrency.new(nil)]
+        end
+      end
+    end
+  end
+end

data/lib/coinsync/outputs/summary.rb

@@ -17,6 +17,8 @@ module CoinSync
         totals = Hash.new { BigDecimal(0) }
 
         transactions.each do |tx|
+          break if args.first.to_i > 0 && tx.time.year >= args.first.to_i
+
           if tx.bought_currency.crypto?
             amount = totals[tx.bought_currency]
             totals[tx.bought_currency] = amount + tx.bought_amount

data/lib/coinsync/price_loaders/all.rb

@@ -0,0 +1 @@
+Dir[File.join(File.dirname(__FILE__), '*.rb')].each { |f| require(f) }

data/lib/coinsync/price_loaders/base.rb

@@ -0,0 +1,61 @@
+require 'bigdecimal'
+
+require_relative 'cache'
+require_relative '../currencies'
+
+module CoinSync
+  module PriceLoaders
+    def self.registered
+      @price_loaders ||= {}
+    end
+
+    class Base
+      def self.register_price_loader(key)
+        if PriceLoaders.registered[key.to_sym]
+          raise "Price loader has already been registered at '#{key}'"
+        else
+          PriceLoaders.registered[key.to_sym] = self
+        end
+      end
+
+      def initialize(options)
+        @options = options
+        @currency = currency
+        @cache = Cache.new(cache_name)
+      end
+
+      def cache_name
+        self.class.name.downcase.split('::').last
+      end
+
+      def get_price(coin, time)
+        (coin.is_a?(CryptoCurrency)) or raise "#{self.class}: 'coin' should be a CryptoCurrency"
+        (time.is_a?(Time)) or raise "#{self.class}: 'time' should be a Time"
+
+        data = @cache[coin, time]
+
+        if data.nil?
+          data = fetch_price(coin, time)
+          @cache[coin, time] = data
+        end
+
+        price = data.is_a?(Array) ? data.first : data
+
+        [convert_price(price), @currency]
+      end
+
+      def convert_price(price)
+        case price
+        when BigDecimal then price
+        when String, Integer then BigDecimal.new(price)
+        when Float then BigDecimal.new(price, 0)
+        else raise "Unexpected price value: #{price.inspect}"
+        end
+      end
+
+      def finalize
+        @cache.save
+      end
+    end
+  end
+end

data/lib/coinsync/price_loaders/cache.rb

@@ -0,0 +1,34 @@
+require 'fileutils'
+require 'json'
+
+module CoinSync
+  module PriceLoaders
+    class Cache
+      def initialize(name)
+        @name = name
+        @filename = "data/prices/#{name}.json"
+
+        if File.exist?(@filename)
+          @prices = JSON.parse(File.read(@filename))
+        else
+          @prices = {}
+        end
+      end
+
+      def [](coin, time)
+        @prices[coin.code] ||= {}
+        @prices[coin.code][time.to_i.to_s]
+      end
+
+      def []=(coin, time, price)
+        @prices[coin.code] ||= {}
+        @prices[coin.code][time.to_i.to_s] = price
+      end
+
+      def save
+        FileUtils.mkdir_p(File.dirname(@filename))
+        File.write(@filename, JSON.generate(@prices))
+      end
+    end
+  end
+end

data/lib/coinsync/price_loaders/cryptowatch.rb

@@ -0,0 +1,34 @@
+require_relative 'base'
+require_relative '../utils'
+
+module CoinSync
+  module PriceLoaders
+    class Cryptowatch < Base
+      register_price_loader :cryptowatch
+
+      def initialize(options)
+        options.currency = options.currency&.upcase || 'USD'
+        options.exchange ||= 'bitfinex'
+
+        super
+
+        Utils.lazy_require(self, 'cointools')
+
+        @cryptowatch ||= CoinTools::Cryptowatch.new
+      end
+
+      def cache_name
+        "cryptowatch-#{@options.exchange}-#{@options.currency.downcase}"
+      end
+
+      def currency
+        FiatCurrency.new(@options.currency)
+      end
+
+      def fetch_price(coin, time)
+        result = @cryptowatch.get_price_fast(@options.exchange, coin.code.downcase + @options.currency.downcase, time)
+        [result.price, result.time.to_i]
+      end
+    end
+  end
+end

data/lib/coinsync/transaction.rb

@@ -105,7 +105,7 @@ module CoinSync
         raise "Transaction: '#{bought_currency}' is not a valid currency"
       end
 
-      (bought_amount > 0) or raise "Transaction: bought_amount should be positive (#{bought_amount})"
+      (bought_amount >= 0) or raise "Transaction: bought_amount should not be negative (#{bought_amount})"
 
       if sold_amount.is_a?(BigDecimal)
         @sold_amount = sold_amount

data/lib/coinsync/utils.rb

@@ -0,0 +1,13 @@
+module CoinSync
+  module Utils
+    def self.lazy_require(source, name)
+      begin
+        require(name)
+      rescue LoadError
+        gem = name.split('/').first
+        puts "#{source.class}: gem '#{gem}' is not installed"
+        exit 1
+      end
+    end
+  end
+end

data/lib/coinsync/version.rb

@@ -1,3 +1,3 @@
 module CoinSync
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/coinsync.rb

@@ -5,13 +5,14 @@ require "coinsync/builder"
 require "coinsync/config"
 require "coinsync/crypto_classifier"
 require "coinsync/currencies"
-require "coinsync/currency_converter"
+require "coinsync/currency_conversion_task"
 require "coinsync/formatter"
 require "coinsync/import_task"
 require "coinsync/request"
 require "coinsync/run_command_task"
 require "coinsync/source"
 require "coinsync/transaction"
+require "coinsync/utils"
 require "coinsync/version"
 
 module CoinSync

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: coinsync
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Kuba Suder
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-09 00:00:00.000000000 Z
+date: 2018-04-24 00:00:00.000000000 Z
 dependencies: []
 description: 
 email:
@@ -30,11 +30,11 @@ files:
 - lib/coinsync/config.rb
 - lib/coinsync/crypto_classifier.rb
 - lib/coinsync/currencies.rb
-- lib/coinsync/currency_converter.rb
+- lib/coinsync/currency_conversion_task.rb
 - lib/coinsync/currency_converters/all.rb
 - lib/coinsync/currency_converters/base.rb
 - lib/coinsync/currency_converters/cache.rb
-- lib/coinsync/currency_converters/fixer.rb
+- lib/coinsync/currency_converters/exchangeratesapi.rb
 - lib/coinsync/currency_converters/nbp.rb
 - lib/coinsync/formatter.rb
 - lib/coinsync/import_task.rb
@@ -60,13 +60,19 @@ files:
 - lib/coinsync/outputs/base.rb
 - lib/coinsync/outputs/list.rb
 - lib/coinsync/outputs/raw.rb
+- lib/coinsync/outputs/split_list.rb
 - lib/coinsync/outputs/summary.rb
+- lib/coinsync/price_loaders/all.rb
+- lib/coinsync/price_loaders/base.rb
+- lib/coinsync/price_loaders/cache.rb
+- lib/coinsync/price_loaders/cryptowatch.rb
 - lib/coinsync/request.rb
 - lib/coinsync/run_command_task.rb
 - lib/coinsync/source.rb
 - lib/coinsync/source_filter.rb
 - lib/coinsync/table_printer.rb
 - lib/coinsync/transaction.rb
+- lib/coinsync/utils.rb
 - lib/coinsync/version.rb
 homepage: https://github.com/mackuba/coinsync
 licenses: