spec_selector 0.1.7 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 94f3b90855ec30f1707b90ab4bfdf700ab37f10f26b23aa762cbeb078d3f4e85
-  data.tar.gz: 075f18af13b28407c5f208cfc6a73960d92284d181f47e40289aca31e6075379
+  metadata.gz: d5ebcfc2cf3d1b1779bab9de9470bf160c00566c830cebaf290c44f26ba7351b
+  data.tar.gz: e80c880103bf8f7cc80701804fe227bff7d3c4de6cad50208c31a00ae6924ec4
 SHA512:
-  metadata.gz: 40b4f018c8669950ce858fe89f3d2b7f588341f30ee1eb47f16855db3a2ff81c6bc0abbb4a899a880bb0f39cdc2656efb43aa00f201d7f3e2274224256605970
-  data.tar.gz: 282dac133a54b2d15ae16fff9c7618538f6af5c3ba007540b744f413903adb06b03b4a3cd2659c2641379b23e20cf78cb59234e0a650779e9178ad00ac6e658f
+  metadata.gz: f0a033f8cdc4a013e303ddfb00e942c117cca3a887792be54e7cc04e63561eb836f88b1e728b8fb7845fc2f9a6979a926d061df9d75f1db098a5de4e203e410d
+  data.tar.gz: f463910ca22286b2b605d08d29894004bdea3319e4f4c6b6b89412400a1dfb0576406ee76bbadf068d706638e655c0b7b007c2a512ca4cda523e417023319353

metadata

@@ -1,11 +1,11 @@
 --- !ruby/object:Gem::Specification
 name: spec_selector
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.8
 platform: ruby
 authors:
 - Trevor Almon
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain:
 - |
@@ -34,28 +34,22 @@ cert_chain:
   2oaEU1xxH+4n3qzECM32PIry9QVrTud/3/ouDLy4LVVyutD5ZANsVQrr0y8vEA6+
   OXcnI0Yc8EI4dmIAwDI0ZfBo2OgFBxNJCeurVx36tUPsSWjJUd0BeA==
   -----END CERTIFICATE-----
-date: 2021-03-30 00:00:00.000000000 Z
+date: 2021-12-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.0.0
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '4'
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.0.0
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '4'
+        version: '3.0'
 description: "  SpecSelector is an RSpec formatter that opens a utility \n  menu in
   your terminal window when you run tests (rather \n  than just printing static text).
   The utility allows you to \n  select, view, filter, and rerun specific test results
@@ -65,7 +59,6 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- CHANGELOG.md
 - README.md
 - lib/spec_selector.rb
 - lib/spec_selector/data_map.rb
@@ -79,16 +72,6 @@ files:
 - lib/spec_selector/terminal.rb
 - lib/spec_selector/ui.rb
 - license.md
-- spec/factories.rb
-- spec/shared.rb
-- spec/spec_helper.rb
-- spec/spec_selector_spec.rb
-- spec/spec_selector_util/data_map_spec.rb
-- spec/spec_selector_util/data_presentation_spec.rb
-- spec/spec_selector_util/format_spec.rb
-- spec/spec_selector_util/helpers_spec.rb
-- spec/spec_selector_util/initialize_spec.rb
-- spec/spec_selector_util/ui_spec.rb
 homepage: https://github.com/TrevorA-TrevorA/spec_selector
 licenses:
 - MIT
@@ -96,7 +79,7 @@ metadata:
   source_code_uri: https://github.com/TrevorA-TrevorA/spec_selector
   homepage_uri: https://github.com/TrevorA-TrevorA/spec_selector
   changelog_uri: https://github.com/TrevorA-TrevorA/spec_selector/blob/master/CHANGELOG.md
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -111,8 +94,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.2.21
+signing_key:
 specification_version: 4
 summary: A results viewer and filter utility for RSpec
 test_files: []

data/CHANGELOG.md

@@ -1,9 +0,0 @@
-**version 0.1.6** 
-<br>
-<br>
-Corrected a test rerun bug as well as a problem with key control regex patterns; made a slight modification to key controls: T is no longer case-sensitive and will now rerun the top failed test result from the current set. To view the top failed result from the current set without rerunning, press SPACEBAR.
-
-**version 0.1.7** 
-<br>
-<br>
-Updated key control instructions display text.

