coinsync 0.1.0

data/lib/coinsync/outputs/all.rb

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

data/lib/coinsync/outputs/base.rb

@@ -0,0 +1,32 @@
+require_relative '../crypto_classifier'
+require_relative '../formatter'
+
+module CoinSync
+  module Outputs
+    def self.registered
+      @outputs ||= {}
+    end
+
+    class Base
+      def self.register_output(key)
+        if Outputs.registered[key]
+          raise "Output has already been registered at '#{key}'"
+        else
+          Outputs.registered[key] = self
+        end
+      end
+
+      def initialize(config, target_file)
+        @config = config
+        @target_file = target_file
+
+        @formatter = Formatter.new(config)
+        @classifier = CryptoClassifier.new(config)
+      end
+
+      def requires_currency_conversion?
+        false
+      end
+    end
+  end
+end

data/lib/coinsync/outputs/list.rb

@@ -0,0 +1,123 @@
+require 'csv'
+
+require_relative 'base'
+
+module CoinSync
+  module Outputs
+    class List < Base
+      register_output :list
+
+      def requires_currency_conversion?
+        true
+      end
+
+      def process_transactions(transactions, *args)
+        CSV.open(@target_file, 'w', col_sep: @config.column_separator) do |csv|
+          csv << headers
+
+          transactions.each do |tx|
+            csv << transaction_to_csv(tx)
+          end
+        end
+      end
+
+      def headers
+        line = [
+          'No.',
+          'Exchange',
+          'Type',
+          'Date',
+          'Amount',
+          'Asset',
+          'Total value',
+          'Price',
+          'Currency'
+        ].map { |l| @config.translate(l) }
+
+        if currency = @config.convert_to_currency
+          line += [
+            @config.translate('Total value ($CURRENCY)').gsub('$CURRENCY', currency.code),
+            @config.translate('Price ($CURRENCY)').gsub('$CURRENCY', currency.code),
+            @config.translate('Exchange rate')
+          ]
+        end
+
+        line
+      end
+
+      def transaction_to_csv(tx)
+        if tx.purchase? || tx.sale?
+          fiat_transaction_to_csv(tx)
+        else
+          swap_transaction_to_csv(tx)
+        end
+      end
+
+      def fiat_transaction_to_csv(tx)
+        csv = [
+          tx.number || 0,
+          tx.exchange,
+          @config.translate(tx.type.to_s.capitalize),
+          @formatter.format_time(tx.time),
+          @formatter.format_crypto(tx.crypto_amount),
+          tx.crypto_currency.code,
+          @formatter.format_fiat(tx.fiat_amount),
+          @formatter.format_fiat_price(tx.price),
+          tx.fiat_currency.code || '–'
+        ]
+
+        if @config.convert_to_currency
+          if 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)
+        if @classifier.is_purchase?(tx)
+          tx_type = Transaction::TYPE_PURCHASE
+          asset = tx.bought_currency
+          asset_amount = tx.bought_amount
+          currency = tx.sold_currency
+          currency_amount = tx.sold_amount
+        else
+          tx_type = Transaction::TYPE_SALE
+          asset = tx.sold_currency
+          asset_amount = tx.sold_amount
+          currency = tx.bought_currency
+          currency_amount = tx.bought_amount
+        end
+
+        csv = [
+          tx.number || 0,
+          tx.exchange,
+          @config.translate(tx_type.to_s.capitalize),
+          @formatter.format_time(tx.time),
+          @formatter.format_crypto(asset_amount),
+          asset.code,
+          @formatter.format_crypto(currency_amount),
+          @formatter.format_crypto(currency_amount / asset_amount),
+          currency.code
+        ]
+
+        if @config.convert_to_currency
+          csv += [nil, nil, nil]
+        end
+
+        csv
+      end
+    end
+  end
+end

data/lib/coinsync/outputs/raw.rb

@@ -0,0 +1,45 @@
+require 'csv'
+
+require_relative 'base'
+
+module CoinSync
+  module Outputs
+    class Raw < Base
+      register_output :raw
+
+      def process_transactions(transactions, *args)
+        CSV.open(@target_file, 'w', col_sep: @config.column_separator) do |csv|
+          csv << headers
+
+          transactions.each do |tx|
+            csv << transaction_to_csv(tx)
+          end
+        end
+      end
+
+      def headers
+        [
+          'Exchange',
+          'Date',
+          'Bought amount',
+          'Bought currency',
+          'Sold amount',
+          'Sold currency'
+        ]
+      end
+
+      def transaction_to_csv(tx)
+        [
+          tx.exchange,
+          @formatter.format_time(tx.time),
+          tx.bought_currency.crypto? ?
+            @formatter.format_crypto(tx.bought_amount) : @formatter.format_fiat(tx.bought_amount),
+          tx.bought_currency.code,
+          tx.sold_currency.crypto? ?
+            @formatter.format_crypto(tx.sold_amount) : @formatter.format_fiat(tx.sold_amount),
+          tx.sold_currency.code
+        ]
+      end
+    end
+  end
+end

