rspec-cover_it 0.0.7 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 63e1b79c2f0b0d52869caa48e5d7dcfee100a726f1fb4698bcbef5d228179ec4
-  data.tar.gz: 24d36270a6320b920f30134c8bb354b77325b16e4a311b1fb018470c72f0c5a7
+  metadata.gz: e0d27633b32f88f6dcc94af45b0ecd536b785c6229e3808ef0a1b95058f20b62
+  data.tar.gz: 0ade00b1ddfa4db191e9d927f6361bfcf8de243b543f2592ecbefd4a0b7f84de
 SHA512:
-  metadata.gz: 3f8774a17ea6e1170471182cf768cbd7fc0e3f69a8cf2d04445d7a7ae0e7e04947b6a75205aa2d53eaaeef104597447608b3873413b73bfda2d9b83ce015bec6
-  data.tar.gz: 3cf13d18a7658e6769d672e1d130ace9e3842ce1e3e7edfdf21e3c64753fb47668da6c7fa16690bc78e6741aa58cd03bdf1344d7c98b50a6fdbf51de03ba5ec1
+  metadata.gz: e29cce1280f10140900b51f384b0e2e73a98e8b4fc1e79caf170e71e9c3cf64fac01fdcd5560472580c9544cde5169722db18508bfe119164e2f1dfe11dda9ba
+  data.tar.gz: 8895302c10ac12dbab2e71292e47f055067337d415650f8cd28671180d5690c1ea8ed59c4665cdc99ee9776af29e1372533b862cf73d2058fea3663c722c3525

data/.github/workflows/linters.yml

@@ -0,0 +1,34 @@
+name: Linters
+
+on: [push]
+
+jobs:
+  StandardRB:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Set up ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 3.1
+
+      - name: Cache gems
+        uses: actions/cache@v3
+        with:
+          path: vendor/bundle
+          key: ${{ runner.os }}-linters-${{ hashFiles('Gemfile.lock') }}
+          restore-keys:
+            ${{ runner.os }}-linters-
+
+      - name: Install gems
+        run: bundle install --jobs 4 --retry 3
+
+      - name: Run standard
+        run: bundle exec standardrb
+
+      - name: Run rubocop (complexity checks)
+        run: bundle exec rubocop --parallel
+
+      - name: Run markdownlint
+        run: bundle exec mdl .

data/.github/workflows/rspec.yml

@@ -0,0 +1,33 @@
+name: RSpec
+
+on: [push]
+
+jobs:
+  RSpec:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby-version: ['2.7', '3.0', '3.1', '3.2', 'head']
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Set up ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby-version }}
+
+      - name: Cache gems
+        uses: actions/cache@v3
+        with:
+          path: vendor/bundle
+          key: ${{ runner.os }}-rspec-${{ matrix.ruby-version }}-${{ hashFiles('Gemfile.lock') }}
+          restore-keys:
+            ${{ runner.os }}-rspec-${{ matrix.ruby-version }}-
+
+      - name: Install gems
+        run: bundle install --jobs 4 --retry 3
+
+      - name: Run RSpec
+        run: SIMPLECOV=true SIMPLECOV_TEXT=true bundle exec rspec

data/.mdl_rules.rb

@@ -0,0 +1,2 @@
+all
+rule "MD013", ignore_code_blocks: true

data/.mdlrc

@@ -0,0 +1,2 @@
+style File.expand_path("../.mdl_rules.rb", __FILE__)
+git_recurse true

data/.quiet_quality.yml

@@ -0,0 +1,8 @@
+---
+default_tools: ["standardrb", "rubocop", "markdown_lint", "rspec"]
+executor: concurrent
+comparison_branch: main
+changed_files: false
+filter_messages: false
+logging: light
+colorize: true

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,21 @@
+---
+AllCops:
+  SuggestExtensions: false
+  DisabledByDefault: true
+
+Metrics/AbcSize:
+  Max: 15
+Metrics/CyclomaticComplexity:
+  Max: 8
+Metrics/PerceivedComplexity:
+  Max: 7
+
+Metrics/ClassLength:
+  CountComments: false
+  Max: 150
+Metrics/MethodLength:
+  CountComments: false
+  Max: 15
+Metrics/ParameterLists:
+  Max: 5
+  CountKeywordArgs: true

data/README.md

@@ -1,138 +1,116 @@
 # RSpec::CoverIt
 
