rubocop 0.76.0 → 0.80.1

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

@@ -19,9 +19,9 @@ module RuboCop
       #
       # @example
       #   # bad
-      #   # rubocop:disable Metrics/LineLength
+      #   # rubocop:disable Layout/LineLength
       #   x += 1
-      #   # rubocop:enable Metrics/LineLength
+      #   # rubocop:enable Layout/LineLength
       #
       #   # good
       #   x += 1
@@ -213,7 +213,7 @@ module RuboCop
         end
 
         def matching_range(haystack, needle)
-          offset = (haystack.source =~ Regexp.new(Regexp.escape(needle)))
+          offset = haystack.source.index(needle)
           return unless offset
 
           offset += haystack.begin_pos

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

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
-# The Lint/RedundantCopEnableDirective cop needs to be disabled so as
-# to be able to provide a (bad) example of an unneeded enable.
+# The Lint/RedundantCopEnableDirective and Lint/RedundantCopDisableDirective
+# cops need to be disabled so as to be able to provide a (bad) example of an
+# unneeded enable.
 
 # rubocop:disable Lint/RedundantCopEnableDirective
+# rubocop:disable Lint/RedundantCopDisableDirective
 module RuboCop
   module Cop
     module Lint
@@ -15,21 +17,21 @@ module RuboCop
       # @example
       #   # bad
       #   foo = 1
-      #   # rubocop:enable Metrics/LineLength
+      #   # rubocop:enable Layout/LineLength
       #
       #   # good
       #   foo = 1
       # @example
       #   # bad
-      #   # rubocop:disable Metrics/LineLength
-      #   baaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaarrrrrrrrrrrrr
-      #   # rubocop:enable Metrics/LineLength
+      #   # rubocop:disable Style/StringLiterals
+      #   foo = "1"
+      #   # rubocop:enable Style/StringLiterals
       #   baz
       #   # rubocop:enable all
       #
       #   # good
-      #   # rubocop:disable Metrics/LineLength
-      #   baaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaarrrrrrrrrrrrr
+      #   # rubocop:disable Style/StringLiterals
+      #   foo = "1"
       #   # rubocop:enable all
       #   baz
       class RedundantCopEnableDirective < Cop
@@ -112,3 +114,6 @@ module RuboCop
     end
   end
 end
+
+# rubocop:enable Lint/RedundantCopDisableDirective
+# rubocop:enable Lint/RedundantCopEnableDirective

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

@@ -146,7 +146,7 @@ module RuboCop
           grandparent = node.parent.parent
 
           parent.when_type? || parent.send_type? || part_of_an_array?(node) ||
-            (grandparent&.resbody_type?)
+            grandparent&.resbody_type?
         end
 
         def remove_brackets(array)

data/lib/rubocop/cop/lint/{string_conversion_in_interpolation.rb → redundant_string_coercion.rb}

@@ -17,7 +17,7 @@ module RuboCop
       #   # good
       #
       #   "result is #{something}"
-      class StringConversionInInterpolation < Cop
+      class RedundantStringCoercion < Cop
         include Interpolation
 
         MSG_DEFAULT = 'Redundant use of `Object#to_s` in interpolation.'

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

@@ -50,7 +50,7 @@ module RuboCop
         def autocorrect(node)
           lambda do |corrector|
             redundant_with_index?(node) do |send|
-              if send.method_name == :each_with_index
+              if send.method?(:each_with_index)
                 corrector.replace(send.loc.selector, 'each')
               else
                 corrector.remove(with_index_range(send))
@@ -63,7 +63,7 @@ module RuboCop
         private
 
         def message(node)
-          if node.method_name == :each_with_index
+          if node.method?(:each_with_index)
             MSG_EACH_WITH_INDEX
           else
             MSG_WITH_INDEX

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

@@ -51,7 +51,7 @@ module RuboCop
         def autocorrect(node)
           lambda do |corrector|
             redundant_with_object?(node) do |send|
-              if send.method_name == :each_with_object
+              if send.method?(:each_with_object)
                 corrector.replace(with_object_range(send), 'each')
               else
                 corrector.remove(with_object_range(send))
@@ -64,7 +64,7 @@ module RuboCop
         private
 
         def message(node)
-          if node.method_name == :each_with_object
+          if node.method?(:each_with_object)
             MSG_EACH_WITH_OBJECT
           else
             MSG_WITH_OBJECT

data/lib/rubocop/cop/lint/{handle_exceptions.rb → suppressed_exception.rb}

@@ -74,7 +74,7 @@ module RuboCop
       #   rescue
       #     # do nothing but comment
       #   end
