rubocop 1.22.3 → 1.25.0

data/lib/rubocop/cop/lint/useless_ruby2_keywords.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop looks for `ruby2_keywords` calls for methods that do not need it.
+      #
+      # `ruby2_keywords` should only be called on methods that accept an argument splat
+      # (`*args`) but do not explicit keyword arguments (`k:` or `k: true`) or
+      # a keyword splat (`**kwargs`).
+      #
+      # @example
+      #   # good (splat argument without keyword arguments)
+      #   ruby2_keywords def foo(*args); end
+      #
+      #   # bad (no arguments)
+      #   ruby2_keywords def foo; end
+      #
+      #   # good
+      #   def foo; end
+      #
+      #   # bad (positional argument)
+      #   ruby2_keywords def foo(arg); end
+      #
+      #   # good
+      #   def foo(arg); end
+      #
+      #   # bad (double splatted argument)
+      #   ruby2_keywords def foo(**args); end
+      #
+      #   # good
+      #   def foo(**args); end
+      #
+      #   # bad (keyword arguments)
+      #   ruby2_keywords def foo(i:, j:); end
+      #
+      #   # good
+      #   def foo(i:, j:); end
+      #
+      #   # bad (splat argument with keyword arguments)
+      #   ruby2_keywords def foo(*args, i:, j:); end
+      #
+      #   # good
+      #   def foo(*args, i:, j:); end
+      #
+      #   # bad (splat argument with double splat)
+      #   ruby2_keywords def foo(*args, **kwargs); end
+      #
+      #   # good
+      #   def foo(*args, **kwargs); end
+      #
+      #   # bad (ruby2_keywords given a symbol)
+      #   def foo; end
+      #   ruby2_keywords :foo
+      #
+      #   # good
+      #   def foo; end
+      #
+      #   # bad (ruby2_keywords with dynamic method)
+      #   define_method(:foo) { |arg| }
+      #   ruby2_keywords :foo
+      #
+      #   # good
+      #   define_method(:foo) { |arg| }
+      #
+      class UselessRuby2Keywords < Base
+        MSG = '`ruby2_keywords` is unnecessary for method `%<method_name>s`.'
+        RESTRICT_ON_SEND = %i[ruby2_keywords].freeze
+
+        # Looks for statically or dynamically defined methods with a given name
+        # @!method method_definition(node, method_name)
+        def_node_matcher :method_definition, <<~PATTERN
+          {
+            (def %1 ...)
+            ({block numblock} (send _ :define_method (sym %1)) ...)
+          }
+        PATTERN
+
+        def on_send(node)
+          if node.first_argument.def_type?
+            inspect_def(node, node.first_argument)
+          elsif node.first_argument.sym_type?
+            inspect_sym(node, node.first_argument)
+          end
+        end
+
+        private
+
+        def inspect_def(node, def_node)
+          return if allowed_arguments(def_node.arguments)
+
+          add_offense(node.loc.selector, message: format(MSG, method_name: def_node.method_name))
+        end
+
+        def inspect_sym(node, sym_node)
+          return unless node.parent
+
+          method_name = sym_node.value
+          definition = node.parent.each_child_node.detect { |n| method_definition(n, method_name) }
+
+          return unless definition
+          return if allowed_arguments(definition.arguments)
+
+          add_offense(node, message: format(MSG, method_name: method_name))
+        end
+
+        # `ruby2_keywords` is only allowed if there's a `restarg` and no keyword arguments
+        def allowed_arguments(arguments)
+          return false if arguments.empty?
+
+          arguments.each_child_node(:restarg).any? &&
+            arguments.each_child_node(:kwarg, :kwoptarg, :kwrestarg).none?
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/metrics/block_length.rb

@@ -50,6 +50,7 @@ module RuboCop
 
           check_code_length(node)
         end
+        alias on_numblock on_block
 
         private
 

data/lib/rubocop/cop/metrics/cyclomatic_complexity.rb

@@ -46,15 +46,6 @@ module RuboCop
           1
         end
 
