kovid 0.6.2 → 0.6.7

data/lib/kovid/helpers.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'terminal-table'
+
 module Kovid
   module_function
 
@@ -14,4 +15,25 @@ module Kovid
     date_to_parse = Date.strptime(date, '%m/%d/%y').to_s
     Date.parse(date_to_parse).strftime('%d %b, %y')
   end
+
+  def comma_delimit(number)
+    number.to_s.chars.to_a.reverse.each_slice(3).map(&:join).join(',').reverse
+  end
+
+  # Insert + sign to format positive numbers
+  def add_plus_sign(num)
+    num.to_i.positive? ? "+#{comma_delimit(num)}" : comma_delimit(num).to_s
+  end
+
+  def format_country_history_numbers(load)
+    load['timeline'].values.map(&:values).transpose.each do |data|
+      data.map! { |number| Kovid.comma_delimit(number) }
+    end
+  end
+
+  def lookup_us_state(state)
+    us = Carmen::Country.coded('USA')
+    lookup = us.subregions.coded(state) || us.subregions.named(state)
+    lookup ? lookup.name : state
+  end
 end

data/lib/kovid/historians.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Kovid
+  module Historians
+    include Constants
+
+    def history(country, last)
+      # TODO: Write checks for when country is spelt wrong.
+      rows = []
+
+      stats = if last
+                Kovid.format_country_history_numbers(country).last(last.to_i)
+              else
+                Kovid.format_country_history_numbers(country)
+              end
+
+      dates = if last
+                country['timeline']['cases'].keys.last(last.to_i)
+              else
+                country['timeline']['cases'].keys
+              end
+
+      unless last
+        stats = stats.reject { |stat| stat[0].to_i.zero? && stat[1].to_i.zero? }
+        dates = dates.last(stats.count)
+      end
+
+      stats.each_with_index do |val, index|
+        val.unshift(Kovid.dateman(dates[index]))
+      end.each do |row|
+        rows << row
+      end
+
+      if stats.size > 10
+        rows << FOOTER_LINE
+        rows << DATE_CASES_DEATHS_RECOVERED
+      end
+
+      Terminal::Table.new(
+        title: country['country'].upcase,
+        headings: DATE_CASES_DEATHS_RECOVERED,
+        rows: rows
+      )
+    end
+
+    def histogram(country, date_string)
+      @date = date_string.split('.')
+
+      if @date.last.to_i != 20
+        Kovid.info_table('Only 2020 histgrams are available.')
+        return
+      end
+
+      # From dates where number of !cases.zero?
+      country_cases = country['timeline']['cases']
+      positive_cases_figures = country_cases.values.reject(&:zero?)
+      dates = country_cases.reject { |_k, v| v.zero? }.keys
+      data = []
+
+      # TODO: Refactor
+      # Returns array of days.to_i from the date param
+      dates = dates.map do |date|
+        date.split('/')
+      end.select do |date|
+        date.last == @date.last
+      end.select do |date|
+        date.first == @date.first
+      end.map do |array|
+        array[1]
+      end.map(&:to_i).last(positive_cases_figures.count)
+
+      # Arranges dates and figures in [x,y] for histogram
+      # With x being day, y being number of cases
+      if dates.empty?
+        if @date.first.to_i > Time.now.month
+          msgs = [
+            'Seriously...??! 😏', 'Did you just check the future??',
+            'You just checked the future Morgan.',
+            'Knowing too much of your future is never a good thing.'
+          ]
+
+          Kovid.info_table(msgs.sample)
+        else
+          Kovid.info_table('Check your spelling/No infections for this month.')
+        end
+
+      else
+        dates.each_with_index do |val, index|
+          data << [val, positive_cases_figures[index]]
+        end
+        y_range = AsciiCharts::Cartesian.new(
+          data, bar: true, hide_zero: true
+        ).y_range
+
+        last_two_y = y_range.last 2
+        y_interval = last_two_y.last - last_two_y.first
+
+        scale("Scale on Y: #{y_interval}:#{(
+          y_interval / last_two_y.last.to_f * positive_cases_figures.last
+        ).round(2) / y_interval}")
+
+        puts 'Experimental feature, please report issues.'
+
+        AsciiCharts::Cartesian.new(data, bar: true, hide_zero: true).draw
+      end
+    end
+  end
+end

