spec_selector 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ee389a398dc0b3c27c22993575b8062e8d01e98f34984c9fb8ca7ac5d4fbfb79
+  data.tar.gz: e3bbbfd79b14f98abf321dc72b246dae1a505ea000c86e48d2aacb3aeaee9776
+SHA512:
+  metadata.gz: 6fa192690d6a205f5cf726be2a222cf4f8fab78c028af23c4a23fd408d38642f78f6f86f361108ccb2510c4d3a78cab0bf104ef068c5ae3ba701146e1d3f07c1
+  data.tar.gz: 2e1a87593d1ce2a8235bc62c5af1f4a3a9c8e5f38a98a95b9667d8fac98fc788e54f3b28acf3676073f1b7b2860185c2d0112c9e02ff6d1ab1f8585502c7efcb

data/README.md

@@ -0,0 +1,48 @@
+# spec_selector
+
+SpecSelector is an RSpec formatter than opens a utility menu in your terminal window when you run tests (rather than just printing static text). The utility allows you to select, view, filter, and rerun specific test results with simple key controls. 
+
+**view test results**
+
+Upon finishing the test run, the test result tree appears as a formatted list of top-level example groups. Select an example group to view its subgroups, select a subgroup to view its examples, and so on. You can view your test results with the selection tool, or just press T to immediately view the top failed test. 
+
+**filter and rerun test results**
+
+Using the selection tool, press M to add the selected group or example to the inclusion filter. Press R to rerun RSpec with only selected tests.
+
+Without using the selection tool, press F to rerun only failed tests. Press SHIFT + T to rerun only the top failed test.
+
+Press C to clear the inclusion filter. Press A to clear the inclusion filter and rerun RSpec with all tests.
+
+Press V to view the inclusion filter as a selection list. 
+
+_Filter Modes_
+
+Whenever the inclusion filter is not empty, the filter mode will display at the top center of the terminal window. 
+
+There are two filter modes: _description_ and _location_. 
+
+The filter always uses description matching by default, but will use location (line number) matching if examples without descriptions (i.e. "one-liners") are selected for inclusion.
+
+**Installation**
+
+````
+gem install spec_selector
+````
+
+Once installed, add the following line to your .rspec file:
+
+````
+--format SpecSelector
+````
+
+Or, use the -f option on the command line
+
+````
+rspec -f SpecSelector
+````
+
+**Author**
+
+Trevor Almon
+ 

data/lib/spec_selector.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'io/console'
+require 'json'
+require 'byebug'
+require 'pry'
+require_relative 'spec_selector/terminal'
+require_relative 'spec_selector/UI'
+require_relative 'spec_selector/format'
+require_relative 'spec_selector/data_presentation'
+require_relative 'spec_selector/helpers'
+require_relative 'spec_selector/data_map'
+require_relative 'spec_selector/initialize'
+require_relative 'spec_selector/instructions'
+require_relative 'spec_selector/state'
+
+# The SpecSelector instance receives example execution data from the reporter
+# and arranges it into a formatted, navigable map.
+class SpecSelector
+  include SpecSelectorUtil::UI
+  include SpecSelectorUtil::Terminal
+  include SpecSelectorUtil::Format
+  include SpecSelectorUtil::DataPresentation
+  include SpecSelectorUtil::Helpers
+  include SpecSelectorUtil::DataMap
+  include SpecSelectorUtil::Initialize
+  include SpecSelectorUtil::Instructions
+  include SpecSelectorUtil::State
+
+  RSpec::Core::Formatters.register self,
+                                   :message,
+                                   :example_group_started,
+                                   :example_passed,
+                                   :example_pending,
+                                   :example_failed,
+                                   :dump_summary
+
+  def initialize(output)
+    @output = output
+    hide_cursor
+    initialize_all
+  end
+
+  def message(notification)
+    @messages << notification.message
+  end
+
+  def example_group_started(notification)
+    group = notification.group
+    map_group(group)
+    @groups[group.metadata[:block]] = group
+    check_inclusion_status(group)
+  end
+
+  def example_passed(notification)
+    clear_frame
+    @passed << notification.example
+    map_example(notification.example)
+    check_inclusion_status(notification.example)
+    @pass_count += 1
+    status_count
+  end
+
+  def example_pending(notification)
+    clear_frame
+    @pending_summaries[notification.example] = notification
+    @pending << notification.example
+    map_example(notification.example)
+    check_inclusion_status(notification.example)
+    @pending_count += 1
+    status_count
+  end
+
+  def example_failed(notification)
+    clear_frame
+    @failure_summaries[notification.example] = notification
+    @failed << notification.example
+    map_example(notification.example)
+    check_inclusion_status(notification.example)
+    @fail_count += 1
+    status_count
+  end
+
+  def dump_summary(notification)
+    @example_count = notification.example_count
+    @outside_errors_count = notification.errors_outside_of_examples_count
+    errors_before_formatter_initialization
+    print_errors(notification) if @outside_errors_count.positive?
+    messages_only if @map.empty?
+    examples_summary(notification)
+  end
+end

