coinpare 0.0.0 → 0.1.0

data/lib/coinpare/command.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Coinpare
+  class Command
+    SYMBOLS = {
+      down_arrow: '▼',
+      up_arrow: '▲'
+    }.freeze
+
+    # The default interval for auto updating data
+    DEFAULT_INTERVAL = 5
+
+    trap('SIGINT') { exit }
+
+    # Main configuration
+    # @api public
+    def config
+      @config ||= begin
+        config = TTY::Config.new
+        config.filename = 'coinpare'
+        config.extname = '.toml'
+        config.append_path Dir.pwd
+        config.append_path Dir.home
+        config
+      end
+    end
+
+    # Time for when the data was fetched
+    # @api public
+    def timestamp
+      "#{Time.now.strftime("%d %B %Y")} at #{Time.now.strftime("%I:%M:%S %p %Z")}"
+    end
+
+    # The exchange, currency & time banner
+    # @api public
+    def banner(settings)
+      "\n#{add_color('Exchange', :yellow)} #{settings['exchange']}  " \
+      "#{add_color('Currency', :yellow)} #{settings['base'].upcase}  " \
+      "#{add_color('Time', :yellow)} #{timestamp}\n\n"
+    end
+
+    # Provide arrow for marking value growth or decline
+    # @api public
+    def pick_arrow(change)
+      return if change.zero?
+      change > 0 ? SYMBOLS[:up_arrow] : SYMBOLS[:down_arrow]
+    end
+
+    def add_color(str, color)
+      @options["no-color"] || color == :none ? str : @pastel.decorate(str, color)
+    end
+
+    def pick_color(change)
+      return :none if change.zero?
+      change > 0 ? :green : :red
+    end
+
+    def percent(value)
+      (value * 100).round(2)
+    end
+
+    def percent_change(before, after)
+      (after - before) / before.to_f * 100
+    end
+
+    def shorten_currency(value)
+      if value > 10 ** 9
+         (value / 10 ** 9).to_f.round(2).to_s + ' B'
+      elsif value > 10 ** 6
+        (value / 10 ** 6).to_f.round(2).to_s + ' M'
+      else
+        value
+      end
+    end
+
+    def precision(value, decimals = 2)
+      part = value.to_s.split('.')[1]
+      return 0 if part.nil?
+      value.between?(0, 1) ? (part.index(/[^0]/) + decimals) : decimals
+    end
+
+    def round_to(value, prec = nil)
+      prec = precision(value) if prec.nil?
+      "%.#{prec}f" % value
+    end
+
+    def number_to_currency(value)
+      whole, part = value.to_s.split('.')
+      part = '.' + part unless part.nil?
+      "#{whole.gsub(/(\d)(?=(\d{3})+(?!\d))/, '\\1,')}#{part}"
+    end
+
+    # Execute this command
+    #
+    # @api public
+    def execute(*)
+      raise(
+        NotImplementedError,
+        "#{self.class}##{__method__} must be implemented"
+      )
+    end
+
+    # The cursor movement
+    #
+    # @see http://www.rubydoc.info/gems/tty-cursor
+    #
+    # @api public
+    def cursor
+      require 'tty-cursor'
+      TTY::Cursor
+    end
+
+    # Open a file or text in the user's preferred editor
+    #
+    # @see http://www.rubydoc.info/gems/tty-editor
+    #
+    # @api public
+    def editor
+      require 'tty-editor'
+      TTY::Editor
+    end
+
+    # Get terminal screen properties
+    #
+    # @see http://www.rubydoc.info/gems/tty-screen
+    #
+    # @api public
+    def screen
+      require 'tty-screen'
+      TTY::Screen
+    end
+  end # Command
+end # Coinpare

data/lib/coinpare/commands/.gitkeep

@@ -0,0 +1 @@
+#