data/lib/kovid/painter.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'rainbow'
-
 class String
   def paint_white
     Rainbow(self).white.bg(:black).bold

data/lib/kovid/request.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'json'
+require 'carmen'
 require_relative 'tablelize'
 require_relative 'cache'
 require_relative 'uri_builder'
@@ -15,16 +16,18 @@ module Kovid
 
     EU_ISOS = %w[AT BE BG CY CZ DE DK EE ES FI FR GR HR HU IE IT LT \
                  LU LV MT NL PL PT RO SE SI SK].freeze
-    EUROPE_ISOS = EU_ISOS + %w[GB IS NO CH MC AD SM VA BA RS ME MK AL\
-                               BY UA RU MD]
+    EUROPE_ISOS = EU_ISOS + %w[GB IS NO CH MC AD SM VA BA RS ME MK AL \
+                               BY UA RU MD].freeze
     AFRICA_ISOS = %w[DZ AO BJ BW BF BI CM CV CF TD KM CD CG CI DJ EG \
-                     GQ ER SZ ET GA GM GH GN GW KE LS LR LY MG MW ML MR MU MA MZ NA NE \
-                     NG RW ST SN SC SL SO ZA SS SD TZ TG TN UG ZM ZW EH].freeze
-    SOUTH_AMERICA_ISOS = ['AR' 'BO', 'BV', 'BR', 'CL', 'CO', 'EC', \
-                          'FK', 'GF', 'GY', 'PY', 'PE', 'GS', 'SR', 'UY', 'VE'].freeze
+                     GQ ER SZ ET GA GM GH GN GW KE LS LR LY MG MW ML \
+                     MR MU MA MZ NA NE NG RW ST SN SC SL SO ZA SS SD \
+                     TZ TG TN UG ZM ZW EH].freeze
+    SOUTH_AMERICA_ISOS = %w[AR BO BV BR CL CO EC FK GF GY PY PE GS SR \
+                            UY VE].freeze
     ASIA_ISOS = %w[AE AF AM AZ BD BH BN BT CC CN CX GE HK ID IL IN \
-                   IQ IR JO JP KG KH KP KR KW KZ LA LB LK MM MN MO MY NP OM PH PK \
-                   PS QA SA SG SY TH TJ TL TM TR TW UZ VN YE].freeze
+                   IQ IR JO JP KG KH KP KR KW KZ LA LB LK MM MN MO \
+                   MY NP OM PH PK PS QA SA SG SY TH TJ TL TM TR TW \
+                   UZ VN YE].freeze
 
     class << self
       def eu_aggregate
@@ -70,7 +73,7 @@ module Kovid
       def by_country(country_name)
         response = fetch_country(country_name)
 
-        if response.values.first.include?('not found')
+        if response.key?('message')
           not_found(country_name)
         else
           Kovid::Tablelize.country_table(response)
@@ -82,7 +85,7 @@ module Kovid
       def by_country_full(country_name)
         response = fetch_country(country_name)
 
-        if response.values.first.include?('not found')
+        if response.key?('message')
           not_found(country_name)
         else
           Kovid::Tablelize.full_country_table(response)
@@ -107,7 +110,7 @@ module Kovid
       end
 
       def state(state)
-        response = fetch_state(state)
+        response = fetch_state(Kovid.lookup_us_state(state))
         if response.nil?
           not_found(state)
         else
@@ -119,7 +122,6 @@ module Kovid
 
       def states(states)
         compared_states = fetch_compared_states(states)
-
         Kovid::Tablelize.compare_us_states(compared_states)
       rescue JSON::ParserError
         puts SERVER_DOWN
@@ -147,7 +149,9 @@ module Kovid
       end
 
       def cases