-Still a work in progress, but this gem is intended to give us a simpler and
-more _targeted_ way to manage coverage. The usual system for a large project
-is a single overarching SimpleCov target; with good tooling, there will be
-something checking that all of the lines of each PR get covered by the tests
-in that PR, and there are checks that the overall coverage number doesn't drop
-too far.. but it's a _sloppy, messy, lossy_ approach. Code loses coverage,
-code gets added with no tests, tests get removed and other code becomes less
-covered, and a lot of the time, that's because the _coverage is a lie_.
-
-Your coverage tool is telling you.. how many times each line of code _got run_
-during your entire test suite. But it's not telling you what is doing the
-running, which means that often large swathes of code are actually only covered
-incidentally, through tests that aren't intended to exercise that code, but
-_happens to_.
-
-This approach was moderately inspired by https://github.com/jamesdabbs/rspec-coverage,
-which was itself apparently inspired by a rubyconf 2016 talk by Ryan Davis. That
-talk and library are mostly concerned with making sure that we don't _overcount_
-coverage though, while this one has three goals:
-
-1. Make coverage enforcement simpler
-1. Enforce coverage _in the test suite_ (or nearly so)
-1. Make coverage enforcement more local and specific.
-
-## Tentative Usage
-
-Note that this bit isn't really implemented, but is more of an outline of how I
-intend the library to work. This is currently a spike, and not a functioning gem.
-
-You set up `RSpec::CoverIt` in your `spec_helper.rb` - require `rspec/cover_it`,
-and then `RSpec::CoverIt.setup(**config_options)` (before loading your code, as
-you would with any other coverage library). It's.. _semi_ compatible with other
-coverage systems - it only starts Coverage if it's not already running, and it
-only uses `peek_result`, so it doesn't affect other systems outcomes.
-Rough configuration options:
-
-* `filter`: Only paths starting with this (matching this regex?) can matter
-* `autoenforce`: off by default - with this disabled, you turn on coverage
-  enforcement for a given top-level describe ExampleGroup by adding metadata
-  like `cover_it: true` or `cover_it: 95`. If it's enabled though, you instead
-  can turn enforcement _off_ for an example group by setting `cover_it: false`.
-* `global_threshold`: 100% by default. This whole "90% coverage is the right
-  target" thing is mostly a side-effect of the way we check the entire project
-  under one number.. but it's an easy setting to support, and I'm sure people
-  will disagree with me.
-
-## Example Group Metadata
-
-In example groups, you can use metadata to control the behavior of
-`rspec-cover_it`. These keys have meaning:
-
-* `cover_it`: if boolean, it enables or disables the coverage enforcement for
-  this ExampleGroup. If numeric, it's enabling, and specifying the coverage
-  threshold at the same time (as a percentage - `cover_it: 95` requires 95%
-  coverage of the target class by this example group).
-* `covers_path`: The path (relative to the spec file!) of the code the spec is
-  intending to cover. Later, this can be an array of paths, for the multi-spec
-  case `covers` is intended for as well. This is an annoying work-around for
-  the fact that we can't perfectly infer the location of the source code in
-  some cases - in particular, `lib/foo/version.rb` tends to cause a problem
-  for specs on `foo.rb`, since the version file is invariably loaded first.
-  Note - in gems, this _frequently_ also happens when you glob-load a directory
-  _before_ defining the namespace they are all loading objects into. Then the
-  first file in that directory that loads ends up being the one that actually
-  creates the namespace.
-* `covers`: An array of classes and modules that this example groups _thinks
-  it is completely testing_. Ideally, you'd have a separate test file for each,
-  but sometimes that's hard to do - you can let one spec claim responsibility
-  for multiple classes and modules (such as Concerns) using this. Be default
-  it is just `[described_class]`. Additionally, if your top-level example
-  group _does not describe a Class or Module_, you may use `covers` to let it
-  invoke `rspec-cover_it` anyway - some people `describe "a descriptive string"`
-  instead of `describe AClass`, and .. fine.
-
-## Implementation
-
-We record the coverage information in a `before(:suite)` rspec hook using
-`Coverage.peek_result`, and hold onto that information. Then before and after
-each 'context' (which really amounts to 'each spec file'), we grab the coverage
-information again.
-
-We use `Object.const_source_location` to find the file that defines the
-`described_class`, and _that_ is what is being assessed for coverage. This
-means that, if you are reopening the class somewhere else, that coverage won't
-be checked; if you are including 15 Concerns, and don't intend to write separate
-specs for them, be sure to list them as `covers:` metadata on the test. Also,
-shame!
-
-## Output
-
-When there's missing coverage on the class under test, you'll currently see
-output like this:
+The standard approach to monitoring "test coverage" in ruby is a tool called
+[SimpleCov](https://github.com/simplecov-ruby/simplecov), and a variety of
+systems made to hook into its output, to display a single number that represents
+how much of your _total code_ is executed during your test suite. You set up
+SimpleCov, and then you commit your team to maintaining whatever test coverage
+number you already have achieved globally, or to improving that coverage number.
+If you have one of the better tools, you can commit to things like "all merged
+PRs should have 100% (or 95%, etc) coverage on all of their touched code."
+
+That's.. better than nothing. A lot better - it can especially tell you when you
+forgot to write tests for some component, or when you're adjusting a class that
+doesn't have any tests written for it. But it's _not great_, not compared to a
+system like RSpec that lets you specify with _granularity_ how things should
+behave. The problem with SimpleCov is that it's _holistic_ - you can't adopt
+simplecov one class at a time, or enforce full coverage on new code _in your
+CI system_, you need external tooling with state persistence for that.
+
+`RSpec::CoverIt` takes a different approach, somewhat inspired by the
+[rspec-coverage](https://github.com/jamesdabbs/rspec-coverage) gem (which was
+itself apparently inspired by a rubyconf-2016 talk by Ryan Davis). With CoverIt,
+coverage-enforcement happens as part of your test-suite, enforced by rspec
+either globally or as specified.
+
+## Installation and Setup
+
+Add the gem to your Gemfile or gemspec just like `simplecov` or `rspec`. Then
+in your `spec_helper.rb`, _before_ you require your application or gem code,
+require `rspec/cover_it`, and then invoke `RSpec::CoverIt.setup`, with the
+appropriate options to configure it (described further down). A reasonable
+initial setup might look like this:
 
 ```
-❯ rspec
-
-Randomized with seed 29392
-...............................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................
-An error occurred in an `after(:context)` hook.
-Failure/Error: fail(MissingCoverage, message)
-  Missing coverage in /Users/emueller/src/quiet_quality/lib/quiet_quality/message.rb on line 7
-# /Users/emueller/src/rspec-cover_it/lib/rspec/cover_it/context_coverage.rb:40:in `enforce!'
-# /Users/emueller/src/rspec-cover_it/lib/rspec/cover_it/coverage_state.rb:37:in `block in finish_tracking_for'
-# /Users/emueller/src/rspec-cover_it/lib/rspec/cover_it/coverage_state.rb:35:in `finish_tracking_for'
-# /Users/emueller/src/rspec-cover_it/lib/rspec/cover_it.rb:26:in `block (2 levels) in setup'
-.....................................................................................................................................................................................................................................................................................................
-
-Finished in 1.06 seconds (files took 0.28925 seconds to load)
-852 examples, 0 failures, 1 error occurred outside of examples
+require "rspec/cover_it"
+project_root = File.expand_path("../..", __FILE__)
+RSpec::CoverIt.setup(filter: project_root, autoenforce: true)
+
+require File.expand_path("../../lib/my_gem", __FILE__)
 ```
 
-## Drawbacks and Shortcomings
-
-There's nothing in here that stops you from failing to write tests for a class
-at all! If you're using SimpleCov and you've got 100% coverage already, that's
-one of the benefits.. I could pretty reasonably include some kind of
-`after(:suite)` hook that optionally checks net coverage, but.. simplecov does
-that, and the concurrent-testing game makes this a _painful_ topic in reality.
-That's not the goal here, and I'm not going to worry about it.
-
-As initially implemented, it fails your tests if you don't run the entire test
-file. `rspec spec/foo_spec.rb:32` will error, because .. running only one of
-your tests _doesn't cover the class_. I have a solution for this, but it uses
-some non-public bits of RSpec, so I'm trying to find a better answer still.
-(Conversation started in their
-[issue tracker](https://github.com/rspec/rspec-core/issues/3037))
-
-We're using `Object.const_source_location` to find the path of the source file
-defining a given constant. That _mostly_ works, but it actually gives the path
-of the _first_ source file that defined that constant. So if your gem defines
-its version in `lib/foo/version.rb` (as an example), in a separate file from
-lib/foo.rb, the _path_ for `Foo` may end up being the former. Which is.. not
-going to have much coverable code, of course. This is an edge case, but one
-that is likely to occur fairly regularly. I haven't thought of a _good_ solution
-yet. Perhaps if the `covers` array includes a string, we should treat it as a
-relative path?
+## Configuration and Usage
+
+When invoking `RSpec::CoverIt.setup`, you may supply these options:
+
+* `filter`: Don't track coverage information about files that don't start with
+  this prefix - this is largely a performance optimization, allowing the pretest
+  coverage tracking to track information only about the current project, and not
+  the various gems it might depend on.
+* `autoenforce`: This is off by default, which means that coverage-enforcement
+  will only be applied to top-level example groups that _request_ it, by
+  supplying the `cover_it: true` spec metaddata. If you configure `autoenforce`
+  to be `true`, then all specs will attempt to enforce coverage, as long as they
+  can figure out their targets (unless they are told not to).
+
+When setting up a test file, you can configure some additional details for that
+example group - `CoverIt` is aware of the following bits of spec metadata:
+
+* `cover_it`: If supplied with a truthy value, it activates coverage enforcement
+  for this example-group - if supplied with a falsey value, it _deactivates_
+  enforcement. If supplied with a _numeric_ value, it is treated as a percentage,
+  and used to configure the target coverage threshold for the class' definition,
+  a feature which I intend not to use, but I expect some people to care deeply
+  about.
+* `covers_path`: in certain cases, a class or module may be "defined" in several
+  locations. While actually enforcing coverage for multiple code files from one
+  test file isn't yet implemented, if `rspec-cover_it` infers the location of
+  the code under test _incorrectly_, you can tell it where to actually enforce
+  coverage against by supplying a path here (relative to the directory
+  containing the test file).
+
+## Implementation Approach
+
+When setting up the tool, we activate the built-in ruby Coverage system (we
+start it in legacy-supporting mode, but we are compatible with it having already
+been started in the more modern mode as well). Then we register three rspec
+hooks:
+
+* Before the suite _starts_ (which should be after everything is loaded), we
+  record the coverage _so far_ - this is the 'initialization' coverage, which
+  mostly includes the lines that run during class evaluation.
+* Before each 'context' (spec file), we record the coverage information
+* After each 'context' we record the coverage information _again_. Then we
+  subtract the two sets of coverage, which tells us how many times each line
+  was run _during this example group_, and add it to the 'initialization'
+  coverage to see the effective coverage for just this test file.
+
+Then, for each test file, we use ruby's source-introspection system to tell
+us where the "described class" was defined, and check what fraction of that
+source file is effectively covered by this example group. If there is some
+missing coverage, we raise an exception explaining the missing coverage.
+
+But of course, if you only run part of the tests in a spec file (perhaps by
+specifying a line number, or a description filter with `-e`), it probably won't
+be fully covered. We don't want to fail the test suite every time you're working
+on the specs for something, so we reach into RSpec a little to check if the
+set of _filtered_ examples (the ones being run) match the _full_ set of
+examples. If they don't, don't bother checking coverage for this test file.
+
+## Caveats and Shortcomings
+
+For the moment, there is no support for _autoloading_, which makes this library
+awkward to use for the majority of large rails applications. I intend to resolve
+this issue soon, but it's not a trivial one, as coverage-tracking on a per-spec
+basis relies on being able to separate coverage that happens during code-loading
+from coverage that happens during "tests other than this spec which have already
+occurred" - we'll need to add some kind of autoloading hooks to support it
+properly.
+
+Until then, the gem will only be useful to a rails application in an eager-
+loaded context - that's not a major issue in CI, but it's awkward when running
+tests locally. Happily, `rspec-cover_it` is fully compatible with `simplecov`
+(though you do need to start `SimpleCov` _before_ `Rspec::CoverIt`), so you can
+simply use simplecov locally when resolving coverage issues (or set up eager-
+loading locally based on an environment variable, the solution I prefer), and
+still use `RSpec::CoverIt` to enforce coverage in your CI system.

data/lib/rspec/cover_it/context.rb

@@ -24,10 +24,6 @@ module RSpec
         metadata.fetch(:described_class, nil)
       end
 
-      def target_class_name
-        target_class.name
-      end
-
       def scope_name
         scope.file_path
       end
@@ -55,7 +51,8 @@ module RSpec
       end
 
       def inferred_path
-        Object.const_source_location(target_class_name).first
+        return nil if target_class.nil?
+        Object.const_source_location(target_class.name).first
       end
     end
   end

data/lib/rspec/cover_it/context_coverage.rb

@@ -8,23 +8,22 @@ module RSpec
 
       attr_accessor :precontext_coverage, :postcontext_coverage
 
-      def pretest_coverage
-        @_pretest_coverage ||= pretest_results[target_path]
-      end
-
       def local_coverage
-        return nil unless precontext_coverage && postcontext_coverage
+        assert_ready!
+        return nil unless precontext_coverage && postcontext_coverage && coverable_lines?
         @_local_coverage ||= pretest_coverage
           .zip(precontext_coverage, postcontext_coverage)
           .map { |a, b, c| line_calculation(a, b, c) }
       end
 
       def local_coverage_rate
+        assert_ready!
         return nil unless covered_line_count
         covered_line_count.to_f / coverable_line_count.to_f
       end
 
       def enforce!(default_threshold:)
+        assert_ready!
         if precovered?
           fail_with_missing_code!
         elsif local_coverage_rate < (context.specific_threshold || default_threshold)
@@ -34,6 +33,19 @@ module RSpec
 
       private
 
+      def pretest_coverage
+        @_pretest_coverage ||= pretest_results[target_path]
+      end
+
+      def coverable_lines?
+        pretest_coverage.compact.any?
+      end
+
+      def assert_ready!
+        return if precontext_coverage && postcontext_coverage
+        fail(NotReady, "ContextCoverage was not ready yet, something has gone wrong")
+      end
+
       def fail_with_missing_code!
         fail(MissingCode, <<~MESSAGE.tr("\n", " "))
           Example group `#{context.scope_name}` is attempting to cover the code for class
@@ -46,21 +58,37 @@ module RSpec
         MESSAGE
       end
 
+      def uncovered_lines
+        @_uncovered_lines ||= local_coverage.each_with_index.select { |v, _i| v&.zero? }.map(&:last)
+      end
+
+      def single_uncovered_line_summary
+        "on line #{uncovered_lines.first}"
+      end
+
+      def few_uncovered_lines_summary
+        "on lines #{uncovered_lines.map(&:to_s).join(", ")}"
+      end
+
+      def many_uncovered_lines_summary
+        shortened_list = uncovered_lines.first(10).map(&:to_s).join(", ")
+        "on #{uncovered_lines.length} lines, including #{shortened_list}"
+      end
+
+      def uncovered_lines_summary
+        if uncovered_lines.length == 1
+          single_uncovered_line_summary
+        elsif uncovered_lines.length <= 10
+          few_uncovered_lines_summary
+        else
+          many_uncovered_lines_summary
+        end
+      end
+
       def fail_with_missing_coverage!
-        lines = local_coverage.each_with_index.select { |v, _i| v&.zero? }.map(&:last)
-
-        summary =
-          if lines.length == 1
-            "on line #{lines.first}"
-          elsif lines.length <= 10
-            "on lines #{lines.map(&:to_s).join(", ")}"
-          else
-            "on #{lines.length} lines, including #{lines.first(10).map(&:to_s).join(", ")}"
-          end
-
-        fail(MissingCoverage, <<~MESSAGE.tr("\n", " "))
+        fail(MissingCoverage, <<~MESSAGE.tr("\n", " ").strip)
           Example group `#{context.scope_name}` is missing coverage on
-          `#{context.target_class}` in `#{context.target_path}` #{summary}
+          `#{context.target_class}` in `#{context.target_path}` #{uncovered_lines_summary}
         MESSAGE
       end
 

data/lib/rspec/cover_it/coverage_state.rb

@@ -1,7 +1,8 @@
 module RSpec
   module CoverIt
     class CoverageState
-      attr_reader :filter
+      attr_accessor :pretest_results
+      attr_reader :filter, :context_coverages
 
       def initialize(filter: nil, autoenforce: false, default_threshold: 100.0)
         @filter, @autoenforce, @default_threshold = filter, autoenforce, default_threshold
@@ -23,25 +24,22 @@ module RSpec
         context = context_for(scope, rspec_context)
         return unless context.cover_it?
 
-        context_coverage_for(context).tap do |context_coverage|
-          context_coverage.precontext_coverage = get_current_coverage(context.target_path)
-        end
+        context_coverage = ContextCoverage.new(context: context, pretest_results: pretest_results)
+        context_coverage.precontext_coverage = get_current_coverage(context.target_path)
+        @context_coverages[context.target_class] = context_coverage
       end
 
       def finish_tracking_for(scope, rspec_context)
         context = context_for(scope, rspec_context)
         return unless context.cover_it?
 
-        context_coverage_for(context).tap do |context_coverage|
-          context_coverage.postcontext_coverage = get_current_coverage(context.target_path)
-          context_coverage.enforce!(default_threshold: default_threshold_rate)
-        end
+        context_coverage = @context_coverages.fetch(context.target_class)
+        context_coverage.postcontext_coverage = get_current_coverage(context.target_path)
+        context_coverage.enforce!(default_threshold: default_threshold_rate)
       end
 
       private
 
-      attr_reader :pretest_results
-
       def autoenforce?
         @autoenforce
       end
@@ -54,25 +52,16 @@ module RSpec
         Context.new(scope: scope, rspec_context: rspec_context, autoenforce: autoenforce?)
       end
 
-      def context_coverage_for(context)
-        @context_coverages[context.target_class] ||= ContextCoverage.new(
-          context: context,
-          pretest_results: pretest_results
-        )
-      end
-
       def get_current_coverage(path = nil)
         result = Coverage.peek_result
 
         if path
           value = result[path]
           value.is_a?(Hash) ? value.fetch(:lines) : value
+        elsif result.any? { |_k, v| v.is_a?(Hash) }
+          result.transform_values { |v| v.fetch(:lines) }
         else
-          if result.any? { |_k, v| v.is_a?(Hash) }
-            result.transform_values { |v| v.fetch(:lines) }
-          else
-            result
-          end
+          result
         end
       end
     end

data/lib/rspec/cover_it/version.rb

@@ -1,5 +1,5 @@
 module RSpec
   module CoverIt
-    VERSION = "0.0.7"
+    VERSION = "0.1.0"
   end
 end

data/lib/rspec/cover_it.rb

@@ -3,6 +3,7 @@ require "coverage"
 module RSpec
   module CoverIt
     Error = Class.new(StandardError)
+    NotReady = Class.new(Error)
     MissingCode = Class.new(Error)
     MissingCoverage = Class.new(Error)
   end
@@ -19,10 +20,19 @@ module RSpec
 
     def self.setup(filter: nil, autoenforce: false)
       RSpec::CoverIt.state = CoverageState.new(filter: filter, autoenforce: autoenforce)
-      RSpec::CoverIt.state.start_tracking
+      setup_pretest_tracking
+      setup_per_context_tracking
+    end
 
+    private_class_method def self.setup_pretest_tracking
+      RSpec::CoverIt.state.start_tracking
       RSpec.configure do |config|
         config.prepend_before(:suite) { RSpec::CoverIt.state.finish_load_tracking }
+      end
+    end
+
+    private_class_method def self.setup_per_context_tracking
+      RSpec.configure do |config|
         config.prepend_before(:context) { |context| RSpec::CoverIt.state.start_tracking_for(self.class, context) }
         config.append_after(:context) { |context| RSpec::CoverIt.state.finish_tracking_for(self.class, context) }
       end

data/rspec-cover_it.gemspec

@@ -31,6 +31,8 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "pry", "~> 0.14"
   spec.add_development_dependency "standard", "~> 1.28"
+  spec.add_development_dependency "rubocop", "~> 1.28"
   spec.add_development_dependency "mdl", "~> 0.12"
   spec.add_development_dependency "quiet_quality", "~> 1.2"
+  spec.add_development_dependency "simplecov", "~> 0.22.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rspec-cover_it
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.1.0
 platform: ruby
 authors:
 - Eric Mueller
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-06-07 00:00:00.000000000 Z
+date: 2023-06-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.28'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.28'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.28'
 - !ruby/object:Gem::Dependency
   name: mdl
   requirement: !ruby/object:Gem::Requirement
@@ -80,6 +94,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.22.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.22.0
 description: |
   We're all used to tools that enforce _total_ coverage numbers, but this gem
   tries for something different. Instead of keeping your whole project above
@@ -91,7 +119,14 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/linters.yml"
+- ".github/workflows/rspec.yml"
 - ".gitignore"
+- ".mdl_rules.rb"
+- ".mdlrc"
+- ".quiet_quality.yml"
+- ".rspec"
+- ".rubocop.yml"
 - Gemfile
 - LICENSE
 - README.md