-        def block_method(node)
-          case node.type
-          when :block
-            node.method_name
-          when :block_pass
-            node.parent.method_name
-          end
-        end
-
         def count_block?(block)
           KNOWN_ITERATING_METHODS.include? block.method_name
         end

data/lib/rubocop/cop/metrics/method_length.rb

@@ -52,6 +52,7 @@ module RuboCop
 
           check_code_length(node)
         end
+        alias on_numblock on_block
 
         private
 

data/lib/rubocop/cop/metrics/module_length.rb

@@ -44,7 +44,7 @@ module RuboCop
 
         # @!method module_definition?(node)
         def_node_matcher :module_definition?, <<~PATTERN
-          (casgn nil? _ (block (send (const {nil? cbase} :Module) :new) ...))
+          (casgn nil? _ ({block numblock} (send (const {nil? cbase} :Module) :new) ...))
         PATTERN
 
         def message(length, max_length)

data/lib/rubocop/cop/metrics/parameter_lists.rb

@@ -10,7 +10,7 @@ module RuboCop
       # as they add less complexity than positional or optional parameters.
       #
       # NOTE: Explicit block argument `&block` is not counted to prevent
-      #       erroneous change that is avoided by making block argument implicit.
+      # erroneous change that is avoided by making block argument implicit.
       #
       # @example Max: 3
       #   # good

data/lib/rubocop/cop/metrics/utils/code_length_calculator.rb

@@ -135,7 +135,7 @@ module RuboCop
 
           def extract_body(node)
             case node.type
-            when :class, :module, :block, :def, :defs
+            when :class, :module, :block, :numblock, :def, :defs
               node.body
             when :casgn
               _scope, _name, value = *node

data/lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb

@@ -59,7 +59,7 @@ module RuboCop
 
           # @!method attribute_call?(node)
           def_node_matcher :attribute_call?, <<~PATTERN