data/lib/coinsync/outputs/summary.rb

@@ -0,0 +1,48 @@
+require 'bigdecimal'
+
+require_relative 'base'
+require_relative '../currencies'
+require_relative '../table_printer'
+
+module CoinSync
+  module Outputs
+    class Summary < Base
+      register_output :summary
+
+      def requires_currency_conversion?
+        false
+      end
+
+      def process_transactions(transactions, *args)
+        totals = Hash.new { BigDecimal(0) }
+
+        transactions.each do |tx|
+          if tx.bought_currency.crypto?
+            amount = totals[tx.bought_currency]
+            totals[tx.bought_currency] = amount + tx.bought_amount
+          end
+
+          if tx.sold_currency.crypto?
+            amount = totals[tx.sold_currency]
+            if amount >= tx.sold_amount
+              totals[tx.sold_currency] = amount - tx.sold_amount
+            else
+              raise "Summary: couldn't sell #{@formatter.format_crypto(tx.sold_amount)} #{tx.sold_currency.code} " +
+                "if only #{@formatter.format_crypto(amount)} was owned"
+            end
+          end
+        end
+
+        rows = totals.map do |currency, amount|
+          [
+            currency.code,
+            @formatter.format_crypto(amount)
+          ]
+        end
+
+        printer = TablePrinter.new
+        printer.print_table(['Coin', 'Amount'], rows, alignment: [:ljust, :rjust])
+      end
+    end
+  end
+end

data/lib/coinsync/request.rb

@@ -0,0 +1,31 @@
+require 'net/http'
+require 'uri'
+
+require_relative 'version'
+
+module CoinSync
+  module Request
+    def self.get(url, &block)
+      self.request(url, Net::HTTP::Get, &block)
+    end
+
+    def self.post(url, &block)
+      self.request(url, Net::HTTP::Post, &block)
+    end
+
+    private
+
+    def self.request(url, request_type)
+      url = URI(url) if url.is_a?(String)
+
+      Net::HTTP.start(url.host, url.port, use_ssl: true) do |http|
+        request = request_type.new(url)
+        request['USER_AGENT'] = "coinsync/#{CoinSync::VERSION}"
+
+        yield request if block_given?
+
+        http.request(request)
+      end
+    end
+  end
+end

data/lib/coinsync/run_command_task.rb

@@ -0,0 +1,20 @@
+require_relative 'importers/all'
+
+module CoinSync
+  class RunCommandTask
+    def initialize(config)
+      @config = config
+    end
+
+    def run(source_name, command, args = [])
+      source = @config.sources[source_name] or raise "Source not found in the config file: '#{source_name}'"
+      importer = source.importer
+
+      if importer.class.registered_commands.include?(command.to_sym)
+        importer.send(command.to_sym, *args)
+      else
+        raise "#{source_name}: no such command: #{command}"
+      end
+    end
+  end
+end

data/lib/coinsync/source.rb

@@ -0,0 +1,43 @@
+require_relative 'importers/all'
+
+module CoinSync
+  class Source
+    attr_reader :key, :params, :filename
+
+    def initialize(config, key)
+      @config = config
+      @key = key
+
+      definition = config.source_definitions[key]
+
+      if definition.is_a?(Hash)
+        @params = definition
+        @filename = definition['file']
+        type = (definition['type'] || key).to_sym
+      elsif definition.is_a?(String)
+        @params = {}
+        @filename = definition
+        type = key.to_sym
+      elsif !config.source_definitions.has_key?(key)
+        raise "No such key in source list: '#{key}'"
+      else
+        raise "Unexpected source definition for '#{key}': #{definition}"
+      end
+
+      @importer_class = Importers.registered[type]
+
+      if @importer_class.nil?
+        if @params['type']
+          raise "Unknown source type for '#{key}': #{params['type']}"
+        else
+          raise "Unknown source type for '#{key}': please include a 'type' parameter " +
+            "or use a name of an existing importer"
+        end
+      end
+    end
+
+    def importer
+      @importer ||= @importer_class.new(@config, @params)
+    end
+  end
+end

data/lib/coinsync/source_filter.rb

