doing 2.1.16 → 2.1.21

data/lib/doing/string_chronify.rb

@@ -26,12 +26,12 @@ module Doing
     ##
     def chronify(**options)
       now = Time.now
-      raise InvalidTimeExpression, "Invalid time expression #{inspect}" if to_s.strip == ''
+      raise Errors::InvalidTimeExpression, "Invalid time expression #{inspect}" if to_s.strip == ''
 
       secs_ago = if match(/^(\d+)$/)
                    # plain number, assume minutes
                    Regexp.last_match(1).to_i * 60
-                 elsif (m = match(/^(?:(?<day>\d+)d)?(?:(?<hour>\d+)h)?(?:(?<min>\d+)m)?$/i))
+                 elsif (m = match(/^(?:(?<day>\d+)d)? *(?:(?<hour>\d+)h)? *(?:(?<min>\d+)m)?$/i))
                    # day/hour/minute format e.g. 1d2h30m
                    [[m['day'], 24 * 3600],
                     [m['hour'], 3600],
@@ -39,14 +39,23 @@ module Doing
                  end
 
       if secs_ago
-        now - secs_ago
+        res = now - secs_ago
+        Doing.logger.debug('Parser:', %(date/time string "#{self}" interpreted as #{res} (#{secs_ago} seconds ago)))
       else
-        Chronic.parse(self, {
-                        guess: options.fetch(:guess, :begin),
-                        context: options.fetch(:future, false) ? :future : :past,
-                        ambiguous_time_range: 8
-                      })
+        date_string = dup
+        date_string = 'today' if date_string.match(REGEX_DAY) && now.strftime('%a') =~ /^#{Regexp.last_match(1)}/i
+        date_string = "#{options[:context].to_s} #{date_string}" if date_string =~ REGEX_TIME && options[:context]
+
+        res = Chronic.parse(date_string, {
+                              guess: options.fetch(:guess, :begin),
+                              context: options.fetch(:future, false) ? :future : :past,
+                              ambiguous_time_range: 8
+                            })
+
+        Doing.logger.debug('Parser:', %(date/time string "#{self}" interpreted as #{res}))
       end
+
+      res
     end
 
     ##
@@ -152,6 +161,10 @@ module Doing
       end
     end
 
+    def is_range?
+      self =~ / (to|through|thru|(un)?til|-+) /
+    end
+
     ##
     ## Splits a range string and returns an array of
     ## DateTime objects as [start, end]. If only one date is
@@ -163,20 +176,45 @@ module Doing
     ## "mon 3pm to mon 5pm".split_date_range
     ##
     def split_date_range
+      time_rx = /^(\d{1,2}+(:\d{1,2}+)?( *(am|pm))?|midnight|noon)$/
+      range_rx = / (to|through|thru|(?:un)?til|-+) /
+
       date_string = dup
-      case date_string
-      when / (to|through|thru|(un)?til|-+) /
-        dates = date_string.split(/ (?:to|through|thru|(?:un)?til|-+) /)
-        start = dates[0].chronify(guess: :begin)
-        finish = dates[-1].chronify(guess: :end)
+
+      if date_string.is_range?
+        # Do we want to differentiate between "to" and "through"?
+        # inclusive = date_string =~ / (through|thru|-+) / ? true : false
+        inclusive = true
+
+        dates = date_string.split(range_rx)
+        if dates[0].strip =~ time_rx && dates[-1].strip =~ time_rx
+          start = dates[0].strip
+          finish = dates[-1].strip
+        else
+          start = dates[0].chronify(guess: :begin, future: false)
+          finish = dates[-1].chronify(guess: inclusive ? :end : :begin, future: false)
+        end
+
+        raise Errors::InvalidTimeExpression, 'Unrecognized date string' if start.nil? || finish.nil?
+
       else
-        start = date_string.chronify(guess: :begin)
-        finish = nil
+        if date_string.strip =~ time_rx
+          start = date_string.strip
+          finish = nil
+        else
+          start = date_string.strip.chronify(guess: :begin, future: false)
+          finish = date_string.strip.chronify(guess: :end)
+        end
+        raise Errors::InvalidTimeExpression, 'Unrecognized date string' unless start
+
       end
 
-      raise InvalidTimeExpression, 'Unrecognized date string' unless start
 
-      Doing.logger.debug('Parser:', "date range interpreted as #{start.strftime('%F %R')} -- #{finish ? finish.strftime('%F %R') : 'now'}")
+      if start.is_a? String
+        Doing.logger.debug('Parser:', "--from string interpreted as time span, from #{start || '12am'} to #{finish || '11:59pm'}")
+      else
+        Doing.logger.debug('Parser:', "date range interpreted as #{start.strftime('%F %R')} -- #{finish ? finish.strftime('%F %R') : 'now'}")
+      end
       [start, finish]
     end
   end

data/lib/doing/types.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+REGEX_BOOL = /^(?:and|all|any|or|not|none|p(?:at(?:tern)?)?)$/i
+REGEX_SORT_ORDER = /^(?:a(?:sc)?|d(?:esc)?)$/i
+REGEX_VALUE_QUERY = /^(?:!)?@?(?:\S+) +(?:!?[<>=][=*]?|[$*^]=) +(?:.*?)$/
+REGEX_CLOCK = '(?:\d{1,2}+(?::\d{1,2}+)?(?: *(?:am|pm))?|midnight|noon)'
+REGEX_TIME = /^#{REGEX_CLOCK}$/i
+REGEX_DAY = /^(mon|tue|wed|thur?|fri|sat|sun)(\w+(day)?)?$/i
+REGEX_RANGE_INDICATOR = ' +(?:to|through|thru|(?:un)?til|-+) +'
+REGEX_RANGE = /^\S+#{REGEX_RANGE_INDICATOR}+\S+/i
+REGEX_TIME_RANGE = /^#{REGEX_CLOCK}#{REGEX_RANGE_INDICATOR}#{REGEX_CLOCK}$/i
+
+InvalidExportType = Class.new(RuntimeError)
+MissingConfigFile = Class.new(RuntimeError)
+TagArray = Class.new(Array)
+DateBeginString = Class.new(DateTime)
+DateEndString = Class.new(DateTime)
+DateRangeString = Class.new(Array)
+DateIntervalString = Class.new(DateTime)

data/lib/doing/version.rb

@@ -1,3 +1,3 @@
 module Doing
-  VERSION = '2.1.16'
+  VERSION = '2.1.21'
 end

data/lib/doing/wwid.rb

@@ -305,6 +305,28 @@ module Doing
       view
     end
 
+    def add_with_editor(**options)
+      raise MissingEditor, 'No EDITOR variable defined in environment' if Util.default_editor.nil?
+
+      input = options[:date].strftime('%F %R | ')
+      input += options[:title]
+      input += "\n#{options[:note]}" if options[:note]
+      input = fork_editor(input).strip
+
+      d, title, note = format_input(input)
+      raise EmptyInput, 'No content' if title.empty?
+
+      if options[:ask]
+        ask_note = Doing::Prompt.read_lines(prompt: 'Add a note')
+        note.add(ask_note) unless ask_note.empty?
+      end
+
+      date = d.nil? ? options[:date] : d
+      finish = options[:finish_last] || false
+      add_item(title.cap_first, options[:section], { note: note, back: date, timed: finish })
+      write(@doing_file)
+    end
+
     ##
     ## Adds an entry
     ##
@@ -356,7 +378,7 @@ module Doing
 
       @content.push(entry)
       # logger.count(:added, level: :debug)
-      logger.info('New entry:', %(added "#{entry.title}" to #{section}))
+      logger.info('New entry:', %(added "#{entry.date.relative_date}: #{entry.title}" to #{section}))
 
       Hooks.trigger :post_entry_added, self, entry.dup
     end
@@ -454,7 +476,8 @@ module Doing
       opt ||= {}
       if item.should_finish?
         if item.should_time?
-          item.title.tag!('done', value: Time.now.strftime('%F %R'))
+          finish_date = verify_duration(item.date, Time.now, title: item.title)
+          item.title.tag!('done', value: finish_date.strftime('%F %R'))
         else
           item.title.tag!('done')
         end
@@ -484,7 +507,7 @@ module Doing
       end
 
       # @content.update_item(original, item)
-      add_item(title, section, { note: note, back: opt[:date], timed: true })
+      add_item(title, section, { note: note, back: opt[:date], timed: false })
     end
 
     ##
@@ -633,42 +656,25 @@ module Doing
 
       opt[:time_filter] = [nil, nil]
       if opt[:from] && !opt[:date_filter]
-        date_string = opt[:from]
-        case date_string
-        when / (to|through|thru|(un)?til|-+) /
-          dates = date_string.split(/ (?:to|through|thru|(?:un)?til|-+) /)
-          if dates[0].strip =~ time_rx && dates[-1].strip =~ time_rx
-            time_start = dates[0].strip
-            time_end = dates[-1].strip
-          else
-            start = dates[0].chronify(guess: :begin)
-            finish = dates[-1].chronify(guess: :end)
-          end
-        when time_rx
-          time_start = date_string
-          time_end = nil
-        else
-          start = date_string.chronify(guess: :begin)
-          finish = false
+        if opt[:from][0].is_a?(String) && opt[:from][0] =~ time_rx
+          time_start, time_end = opt[:from]
+        elsif opt[:from].is_a?(Time)
+          start, finish = opt[:from]
         end
 
         if time_start
           opt[:time_filter] = [time_start, time_end]
-          Doing.logger.debug('Parser:', "--from string interpreted as time span, from #{time_start ? time_start : '12am'} to #{time_end ? time_end : '11:59pm'}")
         else
-          raise InvalidTimeExpression, 'Unrecognized date string' unless start
-
-          opt[:date_filter] = [start, finish]
-          Doing.logger.debug('Parser:', "--from string interpreted as #{start.strftime('%F %R')} -- #{finish ? finish.strftime('%F %R') : 'now'}")
+          opt[:date_filter] = opt[:from]
         end
       end
 
-      if opt[:before] =~ time_rx
+      if opt[:before].is_a?(String) && opt[:before] =~ time_rx
         opt[:time_filter][1] = opt[:before]
         opt[:before] = nil
       end
 
-      if opt[:after] =~ time_rx
+      if opt[:after].is_a?(String) && opt[:after] =~ time_rx
         opt[:time_filter][0] = opt[:after]
         opt[:after] = nil
       end
@@ -734,7 +740,7 @@ module Doing
           start_time = start_string.chronify(guess: :begin)
 
           end_string = if opt[:time_filter][1].nil?
-                         "#{item.date.next_day.strftime('%Y-%m-%d')} 12am"
+                         "#{item.date.to_datetime.next_day.strftime('%Y-%m-%d')} 12am"
                        else
                          "#{item.date.strftime('%Y-%m-%d')} #{opt[:time_filter][1]}"
                        end
@@ -753,22 +759,26 @@ module Doing
         end
 
         if keep && opt[:before]
-          time_string = opt[:before]
-          if time_string =~ time_rx
-            cutoff = "#{item.date.strftime('%Y-%m-%d')} #{time_string}".chronify(guess: :begin)
+          before = opt[:before]
+          if before =~ time_rx
+            cutoff = "#{item.date.strftime('%Y-%m-%d')} #{before}".chronify(guess: :begin)
+          elsif before.is_a?(String)
+            cutoff = before.chronify(guess: :begin)
           else
-            cutoff = time_string.chronify(guess: :begin)
+            cutoff = before
           end
           keep = cutoff && item.date <= cutoff
           keep = opt[:not] ? !keep : keep
         end
 
         if keep && opt[:after]
-          time_string = opt[:after]
-          if time_string =~ time_rx
-            cutoff = "#{item.date.strftime('%Y-%m-%d')} #{time_string}".chronify(guess: :end)
+          after = opt[:after]
+          if after =~ time_rx
+            cutoff = "#{item.date.strftime('%Y-%m-%d')} #{after}".chronify(guess: :end)
+          elsif after.is_a?(String)
+            cutoff = after.chronify(guess: :end)
           else
-            cutoff = time_string.chronify(guess: :end)
+            cutoff = after
           end
           keep = cutoff && item.date >= cutoff
           keep = opt[:not] ? !keep : keep
@@ -798,14 +808,14 @@ module Doing
     end
 
     def delete_items(items, force: false)
-      res = force ? true : Prompt.yn("Delete #{items.size} #{items.size == 1 ? 'item' : 'items'}?", default_response: 'y')
-      if res
-        items.each do |i|
-          deleted = @content.delete_item(i, single: items.count == 1)
-          Hooks.trigger :post_entry_removed, self, deleted
-        end
-        write(@doing_file)
-      end
+      items.slice(0, 5).each { |i| puts i.to_pretty } unless force
+      puts softpurple("+ #{items.size - 5} additional #{'item'.to_p(items.size - 5)}") if items.size > 5 && !force
+
+      res = force ? true : Prompt.yn("Delete #{items.size} #{'item'.to_p(items.size)}?", default_response: 'y')
+      return unless res
+
+      items.each { |i| Hooks.trigger :post_entry_removed, self, @content.delete_item(i, single: items.count == 1) }
+      write(@doing_file)
     end
 
     def edit_items(items)
@@ -934,6 +944,7 @@ module Doing
         actions = [
           'add tag',
           'remove tag',
+          'autotag',
           'cancel',
           'delete',
           'finish',
@@ -960,6 +971,8 @@ module Doing
             opt[:resume] = true
           when /reset/
             opt[:reset] = true
+          when /autotag/
+            opt[:autotag] = true
           when /(add|remove) tag/
             type = action =~ /^add/ ? 'add' : 'remove'
             raise InvalidArgument, "'add tag' and 'remove tag' can not be used together" if opt[:tag]
@@ -1071,6 +1084,21 @@ module Doing
         end
       end
 
+      if opt[:autotag]
+        items.map! do |i|
+          new_title = autotag(i.title)
+          if new_title == i.title
+            logger.count(:skipped, level: :debug, message: '%count unchaged %items')
+            # logger.debug('Autotag:', 'No changes')
+          else
+            logger.count(:added_tags)
+            logger.write(items.count == 1 ? :info : :debug, 'Tagged:', new_title)
+            i.title = new_title
+            Hooks.trigger :post_entry_updated, self, i
+          end
+        end
+      end
+
       if opt[:tag]
         tag = opt[:tag]
         items.map! do |i|
@@ -1098,10 +1126,7 @@ module Doing
 
       return unless opt[:output]
 
-      items.map! do |i|
-        i.title = "#{i.title} @project(#{i.section})"
-        i
-      end
+      items.each { |i| i.title = "#{i.title} @section(#{i.section})" }
 
       export_items = Items.new
       export_items.concat(items)
@@ -1138,6 +1163,8 @@ module Doing
     def verify_duration(date, finish_date, title: nil)
       max_elapsed = @config.dig('interaction', 'confirm_longer_than') || 0
       max_elapsed = max_elapsed.chronify_qty if max_elapsed.is_a?(String)
+      date = date.chronify(guess: :end, context: :today) if finish_date.is_a?(String)
+
       elapsed = finish_date - date
 
       if max_elapsed.positive? && (elapsed > max_elapsed)
@@ -1316,7 +1343,7 @@ module Doing
     ##
     ## @return     [Item] the next chronological item in the index
     ##
-    def next_item(item, options)
+    def next_item(item, options = {})
       options ||= {}
       items = filter_items(Items.new, opt: options)
 
@@ -1640,9 +1667,9 @@ module Doing
         opt[:menu] = !opt[:force]
         opt[:query] = '' # opt[:search]
         opt[:multiple] = true
-        selected = Prompt.choose_from_items(items, include_section: opt[:section] =~ /^all$/i, **opt)
+        selected = Prompt.choose_from_items(items.reverse, include_section: opt[:section] =~ /^all$/i, **opt)
 
-        raise NoResults, 'no items selected' if selected.empty?
+        raise NoResults, 'no items selected' if selected.nil? || selected.empty?
 
         act_on(selected, opt)
         return
@@ -1650,6 +1677,7 @@ module Doing
 
       opt[:output] ||= 'template'
       opt[:wrap_width] ||= @config['templates']['default']['wrap_width'] || 0
+
       output(items, title, is_single, opt)
     end
 
@@ -1746,7 +1774,7 @@ module Doing
       opt[:sort_tags] ||= false
       section = guess_section(section)
       # :date_filter expects an array with start and end date
-      dates = [dates, dates] if dates.instance_of?(String)
+      dates = dates.split_date_range if dates.instance_of?(String)
 
       list_section({
                      section: section,

data/lib/examples/commands/later.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# Example command that calls an existing command (tag) with
+# preset options
+desc 'Add an item to the Later section'
+arg_name 'ENTRY'
+command :later do |c|
+  c.example 'doing later "Something I\'ll think about tomorrow"', desc: 'Add an entry to the Later section'
+  c.example 'doing later -e', desc: 'Open $EDITOR to create an entry and optional note'
+
+  c.desc "Edit entry with #{Doing::Util.default_editor}"
+  c.switch %i[e editor], negatable: false, default_value: false
+
+  c.desc 'Backdate start time to date string [4pm|20m|2h|yesterday noon]'
+  c.arg_name 'DATE_STRING'
+  c.flag %i[b back started], type: DateBeginString
+
+  c.desc 'Note'
+  c.arg_name 'TEXT'
+  c.flag %i[n note]
+
+  c.desc 'Prompt for note via multi-line input'
+  c.switch %i[ask], negatable: false, default_value: false
+
+  c.action do |global_options, options, args|
+    cmd = commands[:now]
+    options[:section] = 'Later'
+    options[:finish_last] = false
+    action = cmd.send(:get_action, nil)
+    action.call(global_options, options, args)
+  end
+end

data/lib/helpers/threaded_tests.rb

@@ -0,0 +1,250 @@
+#!/usr/bin/env ruby
+
+require 'tty-spinner'
+require 'tty-progressbar'
+require './lib/doing'
+require 'open3'
+require 'shellwords'
+
+class ::String
+  include Doing::Color
+
+  def highlight_errors
+    cols = `tput cols`.strip.to_i
+
+    string = dup
+
+    errs = string.scan(/(?<==\n)(?:Failure|Error):.*?(?=\n=+)/m)
+
+    errs.map! do |error|
+      err = error.dup
+
+      err.gsub!(%r{^(/.*?/)([^/:]+):(\d+):in (.*?)$}) do
+        m = Regexp.last_match
+        "#{m[1].white}#{m[2].bold.white}:#{m[3].yellow}:in #{m[4].cyan}"
+      end
+      err.gsub!(/(Failure|Error): (.*?)\((.*?)\):\n  (.*?)(?=\n)/m) do
+        m = Regexp.last_match
+        [
+          m[1].bold.boldbgred.white,
+          m[3].bold.boldbgcyan.white,
+          m[2].bold.boldbgyellow.black,
+          " #{m[4]} ".bold.boldbgwhite.black.reset
+        ].join(':'.boldblack.boldbgblack.reset)
+      end
+      err.gsub!(/(<.*?>) (was expected to) (.*?)\n( *<.*?>)./m) do
+        m = Regexp.last_match
+        "#{m[1].bold.green} #{m[2].white} #{m[3].boldwhite.boldbgred.reset}\n#{m[4].bold.white}"
+      end
+      err.gsub!(/(Finished in) ([\d.]+) (seconds)/) do
+        m = Regexp.last_match
+        "#{m[1].green} #{m[2].bold.white} #{m[3].green}"
+      end
+      err.gsub!(/(\d+) (failures)/) do
+        m = Regexp.last_match
+        "#{m[1].bold.red} #{m[2].red}"
+      end
+      err.gsub!(/100% passed/) do |m|
+        m.bold.green
+      end
+
+      err
+    end
+
+    errs.join("\n#{('=' * cols).blue}\n")
+  end
+end
+
+class ThreadedTests
+  include Doing::Color
+
+  def run(pattern: '*', max_threads: 24, max_tests: 0)
+    start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+    max_threads = 24 if max_threads == 0
+
+    c = Doing::Color
+    c.coloring = true
+
+    pattern = "test/doing_*#{pattern}*_test.rb"
+
+    tests = Dir.glob(pattern)
+
+    if max_tests > 0
+      tests = tests.slice(0, max_tests - 1)
+    end
+
+    puts "#{tests.count} test files".boldcyan
+
+    banner = [
+      'Running tests '.bold.white,
+      '['.black,
+      ':bar'.boldcyan,
+      '] '.black,
+      'T'.green,
+      '/'.white,
+      'A'.cyan,
+      ' ('.white,
+      max_threads.to_s.bold.magenta,
+      ' threads)'.white
+    ].join('')
+    progress = TTY::ProgressBar::Multi.new(banner,
+                                           width: 12,
+                                           hide_cursor: true)
+    children = []
+    tests.each do |t|
+      test_name = File.basename(t, '.rb').sub(/doing_(.*?)_test/, '\1')
+      new_sp = progress.register("[#{':bar'.cyan}] #{test_name.bold.white}:status", total: 2, width: 1, head: '.', hide_cursor: true)
+      children.push([test_name, new_sp, nil])
+    end
+
+    @elapsed = 0.0
+    @test_total = 0
+    @assrt_total = 0
+    @error_out = []
+    # progress.start
+
+    begin
+      while children.count.positive?
+        threads = []
+        slices = children.slice!(0, max_threads)
+        slices.each { |c| c[1].start }
+        slices.each do |s|
+          bar = s[1]
+          bar.advance(status: ": #{'running'.green}")
+
+          threads << Thread.new do
+            out, _err, status = Open3.capture3(ENV, 'rake', "test:#{s[0]}", stdin_data: nil)
+            unless status.success?
+              m = out.match(/(?<fail>\d+) failures, (?<err>\d+) errors/)
+              status = ": #{m['fail'].bold.red} #{'failures'.red}, #{m['err'].bold.red} #{'errors'.red}"
+              bar.update(head: '✖'.boldred)
+              bar.advance(head: '✖'.boldred, status: status)
+
+              # errs = out.scan(/(?:Failure|Error): [\w_]+\((?:.*?)\):(?:.*?)(?=\n=======)/m)
+              @error_out.push(out.highlight_errors)
+              bar.finish
+
+              Thread.exit
+            end
+
+            time = out.match(/^Finished in (?<time>\d+\.\d+) seconds\./)
+            count = out.match(/^(?<tests>\d+) tests, (?<assrt>\d+) assertions, (?<fails>\d+) failures, (?<errs>\d+) errors/)
+            status = [
+              ': ',
+              count['tests'].green,
+              '/',
+              count['assrt'].cyan,
+              # ' (',
+              # count['fails'].to_i == 0 ? '-'.dark.white.reset : count['fails'].bold.red,
+              # '/',
+              # count['errs'].to_i == 0 ? '-'.dark.white.reset : count['errs'].bold.red,
+              # ') ',
+              ' ',
+              time['time'].to_f.round(3).to_s.yellow,
+              's'
+            ].join('')
+            bar.update(head: '✔'.boldgreen)
+            bar.advance(head: '✔'.boldgreen, status: status)
+            @test_total += count['tests'].to_i
+            @assrt_total += count['assrt'].to_i
+            @elapsed += time['time'].to_f
+
+            bar.finish
+          end
+        end
+        threads.each { |t| t.join }
+      end
+
+      finish_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      progress.finish
+
+      output = []
+      if @error_out.count.positive?
+        output << c.boldred("#{@error_out.count} Issues")
+      else
+        output << c.green('Success')
+      end
+      output << c.green("#{@test_total} tests")
+      output << c.cyan("#{@assrt_total} assertions")
+      output << c.yellow("#{(finish_time - start_time).round(3)}s")
+      puts output.join(', ')
+
+      puts @error_out.join("\n----\n".boldwhite) if @error_out.count.positive?
+    rescue
+      progress.stop
+    end
+  end
+end
+
+
+# require 'pastel'
+### Individual tests, multiple spinners
+# pastel = Pastel.new
+# format = "[#{pastel.yellow(':spinner')}] #{pastel.white("Running tests")} (#{pastel.green('tests')}/#{pastel.cyan('assertions')} #{pastel.yellow('time')})"
+# spinners = TTY::Spinner::Multi.new(format, format: :dots, success_mark: pastel.green('✔'), error_mark: pastel.red('✖'))
+# children = []
+# tests = Dir.glob('test/doing_*_test.rb').each do |t|
+#   test_name = File.basename(t, '.rb').sub(/doing_(.*?)_test/, '\1')
+#   new_sp = spinners.register "[#{pastel.cyan(':spinner')}] #{test_name}:msg"
+#   new_sp.update(msg: '')
+#   children.push([test_name, new_sp])
+# end
+
+# @elapsed = 0.0
+# @test_total = 0
+# @assrt_total = 0
+# spinners.auto_spin
+
+# children.each do |spinner|
+#   spinner[1].run do |s|
+#     out, _err, status = Open3.capture3(ENV, 'rake', "test:#{spinner[0]}", stdin_data: nil)
+#     unless status.success?
+#       s.update(msg: "#{pastel.red('- FAILURE:')} #{pastel.bold.white(func)} in #{pastel.bold.yellow(tst)}")
+#       s.error
+#       s.stop
+#       puts `echo #{Shellwords.escape(out)} | colout '^(/.*?/)([^/:]+):(\d+):in (.*?)$' white,yellow,green,magenta | colout 'Failure: (.*?)\\((.*?)\\)' red,green | colout '(.*?) (was expected to be)' green,red | colout '(Finished in) ([\d.]+) (seconds)' green,white,green | colout '(\d+ failures)' red | colout '(100% passed)' green`
+#       Process.exit
+#     end
+
+#     time = out.match(/^Finished in (?<time>\d+\.\d+) seconds\./)
+#     count = out.match(/^(?<tests>\d+) tests, (?<assrt>\d+) assertions/)
+#     s.update(msg: ": #{pastel.green(count['tests'])}/#{pastel.cyan(count['assrt'])} #{pastel.yellow(time['time'].to_f.round(3))}s")
+#     @test_total += count['tests'].to_i
+#     @assrt_total += count['assrt'].to_i
+#     @elapsed += time['time'].to_f
+#     s.success
+#   end
+# end
+
+# output = []
+# output << pastel.green('Success')
+# output << pastel.green("#{@test_total} tests")
+# output << pastel.cyan("#{@assrt_total} assertions")
+# output << pastel.yellow("#{@elapsed.round(4)}s")
+# puts output.join(', ')
+
+### Parallel test single spinner
+# pastel = Pastel.new
+# format = "[#{pastel.yellow(':spinner')}] #{pastel.white('Running parallel tests')} :msg"
+# spinner = TTY::Spinner.new(format, format: :dots, success_mark: pastel.green('✔'), error_mark: pastel.red('✖'))
+
+# spinner.run do |sp|
+#   sp.update(msg: '')
+#   out, err, status = Open3.capture3(ENV, 'rake', 'parallel:test', stdin_data: nil)
+
+#   unless status.success?
+#     failure = out.match(/^Failure: (.*?)\(([A-Z].*?)\)/)
+#     func = failure[1]
+#     tst = failure[2]
+#     sp.update(msg: "#{pastel.red('- FAILURE:')} #{pastel.bold.white(func)} in #{pastel.bold.yellow(tst)}")
+#     sp.error
+#     sp.stop
+#     puts `echo #{Shellwords.escape(out)} | colout '^(/.*?/)([^/:]+):(\d+):in (.*?)$' white,yellow,green,magenta | colout 'Failure: (.*?)\\((.*?)\\)' red,green | colout '(.*?) (was expected to be)' green,red | colout '(Finished in) ([\d.]+) (seconds)' green,white,green | colout '(\d+ failures)' red | colout '(100% passed)' green`
+#     Process.exit
+#   end
+
+#   sp.update(msg: pastel.green('- All tests passed'))
+#   sp.success
+# end