-      class HandleExceptions < Cop
+      class SuppressedException < Cop
         MSG = 'Do not suppress exceptions.'
 
         def on_resbody(node)

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

@@ -9,23 +9,64 @@ module RuboCop
       # always being defined, and thus access modifiers guarding such methods
       # are not redundant.
       #
-      # @example
+      # This cop has `ContextCreatingMethods` option. The default setting value
+      # is an empty array that means no method is specified.
+      # This setting is an array of methods which, when called, are known to
+      # create its own context in the module's current access context.
+      #
+      # It also has `MethodCreatingMethods` option. The default setting value
+      # is an empty array that means no method is specified.
+      # This setting is an array of methods which, when called, are known to
+      # create other methods in the module's current access context.
       #
+      # @example
+      #   # bad
       #   class Foo
       #     public # this is redundant (default access is public)
       #
       #     def method
       #     end
+      #   end
       #
-      #     private # this is not redundant (a method is defined)
-      #     def method2
+      #   # bad
+      #   class Foo
+      #     # The following is redundant (methods defined on the class'
+      #     # singleton class are not affected by the public modifier)
+      #     public
+      #
+      #     def self.method3
       #     end
+      #   end
       #
+      #   # bad
+      #   class Foo
+      #     protected
+      #
+      #     define_method(:method2) do
+      #     end
+      #
+      #     protected # this is redundant (repeated from previous modifier)
+      #
+      #     [1,2,3].each do |i|
+      #       define_method("foo#{i}") do
+      #       end
+      #     end
+      #   end
+      #
+      #   # bad
+      #   class Foo
       #     private # this is redundant (no following methods are defined)
       #   end
       #
-      # @example
+      #   # good
+      #   class Foo
+      #     private # this is not redundant (a method is defined)
+      #
+      #     def method2
+      #     end
+      #   end
       #
+      #   # good
       #   class Foo
       #     # The following is not redundant (conditionally defined methods are
       #     # considered as always defining a method)
@@ -35,31 +76,22 @@ module RuboCop
       #       def method
       #       end
       #     end
+      #   end
       #
-      #     protected # this is not redundant (method is defined)
+      #   # good
+      #   class Foo
+      #     protected # this is not redundant (a method is defined)
       #
       #     define_method(:method2) do
       #     end
-      #
-      #     protected # this is redundant (repeated from previous modifier)
-      #
-      #     [1,2,3].each do |i|
-      #       define_method("foo#{i}") do
-      #       end
-      #     end
-      #
-      #     # The following is redundant (methods defined on the class'
-      #     # singleton class are not affected by the public modifier)
-      #     public
-      #
-      #     def self.method3
-      #     end
       #   end
       #
-      # @example
+      # @example ContextCreatingMethods: concerning
       #   # Lint/UselessAccessModifier:
       #   #   ContextCreatingMethods:
       #   #     - concerning
+      #
+      #   # good
       #   require 'active_support/concern'
       #   class Foo
       #     concerning :Bar do
@@ -79,10 +111,12 @@ module RuboCop
       #     end
       #   end
       #
-      # @example
+      # @example MethodCreatingMethods: delegate
       #   # Lint/UselessAccessModifier:
       #   #   MethodCreatingMethods:
       #   #     - delegate
+      #
+      #   # good
       #   require 'active_support/core_ext/module/delegation'
       #   class Foo
       #     # this is not redundant because `delegate` creates methods
@@ -141,7 +175,7 @@ module RuboCop
 
         def access_modifier?(node)
           node.bare_access_modifier? ||
-            node.method_name == :private_class_method
+            node.method?(:private_class_method)
         end
 
         def check_scope(node)
@@ -169,7 +203,7 @@ module RuboCop
         def check_send_node(node, cur_vis, unused)
           if node.bare_access_modifier?
             check_new_visibility(node, unused, node.method_name, cur_vis)
-          elsif node.method_name == :private_class_method && !node.arguments?
+          elsif node.method?(:private_class_method) && !node.arguments?
             add_offense(node, message: format(MSG, current: node.method_name))
             [cur_vis, unused]
           end

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

@@ -6,6 +6,10 @@ module RuboCop
       # This cop checks for setter call to local variable as the final
       # expression of a function definition.
       #
+      # Note: There are edge cases in which the local variable references a
+      # value that is also accessible outside the local scope. This is not
+      # detected by the cop, and it can yield a false positive.
+      #
       # @example
       #
       #   # bad
@@ -155,7 +159,7 @@ module RuboCop
             return true if node.literal?
             return false unless node.send_type?
 
-            node.method_name == :new
+            node.method?(:new)
           end
         end
       end

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

