```ruby
# frozen_string_literal: true

module RuboCop
  module Cop
    module RSpec
      # Omit the default :each argument for RSpec hooks.
      #
      # @example
      #   # bad
      #   before(:each) do
      #     ...
      #   end
      #
      #   # good
      #   before do
      #     ...
      #   end
      class HookArgument < RuboCop::Cop::Cop
        include RuboCop::RSpec::Util

        MSG = 'Omit the default `:%s` argument for RSpec hooks.'.freeze

        HOOK_METHODS = [:after, :around, :before].freeze
        DEFAULT_ARGS = [:each, :example].freeze

        def on_send(node)
          return unless HOOK_METHODS.include?(node.method_name) &&
              node.children.drop(2).one?

          arg_node = one(node.method_args)
          arg, = *arg_node

          return unless DEFAULT_ARGS.include?(arg)

          add_offense(arg_node, :expression, format(MSG, arg))
        end
      end
    end
  end
end
```

Refactor cop to use node_matcher
user
```ruby
# frozen_string_literal: true

module RuboCop
  module Cop
    module RSpec
      # Omit the default :each argument for RSpec hooks.
      #
      # @example
      #   # bad
      #   before(:each) do
      #     ...
      #   end
      #
      #   # good
      #   before do
      #     ...
      #   end
      class HookArgument < RuboCop::Cop::Cop
        MSG = 'Omit the default `%p` argument for RSpec hooks.'.freeze

        HOOKS = '{:before :after :around}'.freeze

        def_node_matcher :scoped_hook, <<-PATTERN
        (block (send nil #{HOOKS} $(sym {:each :example})) ...)
        PATTERN

        def_node_matcher :unscoped_hook, "(block (send nil #{HOOKS}) ...)"

        def on_block(node)
          hook(node) do |scope|
            return unless scope

            add_offense(scope, :expression, format(MSG, *scope))
          end
        end

        private

        def hook(node, &block)
          scoped_hook(node, &block) || unscoped_hook(node, &block)
        end
      end
    end
  end
end
```
assistant