rubocop 0.78.0 → 0.82.0

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

@@ -42,13 +42,13 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            node.values.each do |value|
+            node.each_value do |value|
               range = value.loc.expression
 
               match = range.source.match(TRAILING_QUOTE)
               corrector.remove_trailing(range, match[0].length) if match
 
-              if range.source =~ LEADING_QUOTE
+              if LEADING_QUOTE.match?(range.source)
                 corrector.remove_leading(range, 1)
               end
             end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for `raise` or `fail` statements which are
+      # raising `Exception` class.
+      #
+      # You can specify a module name that will be an implicit namespace
+      # using `AllowedImplicitNamespaces` option. The cop cause a false positive
+      # for namespaced `Exception` when a namespace is omitted. This option can
+      # prevent the false positive by specifying a namespace to be omitted for
+      # `Exception`. Alternatively, make `Exception` a fully qualified class
+      # name with an explicit namespace.
+      #
+      # @example
+      #   # bad
+      #   raise Exception, 'Error message here'
+      #
+      #   # good
+      #   raise StandardError, 'Error message here'
+      #
+      # @example AllowedImplicitNamespaces: ['Gem']
+      #   # good
+      #   module Gem
+      #     def self.foo
+      #       raise Exception # This exception means `Gem::Exception`.
+      #     end
+      #   end
+      class RaiseException < Cop
+        MSG = 'Use `StandardError` over `Exception`.'
+
+        def_node_matcher :exception?, <<~PATTERN
+          (send nil? {:raise :fail} (const ${cbase nil?} :Exception) ... )
+        PATTERN
+
+        def_node_matcher :exception_new_with_message?, <<~PATTERN
+          (send nil? {:raise :fail}
+            (send (const ${cbase nil?} :Exception) :new ... ))
+        PATTERN
+
+        def on_send(node)
+          exception?(node, &check(node)) ||
+            exception_new_with_message?(node, &check(node))
+        end
+
+        private
+
+        def check(node)
+          lambda do |cbase|
+            return if cbase.nil? && implicit_namespace?(node)
+
+            add_offense(node)
+          end
+        end
+
+        def implicit_namespace?(node)
+          return false unless (parent = node.parent)
+
+          if parent.module_type?
+            namespace = parent.identifier.source
+
+            return allow_implicit_namespaces.include?(namespace)
+          end
+
+          implicit_namespace?(parent)
+        end
+
+        def allow_implicit_namespaces
+          cop_config['AllowedImplicitNamespaces'] || []
+        end
+      end
+    end
+  end
+end

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

@@ -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
@@ -21,15 +23,15 @@ module RuboCop
       #   foo = 1
       # @example
       #   # bad
-      #   # rubocop:disable Layout/LineLength
-      #   baaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaarrrrrrrrrrrrr
-      #   # rubocop:enable Layout/LineLength
+      #   # rubocop:disable Style/StringLiterals
+      #   foo = "1"
+      #   # rubocop:enable Style/StringLiterals
       #   baz
       #   # rubocop:enable all
       #
       #   # good
-      #   # rubocop:disable Layout/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_string_coercion.rb