data/lib/spec_selector/data_map.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module SpecSelectorUtil
+  # The DataMap module contains methods used to build a hash map of nested
+  # lists, which can be rendered in their interactive form through the
+  # DataPresentation methods.
+  module DataMap
+    def top_level_push(group)
+      @map[:top_level] ||= []
+      @map[:top_level] << group
+      @map[group.metadata[:block]] ||= []
+    end
+
+    def parent_data(data)
+      keys = data.keys
+      return data[:example_group] if keys.include?(:example_group)
+      return data[:parent_example_group] if keys.include?(:parent_example_group)
+
+      nil
+    end
+
+    def map_group(group)
+      if !group.metadata[:parent_example_group]
+        top_level_push(group)
+      else
+        parent = group.metadata[:parent_example_group][:block]
+        @map[parent] ||= []
+        @map[parent] << group
+        @map[group.metadata[:block]] ||= []
+      end
+    end
+
+    def map_example(example)
+      group = example.example_group
+      @map[group.metadata[:block]] << example
+    end
+  end
+end

data/lib/spec_selector/data_presentation.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module SpecSelectorUtil
+  # The DataPresentation module contains methods used to render mapped data.
+  module DataPresentation
+    def test_data_summary
+      status_count
+      print_summary
+    end
+
+    # If an exception is raised before an instance of SpecSelector is
+    # initialized (for instance, a TypeError raised due to a configuration
+    # problem), the MessageNotification will be sent to the registered
+    # default formatter instead and will not be accessable to SpecSelector.
+    # In such a case, the formatted error information is printed immediately
+    # in the manner determined by the default formatter. This method simply
+    # checks for a condition caused by that situation and leaves the error
+    # information displayed until the user exits.
+    def errors_before_formatter_initialization
+      if @outside_errors_count.positive? && @messages == ['No examples found.']
+        empty_line
+        exit_only
+      end
+    end
+
+    def print_errors(notification)
+      clear_frame
+      print_messages
+      errors_summary(notification)
+    end
+
+    def print_messages
+      printed = 0
+      @messages.each do |message|
+        next if message.include?('Run options: include {:full_description=>')
+        next if message.include?('Run options: include {:locations=>')
+
+        italicize(message)
+        printed += 1
+      end
+      empty_line if printed.positive?
+    end
+
+    def examples_summary(notification)
+      @summary_notification = notification
+      status_summary(notification)
+
+      @list = if @inclusion_filter.empty? || @inclusion_filter.count > 10
+                @map[:top_level]
+              else
+                @inclusion_filter
+              end
+
+      selector
+    end
+
+    def errors_summary(notification)
+      err_count = notification.errors_outside_of_examples_count
+      word_form = err_count > 1 ? 'errors' : 'error'
+      italicize "Finished in #{notification.duration} seconds"
+      italicize "Files loaded in #{notification.load_time}"
+      empty_line
+      italicize "#{err_count} #{word_form} occurred outside of examples"
+      italicize 'Examples were not successfully executed'
+      exit_only
+    end
+
+    def status_count
+      pass_count
+      pending_count if @pending_count.positive?
+      fail_count
+      empty_line
+    end
+
+    def print_summary
+      @summary.each { |sum| italicize(sum) }
+      empty_line
+    end
+
+    def exclude_passing!
+      alt_map = @map.reject { |_, v| v.all? { |g| all_passed?(fetch_examples(g)) } }
+      alt_map.transform_values! { |v| v.reject { |g| all_passed?(fetch_examples(g)) } }
+      @active_map = alt_map
+      @exclude_passing = true
+    end
+
+    def include_passing!
+      @active_map = @map
+      @exclude_passing = false
+    end
+
+    def toggle_passing
+      return if all_passing?
+
+      @exclude_passing ? include_passing! : exclude_passing!
+      return if @example_display && @list != @passed && !@instructions
+
+      exit_instruction_page if @instructions
+      p_data = parent_data(@selected.metadata)
+      key = p_data ? p_data[:block] : :top_level
+      new_list = @active_map[key]
+      @list = new_list
+      @selected = nil
+      @example_display = false
+      set_selected
+      display_list
+    end
+
+    def status_summary(notification)
+      @summary = []
+      @summary << "Total Examples: #{@example_count}"
+      @summary << "Finished in #{notification.duration} seconds"
+      @summary << "Files loaded in #{notification.load_time} seconds"
+    end
+
+    def display_list
+      clear_frame
+      display_filter_mode
+      test_data_summary
+      print_messages unless @messages.empty?
+      all_passed_message if all_passing?
+      basic_instructions
+      empty_line
+
+      @list.each { |item| format_list_item(item) }
+    end
+
+    def view_inclusion_filter
+      if @inclusion_filter.empty?
+        empty_filter_notice
+        return
+      end
+
+      @example_display = false
+      exit_instruction_page if @instructions
+      @list = @inclusion_filter
+      @selected = @list.first unless @selected.metadata[:include]
+      set_selected
+      display_list
+    end
+
+    def refresh_display
+      set_selected
+      @example_display ? display_example : display_list
+    end
+
+    def display_example
+      @example_display = true
+      clear_frame
+      display_filter_mode
+      test_data_summary
+      status = @selected.execution_result.status
+      @list, data = example_list
+      example_summary_instructions
+      @output.puts 'Added to filter √' if @selected.metadata[:include]
+      @selector_index = @list.index(@selected)
+      view_other_examples(status) if @list.count > 1 && @instructions
+      format_example(status, data)
+    end
+
+    def example_list
+      status = @selected.execution_result.status
+      result_list = @failed if status == :failed
+      result_list = @pending if status == :pending
+      result_list = @passed if status == :passed
+
+      data = @failure_summaries[@selected] if status == :failed
+      data = @pending_summaries[@selected] if status == :pending
+
+      [result_list, data]
+    end
+
+    def messages_only
+      clear_frame
+      print_messages
+      exit_only
+    end
+  end
+end