-        response = JSON.parse(Typhoeus.get(UriBuilder.new('/all').url, cache_ttl: 900).response_body)
+        response = JSON.parse(
+          Typhoeus.get(UriBuilder.new('/all').url, cache_ttl: 900).response_body
+        )
 
         Kovid::Tablelize.cases(response)
       rescue JSON::ParserError
@@ -156,7 +160,11 @@ module Kovid
 
       def history(country, last)
         history_path = UriBuilder.new('/v2/historical').url
-        response = JSON.parse(Typhoeus.get(history_path + "/#{country}", cache_ttl: 900).response_body)
+        response = JSON.parse(
+          Typhoeus.get(
+            history_path + "/#{country}", cache_ttl: 900
+          ).response_body
+        )
 
         Kovid::Tablelize.history(response, last)
       rescue JSON::ParserError
@@ -165,7 +173,11 @@ module Kovid
 
       def histogram(country, date)
         history_path = UriBuilder.new('/v2/historical').url
-        response = JSON.parse(Typhoeus.get(history_path + "/#{country}", cache_ttl: 900).response_body)
+        response = JSON.parse(
+          Typhoeus.get(
+            history_path + "/#{country}", cache_ttl: 900
+          ).response_body
+        )
 
         Kovid::Tablelize.histogram(response, date)
       end
@@ -183,14 +195,20 @@ module Kovid
 
       def fetch_countries(list)
         list.map do |country|
-          JSON.parse(Typhoeus.get(COUNTRIES_PATH + "/#{country}", cache_ttl: 900).response_body)
+          JSON.parse(
+            Typhoeus.get(
+              COUNTRIES_PATH + "/#{country}", cache_ttl: 900
+            ).response_body
+          )
         end.sort_by { |json| -json['cases'] }
       end
 
       def fetch_compared_states(submitted_states)
-        state_data = fetch_state_data
+        submitted_states.map! { |s| Kovid.lookup_us_state(s) }
 
-        state_data.select { |state| submitted_states.include?(state['state'].downcase) }
+        fetch_state_data.select do |state|
+          submitted_states.include?(state['state'])
+        end
       end
 
       def fetch_state_data
@@ -198,6 +216,8 @@ module Kovid
       end
 
       def fetch_country(country_name)
+        # TODO: Match ISOs to full country names
+        country_name = 'nl' if country_name == 'netherlands'
         country_url = COUNTRIES_PATH + "/#{country_name}"
 
         JSON.parse(Typhoeus.get(country_url, cache_ttl: 900).response_body)
@@ -209,7 +229,9 @@ module Kovid
 
       def fetch_province(province)
         response = fetch_jhucsse
-        response.select { |datum| datum['province'] == capitalize_words(province) }.first
+        response.select do |datum|
+          datum['province'] == capitalize_words(province)
+        end.first
       end
 
       def fetch_provinces(provinces)
@@ -219,19 +241,35 @@ module Kovid
       end
 
       def fetch_state(state)
-        states_array = JSON.parse(Typhoeus.get(STATES_URL, cache_ttl: 900).response_body)
+        states_array = JSON.parse(
+          Typhoeus.get(STATES_URL, cache_ttl: 900).response_body
+        )
 
-        states_array.select { |state_name| state_name['state'] == capitalize_words(state) }.first
+        states_array.select do |state_name|
+          state_name['state'] == capitalize_words(state)
+        end.first
       end
 
       def aggregator(isos, meth)
-        countries_array = JSON.parse(Typhoeus.get(UriBuilder.new('/countries').url, cache_ttl: 900).response_body)
-
+        countries_array = JSON.parse(countries_request)
         country_array = countries_array.select do |hash|
           isos.include?(hash['countryInfo']['iso2'])
         end
+        data = countries_aggregator(country_array)
 
-        data = country_array.inject do |base, other|
+        meth === data
+      rescue JSON::ParserError
+        puts SERVER_DOWN
+      end
+
+      def countries_request
+        Typhoeus.get(
+          UriBuilder.new('/countries').url, cache_ttl: 900
+        ).response_body
+      end
+
+      def countries_aggregator(country_array)
+        country_array.inject do |base, other|
           base.merge(other) do |key, left, right|
             left  ||= 0
             right ||= 0