@@ -38,7 +38,7 @@ module RuboCop
           lambda do |corrector|
             receiver = node.receiver
             corrector.replace(
-              node.source_range,
+              node,
               if receiver
                 receiver.source
               else

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

@@ -32,7 +32,7 @@ module RuboCop
         def_node_matcher :bad_method?, <<~PATTERN
           {
             (send $(csend ...) $_ ...)
-            (send $(block (csend ...) ...) $_ ...)
+            (send $({block numblock} (csend ...) ...) $_ ...)
           }
         PATTERN
 

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks unexpected overrides of the `Struct` built-in methods
+      # via `Struct.new`.
+      #
+      # @example
+      #   # bad
+      #   Bad = Struct.new(:members, :clone, :count)
+      #   b = Bad.new([], true, 1)
+      #   b.members #=> [] (overriding `Struct#members`)
+      #   b.clone #=> true (overriding `Object#clone`)
+      #   b.count #=> 1 (overriding `Enumerable#count`)
+      #
+      #   # good
+      #   Good = Struct.new(:id, :name)
+      #   g = Good.new(1, "foo")
+      #   g.members #=> [:id, :name]
+      #   g.clone #=> #<struct Good id=1, name="foo">
+      #   g.count #=> 2
+      #
+      class StructNewOverride < Cop
+        MSG = '`%<member_name>s` member overrides `Struct#%<method_name>s`' \
+              ' and it may be unexpected.'
+
+        STRUCT_METHOD_NAMES = Struct.instance_methods
+        STRUCT_MEMBER_NAME_TYPES = %i[sym str].freeze
+
+        def_node_matcher :struct_new, <<~PATTERN
+          (send
+            (const ${nil? cbase} :Struct) :new ...)
+        PATTERN
+
+        def on_send(node)
+          return unless struct_new(node) do
+            node.arguments.each_with_index do |arg, index|
+              # Ignore if the first argument is a class name
+              next if index.zero? && arg.str_type?
+
+              # Ignore if the argument is not a member name
+              next unless STRUCT_MEMBER_NAME_TYPES.include?(arg.type)
+
+              member_name = arg.value
+
+              next unless STRUCT_METHOD_NAMES.include?(member_name.to_sym)
+
+              message = format(MSG, member_name: member_name.inspect,
+                                    method_name: member_name.to_s)
+              add_offense(arg, message: message)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,7 +5,7 @@ module RuboCop
     module Lint
       # This cop checks for *rescue* blocks with no body.
       #
-      # @example AllowComments: false (default)
+      # @example
       #
       #   # bad
       #   def some_method
@@ -14,25 +14,11 @@ module RuboCop
       #   end
       #
       #   # bad
-      #   def some_method
-      #     do_something
-      #   rescue
-      #     # do nothing
-      #   end
-      #
-      #   # bad
       #   begin
       #     do_something
       #   rescue
       #   end
       #
-      #   # bad
-      #   begin
-      #     do_something
-      #   rescue
-      #     # do nothing
-      #   end
-      #
       #   # good
       #   def some_method
       #     do_something
@@ -47,32 +33,36 @@ module RuboCop
       #     handle_exception
       #   end
       #
-      # @example AllowComments: true
+      # @example AllowComments: true (default)
       #
-      #   # bad
+      #   # good
       #   def some_method
       #     do_something
       #   rescue
+      #     # do nothing
       #   end
       #
-      #   # bad
+      #   # good
       #   begin
       #     do_something
       #   rescue
+      #     # do nothing
       #   end
       #
-      #   # good
+      # @example AllowComments: false
+      #
+      #   # bad
       #   def some_method
       #     do_something
       #   rescue
-      #     # do nothing but comment
+      #     # do nothing
       #   end
       #
-      #   # good
+      #   # bad
       #   begin
       #     do_something
       #   rescue
-      #     # do nothing but comment
+      #     # do nothing
       #   end
       class SuppressedException < Cop
         MSG = 'Do not suppress exceptions.'

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

@@ -33,8 +33,6 @@ module RuboCop
         end
 
         def autocorrect(node)
-          return false if target_ruby_version <= 2.3
-
           lambda do |corrector|
             corrector.replace(node.loc.name, 'Integer')
           end

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

@@ -38,9 +38,34 @@ module RuboCop
       #   def do_something(unused)
       #   end
       #
+      # @example IgnoreNotImplementedMethods: true (default)
+      #   # good
+      #   def do_something(unused)
+      #     raise NotImplementedError
+      #   end
+      #
+      #   def do_something_else(unused)
+      #     fail "TODO"
+      #   end
+      #
+      # @example IgnoreNotImplementedMethods: false
+      #   # bad
+      #   def do_something(unused)
+      #     raise NotImplementedError
+      #   end
+      #
+      #   def do_something_else(unused)
+      #     fail "TODO"
+      #   end
+      #
       class UnusedMethodArgument < Cop
         include UnusedArgument
 
+        def_node_matcher :not_implemented?, <<~PATTERN
+          {(send nil? :raise (const nil? :NotImplementedError))
+           (send nil? :fail ...)}
+        PATTERN
+
         def autocorrect(node)
           UnusedArgCorrector.correct(processed_source, node)
         end
@@ -51,16 +76,17 @@ module RuboCop
           return unless variable.method_argument?
           return if variable.keyword_argument? &&
                     cop_config['AllowUnusedKeywordArguments']
-
-          if cop_config['IgnoreEmptyMethods']
-            body = variable.scope.node.body
-
-            return if body.nil?
-          end
+          return if ignored_method?(variable.scope.node.body)
 
           super
         end
 
+        def ignored_method?(body)
+          cop_config['IgnoreEmptyMethods'] && body.nil? ||
+            cop_config['IgnoreNotImplementedMethods'] &&
+              not_implemented?(body)
+        end
+
         def message(variable)
           message = +"Unused method argument - `#{variable.name}`."
 

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

@@ -21,7 +21,7 @@ module RuboCop
         def_node_matcher :uri_regexp_with_argument?, <<~PATTERN
           (send
             (const ${nil? cbase} :URI) :regexp
-            (str $_))
+            ${(str _) (array ...)})
         PATTERN
 
         def_node_matcher :uri_regexp_without_argument?, <<~PATTERN
@@ -32,7 +32,7 @@ module RuboCop
         def on_send(node)
           uri_regexp_with_argument?(node) do |double_colon, arg|
             register_offense(
-              node, top_level: double_colon ? '::' : '', arg: "('#{arg}')"
+              node, top_level: double_colon ? '::' : '', arg: "(#{arg.source})"
             )
           end
 
@@ -51,10 +51,10 @@ module RuboCop
             double_colon, arg = captured_values
 
             top_level = double_colon ? '::' : ''
-            argument = arg ? "('#{arg}')" : ''
+            argument = arg ? "(#{arg.source})" : ''
 
             corrector.replace(
-              node.loc.expression,
+              node,
               "#{top_level}URI::DEFAULT_PARSER.make_regexp#{argument}"
             )
           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

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

@@ -10,13 +10,29 @@ 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 allowed specification for comments after `# rubocop: disable` is
+        # `DepartmentName/CopName` or` all`.
+        DISABLING_COPS_CONTENT_TOKEN = %r{[A-z]+/[A-z]+|all}.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|
-              check_cop_name(name, comment, offset)
+
+            Regexp.last_match(4).scan(/[^,]+|[\W]+/) do |name|
+              trimmed_name = name.strip
+
+              break if contain_plain_comment?(trimmed_name)
+
+              unless valid_content_token?(trimmed_name)
+                check_cop_name(trimmed_name, comment, offset)
+              end
+
               offset += name.length
             end
           end
@@ -24,20 +40,45 @@ 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
 
         private
 
-        def check_cop_name(name, comment, offset)
-          return if name !~ /^[A-Z]/ || name =~ %r{/}
+        def disable_comment_offset
+          Regexp.last_match(1).length
+        end
 
+        def check_cop_name(name, comment, offset)
           start = comment.location.expression.begin_pos + offset
           range = range_between(start, start + name.length)
+
           add_offense(range, location: range)
         end
+
+        def valid_content_token?(content_token)
+          !/\W+/.match(content_token).nil? ||
+            !DISABLING_COPS_CONTENT_TOKEN.match(content_token).nil?
+        end
+
+        def contain_plain_comment?(name)
+          name == '#'
+        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