rubocop 1.10.0 → 1.14.0

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

@@ -33,6 +33,7 @@ module RuboCop
         MSG_EACH_WITH_INDEX = 'Use `each` instead of `each_with_index`.'
         MSG_WITH_INDEX = 'Remove redundant `with_index`.'
 
+        # @!method redundant_with_index?(node)
         def_node_matcher :redundant_with_index?, <<~PATTERN
           (block
             $(send
@@ -68,10 +69,7 @@ module RuboCop
         end
 
         def with_index_range(send)
-          range_between(
-            send.loc.selector.begin_pos,
-            send.loc.expression.end_pos
-          )
+          range_between(send.loc.selector.begin_pos, send.loc.expression.end_pos)
         end
       end
     end

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

@@ -34,6 +34,7 @@ module RuboCop
 
         MSG_WITH_OBJECT = 'Remove redundant `with_object`.'
 
+        # @!method redundant_with_object?(node)
         def_node_matcher :redundant_with_object?, <<~PATTERN
           (block
             $(send _ {:each_with_object :with_object}
@@ -69,10 +70,7 @@ module RuboCop
         end
 
         def with_object_range(send)
-          range_between(
-            send.loc.selector.begin_pos,
-            send.loc.expression.end_pos
-          )
+          range_between(send.loc.selector.begin_pos, send.loc.expression.end_pos)
         end
       end
     end

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

@@ -23,9 +23,7 @@ module RuboCop
               ' The regexp literal matches `$_` implicitly.'
 
         def on_match_current_line(node)
-          add_offense(node) do |corrector|
-            corrector.replace(node, "#{node.source} =~ $_")
-          end
+          add_offense(node) { |corrector| corrector.replace(node, "#{node.source} =~ $_") }
         end
       end
     end

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

@@ -30,8 +30,7 @@ module RuboCop
       class RequireParentheses < Base
         include RangeHelp
 
-        MSG = 'Use parentheses in the method call to avoid confusion about ' \
-              'precedence.'
+        MSG = 'Use parentheses in the method call to avoid confusion about precedence.'
 
         def on_send(node)
           return if !node.arguments? || node.parenthesized?
@@ -49,8 +48,7 @@ module RuboCop
         def check_ternary(ternary, node)
           return unless ternary.condition.operator_keyword?
 
-          range = range_between(node.source_range.begin_pos,
-                                ternary.condition.source_range.end_pos)
+          range = range_between(node.source_range.begin_pos, ternary.condition.source_range.end_pos)
 
           add_offense(range)
         end

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

@@ -25,8 +25,7 @@ module RuboCop
       #     handle_exception
       #   end
       class RescueException < Base
-        MSG = 'Avoid rescuing the `Exception` class. ' \
-              'Perhaps you meant to rescue `StandardError`?'
+        MSG = 'Avoid rescuing the `Exception` class. Perhaps you meant to rescue `StandardError`?'
 
         def on_resbody(node)
           return unless node.children.first

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

@@ -51,10 +51,7 @@ module RuboCop
 
           add_offense(
             node.loc.keyword.join(rescued.loc.expression),
-            message: format(
-              MSG, invalid_exceptions: invalid_exceptions.map(&:source)
-                                                         .join(', ')
-            )
+            message: format(MSG, invalid_exceptions: invalid_exceptions.map(&:source).join(', '))
           ) do |corrector|
             autocorrect(corrector, node)
           end
@@ -83,9 +80,7 @@ module RuboCop
         end
 
         def invalid_exceptions(exceptions)
-          exceptions.select do |exception|
-            INVALID_TYPES.include?(exception.type)
-          end
+          exceptions.select { |exception| INVALID_TYPES.include?(exception.type) }
         end
       end
     end

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

@@ -63,8 +63,7 @@ module RuboCop
         end
 
         def setter_method?(method_name)
-          method_name.to_s.end_with?('=') &&
-            !AST::Node::COMPARISON_OPERATORS.include?(method_name)
+          method_name.to_s.end_with?('=') && !AST::Node::COMPARISON_OPERATORS.include?(method_name)
         end
       end
     end

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

@@ -26,9 +26,9 @@ module RuboCop
       class SafeNavigationChain < Base
         include NilMethods
 
-        MSG = 'Do not chain ordinary method call' \
-              ' after safe navigation operator.'
+        MSG = 'Do not chain ordinary method call after safe navigation operator.'
 
+        # @!method bad_method?(node)
         def_node_matcher :bad_method?, <<~PATTERN
           {
             (send $(csend ...) $_ ...)

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,
@@ -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

@@ -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,49 @@ 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
 
         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 +80,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 +96,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 +126,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
@@ -88,7 +150,7 @@ module RuboCop
           # 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 +159,29 @@ 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 = "#{quote_type}#{key.value}#{quote_type}"
+            register_offense(
+              key,
+              correction: correction,
+              message: format(MSG_CONSISTENCY, correction: "#{correction}:")
+            )
+          end
+        end
+
+        def quote_type
+          # Use the `Style/StringLiterals` configuration for quoting symbols
+          return '"' unless config.for_cop('Style/StringLiterals')['Enabled']
+
+          config.for_cop('Style/StringLiterals')['EnforcedStyle'] == 'single_quotes' ? "'" : '"'
+        end
       end
     end
   end