@@ -0,0 +1,10 @@
+module CoinSync
+  class SourceFilter
+    def parse_command_line_args(arguments)
+      selected = arguments.select { |a| !a.start_with?('^') }
+      except = (arguments - selected).map { |a| a.gsub(/^\^/, '') }
+
+      [selected, except]
+    end
+  end
+end 

data/lib/coinsync/table_printer.rb

@@ -0,0 +1,29 @@
+module CoinSync
+  class TablePrinter
+    def print_table(header, rows, alignment: nil, separator: '  ')
+      rows.each do |row|
+        if row.length != header.length
+          raise "TablePrinter: All rows should have equal number of cells"
+        end
+
+        if !row.all? { |c| c.is_a?(String) }
+          raise "TablePrinter: All cells should be strings"
+        end
+      end
+
+      ids = (0...header.length)
+      widths = ids.map { |i| (rows + [header]).map { |r| r[i].length }.max }
+
+      puts ids.map { |i| header[i].center(widths[i]) }.join(separator)
+      puts '-' * (widths.inject(&:+) + separator.length * (header.length - 1))
+
+      rows.each do |row|
+        cells = ids.map do |i|
+          row[i].send(alignment && alignment[i] || :ljust, widths[i])
+        end
+
+        puts cells.join(separator)
+      end
+    end
+  end
+end

data/lib/coinsync/transaction.rb

@@ -0,0 +1,125 @@
+require 'bigdecimal'
+
+require_relative 'currencies'
+
+module CoinSync
+  class Transaction
+    TYPE_PURCHASE = :purchase
+    TYPE_SALE = :sale
+    TYPE_SWAP = :swap
+
+    module Amounts
+      attr_reader :bought_currency, :sold_currency, :bought_amount, :sold_amount
+
+      def type
+        if bought_currency.crypto?
+          if sold_currency.crypto?
+            return TYPE_SWAP
+          else
+            return TYPE_PURCHASE
+          end
+        else
+          return TYPE_SALE
+        end
+      end
+
+      def purchase?
+        type == TYPE_PURCHASE
+      end
+
+      def sale?
+        type == TYPE_SALE
+      end
+
+      def swap?
+        type == TYPE_SWAP
+      end
+
+      def fiat_amount
+        case type
+        when TYPE_PURCHASE then sold_amount
+        when TYPE_SALE then bought_amount
+        else raise "Operation not supported for crypto swap transactions"
+        end
+      end
+
+      def crypto_amount
+        case type
+        when TYPE_PURCHASE then bought_amount
+        when TYPE_SALE then sold_amount
+        else raise "Operation not supported for crypto swap transactions"
+        end
+      end
+
+      def fiat_currency
+        case type
+        when TYPE_PURCHASE then sold_currency
+        when TYPE_SALE then bought_currency
+        else raise "Operation not supported for crypto swap transactions"
+        end
+      end
+
+      def crypto_currency
+        case type
+        when TYPE_PURCHASE then bought_currency
+        when TYPE_SALE then sold_currency
+        else raise "Operation not supported for crypto swap transactions"
+        end
+      end
+
+      def price
+        fiat_amount / crypto_amount
+      end
+    end
+
+    class ConvertedAmounts
+      include Amounts
+      attr_writer :bought_currency, :sold_currency, :bought_amount, :sold_amount
+      attr_accessor :exchange_rate
+    end
+
+    attr_reader :exchange, :time
+    attr_accessor :number, :converted
+
+    include Amounts
+
+    def initialize(number: nil, exchange:, bought_currency:, sold_currency:, time:, bought_amount:, sold_amount:)
+      @number = number
+      @exchange = exchange
+
+      if time.is_a?(Time)
+        @time = time.getlocal
+      else
+        raise "Transaction: '#{time}' is not a valid Time object"
+      end
+
+      if bought_amount.is_a?(BigDecimal)
+        @bought_amount = bought_amount
+      else
+        raise "Transaction: '#{bought_amount}' should be a BigDecimal"
+      end
+
+      if bought_currency.is_a?(Currency)
+        @bought_currency = bought_currency
+      else
+        raise "Transaction: '#{bought_currency}' is not a valid currency"
+      end
+
+      (bought_amount > 0) or raise "Transaction: bought_amount should be positive (#{bought_amount})"
+
+      if sold_amount.is_a?(BigDecimal)
+        @sold_amount = sold_amount
+      else
+        raise "Transaction: '#{sold_amount}' should be a BigDecimal"
+      end
+
+      if sold_currency.is_a?(Currency) || sold_amount == 0
+         @sold_currency = sold_currency
+      else
+        raise "Transaction: '#{sold_currency}' is not a valid currency"
+      end
+
+      (sold_amount >= 0) or raise "Transaction: sold_amount should not be negative (#{sold_amount})"
+    end
+  end
+end