data/spec/factories.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-module TestObjects
-  RSN = RSpec::Core::Notifications
-
-  class Example < RSpec::Core::Example
-    attr_accessor :metadata, :execution_result, :description, :example_group
-
-    def initialize
-    end
-  end
-
-  class ExecutionResult < RSpec::Core::Example::ExecutionResult
-    attr_accessor :status
-  end
-
-  class ExampleGroup < RSpec::Core::ExampleGroup
-    attr_accessor :examples, :metadata, :description
-  end
-
-  class SummaryNotification < RSN::SummaryNotification
-    attr_accessor :example_count,
-                  :duration,
-                  :load_time,
-                  :errors_outside_of_example_count
-
-    :examples
-  end
-
-  class SkippedExampleNotification < RSN::SkippedExampleNotification
-    attr_accessor :example
-
-    def fully_formatted(_)
-      "\npending example"
-    end
-  end
-
-  class FailedExampleNotification < RSN::FailedExampleNotification
-    attr_accessor :example
-
-    def initialize
-    end
-
-    def fully_formatted(_)
-      "\nfailed example"
-    end
-  end
-end
-
-FactoryBot.define do
-  factory :execution_result, class: 'TestObjects::ExecutionResult' do
-    status { :passed }
-  end
-
-  factory :example, class: 'TestObjects::Example' do
-    execution_result { build(:execution_result) }
-    description { 'passed' }
-    metadata { {} }
-  end
-
-  factory :example_group, class: 'TestObjects::ExampleGroup' do
-    examples { [build(:example)] }
-    metadata { { block: self } }
-    description do
-      if examples.all? { |ex| ex.execution_result.status == :passed }
-        'passing example group'
-      else
-        'non-passing example group'
-      end
-    end
-  end
-
-  factory :summary_notification, class: 'TestObjects::SummaryNotification' do
-    example_count { 25 }
-    duration { 1.5 }
-    load_time { 0.5 }
-    errors_outside_of_examples_count { 0 }
-  end
-
-  factory :skipped_example_notification,
-          class: 'TestObjects::SkippedExampleNotification' do
-    example
-  end
-
-  factory :failed_example_notification,
-          class: 'TestObjects::FailedExampleNotification' do
-    example
-  end
-end

data/spec/shared.rb

