Replace named parameters with funccalls in patterns

sl4vr · sl4vr · commit f782d361165e · 2020-08-04T20:36:51.000+03:00
diff --git a/lib/rubocop/cop/rspec/described_class.rb b/lib/rubocop/cop/rspec/described_class.rb
@@ -65,6 +65,9 @@ class DescribedClass < Base
           (block (send (const nil? {:Class :Module :Struct}) :new ...) ...)
         PATTERN
 
+        def_node_matcher :rspec_block?,
+                         RuboCop::RSpec::Language.block_pattern('#rspec_all')
+
         def_node_matcher :scope_changing_syntax?, '{def class module}'
 
         def_node_matcher :described_constant, <<-PATTERN
@@ -128,7 +131,7 @@ def scope_change?(node)
         end
 
         def skippable_block?(node)
-          node.block_type? && !block_pattern?(node, rspec_all) && skip_blocks?
+          node.block_type? && !rspec_block?(node) && skip_blocks?
         end
 
         def skip_blocks?
diff --git a/lib/rubocop/cop/rspec/dialect.rb b/lib/rubocop/cop/rspec/dialect.rb
@@ -47,14 +47,15 @@ class Dialect < Base
 
         MSG = 'Prefer `%<prefer>s` over `%<current>s`.'
 
-        def on_send(node)
-          return unless send_pattern?(node, rspec_all)
+        def_node_matcher :rspec_method?,
+                         RuboCop::RSpec::Language.send_pattern('#rspec_all')
 
-          method_name = node.method_name
-          return unless preferred_methods[method_name]
+        def on_send(node)
+          return unless rspec_method?(node)
+          return unless preferred_methods[node.method_name]
 
-          msg = format(MSG, prefer: preferred_method(method_name),
-                            current: method_name)
+          msg = format(MSG, prefer: preferred_method(node.method_name),
+                            current: node.method_name)
 
           add_offense(node, message: msg) do |corrector|
             current = node.loc.selector
diff --git a/lib/rubocop/cop/rspec/empty_example_group.rb b/lib/rubocop/cop/rspec/empty_example_group.rb
@@ -110,10 +110,9 @@ class EmptyExampleGroup < Base
         #     end
         #
         #   @param node [RuboCop::AST::Node]
-        #   @param %1 [Proc] Function to match hooks
         #   @return [Array<RuboCop::AST::Node>] matching nodes
         def_node_matcher :examples_inside_block?, <<~PATTERN