@@ -239,10 +277,6 @@ module Kovid
             left + right unless %w[country countryInfo].include?(key)
           end
         end.compact
-
-        meth === data
-      rescue JSON::ParserError
-        puts SERVER_DOWN
       end
     end
   end

data/lib/kovid/tablelize.rb

@@ -4,206 +4,62 @@ require 'terminal-table'
 require 'date'
 require 'ascii_charts'
 require_relative 'painter'
+require_relative 'constants'
+require_relative 'aggregators'
+require_relative 'historians'
 
 module Kovid
   class Tablelize
-    class << self
-      CASES_DEATHS_RECOVERED = [
-        'Cases'.paint_white,
-        'Deaths'.paint_red,
-        'Recovered'.paint_green
-      ].freeze
-
-      CASES_DEATHS_RECOVERED_CTODAY_DTODAY = [
-        'Cases'.paint_white,
-        'Cases Today'.paint_white,
-        'Deaths'.paint_red,
-        'Deaths Today'.paint_red,
-        'Recovered'.paint_green
-      ].freeze
-
-      DATE_CASES_DEATHS_RECOVERED = [
-        'Date'.paint_white,
-        'Cases'.paint_white,
-        'Deaths'.paint_red,
-        'Recovered'.paint_green
-      ].freeze
-
-      CONTINENTAL_AGGREGATE_HEADINGS = [
-        'Cases'.paint_white,
-        'Cases Today'.paint_white,
-        'Deaths'.paint_red,
-        'Deaths Today'.paint_red,
-        'Recovered'.paint_green,
-        'Active'.paint_yellow,
-        'Critical'.paint_red
-      ].freeze
-
-      COMPARE_COUNTRY_TABLE_FULL = [
-        'Country'.paint_white,
-        'Cases'.paint_white,
-        'Deaths'.paint_red,
-        'Recovered'.paint_green,
-        'Cases Today'.paint_white,
-        'Deaths Today'.paint_red,
-        'Critical'.paint_yellow,
-        'Cases/Million'.paint_white
-      ].freeze
-
-      COMPARE_COUNTRIES_TABLE_HEADINGS = [
-        'Country'.paint_white,
-        'Cases'.paint_white,
-        'Cases Today'.paint_white,
-        'Deaths'.paint_red,
-        'Deaths Today'.paint_red,
-        'Recovered'.paint_green
-      ].freeze
-
-      FULL_COUNTRY_TABLE_HEADINGS = [
-        'Cases'.paint_white,
-        'Deaths'.paint_red,
-        'Recovered'.paint_green,
-        'Cases Today'.paint_white,
-        'Deaths Today'.paint_red,
-        'Critical'.paint_yellow,
-        'Cases/Million'.paint_white
-      ].freeze
-
-      COMPARE_STATES_HEADINGS = [
-        'State'.paint_white,
-        'Cases'.paint_white,
-        'Cases Today'.paint_white,
-        'Deaths'.paint_red,
-        'Deaths Today'.paint_red,
-        'Active'.paint_yellow
-      ].freeze
-
-      COMPARE_PROVINCES_HEADINGS = [
-        'Province'.paint_white,
-        'Confirmed'.paint_white,
-        'Deaths'.paint_red,
-        'Recovered'.paint_green
-      ].freeze
-
-      FOOTER_LINE = ['------------', '------------', '------------', '------------'].freeze
-      COUNTRY_LETTERS = 'A'.upto('Z').with_index(127_462).to_h.freeze
-
-      RIGHT_ALIGN_COLUMNS = {
-        compare_country_table_full: [1, 2, 3, 4, 5, 6, 7],
-        compare_country_table: [1, 2, 3, 4, 5],
-        compare_us_states: [1, 2, 3, 4, 5],
-        compare_provinces: [1, 2, 3]
-      }.freeze
+    extend Kovid::Constants
+    extend Kovid::Aggregators
+    extend Kovid::Historians
 
