coinsync 0.1.0

data/lib/coinsync.rb

@@ -0,0 +1,18 @@
+require "coinsync/balance"
+require "coinsync/balance_task"
+require "coinsync/build_task"
+require "coinsync/builder"
+require "coinsync/config"
+require "coinsync/crypto_classifier"
+require "coinsync/currencies"
+require "coinsync/currency_converter"
+require "coinsync/formatter"
+require "coinsync/import_task"
+require "coinsync/request"
+require "coinsync/run_command_task"
+require "coinsync/source"
+require "coinsync/transaction"
+require "coinsync/version"
+
+module CoinSync
+end

data/lib/coinsync/balance.rb

@@ -0,0 +1,19 @@
+module CoinSync
+  class Balance
+    attr_reader :currency, :available, :locked
+
+    def initialize(currency, available: BigDecimal(0), locked: BigDecimal(0))
+      @currency = currency
+      @available = available
+      @locked = locked
+    end
+
+    def +(balance)
+      return Balance.new(
+        @currency,
+        available: @available + balance.available,
+        locked: @locked + balance.locked
+      )
+    end
+  end
+end

data/lib/coinsync/balance_task.rb

@@ -0,0 +1,65 @@
+require_relative 'balance'
+require_relative 'formatter'
+require_relative 'importers/all'
+
+module CoinSync
+  class BalanceTask
+    def initialize(config)
+      @config = config
+      @formatter = Formatter.new(config)
+    end
+
+    def run(selected = nil, except = nil)
+      balances = {}
+      columns = []
+      rows = []
+
+      @config.filtered_sources(selected, except).each do |key, source|
+        importer = source.importer
+
+        if importer.respond_to?(:can_import?)
+          if importer.can_import?(:balances)
+            print "[#{key}] Importing balances... "
+
+            columns << key
+
+            importer.import_balances.each do |balance|
+              balances[balance.currency] ||= {}
+              balances[balance.currency][key] = balance
+              balances[balance.currency][nil] ||= Balance.new(balance.currency)
+              balances[balance.currency][nil] += balance
+            end
+
+            puts "√"
+          else
+            puts "[#{key}] Skipping import"
+          end
+        end
+      end
+
+      columns.sort!
+
+      balances.keys.sort.each do |coin|
+        row = [coin.code, '|']
+        row += columns.map { |e|
+          available = balances[coin][e]&.available
+          locked = balances[coin][e]&.locked
+          available ? @formatter.format_crypto(available) + (locked > 0 ? ' (+)' : '') : ''
+        }
+        row << '|'
+        row << @formatter.format_crypto(balances[coin][nil].available)
+        rows << row
+      end
+
+      puts
+
+      printer = TablePrinter.new
+      printer.print_table(
+        ['Coin', '|'] + columns + ['|', 'TOTAL'],
+        rows,
+        alignment: [:ljust, :center] + columns.map { |e| :rjust } + [:center, :rjust],
+        separator: '   '
+      )
+    end
+  end
+end

data/lib/coinsync/build_task.rb

@@ -0,0 +1,43 @@
+require 'fileutils'
+
+require_relative 'builder'
+require_relative 'currency_converter'
+require_relative 'outputs/all'
+
+module CoinSync
+  class BuildTask
+    def initialize(config)
+      @config = config
+    end
+
+    def run(output_name, args = [])
+      if output_name.nil?
+        puts "Error: Build task name not given"
+        exit 1
+      end
+
+      output_class = Outputs.registered[output_name.to_sym]
+
+      if output_class.nil?
+        puts "Unknown build task: #{output_name}"
+        exit 1
+      end
+
+      FileUtils.mkdir_p 'build'
+
+      builder = Builder.new(@config)
+      transactions = builder.build_transaction_list
+
+      output = output_class.new(@config, "build/#{output_name}.csv")
+
+      if output.requires_currency_conversion?
+        if @config.convert_to_currency
+          converter = CurrencyConverter.new(@config)
+          converter.process_transactions(transactions)
+        end
+      end
+
+      output.process_transactions(transactions, *args)
+    end
+  end
+end