-          (block !#{SEND_PATTERN} _ #examples?(%1))
+          (block !#{RuboCop::RSpec::Language.send_pattern('#rspec_hooks')} _ #examples?)
         PATTERN
 
         # @!method examples_directly_or_in_block?(node)
@@ -125,12 +124,11 @@ class EmptyExampleGroup < Base
         #     (1..5).each { |divisor| it { is_expected.to divide_by(divisor) } }
         #
         #   @param node [RuboCop::AST::Node]
-        #   @param %1 [Proc] Function to match hooks
         #   @return [Array<RuboCop::AST::Node>] matching nodes
         def_node_matcher :examples_directly_or_in_block?, <<~PATTERN
           {
             #example_or_group_or_include?
-            #examples_inside_block?(%1)
+            #examples_inside_block?
           }
         PATTERN
 
@@ -145,18 +143,17 @@ class EmptyExampleGroup < Base
         #     before { it { whatever here wont run anyway } }
         #
         #   @param node [RuboCop::AST::Node]
-        #   @param %1 [Proc] Function to match hooks
         #   @return [Array<RuboCop::AST::Node>] matching nodes
         def_node_matcher :examples?, <<~PATTERN
           {
-            #examples_directly_or_in_block?(%1)
-            (begin <#examples_directly_or_in_block?(%1) ...>)
+            #examples_directly_or_in_block?
+            (begin <#examples_directly_or_in_block? ...>)
           }
         PATTERN
 
         def on_block(node)
           example_group_body(node) do |body|
-            add_offense(node.send_node) unless examples?(body, rspec_hooks)
+            add_offense(node.send_node) unless examples?(body)
           end
         end
 
diff --git a/lib/rubocop/cop/rspec/empty_hook.rb b/lib/rubocop/cop/rspec/empty_hook.rb
@@ -28,13 +28,16 @@ class EmptyHook < Base
 
         MSG = 'Empty hook detected.'
 
-        def on_block(node)
-          return unless block_pattern?(node, rspec_hooks)
-          return if node.body
+        def_node_matcher :empty_hook?, <<~PATTERN
+          (block $#{RuboCop::RSpec::Language.send_pattern('#rspec_hooks')} _ nil?)	
+        PATTERN
 
-          add_offense(node.send_node) do |corrector|
-            range = range_with_surrounding_space(range: node.loc.expression)
-            corrector.remove(range)
+        def on_block(node)
+          empty_hook?(node) do |hook|
+            add_offense(hook) do |corrector|
+              range = range_with_surrounding_space(range: node.loc.expression)
+              corrector.remove(range)
+            end
           end
         end
       end
diff --git a/lib/rubocop/cop/rspec/empty_line_after_hook.rb b/lib/rubocop/cop/rspec/empty_line_after_hook.rb
@@ -40,7 +40,7 @@ class EmptyLineAfterHook < Base
         MSG = 'Add an empty line after `%<hook>s`.'
 
         def on_block(node)
-          return unless block_pattern?(node, rspec_hooks)
+          return unless hook?(node)
 
           missing_separating_line_offense(node) do |method|
             format(MSG, hook: method)
diff --git a/lib/rubocop/cop/rspec/expect_in_hook.rb b/lib/rubocop/cop/rspec/expect_in_hook.rb
@@ -26,7 +26,7 @@ class ExpectInHook < Base
         def_node_search :expectation, Expectations::ALL.send_pattern
 
         def on_block(node)
-          return unless block_pattern?(node, rspec_hooks)
+          return unless hook?(node)
           return if node.body.nil?
 
           expectation(node.body) do |expect|
diff --git a/lib/rubocop/cop/rspec/expect_output.rb b/lib/rubocop/cop/rspec/expect_output.rb
@@ -42,9 +42,7 @@ def on_gvasgn(node)
         def inside_example_scope?(node)
           return false if node.nil? || example_group?(node)
           return true if example?(node)
-          if block_pattern?(node, rspec_hooks)
-            return RuboCop::RSpec::Hook.new(node).example?
-          end
+          return RuboCop::RSpec::Hook.new(node).example? if hook?(node)
 
           inside_example_scope?(node.parent)
         end
diff --git a/lib/rubocop/cop/rspec/hook_argument.rb b/lib/rubocop/cop/rspec/hook_argument.rb
@@ -65,10 +65,10 @@ class HookArgument < Base
         EXPLICIT_MSG = 'Use `%<scope>p` for RSpec hooks.'
 
         def_node_matcher :scoped_block, <<-PATTERN
-          (block $(send _ %1 (sym ${:each :example})) ...)
+          (block $(send _ #rspec_hooks (sym ${:each :example})) ...)
         PATTERN
 
-        def_node_matcher :unscoped_block, '(block $(send _ %1) ...)'
+        def_node_matcher :unscoped_block, '(block $(send _ #rspec_hooks) ...)'
 
         def on_block(node)
           hook(node) do |method_send, scope_name|
@@ -110,8 +110,7 @@ def implicit_style?
         end
 
         def hook(node, &block)
-          scoped_block(node, rspec_hooks, &block) ||
-            unscoped_block(node, rspec_hooks, &block)
+          scoped_block(node, &block) || unscoped_block(node, &block)
         end
 
         def argument_range(send_node)
diff --git a/lib/rubocop/cop/rspec/hooks_before_examples.rb b/lib/rubocop/cop/rspec/hooks_before_examples.rb
@@ -53,7 +53,7 @@ def check_hooks(node)
 
           node.each_child_node do |child|
             next if child.sibling_index < first_example.sibling_index
-            next unless block_pattern?(child, rspec_hooks)
+            next unless hook?(child)
 
             msg = format(MSG, hook: child.method_name)
             add_offense(child, message: msg) do |corrector|
diff --git a/lib/rubocop/cop/rspec/leading_subject.rb b/lib/rubocop/cop/rspec/leading_subject.rb
@@ -69,7 +69,7 @@ def autocorrect(corrector, node, sibling)
 
         def offending?(node)
           let?(node) ||
-            block_pattern?(node, rspec_hooks) ||
+            hook?(node) ||
             example?(node) ||
             spec_group?(node) ||
             include?(node)
diff --git a/lib/rubocop/cop/rspec/named_subject.rb b/lib/rubocop/cop/rspec/named_subject.rb
@@ -45,17 +45,21 @@ class NamedSubject < Base
         MSG = 'Name your test subject if you need '\
               'to reference it explicitly.'
 
+        def_node_matcher :rspec_block?, <<-PATTERN
+          {	
+            #{Examples::ALL.block_pattern}	
+            #{RuboCop::RSpec::Language.block_pattern('#rspec_hooks')}	
+          }	
+        PATTERN
+
         def_node_matcher :shared_example?, <<-PATTERN
           #{SharedGroups::EXAMPLES.block_pattern}
         PATTERN
 
         def_node_search :subject_usage, '$(send nil? :subject)'
 
         def on_block(node)
-          if !block_pattern?(node, rspec_examles_and_hooks) ||
-              ignored_shared_example?(node)
-            return
-          end
+          return if !rspec_block?(node) || ignored_shared_example?(node)
 
           subject_usage(node) do |subject_node|
             add_offense(subject_node.loc.selector)
@@ -66,18 +70,6 @@ def ignored_shared_example?(node)
           cop_config['IgnoreSharedExamples'] &&
             node.each_ancestor(:block).any?(&method(:shared_example?))
         end
-
-        private
-
-        def rspec_examles_and_hooks
-          ->(keyword) { rspec_rspec_examle_and_hook_keywords.include?(keyword) }
-        end
-
-        def rspec_rspec_examle_and_hook_keywords
-          selectors = Examples::ALL + hook_selectors
-          @rspec_rspec_examle_and_hook_keywords ||=
-            Set.new(selectors.send(:selectors))
-        end
       end
     end
   end
diff --git a/lib/rubocop/cop/rspec/scattered_setup.rb b/lib/rubocop/cop/rspec/scattered_setup.rb
@@ -43,7 +43,7 @@ def on_block(node)
 
         def repeated_hooks(node)
           hooks = RuboCop::RSpec::ExampleGroup.new(node, self)
-            .block_pattern(rspec_hooks)
+            .hooks
             .select(&:knowable_scope?)
             .group_by { |hook| [hook.name, hook.scope, hook.metadata] }
             .values
diff --git a/lib/rubocop/cop/rspec/shared_context.rb b/lib/rubocop/cop/rspec/shared_context.rb
@@ -61,7 +61,15 @@ class SharedContext < Base
 
         examples = (Examples::ALL + Includes::EXAMPLES)
         def_node_search :examples?, examples.send_pattern
-        def_node_search :send_pattern_search?, SEND_PATTERN
+
+        def_node_search :context?, <<-PATTERN
+          (
+            send #rspec? {
+              #{(Helpers::ALL + Includes::CONTEXT + Subject::ALL).node_pattern}
+              #rspec_hooks
+            } ...
+          )
+        PATTERN
 
         def_node_matcher :shared_context, SharedGroups::CONTEXT.block_pattern
         def_node_matcher :shared_example, SharedGroups::EXAMPLES.block_pattern
@@ -83,32 +91,11 @@ def on_block(node)
         private
 
         def context_with_only_examples(node)
-          shared_context(node) do
-            if examples?(node) && !send_pattern_search?(node, context_nodes)
-              yield
-            end
-          end
+          shared_context(node) { yield if examples?(node) && !context?(node) }
         end
 
         def examples_with_only_context(node)
-          shared_example(node) do
-            if send_pattern_search?(node, context_nodes) && !examples?(node)
-              yield
-            end
-          end
-        end
-
-        def context_nodes
-          ->(keyword) { context_node_keywords.include?(keyword) }
-        end
-
-        def context_node_keywords
-          selectors =
-            hook_selectors    +
-            Helpers::ALL      +
-            Includes::CONTEXT +
-            Subject::ALL
-          @context_node_keywords ||= Set.new(selectors.send(:selectors))
+          shared_example(node) { yield if context?(node) && !examples?(node) }
         end
       end
     end
diff --git a/lib/rubocop/rspec/example_group.rb b/lib/rubocop/rspec/example_group.rb
@@ -37,9 +37,8 @@ def examples
         find_all_in_scope(node, :example?).map(&Example.public_method(:new))
       end
 
-      def block_pattern(*args)
-        find_all_in_scope(node, :block_pattern?, *args)
-          .map(&Hook.public_method(:new))
+      def hooks
+        find_all_in_scope(node, :hook?).map(&Hook.public_method(:new))
       end
 
       private
@@ -52,23 +51,21 @@ def block_pattern(*args)
       #
       # @param node [RuboCop::AST::Node] node to recursively search
       # @param predicate [Symbol] method to call with node as argument
-      # @param *args [Array<Object>] parameters which must be supplied
-      # to #match at matching time
       #
       # @return [Array<RuboCop::AST::Node>] discovered nodes
-      def find_all_in_scope(node, predicate, *args)
+      def find_all_in_scope(node, predicate)
         node.each_child_node.flat_map do |child|
-          find_all(child, predicate, *args)
+          find_all(child, predicate)
         end
       end
 
-      def find_all(node, predicate, *args)
-        if predicate_receiver.public_send(predicate, node, *args)
+      def find_all(node, predicate)
+        if predicate_receiver.public_send(predicate, node)
           [node]
         elsif scope_change?(node) || example?(node)
           []
         else
-          find_all_in_scope(node, predicate, *args)
+          find_all_in_scope(node, predicate)
         end
       end
     end
diff --git a/lib/rubocop/rspec/language.rb b/lib/rubocop/rspec/language.rb
@@ -4,12 +4,17 @@ module RuboCop
   module RSpec
     # RSpec public API methods that are commonly used in cops
     module Language
-      BLOCK_PATTERN = <<-PATTERN
-        (block (send {(const {nil? cbase} :RSpec) nil?} %1 ...) ...)
-      PATTERN
-      SEND_PATTERN = <<-PATTERN
-        (send {(const {nil? cbase} :RSpec) nil?} %1 ...)
-      PATTERN
+      module_function
+
+      def block_pattern(keywords_matcher)
+        <<-PATTERN
+          (block (send {(const {nil? cbase} :RSpec) nil?} #{keywords_matcher} ...) ...)
+        PATTERN
+      end
+
+      def send_pattern(keywords_matcher)
+        "(send {(const {nil? cbase} :RSpec) nil?} #{keywords_matcher} ...)"
+      end
 
       # Set of method selectors
       class SelectorSet
diff --git a/lib/rubocop/rspec/language/node_pattern.rb b/lib/rubocop/rspec/language/node_pattern.rb
@@ -21,27 +21,27 @@ module NodePattern
 
         def_node_matcher :example?, Examples::ALL.block_pattern
 
+        def_node_matcher :hook?,
+                         RuboCop::RSpec::Language.block_pattern('#rspec_hooks')
+
         def_node_matcher :let?, Helpers::ALL.block_or_block_pass_pattern
 
         def_node_matcher :include?,
                          Includes::ALL.send_or_block_or_block_pass_pattern
 
         def_node_matcher :subject?, Subject::ALL.block_pattern
 
-        def_node_matcher :block_pattern?, BLOCK_PATTERN
-
-        def_node_matcher :send_pattern?, SEND_PATTERN
-
-        def rspec_hooks
-          ->(keyword) { hooks_set.include?(keyword) }
+        def rspec_hooks(keyword)
+          hooks_set.include?(keyword)
         end
 
-        def rspec_all
-          ->(keyword) { all_set.include?(keyword) }
+        def rspec_all(keyword)
+          all_set.include?(keyword)
         end
 
         protected
 
+        # TODO: Fully replace selectors with sets
         def hooks_set
           @hooks_set ||= Set.new(hook_selectors.send(:selectors))
         end
