rubocop 1.9.1 → 1.22.3

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

@@ -31,8 +31,7 @@ module RuboCop
         include NilMethods
         extend AutoCorrector
 
-        MSG = 'Ensure that safe navigation is used consistently ' \
-          'inside of `&&` and `||`.'
+        MSG = 'Ensure that safe navigation is used consistently inside of `&&` and `||`.'
 
         def on_csend(node)
           return unless node.parent&.operator_keyword?
@@ -46,15 +45,12 @@ module RuboCop
           safe_nav_receiver = node.receiver
 
           method_calls = conditions.select(&:send_type?)
-          unsafe_method_calls =
-            unsafe_method_calls(method_calls, safe_nav_receiver)
+          unsafe_method_calls = unsafe_method_calls(method_calls, safe_nav_receiver)
 
           unsafe_method_calls.each do |unsafe_method_call|
             location = location(node, unsafe_method_call)
 
-            add_offense(location) do |corrector|
-              autocorrect(corrector, unsafe_method_call)
-            end
+            add_offense(location) { |corrector| autocorrect(corrector, unsafe_method_call) }
 
             ignore_node(unsafe_method_call)
           end
@@ -76,9 +72,7 @@ module RuboCop
           parent = node.parent
           unless parent &&
                  (parent.operator_keyword? ||
-                  (parent.begin_type? &&
-                   parent.parent &&
-                   parent.parent.operator_keyword?))
+                  (parent.begin_type? && parent.parent && parent.parent.operator_keyword?))
             return node
           end
 

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

@@ -22,9 +22,9 @@ module RuboCop
       class SafeNavigationWithEmpty < Base
         extend AutoCorrector
 
-        MSG = 'Avoid calling `empty?` with the safe navigation operator ' \
-          'in conditionals.'
+        MSG = 'Avoid calling `empty?` with the safe navigation operator in conditionals.'
 
+        # @!method safe_navigation_empty_in_conditional?(node)
         def_node_matcher :safe_navigation_empty_in_conditional?, <<~PATTERN
           (if (csend (send ...) :empty?) ...)
         PATTERN

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

@@ -43,6 +43,7 @@ module RuboCop
         SEND_METHODS = %i[send public_send __send__].freeze
         RESTRICT_ON_SEND = SEND_METHODS
 