data/lib/spec_selector/format.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module SpecSelectorUtil
+  # The Format module contains methods used for simple text formatting, as well
+  # as methods that determine how specific list items will be formatted.
+  module Format
+    ESCAPE_CODES = {
+      green: '1;32',  # the numeric codes for green, yellow, and red are
+      red: '1;31',    # 32, 31, and 33 respectively. The '1;' is prepended
+      yellow: '1;33', # for bold lettering.
+      italicize: 3,
+      bold: 1
+    }.freeze
+
+    ESCAPE_CODES.each do |sym, num|
+      define_method(sym) do |text, included = false|
+        formatted = "\e[#{num}m#{text}\e[0m"
+        formatted = included ? formatted + ' √' : formatted
+        @output.puts formatted
+      end
+    end
+
+    def fetch_examples(item)
+      return [item] if example?(item)
+
+      examples = item.examples
+      return examples if @map[item.metadata[:block]] == examples
+
+      examples.reject! { |ex| ex.execution_result.status.nil? }
+
+      @map[item.metadata[:block]].each do |d|
+        examples += fetch_examples(d)
+      end
+
+      examples
+    end
+
+    def format_list_item(item)
+      description = lineage(item.metadata)
+      data = example?(item) ? [item] : fetch_examples(item)
+      included = item.metadata[:include]
+
+      if @selected == item
+        highlight(description, included)
+      else
+        green(description, included) if all_passed?(data)
+        yellow(description, included) if any_pending?(data) && !any_failed?(data)
+        red(description, included) if any_failed?(data)
+      end
+    end
+
+    def pass_count
+      green("PASS: #{@pass_count}")
+    end
+
+    def pending_count
+      yellow("PENDING: #{@pending_count}")
+    end
+
+    def fail_count
+      red("FAIL: #{@fail_count}")
+    end
+
+    def highlight(text, included = false)
+      text += ' √' if included
+      @output.puts "\e[1;7m#{text}\e[0m"
+    end
+
+    def lineage(data)
+      parent = parent_data(data)
+      return data[:description] unless parent
+
+      lineage(parent) + ' -> ' + data[:description]
+    end
+
+    def format_example(status, data)
+      if %i[failed pending].include?(status)
+        print_nonpassing_example(data)
+      else
+        print_passing_example
+      end
+    end
+
+    def print_nonpassing_example(data)
+      data = data.fully_formatted(@selector_index + 1).split("\n")
+      data[0] = ''
+      data.insert(1, '-' * term_width)
+      data.insert(3, '-' * term_width)
+      @output.puts data
+    end
+
+    def print_passing_example
+      @output.puts '-' * term_width
+      @output.puts "#{@selector_index + 1}) " + @selected.description
+      @output.puts '-' * term_width
+      green('PASSED')
+    end
+  end
+end