+    class << self
       def country_table(data)
-        rows = [
-          [
-            comma_delimit(data['cases']),
-            check_if_positve(data['todayCases']),
-            comma_delimit(data['deaths']),
-            check_if_positve(data['todayDeaths']),
-            comma_delimit(data['recovered'])
-          ]
-        ]
-
-        if (iso = data['countryInfo']['iso2'])
-          Terminal::Table.new(title: "#{country_emoji(iso)} #{data['country'].upcase}",
-                              headings: CASES_DEATHS_RECOVERED_CTODAY_DTODAY,
-                              rows: rows)
-        else
-          Terminal::Table.new(title: data['country'].upcase,
-                              headings: CASES_DEATHS_RECOVERED_CTODAY_DTODAY,
-                              rows: rows)
-        end
+        Terminal::Table.new(title: country_title(data),
+                            headings: CASES_DEATHS_RECOVERED_CTODAY_DTODAY,
+                            rows: [country_row(data)])
       end
 
       def full_country_table(data)
-        rows = []
-        rows << [
-          comma_delimit(data['cases']),
-          comma_delimit(data['deaths']),
-          comma_delimit(data['recovered']),
-          check_if_positve(data['todayCases']),
-          check_if_positve(data['todayDeaths']),
-          comma_delimit(data['critical']),
-          comma_delimit(data['casesPerOneMillion'])
-        ]
-
-        if iso = data['countryInfo']['iso2']
-          Terminal::Table.new(title: "#{country_emoji(iso)} #{data['country'].upcase}",
-                              headings: FULL_COUNTRY_TABLE_HEADINGS,
-                              rows: rows)
-        else
-          Terminal::Table.new(title: data['country'].upcase,
-                              headings: FULL_COUNTRY_TABLE_HEADINGS,
-                              rows: rows)
-        end
+        Terminal::Table.new(title: country_title(data),
+                            headings: FULL_COUNTRY_TABLE_HEADINGS,
+                            rows: [full_country_row(data)])
       end
 
       def full_province_table(province)
-        headings = [
-          'Confirmed'.paint_white,
-          'Deaths'.paint_red,
-          'Recovered'.paint_green
-        ]
-        rows = []
-        rows << [province['stats']['confirmed'], province['stats']['deaths'], province['stats']['recovered']]
-
-        Terminal::Table.new(title: province['province'].upcase, headings: headings, rows: rows)
+        Terminal::Table.new(
+          title: province['province'].upcase,
+          headings: FULL_PROVINCE_TABLE_HEADINGS,
+          rows: [province_row(province)]
+        )
       end
 
       def full_state_table(state)
-        headings = [
-          'Cases'.paint_white,
-          'Cases Today'.paint_white,
-          'Deaths'.paint_red,
-          'Deaths Today'.paint_red,
-          'Active'.paint_yellow
-        ]
-
-        rows = []
-        rows << [state['cases'], check_if_positve(state['todayCases']), state['deaths'], check_if_positve(state['todayDeaths']), state['active']]
-
-        Terminal::Table.new(title: state['state'].upcase, headings: headings, rows: rows)
+        Terminal::Table.new(
+          title: state['state'].upcase,
+          headings: FULL_STATE_TABLE_HEADINGS,
+          rows: [country_row(state)]
+        )
       end
 
       def compare_countries_table(data)
         rows = []
 
         data.each do |country|
-          base_rows = [
-            comma_delimit(country['cases']),
-            check_if_positve(country['todayCases']),
-            comma_delimit(country['deaths']),
-            check_if_positve(country['todayDeaths']),
-            comma_delimit(country['recovered'])
-          ]
-
-          rows << if (iso = country['countryInfo']['iso2'])
-                    base_rows.unshift("#{country_emoji(iso)} #{country['country'].upcase}")
-                  else
-                    base_rows.unshift(country['country'].upcase.to_s)
-                  end
+          base_rows = country_row(country)
+          rows << base_rows.unshift(country_title(country))
         end
 
         align_columns(:compare_country_table,
-                      Terminal::Table.new(headings: COMPARE_COUNTRIES_TABLE_HEADINGS,
-                                          rows: rows))
+                      Terminal::Table.new(
+                        headings: COMPARE_COUNTRIES_TABLE_HEADINGS,
+                        rows: rows
+                      ))
       end
 
       def compare_countries_table_full(data)