+        # @!method send_with_mixin_argument?(node)
         def_node_matcher :send_with_mixin_argument?, <<~PATTERN
           (send
             (const _ _) {:#{SEND_METHODS.join(' :')}}
@@ -52,9 +53,7 @@ module RuboCop
 
         def on_send(node)
           send_with_mixin_argument?(node) do |method, module_name|
-            message = message(
-              method, module_name.source, bad_location(node).source
-            )
+            message = message(method, module_name.source, bad_location(node).source)
 
             bad_location = bad_location(node)
             add_offense(bad_location, message: message) do |corrector|
@@ -72,10 +71,7 @@ module RuboCop
         end
 
         def message(method, module_name, bad_method)
-          format(
-            MSG,
-            method: method, module_name: module_name, bad_method: bad_method
-          )
+          format(MSG, method: method, module_name: module_name, bad_method: bad_method)
         end
 
         def mixin_method?(node)

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

@@ -64,9 +64,9 @@ module RuboCop
       #   end
       #
       class ShadowedArgument < Base
-        MSG = 'Argument `%<argument>s` was shadowed by a local variable ' \
-              'before it was used.'
+        MSG = 'Argument `%<argument>s` was shadowed by a local variable before it was used.'
 
+        # @!method uses_var?(node)
         def_node_search :uses_var?, '(lvar %)'
 
         def self.joining_forces
@@ -74,9 +74,7 @@ module RuboCop
         end
 
         def after_leaving_scope(scope, _variable_table)
-          scope.variables.each_value do |variable|
-            check_argument(variable)
-          end
+          scope.variables.each_value { |variable| check_argument(variable) }
         end
 
         private
@@ -127,8 +125,7 @@ module RuboCop
             next false if assignment_node.shorthand_asgn?
 
             node_within_block_or_conditional =
-              node_within_block_or_conditional?(assignment_node.parent,
-                                                argument.scope.node)
+              node_within_block_or_conditional?(assignment_node.parent, argument.scope.node)
 
             unless uses_var?(assignment_node, argument.name)
               # It's impossible to decide whether a branch or block is executed,
@@ -144,7 +141,7 @@ module RuboCop
         end
 
         def reference_pos(node)
-          node = node.parent.masgn_type? ? node.parent : node
+          node = node.parent if node.parent.masgn_type?
 
           node.source_range.begin_pos
         end
@@ -161,10 +158,7 @@ module RuboCop
         # Get argument references without assignments' references
         #
         def argument_references(argument)
-          assignment_references = argument
-                                  .assignments
-                                  .flat_map(&:references)
-                                  .map(&:source_range)
+          assignment_references = argument.assignments.flat_map(&:references).map(&:source_range)
 
           argument.references.reject do |ref|
             next false unless ref.explicit?

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

@@ -59,8 +59,7 @@ module RuboCop
             contains_multiple_levels_of_exceptions?(group)
           end
 
-          return if !rescue_group_rescues_multiple_levels &&
-                    sorted?(rescued_groups)
+          return if !rescue_group_rescues_multiple_levels && sorted?(rescued_groups)
 
           add_offense(offense_range(rescues))
         end
@@ -74,18 +73,14 @@ module RuboCop
         end
 
         def rescued_groups_for(rescues)
-          rescues.map do |group|
-            evaluate_exceptions(group)
-          end
+          rescues.map { |group| evaluate_exceptions(group) }
         end
 
         def contains_multiple_levels_of_exceptions?(group)
           # Always treat `Exception` as the highest level exception.
           return true if group.size > 1 && group.include?(Exception)
 
-          group.combination(2).any? do |a, b|
-            compare_exceptions(a, b)
-          end
+          group.combination(2).any? { |a, b| compare_exceptions(a, b) }
         end
 
         def compare_exceptions(exception, other_exception)
@@ -111,6 +106,9 @@ module RuboCop
 
           if rescued_exceptions.any?
             rescued_exceptions.each_with_object([]) do |exception, converted|
+              # FIXME: Workaround `rubocop:disable` comment for JRuby.
+              #        https://github.com/jruby/jruby/issues/6642
+              # rubocop:disable Style/RedundantBegin
               begin
                 RuboCop::Util.silence_warnings do
                   # Avoid printing deprecation warnings about constants
@@ -119,6 +117,7 @@ module RuboCop
               rescue NameError
                 converted << nil
               end
+              # rubocop:enable Style/RedundantBegin
             end
           else
             # treat an empty `rescue` as `rescue StandardError`

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

@@ -10,7 +10,7 @@ module RuboCop
       #
       # NOTE: Shadowing of variables in block passed to `Ractor.new` is allowed
       # because `Ractor` should not access outer variables.
-      # eg. following syle is encouraged:
+      # eg. following style is encouraged:
       #
       #   worker_id, pipe = env
       #   Ractor.new(worker_id, pipe) do |worker_id, pipe|
@@ -42,6 +42,7 @@ module RuboCop
       class ShadowingOuterLocalVariable < Base
         MSG = 'Shadowing outer local variable - `%<variable>s`.'
 
+        # @!method ractor_block?(node)
         def_node_matcher :ractor_block?, <<~PATTERN
           (block (send (const nil? :Ractor) :new ...) ...)
         PATTERN

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

@@ -29,6 +29,7 @@ module RuboCop
         STRUCT_METHOD_NAMES = Struct.instance_methods
         STRUCT_MEMBER_NAME_TYPES = %i[sym str].freeze
 
+        # @!method struct_new(node)
         def_node_matcher :struct_new, <<~PATTERN
           (send
             (const ${nil? cbase} :Struct) :new ...)
@@ -47,8 +48,7 @@ module RuboCop
 
               next unless STRUCT_METHOD_NAMES.include?(member_name.to_sym)
 
-              message = format(MSG, member_name: member_name.inspect,
-                                    method_name: member_name.to_s)
+              message = format(MSG, member_name: member_name.inspect, method_name: member_name.to_s)
               add_offense(arg, message: message)
             end
           end

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

@@ -64,12 +64,51 @@ module RuboCop
       #   rescue
       #     # do nothing
       #   end
+      #
+      # @example AllowNil: true (default)
+      #
+      #   # good
+      #   def some_method
+      #     do_something
+      #   rescue
+      #     nil
+      #   end
+      #
+      #   # good
+      #   begin
+      #     do_something
+      #   rescue
+      #     # do nothing
+      #   end
+      #
+      #   # good
+      #   do_something rescue nil
+      #
+      # @example AllowNil: false
+      #
+      #   # bad
+      #   def some_method
+      #     do_something
+      #   rescue
+      #     nil
+      #   end
+      #
+      #   # bad
+      #   begin
+      #     do_something
+      #   rescue
+      #     nil
+      #   end
+      #
+      #   # bad
+      #   do_something rescue nil
       class SuppressedException < Base
         MSG = 'Do not suppress exceptions.'
 
         def on_resbody(node)
-          return if node.body
+          return if node.body && !nil_body?(node)
           return if cop_config['AllowComments'] && comment_between_rescue_and_end?(node)
+          return if cop_config['AllowNil'] && nil_body?(node)
 
           add_offense(node)
         end
@@ -83,6 +122,10 @@ module RuboCop
           end_line = ancestor.loc.end.line
           processed_source[node.first_line...end_line].any? { |line| comment_line?(line) }
         end
+
+        def nil_body?(node)
+          node.body&.nil_type?
+        end
       end
     end
   end

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

@@ -6,6 +6,12 @@ module RuboCop
       # This cop checks for uses of literal strings converted to
       # a symbol where a literal symbol could be used instead.
       #
+      # There are two possible styles for this cop.
+      # `strict` (default) will register an offense for any incorrect usage.
+      # `consistent` additionally requires hashes to use the same style for
+      # every symbol key (ie. if any symbol key needs to be quoted it requires
+      # all keys to be quoted).
+      #
       # @example
       #   # bad
       #   'string'.to_sym
@@ -21,10 +27,50 @@ module RuboCop
       #   :underscored_symbol
       #   :'hyphenated-string'
       #
+      # @example EnforcedStyle: strict (default)
+      #
+      #   # bad
+      #   {
+      #     'a': 1,
+      #     "b": 2,
+      #     'c-d': 3
+      #   }
+      #
+      #   # good (don't quote keys that don't require quoting)
+      #   {
+      #     a: 1,
+      #     b: 2,
+      #     'c-d': 3
+      #   }
+      #
+      # @example EnforcedStyle: consistent
+      #
+      #   # bad
+      #   {
+      #     a: 1,
+      #     'b-c': 2
+      #   }
+      #
+      #   # good (quote all keys if any need quoting)
+      #   {
+      #     'a': 1,
+      #     'b-c': 2
+      #   }
+      #
+      #   # good (no quoting required)
+      #   {
+      #     a: 1,
+      #     b: 2
+      #   }
+      #
       class SymbolConversion < Base
         extend AutoCorrector
+        include ConfigurableEnforcedStyle
+        include SymbolHelp
 
         MSG = 'Unnecessary symbol conversion; use `%<correction>s` instead.'
+        MSG_CONSISTENCY = 'Symbol hash key should be quoted for consistency; ' \
+                          'use `%<correction>s` instead.'
         RESTRICT_ON_SEND = %i[to_sym intern].freeze
 
         def on_send(node)
@@ -35,7 +81,7 @@ module RuboCop
         end
 
         def on_sym(node)
-          return if properly_quoted?(node.source, node.value.inspect)
+          return if ignored_node?(node) || properly_quoted?(node.source, node.value.inspect)
 
           # `alias` arguments are symbols but since a symbol that requires
           # being quoted is not a valid method identifier, it can be ignored
@@ -51,16 +97,29 @@ module RuboCop
           register_offense(node, correction: node.value.inspect)
         end
 
+        def on_hash(node)
+          # For `EnforcedStyle: strict`, hash keys are evaluated in `on_sym`
+          return unless style == :consistent
+
+          keys = node.keys.select(&:sym_type?)
+
+          if keys.any? { |key| requires_quotes?(key) }
+            correct_inconsistent_hash_keys(keys)
+          else
+            # If there are no symbol keys requiring quoting,
+            # treat the hash like `EnforcedStyle: strict`.
+            keys.each { |key| correct_hash_key(key) }
+          end
+        end
+
         private
 
         def register_offense(node, correction:, message: format(MSG, correction: correction))
-          add_offense(node, message: message) do |corrector|
-            corrector.replace(node, correction)
-          end
+          add_offense(node, message: message) { |corrector| corrector.replace(node, correction) }
         end
 
         def properly_quoted?(source, value)
-          return true if !source.match?(/['"]/) || value.end_with?('=')
+          return true if style == :strict && (!source.match?(/['"]/) || value.end_with?('='))
 
           source == value ||
             # `Symbol#inspect` uses double quotes, but allow single-quoted
@@ -68,6 +127,10 @@ module RuboCop
             source.tr("'", '"') == value
         end
 
+        def requires_quotes?(sym_node)
+          sym_node.value.inspect.match?(/^:".*?"|=$/)
+        end
+
         def in_alias?(node)
           node.parent&.alias_type?
         end
@@ -76,19 +139,15 @@ module RuboCop
           node.parent&.array_type? && node.parent&.percent_literal?
         end
 
-        def hash_key?(node)
-          node.parent&.pair_type? && node == node.parent.child_nodes.first
-        end
-
         def correct_hash_key(node)
           # Although some operators can be converted to symbols normally
           # (ie. `:==`), these are not accepted as hash keys and will
           # raise a syntax error (eg. `{ ==: ... }`). Therefore, if the
-          # symbol does not start with an alpha-numeric or underscore, it
+          # symbol does not start with an alphanumeric or underscore, it
           # will be ignored.
           return unless node.value.to_s.match?(/\A[a-z0-9_]/i)
 
-          correction = node.value.inspect.gsub(/\A:/, '')
+          correction = node.value.inspect.delete_prefix(':')
           return if properly_quoted?(node.source, correction)
 
           register_offense(
@@ -97,6 +156,22 @@ module RuboCop
             message: format(MSG, correction: "#{correction}:")
           )
         end
+
+        def correct_inconsistent_hash_keys(keys)
+          keys.each do |key|
+            ignore_node(key)
+
+            next if requires_quotes?(key)
+            next if properly_quoted?(key.source, %("#{key.value}"))
+
+            correction = %("#{key.value}")
+            register_offense(
+              key,
+              correction: correction,
+              message: format(MSG_CONSISTENCY, correction: "#{correction}:")
+            )
+          end
+        end
       end
     end
   end

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

@@ -21,9 +21,7 @@ module RuboCop
           message =
             "#{diagnostic.message}\n(Using Ruby #{ruby_version} parser; " \
             'configure using `TargetRubyVersion` parameter, under `AllCops`)'
-          add_offense(diagnostic.location,
-                      message: message,
-                      severity: diagnostic.level)
+          add_offense(diagnostic.location, message: message, severity: diagnostic.level)
         end
 
         def add_offense_from_error(error)

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

@@ -23,14 +23,17 @@ module RuboCop
 
         RESTRICT_ON_SEND = %i[to_enum enum_for].freeze
 
+        # @!method enum_conversion_call?(node)
         def_node_matcher :enum_conversion_call?, <<~PATTERN
           (send {nil? self} {:to_enum :enum_for} $_ $...)
         PATTERN
 
+        # @!method method_name?(node, name)
         def_node_matcher :method_name?, <<~PATTERN
           {(send nil? {:__method__ :__callee__}) (sym %1)}
         PATTERN
 
+        # @!method passing_keyword_arg?(node, name)
         def_node_matcher :passing_keyword_arg?, <<~PATTERN
           (pair (sym %1) (lvar %1))
         PATTERN

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

@@ -31,8 +31,7 @@ module RuboCop
       class ToJSON < Base
         extend AutoCorrector
 
-        MSG = '`#to_json` requires an optional argument to be parsable ' \
-          'via JSON.generate(obj).'
+        MSG = '`#to_json` requires an optional argument to be parsable via JSON.generate(obj).'
 
         def on_def(node)
           return unless node.method?(:to_json) && node.arguments.empty?

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

@@ -38,9 +38,7 @@ module RuboCop
 
           trailing_comma = trailing_comma_range(node)
 
-          add_offense(trailing_comma) do |corrector|
-            corrector.remove(trailing_comma)
-          end
+          add_offense(trailing_comma) { |corrector| corrector.remove(trailing_comma) }
         end
 
         private

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for "triple quotes" (strings delimted by any odd number
+      # This cop checks for "triple quotes" (strings delimited by any odd number
       # of quotes greater than 1).
       #
       # Ruby allows multiple strings to be implicitly concatenated by just

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

@@ -48,9 +48,7 @@ module RuboCop
         end
 
         def after_leaving_scope(scope, _variable_table)
-          scope.variables.each_value do |variable|
-            check_variable(variable)
-          end
+          scope.variables.each_value { |variable| check_variable(variable) }
         end
 
         def check_variable(variable)

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

@@ -13,14 +13,19 @@ module RuboCop
       # Keyword arguments (including `**kwargs`) do not get counted towards
       # this, as they are not used by the methods in question.
       #
-      # NOTE: This cop matches for method names only and hence cannot tell apart
-      # methods with same name in different classes.
-      #
       # Method names and their expected arity can be configured like this:
       #
+      # [source,yaml]
+      # ----
       # Methods:
       #   inject: 2
       #   reduce: 2
+      # ----
+      #
+      # @safety
+      #  This cop matches for method names only and hence cannot tell apart
+      #  methods with same name in different classes, which may lead to a
+      #  false positive.
       #
       # @example
       #   # bad

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

@@ -22,6 +22,7 @@ module RuboCop
 
         MSG = 'Use `Integer` instead of `%<klass>s`.'
 
+        # @!method fixnum_or_bignum_const(node)
         def_node_matcher :fixnum_or_bignum_const, <<~PATTERN
           (:const {nil? (:cbase)} ${:Fixnum :Bignum})
         PATTERN

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

@@ -66,6 +66,7 @@ module RuboCop
         MSG = 'Ensure the accumulator `%<accum>s` will be modified by `%<method>s`.'
         MSG_INDEX = 'Do not return an element of the accumulator in `%<method>s`.'
 
+        # @!method reduce_with_block?(node)
         def_node_matcher :reduce_with_block?, <<~PATTERN
           {
             (block (send _recv {:reduce :inject} ...) args ...)
@@ -73,10 +74,12 @@ module RuboCop
           }
         PATTERN
 
+        # @!method accumulator_index?(node, accumulator_name)
         def_node_matcher :accumulator_index?, <<~PATTERN
           (send (lvar %1) {:[] :[]=} ...)
         PATTERN
 
+        # @!method element_modified?(node, element_name)
         def_node_search :element_modified?, <<~PATTERN
           {
             (send _receiver !{:[] :[]=} <`(lvar %1) `_ ...>)               # method(el, ...)
@@ -86,6 +89,7 @@ module RuboCop
           }
         PATTERN
 
+        # @!method lvar_used?(node, name)
         def_node_matcher :lvar_used?, <<~PATTERN
           {
             (lvar %1)
@@ -96,6 +100,7 @@ module RuboCop
           }
         PATTERN
 
+        # @!method expression_values(node)
         def_node_search :expression_values, <<~PATTERN
           {
             (%RuboCop::AST::Node::VARIABLES $_)

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

@@ -51,6 +51,7 @@ module RuboCop
 
         private
 
+        # @!method flow_command?(node)
         def_node_matcher :flow_command?, <<~PATTERN
           {
             return next break retry redo
@@ -80,8 +81,7 @@ module RuboCop
         def check_if(node)
           if_branch = node.if_branch
           else_branch = node.else_branch
-          if_branch && else_branch &&
-            flow_expression?(if_branch) && flow_expression?(else_branch)
+          if_branch && else_branch && flow_expression?(if_branch) && flow_expression?(else_branch)
         end
 
         def check_case(node)
@@ -89,9 +89,7 @@ module RuboCop
           return false unless else_branch
           return false unless flow_expression?(else_branch)
 
-          node.when_branches.all? do |branch|
-            branch.body && flow_expression?(branch.body)
-          end
+          node.when_branches.all? { |branch| branch.body && flow_expression?(branch.body) }
         end
       end
     end