@@ -1,145 +0,0 @@
-RSpec.shared_context 'shared' do
-  let(:spec_selector) { SpecSelector.new(StringIO.new) }
-  let(:output) { spec_selector.ivar(:@output).string }
-  let(:fail_result) { build(:execution_result, status: :failed) }
-  let(:pending_result) { build(:execution_result, status: :pending) }
-  let(:failed_example) { build(:example, execution_result: fail_result, metadata: { description: 'failed_example' }) }
-  let(:pending_example) do
-    build(:example, execution_result: pending_result, metadata: { description: 'pending_example' })
-  end
-  let(:passing_example) do
-    build(:example, metadata: { description: 'passing_example' }, description: 'passing_example')
-  end
-  let(:pass_group) do
-    build(:example_group, examples: [build(:example), build(:example)], metadata: { description: 'pass_group' })
-  end
-  let(:fail_group) { build(:example_group, examples: [failed_example, failed_example]) }
-  let(:pending_group) do
-    build(:example_group, examples: [pending_example, pending_example], metadata: { description: 'pending_group' })
-  end
-  let(:mixed_result_group) { build(:example_group, examples: [passing_example, failed_example, pending_example]) }
-  let(:fail_subgroup) do
-    build(
-      :example_group,
-      metadata: {
-        parent_example_group: {}
-      },
-      examples: [failed_example, failed_example]
-    )
-  end
-
-  let(:pending_subgroup) do
-    build(
-      :example_group,
-      metadata: {
-        parent_example_group: {}
-      },
-      examples: [pending_example, pending_example]
-    )
-  end
-
-  let(:fail_parent_group) { build(:example_group, examples: [], metadata: { description: 'fail_parent_group' }) }
-  let(:pending_parent_group) { build(:example_group, examples: [], metadata: { description: 'pending_parent_group' }) }
-  let(:pass_subgroup) do
-    build(
-      :example_group,
-      metadata: { parent_example_group: pass_parent_group.metadata, description: 'pass_subgroup' },
-      examples: [passing_example, passing_example]
-    )
-  end
-
-  let(:pass_parent_group) { build(:example_group, examples: [], metadata: { description: 'pass_parent_group' }) }
-  let(:mixed_list) { [pass_group, fail_group] }
-  let(:mixed_map) do
-    {
-      :top_level => [pass_group, fail_group],
-      pass_group.metadata[:block] => pass_group.examples,
-      fail_group.metadata[:block] => fail_group.examples
-    }
-  end
-
-  let(:pending_map) do
-    {
-      :top_level => [pending_group],
-      pending_group.metadata[:block] => pending_group.examples
-    }
-  end
-
-  let(:deep_map) do
-    {
-      :top_level => [pending_parent_group, pass_parent_group, fail_parent_group],
-      pending_parent_group.metadata[:block] => [pending_subgroup],
-      pass_parent_group.metadata[:block] => [pass_subgroup],
-      fail_parent_group.metadata[:block] => [fail_subgroup],
-      pending_subgroup.metadata[:block] => pending_subgroup.examples,
-      pass_subgroup.metadata[:block] => pass_subgroup.examples,
-      fail_subgroup.metadata[:block] => fail_subgroup.examples
-    }
-  end
-
-  let(:all_passing_map) do
-    {
-      top_level: [pass_group, pass_group],
-      pass_group.metadata[:block] => pass_group.examples,
-      pass_group.metadata[:block] => pass_group.examples
-    }
-  end
-
-  def allow_methods(*methods)
-    methods.each do |method|
-      allow(spec_selector).to receive(method)
-    end
-  end
-
-  def ivars_set(ivar_hash)
-    ivar_hash.each do |ivar, value|
-      spec_selector.ivar_set(ivar, value)
-    end
-  end
-
-  def ivar_set(sym, value)
-    spec_selector.ivar_set(sym, value)
-  end
-
-  def ivar(sym)
-    spec_selector.ivar(sym)
-  end
-
-  def more_data?(readable)
-    IO.select([readable], nil, nil, 0.000001)
-  end
-
-  def summary_settings(example)
-    case example
-    when failed_example
-      notification_type = :failed_example_notification
-      summary_list = :@failure_summaries
-      ivar = :@failed
-    when pending_example
-      notification_type = :skipped_example_notification
-      summary_list = :@pending_summaries
-      ivar = :@pending
-    end
-
-    ivars_set(:@selected => example, ivar => [example])
-    notification = build(notification_type, example: example)
-    spec_selector.ivar(summary_list)[example] = notification
-  end
-
-  def expect_full_instructions_to_be_displayed
-    expect(output).to include('Press I to hide instructions')
-    expect(output).to include('Press F to exclude passing examples')
-    expect(output).to include('Press ↑ or ↓ to navigate list')
-    expect(output).to include('Press [enter] to select')
-    expect(output).to include('Press Q to exit')
-  end
-
-  def expect_full_instructions_to_be_hidden
-    expect(output).to include('Press I to view instructions')
-    expect(output).not_to include('Press I to hide instructions')
-    expect(output).not_to include('Press F to exclude passing examples')
-    expect(output).not_to include('Press ↑ or ↓ to navigate list')
-    expect(output).not_to include('Press [enter] to select')
-    expect(output).not_to include('Press Q to exit')
-  end
-end

data/spec/spec_helper.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_selector'
-require 'stringio'
-require 'factory_bot'
-require 'timeout'
-require 'shared'
-
-RCN = RSpec::Core::Notifications
-EXAMPLE_STUBS = { description: 'description',
-                  execution_result: 'result',
-                  full_description: 'full_description' }.freeze
-
-alias ivar instance_variable_get
-alias ivar_set instance_variable_set
-
-RSpec.configure do |config|
-  config.expect_with :rspec do |expectations|
-    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
-  end
-
-  config.filter_run_when_matching :focus
-
-  config.mock_with :rspec do |mocks|
-    mocks.verify_partial_doubles = true
-  end
-
-  config.shared_context_metadata_behavior = :apply_to_host_groups
-
-  config.include_context 'shared', include_shared: true
-
-  config.include FactoryBot::Syntax::Methods
-
-  config.before(:suite) do
-    FactoryBot.find_definitions
-  end
-
-  config.around(:example, break_loop: true) do |example|
-    begin
-      Timeout.timeout(0.001) do
-        example.run
-      end
-    rescue Timeout::Error
-      nil
-    end
-  end
-end