-        rows = data.map do |country|
-          [
-            country.fetch('country'),
-            comma_delimit(country.fetch('cases')),
-            comma_delimit(country.fetch('deaths')),
-            comma_delimit(country.fetch('recovered')),
-            check_if_positve(country.fetch('todayCases')),
-            check_if_positve(country.fetch('todayDeaths')),
-            comma_delimit(country.fetch('critical')),
-            comma_delimit(country.fetch('casesPerOneMillion'))
-          ]
-        end
+        rows = data.map { |country| compare_countries_full_row(country) }
 
         align_columns(:compare_country_table_full,
                       Terminal::Table.new(headings: COMPARE_COUNTRY_TABLE_FULL,
@@ -213,23 +69,9 @@ module Kovid
       def compare_us_states(data)
         rows = data.map.with_index do |state, index|
           if index.odd?
-            [
-              state.fetch('state').upcase,
-              comma_delimit(state.fetch('cases')),
-              check_if_positve(state['todayCases']),
-              comma_delimit(state['deaths']),
-              check_if_positve(state['todayDeaths']),
-              comma_delimit(state.fetch('active'))
-            ]
+            us_state_row(state)
           else
-            [
-              state.fetch('state').upcase.paint_highlight,
-              comma_delimit(state.fetch('cases')).paint_highlight,
-              check_if_positve(state['todayCases']).paint_highlight,
-              comma_delimit(state['deaths']).paint_highlight,
-              check_if_positve(state['todayDeaths']).paint_highlight,
-              comma_delimit(state.fetch('active')).paint_highlight
-            ]
+            us_state_row(state).map(&:paint_highlight)
           end
         end
 
@@ -239,14 +81,7 @@ module Kovid
       end
 
       def compare_provinces(data)
-        rows = data.map do |province|
-          [
-            province['province'].upcase,
-            province['stats']['confirmed'],
-            province['stats']['deaths'],
-            province['stats']['recovered']
-          ]
-        end
+        rows = data.map { |province| compare_provinces_row(province) }
 
         align_columns(:compare_provinces,
                       Terminal::Table.new(headings: COMPARE_PROVINCES_HEADINGS,
@@ -254,160 +89,103 @@ module Kovid
       end
 
       def cases(cases)
-        headings = CASES_DEATHS_RECOVERED
-        rows = [
-          [
-            comma_delimit(cases['cases']),
-            comma_delimit(cases['deaths']),
-            comma_delimit(cases['recovered'])
-          ]
-        ]
-
-        Terminal::Table.new(title: '🌍 Total Number of Incidents Worldwide'.upcase, headings: headings, rows: rows)
-      end
-
-      def history(country, last)
-        # Write checks for when country is spelt wrong.
-        headings = DATE_CASES_DEATHS_RECOVERED
-        rows = []
-
-        stats = if last
-                  transpose(country).last(last.to_i)
-                else
-                  transpose(country)
-                end
-
-        dates = if last
-                  country['timeline']['cases'].keys.last(last.to_i)
-                else
-                  country['timeline']['cases'].keys
-                end
-
-        unless last
-          stats = stats.reject { |stat| stat[0].to_i.zero? && stat[1].to_i.zero? }
-          dates = dates.last(stats.count)
-        end
-
-        stats.each_with_index do |val, index|
-          val.unshift(Kovid.dateman(dates[index]))
-        end.each do |row|
-          rows << row
-        end
-
-        if stats.size > 10
-          rows << FOOTER_LINE
-          rows << DATE_CASES_DEATHS_RECOVERED
-        end
-
         Terminal::Table.new(
-          title: country['country'].upcase,
-          headings: headings,
-          rows: rows
+          title: '🌍 Total Number of Incidents Worldwide'.upcase,
+          headings: CASES_DEATHS_RECOVERED,
+          rows: [cases_row(cases)]
         )
       end
 
-      def histogram(country, date_string)
-        @date = date_string.split('.')
-
-        if @date.last.to_i != 20
-          Kovid.info_table('Only 2020 histgrams are available.')
-          return
-        end
-
-        # From dates where number of !cases.zero?
-        positive_cases_figures = country['timeline']['cases'].values.reject(&:zero?)
-        dates = country['timeline']['cases'].reject { |_k, v| v.zero? }.keys
-        data = []
-
-        # Improve this later, like everything else.
-        # Returns array of days.to_i from the date param
-        dates = dates.map do |date|
-          date.split('/')
-        end.select do |date|
-          date.last == @date.last
-        end.select do |date|
-          date.first == @date.first
-        end.map do |array|
-          array[1]
-        end.map(&:to_i).last(positive_cases_figures.count)
-
-        # Arranges dates and figures in [x,y] for histogram
-        # With x being day, y being number of cases
-        if dates.empty?
-          if @date.first.to_i > Time.now.month
-            msgs = [
-              'Seriously...??! 😏', 'Did you just check the future??',
-              'You just checked the future Morgan.',
-              'Knowing too much of your future is never a good thing.'
-            ]
-
-            Kovid.info_table(msgs.sample)
-          else
-            Kovid.info_table('Check your spelling/No infections for this month.')
-          end
+      private
 
+      def country_title(data)
+        iso = data['countryInfo']['iso2']
+        if iso.nil?
+          data['country'].upcase
         else
-          dates.each_with_index do |val, index|
-            data << [val, positive_cases_figures[index]]
-          end
-          y_range = AsciiCharts::Cartesian.new(data, bar: true, hide_zero: true).y_range
-
-          last_two_y = y_range.last 2
-          y_interval = last_two_y.last - last_two_y.first
-
-          scale("Scale on Y: #{y_interval}:#{(y_interval / last_two_y.last.to_f * positive_cases_figures.last).round(2) / y_interval}")
-
-          puts 'Experimental feature, please report issues.'
-
-          AsciiCharts::Cartesian.new(data, bar: true, hide_zero: true).draw
+          "#{country_emoji(iso)} #{data['country'].upcase}"
         end
       end
 
-      def eu_aggregate(eu_data)
-        aggregated_table(eu_data, 'The EU', Kovid::Request::EU_ISOS, '🇪🇺')
+      def country_emoji(iso)
+        COUNTRY_LETTERS.values_at(*iso.chars).pack('U*') + \
+          8203.chr(Encoding::UTF_8)
       end
 
-      def europe_aggregate(europe_data)
-        aggregated_table(europe_data, 'Europe', Kovid::Request::EUROPE_ISOS, '🏰')
+      def cases_row(data)
+        [
+          Kovid.comma_delimit(data['cases']),
+          Kovid.comma_delimit(data['deaths']),
+          Kovid.comma_delimit(data['recovered'])
+        ]
       end
 
-      def africa_aggregate(africa_data)
-        aggregated_table(africa_data, 'Africa',
-                         Kovid::Request::AFRICA_ISOS, '🌍')
+      # Also works for state
+      def country_row(data)
+        [
+          Kovid.comma_delimit(data['cases']),
+          Kovid.add_plus_sign(data['todayCases']),
+          Kovid.comma_delimit(data['deaths']),
+          Kovid.add_plus_sign(data['todayDeaths']),
+          Kovid.comma_delimit(data['recovered'])
+        ]
       end
 
-      def south_america_aggregate(south_america_data)
-        aggregated_table(south_america_data,
-                         'South America',
-                         Kovid::Request::SOUTH_AMERICA_ISOS, '🌎')
+      def full_country_row(data)
+        [
+          Kovid.comma_delimit(data['cases']),
+          Kovid.comma_delimit(data['deaths']),
+          Kovid.comma_delimit(data['recovered']),
+          Kovid.add_plus_sign(data['todayCases']),
+          Kovid.add_plus_sign(data['todayDeaths']),
+          Kovid.comma_delimit(data['critical']),
+          Kovid.comma_delimit(data['casesPerOneMillion'])
+        ]
       end
 
-      def asia_aggregate(asia_data)
-        aggregated_table(asia_data, 'Asia', Kovid::Request::ASIA_ISOS, '🌏')
+      def province_row(data)
+        [
+          data['stats']['confirmed'],
+          data['stats']['deaths'],
+          data['stats']['recovered']
+        ]
       end
 
-      private
-
-      def comma_delimit(number)
-        number.to_s.chars.to_a.reverse.each_slice(3)
-              .map(&:join)
-              .join(',')
-              .reverse
+      def compare_provinces_row(data)
+        [
+          data['province'].upcase,
+          province_row(data)
+        ].flatten
       end
 
-      def check_if_positve(num)
-        num.to_i.positive? ? "+#{comma_delimit(num)}" : comma_delimit(num).to_s
+      def compare_countries_full_row(data)
+        [
+          data.fetch('country'),
+          full_country_row(data)
+        ].flatten
       end
 
-      def country_emoji(iso)
-        COUNTRY_LETTERS.values_at(*iso.chars).pack('U*') + \
-          8203.chr(Encoding::UTF_8)
+      def us_state_row(data)
+        [
+          data.fetch('state').upcase,
+          Kovid.comma_delimit(data.fetch('cases')),
+          Kovid.add_plus_sign(data['todayCases']),
+          Kovid.comma_delimit(data['deaths']),
+          Kovid.add_plus_sign(data['todayDeaths']),
+          Kovid.comma_delimit(data.fetch('active'))
+        ]
       end
 
-      def transpose(load)
-        load['timeline'].values.map(&:values).transpose.each do |data|
-          data.map! { |number| comma_delimit(number) }
-        end
+      def aggregated_row(data)
+        [
+          Kovid.comma_delimit(data['cases']),
+          Kovid.add_plus_sign(data['todayCases']),
+          Kovid.comma_delimit(data['deaths']),
+          Kovid.add_plus_sign(data['todayDeaths']),
+          Kovid.comma_delimit(data['recovered']),
+          Kovid.comma_delimit(data['active']),
+          Kovid.comma_delimit(data['critical'])
+        ]
       end
 
       def scale(msg)
@@ -416,32 +194,26 @@ module Kovid
       end
 
       def aggregated_table(collated_data, continent, iso, emoji)
-        title = if emoji.codepoints.size > 1
-                  emoji + 8203.chr(Encoding::UTF_8) + \
-                    " Aggregated Data on #{continent} (#{iso.size} States)".upcase
-                else
-                  emoji + \
-                    " Aggregated Data on #{continent} (#{iso.size} States)".upcase
-                end
-
-        rows = []
-        rows << [
-          comma_delimit(collated_data['cases']),
-          check_if_positve(collated_data['todayCases']),
-          comma_delimit(collated_data['deaths']),
-          check_if_positve(collated_data['todayDeaths']),
-          comma_delimit(collated_data['recovered']),
-          comma_delimit(collated_data['active']),
-          comma_delimit(collated_data['critical'])
-        ]
+        title = aggregated_table_title(continent, iso, emoji)
 
         Terminal::Table.new(
           title: title,
           headings: CONTINENTAL_AGGREGATE_HEADINGS,
-          rows: rows
+          rows: [aggregated_row(collated_data)]
         )
       end
 
+      def aggregated_table_title(continent, iso, emoji)
+        aggregated_data_continent = ' Aggregated Data on ' \
+          "#{continent} (#{iso.size} States)".upcase
+
+        if emoji.codepoints.size > 1
+          emoji + 8203.chr(Encoding::UTF_8) + aggregated_data_continent
+        else
+          emoji + aggregated_data_continent
+        end
+      end
+
       def align_columns(table_type, table)
         return table unless RIGHT_ALIGN_COLUMNS[table_type]