data/lib/coinsync/builder.rb

@@ -0,0 +1,32 @@
+require_relative 'importers/all'
+
+module CoinSync
+  class Builder
+    attr_reader :transactions
+
+    def initialize(config)
+      @config = config
+    end
+
+    def build_transaction_list
+      transactions = []
+
+      @config.sources.each do |key, source|
+        if source.importer.can_build?
+          if source.filename.nil?
+            raise "No filename specified for '#{key}', please add a 'file' parameter."
+          end
+
+          File.open(source.filename, 'r') do |file|
+            transactions.concat(source.importer.read_transaction_list(file))
+          end
+        end
+      end
+
+      transactions.each_with_index { |tx, i| tx.number = i + 1 }
+
+      @transactions = transactions.sort_by { |tx| [tx.time, tx.number] }
+      @transactions.each_with_index { |tx, i| tx.number = i + 1 }
+    end
+  end
+end

data/lib/coinsync/config.rb

@@ -0,0 +1,94 @@
+require 'yaml'
+
+require_relative 'source'
+
+module CoinSync
+  class Config
+    attr_reader :source_definitions, :settings
+
+    DEFAULT_CONFIG = 'config.yml'
+
+    def self.load_from_file(filename = nil)
+      yaml = YAML.load(File.read(filename || DEFAULT_CONFIG))
+      self.new(yaml, filename)
+    end
+
+    def initialize(yaml, config_path = nil)
+      @source_definitions = yaml['sources'] or raise 'Config: No sources listed'
+      @settings = yaml['settings'] || {}
+      @labels = @settings['labels'] || {}
+
+      if includes = yaml['include']
+        includes.each do |file|
+          directory = config_path ? [config_path, '..'] : ['.']
+          require(File.expand_path(File.join(*directory, file)))
+        end
+      end
+
+      set_timezone(timezone) if timezone
+    end
+
+    def sources
+      @sources ||= Hash[@source_definitions.keys.map { |key| [key, Source.new(self, key)] }]
+    end
+
+    def filtered_sources(selected, except = nil)
+      included = if selected.nil? || selected.empty?
+        sources.values
+      else
+        selected = [selected] unless selected.is_a?(Array)
+
+        selected.map do |key|
+          sources[key] or raise "Source not found in the config file: '#{key}'"
+        end
+      end
+
+      if except
+        except = [except] unless except.is_a?(Array)
+        included -= except.map { |key| sources[key] }
+      end
+
+      Hash[included.map { |source| [source.key, source] }]
+    end
+
+    def set_timezone(timezone)
+      ENV['TZ'] = timezone
+    end
+
+    def base_cryptocurrencies
+      settings['base_cryptocurrencies'] || ['USDT', 'BTC', 'ETH', 'BNB', 'KCS', 'LTC', 'BCH', 'NEO']
+    end
+
+    def column_separator
+      settings['column_separator'] || ','
+    end
+
+    def decimal_separator
+      custom_decimal_separator || '.'
+    end
+
+    def custom_decimal_separator
+      settings['decimal_separator']
+    end
+
+    def convert_to_currency
+      settings['convert_to'] ? FiatCurrency.new(settings['convert_to']) : nil
+    end
+
+    def currency_converter
+      settings['convert_with']&.to_sym || :fixer
+    end
+
+    def time_format
+      settings['time_format']
+    end
+
+    def timezone
+      settings['timezone']
+    end
+
+    def translate(label)
+      @labels[label] || label
+    end
+  end
+end 

data/lib/coinsync/crypto_classifier.rb