@@ -20,7 +20,7 @@ module RuboCop
         alias on_defs on_def
 
         def on_block(node)
-          return unless node.send_node.method_name == :define_method
+          return unless node.send_node.method?(:define_method)
 
           check_code_length(node)
         end

data/lib/rubocop/cop/migration/department_name.rb

@@ -10,13 +10,24 @@ module RuboCop
 
         MSG = 'Department name is missing.'
 
+        DISABLE_COMMENT_FORMAT =
+          /\A(# *rubocop *: *((dis|en)able|todo) +)(.*)/.freeze
+
+        # The token that makes up a disable comment.
+        # The token used after `# rubocop: disable` are `A-z`, `/`, and `,`.
+        # Also `A-z` includes `all`.
+        DISABLING_COPS_CONTENT_TOKEN = %r{[A-z/,]+}.freeze
+
         def investigate(processed_source)
           processed_source.each_comment do |comment|
-            next if comment.text !~ /\A(# *rubocop:((dis|en)able|todo) +)(.*)/
+            next if comment.text !~ DISABLE_COMMENT_FORMAT
 
             offset = Regexp.last_match(1).length
             Regexp.last_match(4).scan(%r{[\w/]+|\W+}) do |name|
+              break unless valid_content_token?(name.strip)
+
               check_cop_name(name, comment, offset)
+
               offset += name.length
             end
           end
@@ -24,8 +35,13 @@ module RuboCop
 
         def autocorrect(range)
           shall_warn = false
-          qualified_cop_name = Cop.registry.qualified_cop_name(range.source,
+          cop_name = range.source
+          qualified_cop_name = Cop.registry.qualified_cop_name(cop_name,
                                                                nil, shall_warn)
+          unless qualified_cop_name.include?('/')
+            qualified_cop_name = qualified_legacy_cop_name(cop_name)
+          end
+
           ->(corrector) { corrector.replace(range, qualified_cop_name) }
         end
 
@@ -38,6 +54,18 @@ module RuboCop
           range = range_between(start, start + name.length)
           add_offense(range, location: range)
         end
+
+        def valid_content_token?(content_token)
+          !DISABLING_COPS_CONTENT_TOKEN.match(content_token).nil?
+        end
+
+        def qualified_legacy_cop_name(cop_name)
+          legacy_cop_names = RuboCop::ConfigObsoletion::OBSOLETE_COPS.keys
+
+          legacy_cop_names.detect do |legacy_cop_name|
+            legacy_cop_name.split('/')[1] == cop_name
+          end
+        end
       end
     end
   end

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

@@ -35,7 +35,7 @@ module RuboCop
             # If this offense is within a line range that is already being
             # realigned by autocorrect, we report the offense without
             # autocorrecting it. Two rewrites in the same area by the same
-            # cop can not be handled. The next iteration will find the
+            # cop cannot be handled. The next iteration will find the
             # offense again and correct it.
             add_offense(nil, location: expr)
           else

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

@@ -60,6 +60,10 @@ module RuboCop
       alias conflicting_styles_detected no_acceptable_style!
       alias unrecognized_style_detected no_acceptable_style!
 
+      def style_configured?
+        cop_config.key?(style_parameter_name)
+      end
+
       def style
         @style ||= begin
           s = cop_config[style_parameter_name].to_sym

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

@@ -39,15 +39,15 @@ module RuboCop
         end
       end
 
-      def leading_comment_lines
-        comments = processed_source.comments
-
-        comments.each_with_object([]) do |comment, leading_comments|
-          next if comment.loc.line > 3
-
-          leading_comments << comment.text
+      def frozen_string_literal_specified?
+        leading_comment_lines.any? do |line|
+          MagicComment.parse(line).frozen_string_literal_specified?
         end
       end
+
+      def leading_comment_lines
+        processed_source.comments.first(3).map(&:text)
+      end
     end
   end
 end

data/lib/rubocop/cop/mixin/{hash_alignment.rb → hash_alignment_styles.rb}

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     # Common functionality for checking hash alignment.
-    module HashAlignment
+    module HashAlignmentStyles
       # Handles calculation of deltas when the enforced style is 'key'.
       class KeyAlignment
         def checkable_layout?(_node)

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

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for Style/HashTransformKeys and
+    # Style/HashTransformValues
+    module HashTransformMethod
+      def on_block(node)
+        on_bad_each_with_object(node) do |*match|
+          handle_possible_offense(node, match, 'each_with_object')
+        end
+      end
+
+      def on_send(node)
+        on_bad_hash_brackets_map(node) do |*match|
+          handle_possible_offense(node, match, 'Hash[_.map {...}]')
+        end
+        on_bad_map_to_h(node) do |*match|
+          handle_possible_offense(node, match, 'map {...}.to_h')
+        end
+      end
+
+      def on_csend(node)
+        on_bad_map_to_h(node) do |*match|
+          handle_possible_offense(node, match, 'map {...}.to_h')
+        end
+      end
+
+      def autocorrect(node)
+        lambda do |corrector|
+          correction = prepare_correction(node)
+          execute_correction(corrector, node, correction)
+        end
+      end
+
+      private
+
+      # @abstract Implemented with `def_node_matcher`
+      def on_bad_each_with_object(_node)
+        raise NotImplementedError
+      end
+
+      # @abstract Implemented with `def_node_matcher`
+      def on_bad_hash_brackets_map(_node)
+        raise NotImplementedError
+      end
+
+      # @abstract Implemented with `def_node_matcher`
+      def on_bad_map_to_h(_node)
+        raise NotImplementedError
+      end
+
+      def handle_possible_offense(node, match, match_desc)
+        captures = extract_captures(match)
+
+        # If key didn't actually change either, this is most likely a false
+        # positive (receiver isn't a hash).
+        return if captures.noop_transformation?
+
+        # Can't `transform_keys` if key transformation uses value, or
+        # `transform_values` if value transformation uses key.
+        return if captures.transformation_uses_both_args?
+
+        add_offense(
+          node,
+          message: "Prefer `#{new_method_name}` over `#{match_desc}`."
+        )
+      end
+
+      # @abstract
+      #
+      # @return [Captures]
+      def extract_captures(_match)
+        raise NotImplementedError
+      end
+
+      # @abstract
+      #
+      # @return [String]
+      def new_method_name
+        raise NotImplementedError
+      end
+
+      def prepare_correction(node)
+        if (match = on_bad_each_with_object(node))
+          Autocorrection.from_each_with_object(node, match)
+        elsif (match = on_bad_hash_brackets_map(node))
+          Autocorrection.from_hash_brackets_map(node, match)
+        elsif (match = on_bad_map_to_h(node))
+          Autocorrection.from_map_to_h(node, match)
+        else
+          raise 'unreachable'
+        end
+      end
+
+      def execute_correction(corrector, node, correction)
+        correction.strip_prefix_and_suffix(node, corrector)
+        correction.set_new_method_name(new_method_name, corrector)
+
+        captures = extract_captures(correction.match)
+        correction.set_new_arg_name(captures.transformed_argname, corrector)
+        correction.set_new_body_expression(
+          captures.transforming_body_expr,
+          corrector
+        )
+      end
+
+      # Internal helper class to hold match data
+      Captures = Struct.new(
+        :transformed_argname,
+        :transforming_body_expr,
+        :unchanged_body_expr
+      ) do
+        def noop_transformation?
+          transforming_body_expr.lvar_type? &&
+            transforming_body_expr.children == [transformed_argname]
+        end
+
+        def transformation_uses_both_args?
+          transforming_body_expr.descendants.include?(unchanged_body_expr)
+        end
+      end
+
+      # Internal helper class to hold autocorrect data
+      Autocorrection = Struct.new(:match, :block_node, :leading, :trailing) do # rubocop:disable Metrics/BlockLength
+        def self.from_each_with_object(node, match)
+          new(match, node, 0, 0)
+        end
+
+        def self.from_hash_brackets_map(node, match)
+          new(match, node.children.last, 'Hash['.length, ']'.length)
+        end
+
+        def self.from_map_to_h(node, match)
+          strip_trailing_chars = node.parent&.block_type? ? 0 : '.to_h'.length
+          new(match, node.children.first, 0, strip_trailing_chars)
+        end
+
+        def strip_prefix_and_suffix(node, corrector)
+          expression = node.loc.expression
+          corrector.remove_leading(expression, leading)
+          corrector.remove_trailing(expression, trailing)
+        end
+
+        def set_new_method_name(new_method_name, corrector)
+          range = block_node.send_node.loc.selector
+          if (send_end = block_node.send_node.loc.end)
+            # If there are arguments (only true in the `each_with_object`
+            # case)
+            range = range.begin.join(send_end)
+          end
+          corrector.replace(range, new_method_name)
+        end
+
+        def set_new_arg_name(transformed_argname, corrector)
+          corrector.replace(
+            block_node.arguments.loc.expression,
+            "|#{transformed_argname}|"
+          )
+        end
+
+        def set_new_body_expression(transforming_body_expr, corrector)
+          corrector.replace(
+            block_node.body.loc.expression,
+            transforming_body_expr.loc.expression.source
+          )
+        end
+      end
+    end
+  end
+end