-            ( {csend send} _receiver _method # and no parameters
+            (call _receiver _method # and no parameters
             )
           PATTERN
 

data/lib/rubocop/cop/mixin/enforce_superclass.rb

@@ -13,6 +13,11 @@ module RuboCop
     # @api private
     module EnforceSuperclass
       def self.included(base)
+        warn Rainbow(
+          '`RuboCop::Cop::EnforceSuperclass` is deprecated and will be removed in RuboCop 2.0. ' \
+          'Please upgrade to RuboCop Rails 2.9 or newer to continue.'
+        ).yellow
+
         # @!method class_definition(node)
         base.def_node_matcher :class_definition, <<~PATTERN
           (class (const _ !:#{base::SUPERCLASS}) #{base::BASE_PATTERN} ...)

data/lib/rubocop/cop/mixin/gemspec_help.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking gem declarations.
+    module GemspecHelp
+      extend NodePattern::Macros
+
+      # @!method gem_specification?(node)
+      def_node_matcher :gem_specification?, <<~PATTERN
+        (block
+          (send
+            (const
+              (const {cbase nil?} :Gem) :Specification) :new)
+          (args
+            (arg $_)) ...)
+      PATTERN
+
+      # @!method gem_specification(node)
+      def_node_search :gem_specification, <<~PATTERN
+        (block
+          (send
+            (const
+              (const {cbase nil?} :Gem) :Specification) :new)
+          (args
+            (arg $_)) ...)
+      PATTERN
+    end
+  end
+end

data/lib/rubocop/cop/mixin/hash_alignment_styles.rb

@@ -43,7 +43,7 @@ module RuboCop
         end
 
         def value_delta(pair)
-          return 0 if pair.value_on_new_line?
+          return 0 if pair.value_on_new_line? || pair.value_omission?
 
           correct_value_column = pair.loc.operator.end.column + 1
           actual_value_column = pair.value.loc.column
@@ -111,7 +111,8 @@ module RuboCop
           correct_value_column = first_pair.key.loc.column +
                                  current_pair.delimiter(true).length +
                                  max_key_width
-          correct_value_column - current_pair.value.loc.column
+
+          current_pair.value_omission? ? 0 : correct_value_column - current_pair.value.loc.column
         end
       end
 
@@ -134,7 +135,7 @@ module RuboCop
         end
 
         def value_delta(first_pair, current_pair)
-          first_pair.value_delta(current_pair)
+          current_pair.value_omission? ? 0 : first_pair.value_delta(current_pair)
         end
       end
 

data/lib/rubocop/cop/mixin/hash_shorthand_syntax.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module checks for Ruby 3.1's hash value omission syntax.
+    module HashShorthandSyntax
+      OMIT_HASH_VALUE_MSG = 'Omit the hash value.'
+      EXPLICIT_HASH_VALUE_MSG = 'Explicit the hash value.'
+
+      def on_pair(node)
+        return if target_ruby_version <= 3.0 || enforced_shorthand_syntax == 'either'
+
+        hash_key_source = node.key.source
+
+        if enforced_shorthand_syntax == 'always'
+          return if node.value_omission? || require_hash_value?(hash_key_source, node)
+
+          message = OMIT_HASH_VALUE_MSG
+          replacement = "#{hash_key_source}:"
+        else
+          return unless node.value_omission?
+
+          message = EXPLICIT_HASH_VALUE_MSG
+          replacement = "#{hash_key_source}: #{hash_key_source}"
+        end
+
+        add_offense(node.value, message: message) do |corrector|
+          corrector.replace(node, replacement)
+        end
+      end
+
+      private
+
+      def enforced_shorthand_syntax
+        cop_config.fetch('EnforcedShorthandSyntax', 'always')
+      end
+
+      def require_hash_value?(hash_key_source, node)
+        return true if without_parentheses_call_expr_follows?(node)
+
+        hash_value = node.value
+        return true unless hash_value.send_type? || hash_value.lvar_type?
+
+        hash_key_source != hash_value.source || hash_key_source.end_with?('!', '?')
+      end
+
+      def without_parentheses_call_expr_follows?(node)
+        return false unless (ancestor = node.parent.parent)
+
+        right_sibling = ancestor.right_sibling
+
+        return true if right_sibling.nil? && without_parentheses?(ancestor)
+        return false unless right_sibling
+        return true if node_with_block_and_arguments?(right_sibling)
+
+        without_parentheses?(ancestor) && without_parentheses?(right_sibling)
+      end
+
+      def without_parentheses?(node)
+        node.respond_to?(:parenthesized?) && !node.parenthesized?
+      end
+
+      def node_with_block_and_arguments?(node)
+        node.respond_to?(:block_type?) && node.block_type? && node.children&.first&.arguments?
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/string_literals_help.rb

@@ -13,11 +13,7 @@ module RuboCop
         if style == :single_quotes
           !double_quotes_required?(src)
         else
-          # The string needs single quotes if:
-          # 1. It contains a double quote
-          # 2. It contains text that would become an escape sequence with double quotes
-          # 3. It contains text that would become an interpolation with double quotes
-          !/" | (?<!\\)\\[aAbcdefkMnprsStuUxzZ0-7] | \#[@{$]/x.match?(src)
+          !/" | \\[^'\\] | \#[@{$]/x.match?(src)
         end
       end
     end

data/lib/rubocop/cop/naming/block_forwarding.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # In Ruby 3.1, anonymous block forwarding has been added.
+      #
+      # This cop identifies places where `do_something(&block)` can be replaced
+      # by `do_something(&)`.
+      #
+      # It also supports the opposite style by alternative `explicit` option.
+      # You can specify the block variable name for auto-correction with `BlockForwardingName`.
+      # The default variable name is `block`. If the name is already in use, it will not be
+      # auto-corrected.
+      #
+      # @example EnforcedStyle: anonymous (default)
+      #
+      #   # bad
+      #   def foo(&block)
+      #     bar(&block)
+      #   end
+      #
+      #   # good
+      #   def foo(&)
+      #     bar(&)
+      #   end
+      #
+      # @example EnforcedStyle: explicit
+      #
+      #   # bad
+      #   def foo(&)
+      #     bar(&)
+      #   end
+      #
+      #   # good
+      #   def foo(&block)
+      #     bar(&block)
+      #   end
+      #
+      class BlockForwarding < Base
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 3.1
+
+        MSG = 'Use %<style>s block forwarding.'
+
+        def on_def(node)
+          return if node.arguments.empty?
+
+          last_argument = node.arguments.last
+          return if expected_block_forwarding_style?(node, last_argument)
+
+          register_offense(last_argument, node)
+
+          node.each_descendant(:block_pass) do |block_pass_node|
+            next if block_pass_node.children.first&.sym_type? ||
+                    last_argument.source != block_pass_node.source
+
+            register_offense(block_pass_node, node)
+          end
+        end
+        alias on_defs on_def
+
+        private
+
+        def expected_block_forwarding_style?(node, last_argument)
+          if style == :anonymous
+            !explicit_block_argument?(last_argument) ||
+              use_kwarg_in_method_definition?(node) ||
+              use_block_argument_as_local_variable?(node, last_argument.source[1..-1])
+          else
+            !anonymous_block_argument?(last_argument)
+          end
+        end
+
+        def use_kwarg_in_method_definition?(node)
+          node.arguments.each_descendant(:kwarg, :kwoptarg).any?
+        end
+
+        def anonymous_block_argument?(node)
+          node.blockarg_type? && node.name.nil?
+        end
+
+        def explicit_block_argument?(node)
+          node.blockarg_type? && !node.name.nil?
+        end
+
+        def register_offense(block_argument, node)
+          add_offense(block_argument, message: format(MSG, style: style)) do |corrector|
+            if style == :anonymous
+              corrector.replace(block_argument, '&')
+
+              arguments = block_argument.parent
+
+              add_parentheses(arguments, corrector) unless arguments.parenthesized_call?
+            else
+              unless use_block_argument_as_local_variable?(node, block_forwarding_name)
+                corrector.replace(block_argument, "&#{block_forwarding_name}")
+              end
+            end
+          end
+        end
+
+        def use_block_argument_as_local_variable?(node, last_argument)
+          return if node.body.nil?
+
+          node.body.each_descendant(:lvar).any? do |lvar|
+            !lvar.parent.block_pass_type? && lvar.source == last_argument
+          end
+        end
+
+        def block_forwarding_name
+          cop_config.fetch('BlockForwardingName', 'block')
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/naming/file_name.rb

@@ -14,6 +14,18 @@ module RuboCop
       # (i.e. `bundler-console` becomes `Bundler::Console`). As such, the
       # gemspec is supposed to be named `bundler-console.gemspec`.
       #
+      # When `ExpectMatchingDefinition` (default: `false`) is `true`, the cop requires
+      # each file to have a class, module or `Struct` defined in it that matches
+      # the filename. This can be further configured using
+      # `CheckDefinitionPathHierarchy` (default: `true`) to determine whether the
+      # path should match the namespace of the above definition.
+      #
+      # When `IgnoreExecutableScripts` (default: `true`) is `true`, files that start
+      # with a shebang line are not considered by the cop.
+      #
+      # When `Regex` is set, the cop will flag any filename that does not match
+      # the regular expression.
+      #
       # @example
       #   # bad
       #   lib/layoutManager.rb
@@ -28,11 +40,19 @@ module RuboCop
         include RangeHelp
 
         MSG_SNAKE_CASE = 'The name of this source file (`%<basename>s`) should use snake_case.'
-        MSG_NO_DEFINITION = '%<basename>s should define a class or module called `%<namespace>s`.'
+        MSG_NO_DEFINITION = '`%<basename>s` should define a class or module called `%<namespace>s`.'
         MSG_REGEX = '`%<basename>s` should match `%<regex>s`.'
 
         SNAKE_CASE = /^[\d[[:lower:]]_.?!]+$/.freeze
 
+        # @!method struct_definition(node)
+        def_node_matcher :struct_definition, <<~PATTERN
+          {
+            (casgn $_ $_        (send (const {nil? cbase} :Struct) :new ...))
+            (casgn $_ $_ (block (send (const {nil? cbase} :Struct) :new ...) ...))
+          }
+        PATTERN
+
         def on_new_investigation
           file_path = processed_source.file_path
           return if config.file_to_exclude?(file_path) || config.allowed_camel_case_file?(file_path)
@@ -103,6 +123,10 @@ module RuboCop
           cop_config['CheckDefinitionPathHierarchy']
         end
 
+        def definition_path_hierarchy_roots
+          cop_config['CheckDefinitionPathHierarchyRoots'] || []
+        end
+
         def regex
           cop_config['Regex']
         end
@@ -126,7 +150,7 @@ module RuboCop
           name = namespace.pop
 
           on_node(%i[class module casgn], node) do |child|
-            next unless (const = child.defined_module)
+            next unless (const = find_definition(child))
 
             const_namespace, const_name = *const
             next if name != const_name && !match_acronym?(name, const_name)
@@ -138,6 +162,15 @@ module RuboCop
           nil
         end
 
+        def find_definition(node)
+          node.defined_module || defined_struct(node)
+        end
+
+        def defined_struct(node)
+          namespace, name = *struct_definition(node)
+          s(:const, namespace, name) if name
+        end
+
         def match_namespace(node, namespace, expected)
           match_partial = partial_matcher!(expected)
 
@@ -177,13 +210,13 @@ module RuboCop
           allowed_acronyms.any? { |acronym| expected.gsub(acronym.capitalize, acronym) == name }
         end
 
-        def to_namespace(path)
+        def to_namespace(path) # rubocop:disable Metrics/AbcSize
           components = Pathname(path).each_filename.to_a
           # To convert a pathname to a Ruby namespace, we need a starting point
           # But RC can be run from any working directory, and can check any path
           # We can't assume that the working directory, or any other, is the
           # "starting point" to build a namespace.
-          start = %w[lib spec test src]
+          start = definition_path_hierarchy_roots
           start_index = nil
 
           # To find the closest namespace root take the path components, and

data/lib/rubocop/cop/security/open.rb

@@ -3,7 +3,8 @@
 module RuboCop
   module Cop
     module Security
-      # This cop checks for the use of `Kernel#open` and `URI.open`.
+      # This cop checks for the use of `Kernel#open` and `URI.open` with dynamic
+      # data.
       #
       # `Kernel#open` and `URI.open` enable not only file access but also process
       # invocation by prefixing a pipe symbol (e.g., `open("| ls")`).
@@ -11,6 +12,9 @@ module RuboCop
       # the argument of `Kernel#open` and `URI.open`. It would be better to use
       # `File.open`, `IO.popen` or `URI.parse#open` explicitly.
       #
+      # NOTE: `open` and `URI.open` with literal strings are not flagged by this
+      # cop.
+      #
       # @safety
       #   This cop could register false positives if `open` is redefined
       #   in a class and then used without a receiver in that class.
@@ -18,12 +22,18 @@ module RuboCop
       # @example
       #   # bad
       #   open(something)
+      #   open("| #{something}")
       #   URI.open(something)
       #
       #   # good
       #   File.open(something)
       #   IO.popen(something)
       #   URI.parse(something).open
+      #
+      #   # good (literal strings)
+      #   open("foo.text")
+      #   open("| foo")
+      #   URI.open("http://example.com")
       class Open < Base
         MSG = 'The use of `%<receiver>sopen` is a serious security risk.'
         RESTRICT_ON_SEND = %i[open].freeze

data/lib/rubocop/cop/style/character_literal.rb

@@ -4,6 +4,12 @@ module RuboCop
   module Cop
     module Style
       # Checks for uses of the character literal ?x.
+      # Starting with Ruby 1.9 character literals are
+      # essentially one-character strings, so this syntax
+      # is mostly redundant at this point.
+      #
+      # ? character literal can be used to express meta and control character.
+      # That's a good use case of ? literal so it doesn't count it as an offense.
       #
       # @example
       #   # bad
@@ -12,8 +18,9 @@ module RuboCop
       #   # good
       #   'x'
       #
-      #   # good
+      #   # good - control & meta escapes
       #   ?\C-\M-d
+      #   "\C-\M-d" # same as above
       class CharacterLiteral < Base
         include StringHelp
         extend AutoCorrector