data/spec/spec_selector_spec.rb

@@ -1,165 +0,0 @@
-# frozen_string_literal: true
-
-describe SpecSelector do
-  include_context 'shared'
-
-  let(:spec_selector) { described_class.new(StringIO.new) }
-
-  let(:output) { spec_selector.ivar(:@output).string }
-  let(:pass_result) { build(:execution_result) }
-  let(:pending_result) { build(:execution_result, status: :pending) }
-
-  let(:fail_result) do
-    build(:execution_result, status: :failed, exception: 'error')
-  end
-
-  describe '#message' do
-    let(:notification) { RCN::MessageNotification.new('message') }
-
-    it 'stores the message string in the @messages array' do
-      messages = spec_selector.ivar(:@messages)
-      spec_selector.message(notification)
-      expect(messages).to include('message')
-    end
-  end
-
-  describe '#example_group_started' do
-    let(:group) do
-      instance_double('ExampleGroup', metadata: { block: 'key' }, examples: [])
-    end
-
-    let(:notification) { RCN::GroupNotification.new(group) }
-
-    it 'passes the example group to SpecSelector#map_group' do
-      expect(spec_selector).to receive(:map_group).with(group)
-      spec_selector.example_group_started(notification)
-    end
-
-    it 'stores example group in the @groups hash' do
-      spec_selector.example_group_started(notification)
-      groups = spec_selector.ivar(:@groups)
-      expect(groups.values).to include(group)
-    end
-  end
-
-  describe '#example_passed' do
-    let(:example) { instance_double('Example', execution_result: pass_result) }
-    let(:notification) { RCN::ExampleNotification.send(:new, example) }
-
-    before do
-      allow(spec_selector).to receive(:map_example)
-      allow(spec_selector).to receive(:check_inclusion_status)
-      spec_selector.example_passed(notification)
-    end
-
-    it 'stores example in @passed array' do
-      passed = spec_selector.ivar(:@passed)
-      expect(passed).to include(example)
-    end
-
-    it 'increments @pass_count' do
-      pass_count = spec_selector.ivar(:@pass_count)
-      expect(pass_count).to eq(1)
-    end
-
-    it 'updates passing example status display' do
-      expect(output).to match(/PASS: \d+/)
-    end
-  end
-
-  describe '#example_pending' do
-    let(:example) { instance_double('Example', execution_result: pending_result) }
-    let(:notification) { RCN::ExampleNotification.send(:new, example) }
-
-    before do
-      allow(spec_selector).to receive(:map_example)
-      allow(spec_selector).to receive(:check_inclusion_status)
-      spec_selector.example_pending(notification)
-    end
-
-    it 'stores example in @pending array' do
-      pending = spec_selector.ivar(:@pending)
-      expect(pending).to include(notification.example)
-    end
-
-    it 'increments @pending_count' do
-      pending_count = spec_selector.ivar(:@pending_count)
-      expect(pending_count).to eq(1)
-    end
-
-    it 'updates pending status display' do
-      expect(output).to match(/PENDING: \d+/)
-    end
-  end
-
-  describe '#example_failed' do
-    let(:example) do
-      instance_double('Example',
-                      full_description: 'full description',
-                      execution_result: fail_result)
-    end
-
-    let(:notification) { RCN::FailedExampleNotification.send(:new, example) }
-
-    before do
-      allow(spec_selector).to receive(:map_example)
-      allow(spec_selector).to receive(:check_inclusion_status)
-      spec_selector.example_failed(notification)
-    end
-
-    it 'stores example in @failed array' do
-      failed = spec_selector.ivar(:@failed)
-      expect(failed).to include(notification.example)
-    end
-
-    it 'increments @fail_count' do
-      fail_count = spec_selector.ivar(:@fail_count)
-      expect(fail_count).to eq(1)
-    end
-
-    it 'calls #status_count' do
-      expect(output).to match(/FAIL: \d+/)
-    end
-  end
-
-  describe '#dump_summary', break_loop: true do
-    let(:notification) { build(:summary_notification) }
-
-    context 'when errors outside of examples have occurred' do
-      let(:notification) do
-        build(:summary_notification, errors_outside_of_examples_count: 2)
-      end
-
-      it 'passes notification to #print_errors' do
-        allow(spec_selector).to receive(:print_errors).and_call_original
-        spec_selector.dump_summary(notification)
-        expect(spec_selector).to have_received(:print_errors).with(notification)
-      end
-    end
-
-    context 'when errors outside of examples have not occured' do
-      it 'does not call #print_errors' do
-        allow(spec_selector).to receive(:print_errors).and_call_original
-        spec_selector.dump_summary(notification)
-        expect(spec_selector).not_to have_received(:print_errors)
-      end
-    end
-
-    context 'when non-error messages are present with no examples' do
-      it 'calls #messages only' do
-        spec_selector.ivar(:@messages) << 'some message'
-        spec_selector.dump_summary(notification)
-      end
-    end
-
-    context 'when examples successfully executed' do
-      it 'passes notification to #examples_summary' do
-        ivar_set(:@map, mixed_map)
-        allow(spec_selector).to receive(:examples_summary).and_call_original
-        spec_selector.dump_summary(notification)
-        expect(spec_selector).to have_received(:examples_summary)
-          .with(notification)
-      end
-    end
-  end
-end