data/lib/coinpare/commands/coins.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'pastel'
+require 'tty-pager'
+require 'tty-spinner'
+require 'tty-table'
+require 'timers'
+
+require_relative '../command'
+require_relative '../fetcher'
+
+module Coinpare
+  module Commands
+    class Coins < Coinpare::Command
+      def initialize(names, options)
+        @names = names
+        @options = options
+        @pastel = Pastel.new
+        @timers = Timers::Group.new
+        @spinner = TTY::Spinner.new(':spinner Fetching data...',
+                                    format: :dots, clear: true)
+      end
+
+      def execute(output: $stdout)
+        pager = TTY::Pager::BasicPager.new(output: output)
+        @spinner.auto_spin
+
+        if @options['watch']
+          output.print cursor.hide
+          interval = @options['watch'].to_f > 0 ? @options['watch'].to_f : DEFAULT_INTERVAL
+          @timers.now_and_every(interval) { display_coins(output, pager) }
+          loop { @timers.wait }
+        else
+          display_coins(output, pager)
+        end
+      ensure
+        @spinner.stop
+        if @options['watch']
+          @timers.cancel
+          output.print cursor.clear_screen_down
+          output.print cursor.show
+        end
+      end
+
+      private
+
+      def display_coins(output, pager)
+        if @names.empty? # no coins provided
+          @names = setup_top_coins
+        end
+        response = Fetcher.fetch_prices(@names.map(&:upcase).join(','),
+                                        @options['base'].upcase, @options)
+        return unless response
+        table = setup_table(response['RAW'], response['DISPLAY'])
+        @spinner.stop
+
+        lines = banner(@options).lines.size + 1 + table.rows_size + 3
+        clear_output(output, lines) { print_results(table, output, pager) }
+      end
+
+      def clear_output(output, lines)
+        output.print cursor.clear_screen_down if @options['watch']
+        yield if block_given?
+        output.print cursor.up(lines) if @options['watch']
+      end
+
+      def print_results(table, output, pager)
+        output.puts banner(@options)
+        pager.page(table.render(:unicode, padding: [0, 1], alignment: :right))
+        output.puts
+      end
+
+      def setup_top_coins
+        response = Fetcher.fetch_top_coins_by_volume(@options['base'].upcase,
+                                                     @options)
+        return unless response
+        response['Data'].map { |coin| coin['CoinInfo']['Name'] }[0...@options['top']]
+      end
+
+      def setup_table(raw_data, display_data)
+        table = TTY::Table.new(header: [
+          { value: 'Coin', alignment: :left },
+          'Price',
+          'Chg. 24H',
+          'Chg.% 24H',
+          'Open 24H',
+          'High 24H',
+          'Low 24H',
+          'Direct Vol. 24H',
+          'Total Vol. 24H',
+          'Market Cap'
+        ])
+
+        @names.each do |name|
+          coin_data = display_data[name.upcase][@options['base'].upcase]
+          coin_raw_data = raw_data[name.upcase][@options['base'].upcase]
+          change24h = coin_raw_data['CHANGE24HOUR']
+          coin_details = [
+            { value: add_color(name.upcase, :yellow), alignment: :left },
+            add_color(coin_data['PRICE'], pick_color(change24h)),
+            add_color("#{pick_arrow(change24h)} #{coin_data['CHANGE24HOUR']}", pick_color(change24h)),
+            add_color("#{pick_arrow(change24h)} #{coin_data['CHANGEPCT24HOUR']}%", pick_color(change24h)),
+            coin_data['OPEN24HOUR'],
+            coin_data['HIGH24HOUR'],
+            coin_data['LOW24HOUR'],
+            coin_data['VOLUME24HOURTO'],
+            coin_data['TOTALVOLUME24HTO'],
+            coin_data['MKTCAP']
+          ]
+          table << coin_details
+        end
+        table
+      end
+    end # Coins
+  end # Commands
+end # Coinpare

data/lib/coinpare/commands/holdings.rb