@@ -0,0 +1,27 @@
+require_relative 'currencies'
+
+module CoinSync
+  class CryptoClassifier
+    MAX_INDEX = 1_000_000
+
+    def initialize(config)
+      @config = config
+      @base_currencies = config.base_cryptocurrencies.map { |c| CryptoCurrency.new(c) }
+    end
+
+    def is_purchase?(transaction)
+      bought_index = @base_currencies.index(transaction.bought_currency) || MAX_INDEX
+      sold_index = @base_currencies.index(transaction.sold_currency) || MAX_INDEX
+
+      if bought_index < sold_index
+        false
+      elsif bought_index > sold_index
+        true
+      else
+        raise "Couldn't determine which cryptocurrency is the base one: #{transaction.bought_currency.code} vs " +
+          "#{transaction.sold_currency.code}. Use the `base_cryptocurrencies` setting to explicitly choose " +
+          "base cryptocurrencies."
+      end
+    end
+  end
+end

data/lib/coinsync/currencies.rb

@@ -0,0 +1,35 @@
+module CoinSync
+  class Currency < Struct.new(:code)
+    def <=>(other)
+      self.code <=> other.code
+    end
+  end
+
+  class FiatCurrency < Currency
+    def fiat?
+      true
+    end
+
+    def crypto?
+      false
+    end
+  end
+
+  class CryptoCurrency < Currency
+    MAPPING = {
+      'XRB' => 'NANO'
+    }
+
+    def initialize(code)
+      super(MAPPING[code] || code)
+    end
+
+    def fiat?
+      false
+    end
+
+    def crypto?
+      true
+    end
+  end
+end

data/lib/coinsync/currency_converter.rb

@@ -0,0 +1,65 @@
+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
+    end
+
+    def process_transactions(transactions)
+      transactions.each do |tx|
+        print '.'
+
+        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
+        elsif tx.sold_currency.fiat? && tx.sold_currency != @target_currency
+          tx.converted = Transaction::ConvertedAmounts.new
+          tx.converted.bought_currency = tx.bought_currency
+          tx.converted.bought_amount = tx.bought_amount
+          tx.converted.sold_currency = @target_currency
+
+          if tx.sold_currency.code
+            tx.converted.exchange_rate = @converter.convert(
+              BigDecimal.new(1),
+              from: tx.sold_currency,
+              to: @target_currency,
+              date: tx.time.to_date
+            )
+            tx.converted.sold_amount = tx.sold_amount * tx.converted.exchange_rate
+          else
+            tx.converted.exchange_rate = nil
+            tx.converted.sold_amount = BigDecimal.new(0)
+          end
+        end
+      end
+
+      @converter.finalize
+
+      puts
+    end
+  end
+end

data/lib/coinsync/currency_converters/all.rb

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

data/lib/coinsync/currency_converters/base.rb

@@ -0,0 +1,46 @@
+require 'bigdecimal'
+
+require_relative 'cache'
+require_relative '../currencies'
+
+module CoinSync
+  module CurrencyConverters
+    def self.registered
+      @converters ||= {}
+    end
+
+    class Base
+      def self.register_converter(key)
+        if CurrencyConverters.registered[key]
+          raise "Currency converter has already been registered at '#{key}'"
+        else
+          CurrencyConverters.registered[key] = self
+        end
+      end
+
+      def initialize
+        @cache = Cache.new(self.class.name.downcase.split('::').last)
+      end
+
+      def convert(amount, from:, to:, date:)
+        (amount > 0) or raise "#{self.class}: amount should be positive"
+        (amount.is_a?(BigDecimal)) or raise "#{self.class}: 'amount' should be a BigDecimal"
+        (from.is_a?(FiatCurrency)) or raise "#{self.class}: 'from' should be a FiatCurrency"
+        (to.is_a?(FiatCurrency)) or raise "#{self.class}: 'to' should be a FiatCurrency"
+        (date.is_a?(Date)) or raise "#{self.class}: 'date' should be a Date"
+
+        if rate = @cache[from, to, date]
+          return rate * amount
+        else
+          rate = fetch_conversion_rate(from: from, to: to, date: date)
+          @cache[from, to, date] = rate
+          return rate * amount
+        end
+      end
+
+      def finalize
+        @cache.save
+      end
+    end
+  end
+end