test-prof 0.10.2 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bfc20add611581574506a80294e893a77997e5905ba0fe521838fbdd190b2360
-  data.tar.gz: 6f0505b7f2b96c65624b81ee9fd4c086b387d7c8efdc7150e0409062efd712a7
+  metadata.gz: e2060dd26a4bec62bd9a3b699e1165c60b8914a74c9fc25b3a0edf84afbd7d2b
+  data.tar.gz: 9b8e3eb78764c130ae78a575a5cdfe5d9e9a440d7b748c108b5088d99dc7261d
 SHA512:
-  metadata.gz: ca925fb486b3b3e1aff9508b670c19028bfe6b0a5b1c3dfe8d3f69b1de74b8cf19187497eb9c899dfae5cacab8390966a58e08ee2f80705cb62b61b2f002686a
-  data.tar.gz: 65a5ab2c334fdb2625ce450a7184316946cdabe684d052b260e6911648d5f94200e888a083b0b31cb078e4391f106875e0cad145599b7a1a71bfc4cbaf77c10a
+  metadata.gz: 6998b3cb30fa82bf6b2311dfa733f0c32694964741aa923b1300115d670c0cfc7e834ad55a9a9b4295e5b02e85d18e529d75d775b16d00ecc44956bee30231aa
+  data.tar.gz: b42a91195b9e6a49522bd33ede09ae9ee769b7ee1678de97d2a0bcf593ab076811f20938f2f2deabe864e22e6c9cab5b0e1b7431da91492b9d7959e7b6b52769

data/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## master (unreleased)
 
+## 0.11.0 (2020-02-09)
+
+- Fix `let_it_be` issue when initialized with an array/enumerable or an AR relation. ([@pirj][])
+
+- Improve `RSpec/AggregateExamples` (formerly `RSpec/AggregateFailures`) cop. ([@pirj][])
+
 ## 0.10.2 (2020-01-07) 🎄
 
 - Fix Ruby 2.7 deprecations. ([@lostie][])