@@ -0,0 +1,266 @@
+# frozen_string_literal: true
+
+require 'toml'
+require 'pastel'
+require 'tty-config'
+require 'tty-prompt'
+require 'tty-spinner'
+require 'tty-table'
+require 'timers'
+
+require_relative '../command'
+require_relative '../fetcher'
+
+module Coinpare
+  module Commands
+    class Holdings < Coinpare::Command
+      def initialize(options)
+        @options = options
+        @pastel = Pastel.new
+        @timers = Timers::Group.new
+        @spinner = TTY::Spinner.new(":spinner Fetching data...",
+                                    format: :dots, clear: true)
+        @interval = @options.fetch('watch', DEFAULT_INTERVAL).to_f
+        config.set('settings', 'color', value: !@options['no-color'])
+      end
+
+      def execute(input: $stdin, output: $stdout)
+        config_saved = config.persisted?
+        if config_saved && @options['edit']
+          editor.open(config.source_file)
+          return
+        elsif @options['edit']
+          output.puts "Sorry, no holdings configuration found."
+          output.print "Run \""
+          output.print "$ #{add_color('coinpare holdings', :yellow)}\" "
+          output.puts "to setup new altfolio."
+          return
+        end
+
+        config.read if config_saved
+
+        holdings = config.fetch('holdings')
+        if holdings.nil? || (holdings && holdings.empty?)
+          info = setup_portfolio(input, output)
+          config.merge(info)
+        elsif @options['add']
+          coin_info = add_coin(input, output)
+          config.append(coin_info, to: ['holdings'])
+        elsif @options['remove']
+          coin_info = remove_coin(input, output)
+          config.remove(*coin_info, from: ['holdings'])
+        elsif @options['clear']
+          prompt = create_prompt(input, output)
+          answer = prompt.yes?('Do you want to remove all holdings?')
+          if answer
+            config.delete('holdings')
+            output.puts add_color("All holdings removed", :red)
+          end
+        end
+
+        holdings = config.fetch('holdings')
+        no_holdings_left = holdings.nil? || (holdings && holdings.empty?)
+        if no_holdings_left
+          config.delete('holdings')
+        end
+
+        # Persist current configuration
+        home_file = ::File.join(Dir.home, "#{config.filename}#{config.extname}")
+        file = config.source_file
+        config.write(file.nil? ? home_file : file, force: true)
+        if no_holdings_left
+          output.puts add_color("Please add holdings to your altfolio!", :green)
+          exit
+        end
+
+        @spinner.auto_spin
+        settings = config.fetch('settings')
+        # command options take precedence over config settings
+        overridden_settings = {}
+        overridden_settings['exchange'] = @options.fetch('exchange', settings.fetch('exchange'))
+        overridden_settings['base']     = @options.fetch('base', settings.fetch('base'))
+        holdings = config.fetch('holdings') { [] }
+        names = holdings.map { |c| c['name'] }
+
+        if @options['watch']
+          output.print cursor.hide
+          @timers.now_and_every(@interval) do
+            display_coins(output, names, overridden_settings)
+          end
+          loop { @timers.wait }
+        else
+          display_coins(output, names, overridden_settings)
+        end
+      ensure
+        @spinner.stop
+        if @options['watch']
+          @timers.cancel
+          output.print cursor.clear_screen_down
+          output.print cursor.show
+        end
+      end
+
+      def display_coins(output, names, overridden_settings)
+        response = Fetcher.fetch_prices(names.join(','),
+                                        overridden_settings['base'].upcase,
+                                        overridden_settings)
+        return unless response
+        table = setup_table(response['RAW'], response['DISPLAY'])
+
+        @spinner.stop
+
+        lines = banner(overridden_settings).lines.size + 1 + table.rows_size + 3
+        clear_output(output, lines) do
+          output.puts banner(overridden_settings)
+          output.puts table.render(:unicode, padding: [0, 1], alignment: :right)
+        end
+      end
+
+      def clear_output(output, lines)
+        output.print cursor.clear_screen_down if @options['watch']
+        yield if block_given?
+        output.print cursor.up(lines) if @options['watch']
+      end
+
+      def create_prompt(input, output)
+        prompt = TTY::Prompt.new(
+          prefix: "[#{add_color('c', :yellow)}] ",
+          input: input, output: output,
+          interrupt: -> { puts; exit 1 },
+          enable_color: !@options['no-color'], clear: true)
+        prompt.on(:keypress) { |e| prompt.trigger(:keydown) if e.value == 'j' }
+        prompt
+      end
+
+      def ask_coin
+        -> (prompt) do
+          key('name').ask('What coin do you own?') do |q|
+            q.required true
+            q.default 'BTC'
+            q.validate(/\w{2,}/, 'Currency can only be chars.')
+            q.convert ->(coin) { coin.upcase }
+          end
+          key('amount').ask('What amount?') do |q|
+            q.required true
+            q.validate(/[\d.]+/, 'Invalid amount provided')
+            q.convert ->(am) { am.to_f }
+          end
+          key('price').ask('At what price per coin?') do |q|
+            q.required true
+            q.validate(/[\d.]+/, 'Invalid prince provided')
+            q.convert ->(p) { p.to_f }
+          end
+        end
+      end
+
+      def add_coin(input, output)
+        prompt = create_prompt(input, output)
+        context = self
+        data = prompt.collect(&context.ask_coin)
+        output.print cursor.up(3)
+        output.print cursor.clear_screen_down
+        data
+      end
+
+      def remove_coin(input, output)
+        prompt = create_prompt(input, output)
+        holdings = config.fetch('holdings')
+        data = prompt.multi_select('Which hodlings to remove?') do |menu|
+          holdings.each do |holding|
+            menu.choice "#{holding['name']} (#{holding['amount']})", holding
+          end
+        end
+        output.print cursor.up(1)
+        output.print cursor.clear_line
+        data
+      end
+
+      def setup_portfolio(input, output)
+        output.print "\nCurrently you have no investments setup...\n" \
+                     "Let's change that and create your altfolio!\n\n"
+
+        prompt = create_prompt(input, output)
+        context = self
+        data = prompt.collect do
+          key('settings') do
+            key('base').ask('What base currency to convert holdings to?') do |q|
+              q.default "USD"
+              q.convert ->(b) { b.upcase }
+              q.validate(/\w{3}/, 'Currency code needs to be 3 chars long')
+            end
+            key('exchange').ask('What exchange would you like to use?') do |q|
+              q.default "CCCAGG"
+              q.required true
+            end
+          end
+
+          while prompt.yes?("Do you want to add coin to your altfolio?")
+            key('holdings').values(&context.ask_coin)
+          end
+        end
+
+        lines = 4 + # intro
+                2 + # base + exchange
+                data['holdings'].size * 4 + 1
+        output.print cursor.up(lines)
+        output.print cursor.clear_screen_down
+
+        data
+      end
+
+      def setup_table(raw_data, display_data)
+        base = @options.fetch('base', config.fetch('settings', 'base')).upcase
+        total_buy = 0
+        total = 0
+        to_symbol = nil
+        table = TTY::Table.new(header: [
+          { value: 'Coin', alignment: :left },
+          'Amount',
+          'Price',
+          'Total Price',
+          'Cur. Price',
+          'Total Cur. Price',
+          'Change',
+          'Change%'
+        ])
+
+        config.fetch('holdings').each do |coin|
+          coin_data = raw_data[coin['name']][base]
+          coin_display_data = display_data[coin['name']][base]
+          past_price = coin['amount'] * coin['price']
+          curr_price = coin['amount'] * coin_data['PRICE']
+          to_symbol = coin_display_data['TOSYMBOL']
+          change = curr_price - past_price
+          arrow = pick_arrow(change)
+          total_buy +=  past_price
+          total += curr_price
+
+          coin_details = [
+            { value: add_color(coin['name'], :yellow), alignment: :left },
+            coin['amount'],
+            "#{to_symbol} #{number_to_currency(round_to(coin['price']))}",
+            "#{to_symbol} #{number_to_currency(round_to(past_price))}",
+            add_color("#{to_symbol} #{number_to_currency(round_to(coin_data['PRICE']))}", pick_color(change)),
+            add_color("#{to_symbol} #{number_to_currency(round_to(curr_price))}", pick_color(change)),
+            add_color("#{arrow} #{to_symbol} #{number_to_currency(round_to(change))}", pick_color(change)),
+            add_color("#{arrow} #{round_to(percent_change(past_price, curr_price))}%", pick_color(change))
+          ]
+          table << coin_details
+        end
+
+        total_change = total - total_buy
+        arrow = pick_arrow(total_change)
+
+        table << [
+          { value: add_color('ALL', :cyan), alignment: :left}, '-', '-',
+          "#{to_symbol} #{number_to_currency(round_to(total_buy))}", '-',
+          add_color("#{to_symbol} #{number_to_currency(round_to(total))}", pick_color(total_change)),
+          add_color("#{arrow} #{to_symbol} #{number_to_currency(round_to(total_change))}", pick_color(total_change)),
+          add_color("#{arrow} #{round_to(percent_change(total_buy, total))}%", pick_color(total_change))
+        ]
+
+        table
+      end
+    end # Holdings
+  end # Commands
+end # Coinpare