data/spec/spec_selector_util/data_map_spec.rb

@@ -1,98 +0,0 @@
-describe 'SpecSelectorUtil::DataMap' do
-  subject(:spec_selector) { SpecSelector.new(StringIO.new) }
-
-  let(:example_group) { build(:example_group) }
-
-  let(:map) { spec_selector.ivar(:@map) }
-
-  describe '#top_level_push' do
-    before { spec_selector.top_level_push(example_group) }
-
-    it 'lazy-initializes @map[:top_level] to an array' do
-      expect(map[:top_level]).to be_an(Array)
-    end
-
-    it 'stores example group in @map[:top_level]' do
-      expect(map[:top_level]).to include(example_group)
-    end
-  end
-
-  # takes takes the metadata hash from an example group or from an
-  # example as its argument
-  describe '#parent_data' do
-    context 'when metadata hash is from an example' do
-      let(:example_metadata) { { example_group: example_group.metadata } }
-      let(:example) { instance_double('Example', metadata: example_metadata) }
-
-      it 'returns metadata of the example group to which the example belongs' do
-        expect(spec_selector.parent_data(example_metadata))
-          .to eq(example_group.metadata)
-      end
-    end
-
-    context 'when metadata hash is from an example group' do
-      context 'when the example group has a parent group' do
-        let(:example_group) do
-          instance_double('ExampleGroup', metadata: {
-                            parent_example_group: { block: :parent_example_block }
-                          })
-        end
-
-        it 'returns the parent group metadata' do
-          expect(spec_selector.parent_data(example_group.metadata))
-            .to eq(example_group.metadata[:parent_example_group])
-        end
-      end
-
-      context 'when the example group does not have a parent group' do
-        it 'returns nil' do
-          expect(spec_selector.parent_data(example_group.metadata)).to be_nil
-        end
-      end
-    end
-  end
-
-  describe '#map_group' do
-    let(:map) { spec_selector.ivar(:@map) }
-
-    before { spec_selector.map_group(example_group) }
-
-    context 'when example group has parent group' do
-      let(:example_group) do
-        instance_double('ExampleGroup', metadata: {
-                          parent_example_group: { block: :parent_block }
-                        })
-      end
-
-      it 'stores the parent block as a key in @map initialized to an array' do
-        expect(map[:parent_block]).to be_an(Array)
-      end
-
-      it 'stores the example group in the parent block array' do
-        expect(map[:parent_block]).to include(example_group)
-      end
-    end
-
-    context 'when example group does not have parent group' do
-      it 'passes the example group to #top_level_push' do
-        expect(map[:top_level]).to include(example_group)
-      end
-    end
-  end
-
-  describe '#map_example' do
-    let(:example) do
-      build(:example, example_group: example_group)
-    end
-
-    before do
-      map[example_group.metadata[:block]] = []
-      example_group.examples << example
-      spec_selector.map_example(example)
-    end
-
-    it 'appends the example to its example group in @map' do
-      expect(map[example_group.metadata[:block]]).to include(example)
-    end
-  end
-end