@@ -515,3 +521,4 @@ Fixes [#10](https://github.com/palkan/test-prof/issues/10).
 [@Envek]: https://github.com/Envek
 [@tyleriguchi]: https://github.com/tyleriguchi
 [@lostie]: https://github.com/lostie
+[@pirj]: https://github.com/pirj

data/lib/test_prof/any_fixture.rb

@@ -80,6 +80,11 @@ module TestProf
       end
 
       def report_stats
+        if cache.stats.empty?
+          log :info, "AnyFixture has not been used"
+          return
+        end
+
         msgs = []
 
         msgs <<

data/lib/test_prof/cops/inject.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# This is shamelessly borrowed from RuboCop RSpec
+# https://github.com/rubocop-hq/rubocop-rspec/blob/master/lib/rubocop/rspec/inject.rb
+module RuboCop
+  # Because RuboCop doesn't yet support plugins, we have to monkey patch in a
+  # bit of our configuration.
+  module Inject
+    PROJECT_ROOT = Pathname.new(__dir__).parent.parent.parent.expand_path.freeze
+    CONFIG_DEFAULT = PROJECT_ROOT.join("config", "default.yml").freeze
+
+    def self.defaults!
+      path = CONFIG_DEFAULT.to_s
+      hash = ConfigLoader.send(:load_yaml_configuration, path)
+      config = Config.new(hash, path)
+      puts "configuration from #{path}" if ConfigLoader.debug?
+      config = ConfigLoader.merge_with_default(config, path)
+      ConfigLoader.instance_variable_set(:@default_configuration, config)
+    end
+  end
+end
+
+RuboCop::Inject.defaults!

data/lib/test_prof/cops/rspec/aggregate_examples.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+require_relative "aggregate_examples/line_range_helpers"
+require_relative "aggregate_examples/metadata_helpers"
+require_relative "aggregate_examples/node_matchers"
+
+require_relative "aggregate_examples/its"
+require_relative "aggregate_examples/matchers_with_side_effects"
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks if example groups contain two or more aggregatable examples.
+      #
+      # @see https://github.com/rubocop-hq/rspec-style-guide#expectations-per-example
+      #
+      # This cop is primarily for reducing the cost of repeated expensive
+      # context initialization.
+      #
+      # @example
+      #
+      #   # bad
+      #   describe do
+      #     specify do
+      #       expect(number).to be_positive
+      #       expect(number).to be_odd
+      #     end
+      #
+      #     it { is_expected.to be_prime }
+      #   end
+      #
+      #   # good
+      #   describe do
+      #     specify do
+      #       expect(number).to be_positive
+      #       expect(number).to be_odd
+      #       is_expected.to be_prime
+      #     end
+      #   end
+      #
+      #   # fair - subject has side effects
+      #   describe do
+      #     specify do
+      #       expect(multiply_by(2)).to be_multiple_of(2)
+      #     end
+      #
+      #     specify do
+      #       expect(multiply_by(3)).to be_multiple_of(3)
+      #     end
+      #   end
+      #
+      # Block expectation syntax is deliberately not supported due to:
+      #
+      # 1. `subject { -> { ... } }` syntax being hard to detect, e.g. the
+      #    following looks like an example with non-block syntax, but it might
+      #    be, depending on how the subject is defined:
+      #
+      #        it { is_expected.to do_something }
+      #
+      #    If the subject is defined in a `shared_context`, it's impossible to
+      #    detect that at all.
+      #
+      # 2. Aggregation should use composition with an `.and`. Also, aggregation
+      #    of the `not_to` expectations is barely possible when a matcher
+      #    doesn't provide a negated variant.
+      #
+      # 3. Aggregation of block syntax with non-block syntax should be in a
+      #    specific order.
+      #
+      # RSpec [comes with an `aggregate_failures` helper](https://relishapp.com/rspec/rspec-expectations/docs/aggregating-failures)
+      # not to fail the example on first unmet expectation that might come
+      # handy with aggregated examples.
+      # It can be [used in metadata form](https://relishapp.com/rspec/rspec-core/docs/expectation-framework-integration/aggregating-failures#use-%60:aggregate-failures%60-metadata),
+      # or [enabled globally](https://relishapp.com/rspec/rspec-core/docs/expectation-framework-integration/aggregating-failures#enable-failure-aggregation-globally-using-%60define-derived-metadata%60).
+      #
+      # @example Globally enable `aggregate_failures`
+      #
+      #   # spec/spec_helper.rb
+      #   config.define_derived_metadata do |metadata|
+      #     unless metadata.key?(:aggregate_failures)
+      #       metadata[:aggregate_failures] = true
+      #     end
+      #   end
+      #
+      # To match the style being used in the spec suite, AggregateExamples
+      # can be configured to add `:aggregate_failures` metadata to the
+      # example or not. The option not to add metadata can be also used
+      # when it's not desired to make expectations after previously failed
+      # ones, commonly known as fail-fast.
+      #
+      # The terms "aggregate examples" and "aggregate failures" not to be
+      # confused. The former stands for putting several expectations to
+      # a single example. The latter means to run all the expectations in
+      # the example instead of aborting on the first one.
+      #
+      # @example AddAggregateFailuresMetadata: true (default)
+      #
+      #   # Metadata set using a symbol
+      #   specify(:aggregate_failures) do
+      #     expect(number).to be_positive
+      #     expect(number).to be_odd
+      #   end
+      #
+      # @example AddAggregateFailuresMetadata: false
+      #
+      #   specify do
+      #     expect(number).to be_positive
+      #     expect(number).to be_odd
+      #   end
+      #
+      class AggregateExamples < Cop
+        include LineRangeHelpers
+        include MetadataHelpers
+        include NodeMatchers
+
+        # Methods from the following modules override and extend methods of this
+        # class, extracting specific behavior.
+        prepend Its
+        prepend MatchersWithSideEffects
+
+        MSG = "Aggregate with the example at line %d."
+
+        def on_block(node)
+          example_group_with_several_examples(node) do |all_examples|
+            example_clusters(all_examples).each do |_, examples|
+              examples[1..-1].each do |example|
+                add_offense(example,
+                  location: :expression,
+                  message: message_for(example, examples[0]))
+              end
+            end
+          end
+        end
+
+        def autocorrect(example_node)
+          clusters = example_clusters_for_autocorrect(example_node)
+          return if clusters.empty?
+
+          lambda do |corrector|
+            clusters.each do |metadata, examples|
+              range = range_for_replace(examples)
+              replacement = aggregated_example(examples, metadata)
+              corrector.replace(range, replacement)
+              examples[1..-1].map { |example| drop_example(corrector, example) }
+            end
+          end
+        end
+
+        private
+
+        # Clusters of examples in the same example group, on the same nesting
+        # level that can be aggregated.
+        def example_clusters(all_examples)
+          all_examples
+            .select { |example| example_with_expectations_only?(example) }
+            .group_by { |example| metadata_without_aggregate_failures(example) }
+            .select { |_, examples| examples.count > 1 }
+        end
+
+        # Clusters of examples that can be aggregated without losing any
+        # information (e.g. metadata or docstrings)
+        def example_clusters_for_autocorrect(example_node)
+          examples_in_group = example_node.parent.each_child_node(:block)
+            .select { |example| example_for_autocorrect?(example) }
+          example_clusters(examples_in_group)
+        end
+
+        def message_for(_example, first_example)
+          format(MSG, first_example.loc.line)
+        end
+
+        def drop_example(corrector, example)
+          aggregated_range = range_by_whole_lines(example.source_range,
+            include_final_newline: true)
+          corrector.remove(aggregated_range)
+        end
+
+        def aggregated_example(examples, metadata)
+          base_indent = " " * examples.first.source_range.column
+          metadata = metadata_for_aggregated_example(metadata)
+          [
+            "#{base_indent}specify#{metadata} do",
+            *examples.map { |example| transform_body(example, base_indent) },
+            "#{base_indent}end\n"
+          ].join("\n")
+        end
+
+        # Extracts and transforms the body, keeping proper indentation.
+        def transform_body(node, base_indent)
+          "#{base_indent}  #{new_body(node)}"
+        end
+
+        def new_body(node)
+          node.body.source
+        end
+      end
+    end
+  end
+end

data/lib/test_prof/cops/rspec/aggregate_examples/its.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      class AggregateExamples < Cop
+        # @example `its`
+        #
+        #   # Supports regular `its` call with an attribute/method name,
+        #   # or a chain of methods expressed as a string with dots.
+        #
+        #   its(:one) { is_expected.to be(true) }
+        #   its('two') { is_expected.to be(false) }
+        #   its('phone_numbers.size') { is_expected.to be 2 }
+        #
+        # @example `its` with single-element array argument
+        #
+        #   # Also supports single-element array argument.
+        #
+        #   its(['headers']) { is_expected.to include(encoding: 'text') }
+        #
+        # @example `its` with multi-element array argument is ambiguous
+        #
+        #   # Does not support `its` with multi-element array argument due to
+        #   # an ambiguity. Transformation depends on the type of the subject:
+        #   # - a Hash: `hash[element1][element2]...`
+        #   # - and arbitrary type: `hash[element1, element2, ...]`
+        #   # It is impossible to infer the type to propose a proper correction.
+        #
+        #   its(['ambiguous', 'elements']) { ... }
+        #
+        # @example `its` with metadata
+        #
+        #   its('header', html: true) { is_expected.to include(text: 'hello') }
+        #
+        module Its
+          extend RuboCop::NodePattern::Macros
+
+          private
+
+          # It's impossible to aggregate `its` body as is, it needs to be
+          # converted to `expect(subject.something).to ...`
+          def new_body(node)
+            return super unless its?(node)
+
+            transform_its(node.body, node.send_node.arguments)
+          end
+
+          def transform_its(body, arguments)
+            argument = arguments.first
+            replacement = case argument.type
+                          when :array
+                            key = argument.values.first
+                            "expect(subject[#{key.source}])"
+                          else
+                            property = argument.value
+                            "expect(subject.#{property})"
+            end
+            body.source.gsub(/is_expected|are_expected/, replacement)
+          end
+
+          def example_metadata(example)
+            return super unless its?(example.send_node)
+
+            # First parameter to `its` is not metadata.
+            example.send_node.arguments[1..-1]
+          end
+
+          def its?(node)
+            node.method_name == :its
+          end
+
+          # In addition to base definition, matches examples with:
+          #   - no `its` with an multiple-element array argument due to
+          #     an ambiguity, when SUT can be a hash, and result will be defined
+          #     by calling `[]` on SUT subsequently, e.g. `subject[one][two]`,
+          #     or any other type of object implementing `[]`, and then all the
+          #     array arguments are passed to `[]`, e.g. `subject[one, two]`.
+          def_node_matcher :example_for_autocorrect?, <<-PATTERN
+            [
+              #super
+              !#its_with_multi_element_array_argument?
+              !#its_with_send_or_var_argument?
+            ]
+          PATTERN
+
+          def_node_matcher :its_with_multi_element_array_argument?, <<-PATTERN
+            (block (send nil? :its (array _ _ ...)) ...)
+          PATTERN
+
+          def_node_matcher :its_with_send_or_var_argument?, <<-PATTERN
+            (block (send nil? :its { send lvar ivar cvar gvar const }) ...)
+          PATTERN
+        end
+      end
+    end
+  end
+end

data/lib/test_prof/cops/rspec/aggregate_examples/line_range_helpers.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      class AggregateExamples < Cop
+        # @internal Support methods for keeping newlines around examples.
+        module LineRangeHelpers
+          include RangeHelp
+
+          private
+
+          def range_for_replace(examples)
+            range = range_by_whole_lines(examples.first.source_range,
+              include_final_newline: true)
+            next_range = range_by_whole_lines(examples[1].source_range)
+            if adjacent?(range, next_range)
+              range.resize(range.length + 1)
+            else
+              range
+            end
+          end
+
+          def adjacent?(range, another_range)
+            range.end_pos + 1 == another_range.begin_pos
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_prof/cops/rspec/aggregate_examples/matchers_with_side_effects.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative "../language"
+
+module RuboCop
+  module Cop
+    module RSpec
+      class AggregateExamples < Cop
+        # When aggregated, the expectations will fail when not supposed to or
+        # have a risk of not failing when expected to. One example is
+        # `validate_presence_of :comment` as it leaves an empty comment after
+        # itself on the subject making it invalid and the subsequent expectation
+        # to fail.
+        # Examples with those matchers are not supposed to be aggregated.
+        #
+        # @example MatchersWithSideEffects
+        #
+        #   # .rubocop.yml
+        #   # RSpec/AggregateExamples:
+        #   #   MatchersWithSideEffects:
+        #   #   - allow_value
+        #   #   - allow_values
+        #   #   - validate_presence_of
+        #
+        #   # bad, but isn't automatically correctable
+        #   describe do
+        #     it { is_expected.to validate_presence_of(:comment) }
+        #     it { is_expected.to be_valid }
+        #   end
+        #
+        # @internal
+        #   Support for taking special care of the matchers that have side
+        #   effects, i.e. leave the subject in a modified state.
+        module MatchersWithSideEffects
+          extend RuboCop::NodePattern::Macros
+          include RuboCop::Cop::RSpec::Language
+
+          MSG_FOR_EXPECTATIONS_WITH_SIDE_EFFECTS =
+            "Aggregate with the example at line %d. IMPORTANT! Pay attention " \
+            "to the expectation order, some of the matchers have side effects."
+
+          private
+
+          def message_for(example, first_example)
+            return super unless example_with_side_effects?(example)
+
+            format(MSG_FOR_EXPECTATIONS_WITH_SIDE_EFFECTS, first_example.loc.line)
+          end
+
+          def matcher_with_side_effects_names
+            cop_config.fetch("MatchersWithSideEffects", [])
+              .map(&:to_sym)
+          end
+
+          def matcher_with_side_effects_name?(matcher_name)
+            matcher_with_side_effects_names.include?(matcher_name)
+          end
+
+          # In addition to base definition, matches examples with:
+          # - no matchers known to have side-effects
+          def_node_matcher :example_for_autocorrect?, <<-PATTERN
+            [ #super !#example_with_side_effects? ]
+          PATTERN
+
+          # Matches the example with matcher with side effects
+          def_node_matcher :example_with_side_effects?, <<-PATTERN
+            (block #{Examples::EXAMPLES.send_pattern} _ #expectation_with_side_effects?)
+          PATTERN
+
+          # Matches the expectation with matcher with side effects
+          def_node_matcher :expectation_with_side_effects?, <<-PATTERN
+            (send #expectation? #{Runners::ALL.node_pattern_union} #matcher_with_side_effects?)
+          PATTERN
+
+          # Matches the matcher with side effects
+          def_node_search :matcher_with_side_effects?, <<-PATTERN
+            (send nil? #matcher_with_side_effects_name? ...)
+          PATTERN
+        end
+      end
+    end
+  end
+end

data/lib/test_prof/cops/rspec/aggregate_examples/metadata_helpers.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      class AggregateExamples < Cop
+        # @internal
+        #   Support methods for example metadata.
+        #   Examples with similar metadata are grouped.
+        #
+        #   Depending on the configuration, `aggregate_failures` metadata
+        #   is added to aggregated examples.
+        module MetadataHelpers
+          private
+
+          def metadata_for_aggregated_example(metadata)
+            metadata_to_add = metadata.compact.map(&:source)
+            if add_aggregate_failures_metadata?
+              metadata_to_add.unshift(":aggregate_failures")
+            end
+            if metadata_to_add.any?
+              "(#{metadata_to_add.join(", ")})"
+            else
+              ""
+            end
+          end
+
+          # Used to group examples for aggregation. `aggregate_failures`
+          # and `aggregate_failures: true` metadata are not taken in
+          # consideration, as it is dynamically set basing on cofiguration.
+          # If `aggregate_failures: false` is set on the example, it's
+          # preserved and is treated as regular metadata.
+          def metadata_without_aggregate_failures(example)
+            metadata = example_metadata(example) || []
+
+            symbols = metadata_symbols_without_aggregate_failures(metadata)
+            pairs = metadata_pairs_without_aggegate_failures(metadata)
+
+            [*symbols, pairs].flatten.compact
+          end
+
+          def example_metadata(example)
+            example.send_node.arguments
+          end
+
+          def metadata_symbols_without_aggregate_failures(metadata)
+            metadata
+              .select(&:sym_type?)
+              .reject { |item| item.value == :aggregate_failures }
+          end
+
+          def metadata_pairs_without_aggegate_failures(metadata)
+            map = metadata.find(&:hash_type?)
+            pairs = map&.pairs || []
+            pairs.reject do |pair|
+              pair.key.value == :aggregate_failures && pair.value.true_type?
+            end
+          end
+
+          def add_aggregate_failures_metadata?
+            cop_config.fetch("AddAggregateFailuresMetadata", false)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_prof/cops/rspec/aggregate_examples/node_matchers.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative "../language"
+
+module RuboCop
+  module Cop
+    module RSpec
+      class AggregateExamples < Cop
+        # @internal
+        #   Node matchers and searchers.
+        module NodeMatchers
+          extend RuboCop::NodePattern::Macros
+          include RuboCop::Cop::RSpec::Language
+
+          private
+
+          def_node_matcher :example_group_with_several_examples, <<-PATTERN
+            (block
+              #{ExampleGroups::ALL.send_pattern}
+              _
+              (begin $...)
+            )
+          PATTERN
+
+          def example_method?(method_name)
+            %i[it specify example scenario].include?(method_name)
+          end
+
+          # Matches examples with:
+          # - expectation statements exclusively
+          # - no title (e.g. `it('jumps over the lazy dog')`)
+          # - no HEREDOC
+          def_node_matcher :example_for_autocorrect?, <<-PATTERN
+            [
+              #example_with_expectations_only?
+              !#example_has_title?
+              !#contains_heredoc?
+            ]
+          PATTERN
+
+          def_node_matcher :example_with_expectations_only?, <<-PATTERN
+            (block #{Examples::EXAMPLES.send_pattern} _
+              { #single_expectation? (begin #single_expectation?+) }
+            )
+          PATTERN
+
+          # Matches the example with a title (e.g. `it('is valid')`)
+          def_node_matcher :example_has_title?, <<-PATTERN
+            (block
+              (send nil? #example_method? str ...)
+              ...
+            )
+          PATTERN
+
+          # Searches for HEREDOC in examples. It can be tricky to aggregate,
+          # especially when interleaved with parenthesis or curly braces.
+          def contains_heredoc?(node)
+            node.each_descendant(:str, :xstr, :dstr).any?(&:heredoc?)
+          end
+
+          def_node_matcher :subject_with_no_args?, <<-PATTERN
+            (send _ _)
+          PATTERN
+
+          def_node_matcher :expectation?, <<-PATTERN
+            {
+              (send nil? {:is_expected :are_expected})
+              (send nil? :expect #subject_with_no_args?)
+            }
+          PATTERN
+
+          def_node_matcher :single_expectation?, <<-PATTERN
+            (send #expectation? #{Runners::ALL.node_pattern_union} _)
+          PATTERN
+        end
+      end
+    end
+  end
+end

data/lib/test_prof/cops/rspec/aggregate_failures.rb

@@ -1,168 +1,26 @@
 # frozen_string_literal: true
 
-require "rubocop"
-require "test_prof/utils"
-
 module RuboCop
   module Cop
     module RSpec
-      # Rejects and auto-corrects the usage of one-liners examples in favour of
-      # :aggregate_failures feature.
-      #
-      # Example:
-      #
-      #  # bad
-      #  it { is_expected.to be_success }
-      #  it { is_expected.to have_header('X-TOTAL-PAGES', 10) }
-      #  it { is_expected.to have_header('X-NEXT-PAGE', 2) }
-      #  its(:status) { is_expected.to eq(200) }
-      #
-      #  # good
-      #  it "returns the second page", :aggregate_failures do
-      #    is_expected.to be_success
-      #    is_expected.to have_header('X-TOTAL-PAGES', 10)
-      #    is_expected.to have_header('X-NEXT-PAGE', 2)
-      #    expect(subject.status).to eq(200)
-      #  end
-      #
-      class AggregateFailures < RuboCop::Cop::Cop
-        # From https://github.com/backus/rubocop-rspec/blob/master/lib/rubocop/rspec/language.rb
-        GROUP_BLOCKS = %i[
-          describe context feature example_group
-        ].freeze
-
-        EXAMPLE_BLOCKS = %i[
-          it its specify example scenario
-        ].freeze
-
-        class << self
-          def supported?
-            return @supported if instance_variable_defined?(:@supported)
-            @supported = TestProf::Utils.verify_gem_version("rubocop", at_least: "0.51.0")
-
-            unless @supported
-              warn "RSpec/AggregateFailures cop requires RuboCop >= 0.51.0. Skipping"
-            end
-
-            @supported
-          end
+      class AggregateExamples
+        def self.inherited(subclass)
+          superclass.registry.enlist(subclass)
         end
+      end
 
-        def on_block(node)
-          return unless self.class.supported?
-
-          method, _args, body = *node
-          return unless body&.begin_type?
-
-          _receiver, method_name, _object = *method
-          return unless GROUP_BLOCKS.include?(method_name)
-
-          return if check_node(body)
-
-          add_offense(
-            node,
-            location: :expression,
-            message: "Use :aggregate_failures instead of several one-liners."
-          )
-        end
-
-        def autocorrect(node)
-          _method, _args, body = *node
-          iter = body.children.each
-
-          first_example = loop do
-            child = iter.next
-            break child if oneliner?(child)
-          end
-
-          base_indent = " " * first_example.source_range.column
-
-          replacements = [
-            header_from(first_example),
-            body_from(first_example, base_indent)
-          ]
-
-          last_example = nil
-
-          loop do
-            child = iter.next
-            break unless oneliner?(child)
-            last_example = child
-            replacements << body_from(child, base_indent)
-          end
-
-          replacements << "#{base_indent}end"
-
-          range = first_example.source_range.begin.join(
-            last_example.source_range.end
-          )
-
-          replacement = replacements.join("\n")
-
-          lambda do |corrector|
-            corrector.replace(range, replacement)
-          end
-        end
-
-        private
-
-        def check_node(node)
-          offenders = 0
-
-          node.children.each do |child|
-            if oneliner?(child)
-              offenders += 1
-            elsif example_node?(child)
-              break if offenders > 1
-              offenders = 0
-            end
-          end
-
-          offenders < 2
-        end
-
-        def oneliner?(node)
-          node&.block_type? &&
-            (node.source.lines.size == 1) &&
-            example_node?(node)
-        end
-
-        def example_node?(node)
-          method, _args, _body = *node
-          _receiver, method_name, _object = *method
-          EXAMPLE_BLOCKS.include?(method_name)
-        end
-
-        def header_from(node)
-          method, _args, _body = *node
-          _receiver, method_name, _object = *method
-          method_name = :it if method_name == :its
-          %(#{method_name} "works", :aggregate_failures do)
-        end
-
-        def body_from(node, base_indent = "")
-          method, _args, body = *node
-          body_source = method.method_name == :its ? body_from_its(method, body) : body.source
-          "#{base_indent}#{indent}#{body_source}"
-        end
-
-        def body_from_its(method, body)
-          subject_attribute = method.arguments.first
-          expectation = body.method_name
-          match = body.arguments.first.source
-
-          if subject_attribute.array_type?
-            hash_keys = subject_attribute.values.map(&:value).join(", ")
-            attribute = "dig(#{hash_keys})"
-          else
-            attribute = subject_attribute.value
-          end
+      class AggregateFailures < AggregateExamples
+        raise "Remove me" if TestProf::VERSION >= "1.0"
 
-          "expect(subject.#{attribute}).#{expectation} #{match}"
+        def initialize(*)
+          super
+          self.class.just_once { warn "`AggregateFailures` cop has been renamed to `AggregateExamples`." }
         end
 
-        def indent
-          @indent ||= " " * (config.for_cop("IndentationWidth")["Width"] || 2)
+        def self.just_once
+          return if @already_done
+          yield
+          @already_done = true
         end
       end
     end

data/lib/test_prof/cops/rspec/language.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+# This is shamelessly borrowed from RuboCop RSpec
+# https://github.com/rubocop-hq/rubocop-rspec/blob/master/lib/rubocop/rspec/language.rb
+module RuboCop
+  module Cop
+    module RSpec
+      # RSpec public API methods that are commonly used in cops
+      module Language
+        RSPEC = "{(const {nil? cbase} :RSpec) nil?}"
+
+        # Set of method selectors
+        class SelectorSet
+          def initialize(selectors)
+            @selectors = selectors
+          end
+
+          def ==(other)
+            selectors.eql?(other.selectors)
+          end
+
+          def +(other)
+            self.class.new(selectors + other.selectors)
+          end
+
+          def include?(selector)
+            selectors.include?(selector)
+          end
+
+          def block_pattern
+            "(block #{send_pattern} ...)"
+          end
+
+          def send_pattern
+            "(send #{RSPEC} #{node_pattern_union} ...)"
+          end
+
+          def node_pattern_union
+            "{#{node_pattern}}"
+          end
+
+          def node_pattern
+            selectors.map(&:inspect).join(" ")
+          end
+
+          protected
+
+          attr_reader :selectors
+        end
+
+        module ExampleGroups
+          GROUPS = SelectorSet.new(%i[describe context feature example_group])
+          SKIPPED = SelectorSet.new(%i[xdescribe xcontext xfeature])
+          FOCUSED = SelectorSet.new(%i[fdescribe fcontext ffeature])
+
+          ALL = GROUPS + SKIPPED + FOCUSED
+        end
+
+        module Examples
+          EXAMPLES = SelectorSet.new(%i[it specify example scenario its])
+          FOCUSED = SelectorSet.new(%i[fit fspecify fexample fscenario focus])
+          SKIPPED = SelectorSet.new(%i[xit xspecify xexample xscenario skip])
+          PENDING = SelectorSet.new(%i[pending])
+
+          ALL = EXAMPLES + FOCUSED + SKIPPED + PENDING
+        end
+
+        module Runners
+          ALL = SelectorSet.new(%i[to to_not not_to])
+        end
+      end
+    end
+  end
+end

data/lib/test_prof/recipes/rspec/let_it_be.rb

@@ -4,15 +4,6 @@ require "test_prof"
 require_relative "./before_all"
 
 module TestProf
-  # Add `#map` to Object as an alias for `then` to use in modifiers
-  using(Module.new do
-    refine Object do
-      def map
-        yield self
-      end
-    end
-  end)
-
   # Just like `let`, but persist the result for the whole group.
   # NOTE: Experimental and magical, for more control use `before_all`.
   module LetItBe
@@ -47,15 +38,14 @@ module TestProf
       end
 
       def wrap_with_modifiers(mods, &block)
-        validate_modifiers! mods
-
         return block if mods.empty?
 
+        validate_modifiers! mods
+
         -> {
-          instance_eval(&block).map do |record|
-            mods.inject(record) do |rec, (k, v)|
-              LetItBe.modifiers.fetch(k).call(rec, v)
-            end
+          record = instance_eval(&block)
+          mods.inject(record) do |rec, (k, v)|
+            LetItBe.modifiers.fetch(k).call(rec, v)
           end
         }
       end
@@ -134,14 +124,26 @@ if defined?(::ActiveRecord)
   TestProf::LetItBe.configure do |config|
     config.register_modifier :reload do |record, val|
       next record unless val
-      next record unless record.is_a?(::ActiveRecord::Base)
-      record.reload
+      next record.reload if record.is_a?(::ActiveRecord::Base)
+
+      if record.respond_to?(:map)
+        next record.map do |rec|
+          rec.is_a?(::ActiveRecord::Base) ? rec.reload : rec
+        end
+      end
+      record
     end
 
     config.register_modifier :refind do |record, val|
       next record unless val
-      next record unless record.is_a?(::ActiveRecord::Base)
-      record.refind
+      next record.refind if record.is_a?(::ActiveRecord::Base)
+
+      if record.respond_to?(:map)
+        next record.map do |rec|
+          rec.is_a?(::ActiveRecord::Base) ? rec.refind : rec
+        end
+      end
+      record
     end
   end
 end

data/lib/test_prof/rubocop.rb

@@ -1,3 +1,14 @@
 # frozen_string_literal: true
 
+require "test_prof/utils"
+supported = TestProf::Utils.verify_gem_version("rubocop", at_least: "0.51.0")
+unless supported
+  warn "TestProf cops require RuboCop >= 0.51.0 to run."
+  return
+end
+
+require "rubocop"
+
+require_relative "cops/inject"
+require "test_prof/cops/rspec/aggregate_examples"
 require "test_prof/cops/rspec/aggregate_failures"

data/lib/test_prof/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TestProf
-  VERSION = "0.10.2"
+  VERSION = "0.11.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: test-prof
 version: !ruby/object:Gem::Version
-  version: 0.10.2
+  version: 0.11.0
 platform: ruby
 authors:
 - Vladimir Dementyev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-07 00:00:00.000000000 Z
+date: 2020-02-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -128,7 +128,15 @@ files:
 - lib/test_prof/before_all.rb
 - lib/test_prof/before_all/adapters/active_record.rb
 - lib/test_prof/before_all/isolator.rb
+- lib/test_prof/cops/inject.rb
+- lib/test_prof/cops/rspec/aggregate_examples.rb
+- lib/test_prof/cops/rspec/aggregate_examples/its.rb
+- lib/test_prof/cops/rspec/aggregate_examples/line_range_helpers.rb
+- lib/test_prof/cops/rspec/aggregate_examples/matchers_with_side_effects.rb
+- lib/test_prof/cops/rspec/aggregate_examples/metadata_helpers.rb
+- lib/test_prof/cops/rspec/aggregate_examples/node_matchers.rb
 - lib/test_prof/cops/rspec/aggregate_failures.rb
+- lib/test_prof/cops/rspec/language.rb
 - lib/test_prof/event_prof.rb
 - lib/test_prof/event_prof/custom_events.rb
 - lib/test_prof/event_prof/custom_events/factory_create.rb