rubocop 0.89.0 → 0.92.0

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

@@ -31,6 +31,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `StandardError` over `Exception`.'
+        RESTRICT_ON_SEND = %i[raise fail].freeze
 
         def_node_matcher :exception?, <<~PATTERN
           (send nil? {:raise :fail} $(const ${cbase nil?} :Exception) ... )

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

@@ -23,13 +23,14 @@ module RuboCop
       class RandOne < Base
         MSG = '`%<method>s` always returns `0`. ' \
               'Perhaps you meant `rand(2)` or `rand`?'
+        RESTRICT_ON_SEND = %i[rand].freeze
 
         def_node_matcher :rand_one?, <<~PATTERN
           (send {(const {nil? cbase} :Kernel) nil?} :rand {(int {-1 1}) (float {-1.0 1.0})})
         PATTERN
 
         def on_send(node)
-          return unless node.method?(:rand) && rand_one?(node)
+          return unless rand_one?(node)
 
           add_offense(node)
         end

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

@@ -41,13 +41,12 @@ module RuboCop
         def on_new_investigation
           return unless offenses_to_check
 
-          comments = processed_source.comments
           cop_disabled_line_ranges = processed_source.disabled_line_ranges
 
           redundant_cops = Hash.new { |h, k| h[k] = Set.new }
 
           each_redundant_disable(cop_disabled_line_ranges,
-                                 offenses_to_check, comments) do |comment, redundant_cop|
+                                 offenses_to_check) do |comment, redundant_cop|
             redundant_cops[comment].add(redundant_cop)
           end
 
@@ -57,19 +56,29 @@ module RuboCop
 
         private
 
+        def previous_line_blank?(range)
+          processed_source.buffer.source_line(range.line - 1).blank?
+        end
+
         def comment_range_with_surrounding_space(range)
-          # Eat the entire comment, the preceding space, and the preceding
-          # newline if there is one.
-          original_begin = range.begin_pos
-          range = range_with_surrounding_space(range: range,
-                                               side: :left,
-                                               newlines: true)
-          range_with_surrounding_space(range: range,
-                                       side: :right,
-                                       # Special for a comment that
-                                       # begins the file: remove
-                                       # the newline at the end.
-                                       newlines: original_begin.zero?)
+          if previous_line_blank?(range)
+            # When the previous line is blank, it should be retained
+            range_with_surrounding_space(range: range, side: :right)
+          else
+            # Eat the entire comment, the preceding space, and the preceding
+            # newline if there is one.
+            original_begin = range.begin_pos
+            range = range_with_surrounding_space(range: range,
+                                                 side: :left,
+                                                 newlines: true)
+
+            range_with_surrounding_space(range: range,
+                                         side: :right,
+                                         # Special for a comment that
+                                         # begins the file: remove
+                                         # the newline at the end.
+                                         newlines: original_begin.zero?)
+          end
         end
 
         def directive_range_in_list(range, ranges)
@@ -88,25 +97,25 @@ module RuboCop
                                        newlines: false)
         end
 
-        def each_redundant_disable(cop_disabled_line_ranges, offenses, comments,
+        def each_redundant_disable(cop_disabled_line_ranges, offenses,
                                    &block)
           disabled_ranges = cop_disabled_line_ranges[COP_NAME] || [0..0]
 
           cop_disabled_line_ranges.each do |cop, line_ranges|
             each_already_disabled(line_ranges,
-                                  disabled_ranges, comments) do |comment|
+                                  disabled_ranges) do |comment|
               yield comment, cop
             end
 
-            each_line_range(line_ranges, disabled_ranges, offenses, comments,
+            each_line_range(line_ranges, disabled_ranges, offenses,
                             cop, &block)
           end
         end
 
-        def each_line_range(line_ranges, disabled_ranges, offenses, comments,
+        def each_line_range(line_ranges, disabled_ranges, offenses,
                             cop)
           line_ranges.each_with_index do |line_range, ix|
-            comment = comments.find { |c| c.loc.line == line_range.begin }
+            comment = processed_source.comment_at_line(line_range.begin)
             next if ignore_offense?(disabled_ranges, line_range)
 
             redundant_cop = find_redundant(comment, offenses, cop, line_range,
@@ -115,7 +124,7 @@ module RuboCop
           end
         end
 
-        def each_already_disabled(line_ranges, disabled_ranges, comments)
+        def each_already_disabled(line_ranges, disabled_ranges)
           line_ranges.each_cons(2) do |previous_range, range|
             next if ignore_offense?(disabled_ranges, range)
             next if previous_range.end != range.begin
@@ -124,14 +133,12 @@ module RuboCop
             # the end of the previous range, it means that the cop was
             # already disabled by an earlier comment. So it's redundant
             # whether there are offenses or not.
-            redundant_comment = comments.find do |c|
-              c.loc.line == range.begin &&
-                # Comments disabling all cops don't count since it's reasonable
-                # to disable a few select cops first and then all cops further
-                # down in the code.
-                !all_disabled?(c)
-            end
-            yield redundant_comment if redundant_comment
+            comment = processed_source.comment_at_line(range.begin)
+
+            # Comments disabling all cops don't count since it's reasonable
+            # to disable a few select cops first and then all cops further
+            # down in the code.
+            yield comment if comment && !all_disabled?(comment)
           end
         end
 
@@ -250,7 +257,7 @@ module RuboCop
         end
 
         def all_cop_names
-          @all_cop_names ||= Cop.registry.names
+          @all_cop_names ||= Registry.global.names
         end
 
         def ends_its_line?(range)

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

@@ -45,18 +45,28 @@ module RuboCop
           return if processed_source.blank?
 
           offenses = processed_source.comment_config.extra_enabled_comments
-          offenses.each do |comment, name|
+          offenses.each { |comment, cop_names| register_offense(comment, cop_names) }
+        end
+
+        private
+
+        def register_offense(comment, cop_names)
+          directive = DirectiveComment.new(comment)
+
+          cop_names.each do |name|
             add_offense(
               range_of_offense(comment, name),
               message: format(MSG, cop: all_or_name(name))
             ) do |corrector|
-              corrector.remove(range_with_comma(comment, name))
+              if directive.match?(cop_names)
+                corrector.remove(range_with_surrounding_space(range: directive.range, side: :right))
+              else
+                corrector.remove(range_with_comma(comment, name))
+              end
             end
           end
         end
 
-        private
-
         def range_of_offense(comment, name)
           start_pos = comment_start(comment) + cop_name_indention(comment, name)
           range_between(start_pos, start_pos + name.size)

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

@@ -26,6 +26,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Remove unnecessary `require` statement.'
+        RESTRICT_ON_SEND = %i[require].freeze
 
         def_node_matcher :unnecessary_require_statement?, <<~PATTERN
           (send nil? :require

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

@@ -35,7 +35,6 @@ module RuboCop
       #     baz
       #   end
       class RescueType < Base
-        include RescueNode
         extend AutoCorrector
 
         MSG = 'Rescuing from `%<invalid_exceptions>s` will raise a ' \

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

@@ -40,10 +40,12 @@ module RuboCop
 
         MSG = 'Use `%<method>s %<module_name>s` instead of `%<bad_method>s`.'
         MIXIN_METHODS = %i[include prepend extend].freeze
+        SEND_METHODS = %i[send public_send __send__].freeze
+        RESTRICT_ON_SEND = SEND_METHODS
 
         def_node_matcher :send_with_mixin_argument?, <<~PATTERN
           (send
-            (const _ _) {:send :public_send :__send__}
+            (const _ _) {:#{SEND_METHODS.join(' :')}}
             ({sym str} $#mixin_method?)
               $(const _ _))
         PATTERN

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

@@ -75,8 +75,7 @@ module RuboCop
 
         def rescued_groups_for(rescues)
           rescues.map do |group|
-            rescue_group, = *group
-            evaluate_exceptions(rescue_group)
+            evaluate_exceptions(group)
           end
         end
 
@@ -117,14 +116,15 @@ module RuboCop
           $VERBOSE = old_verbose
         end
 
-        def evaluate_exceptions(rescue_group)
-          if rescue_group
-            rescued_exceptions = rescued_exceptions(rescue_group)
+        def evaluate_exceptions(group)
+          rescued_exceptions = group.exceptions
+
+          if rescued_exceptions.any?
             rescued_exceptions.each_with_object([]) do |exception, converted|
               begin
                 silence_warnings do
                   # Avoid printing deprecation warnings about constants
-                  converted << Kernel.const_get(exception)
+                  converted << Kernel.const_get(exception.source)
                 end
               rescue NameError
                 converted << nil

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

@@ -3,10 +3,10 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop looks for use of the same name as outer local variables
-      # for block arguments or block local variables.
-      # This is a mimic of the warning
-      # "shadowing outer local variable - foo" from `ruby -cw`.
+      # This cop checks for the use of local variable names from an outer scope
+      # in block arguments or block-local variables. This mirrors the warning
+      # given by `ruby -cw` prior to Ruby 2.6:
+      # "shadowing outer local variable - foo".
       #
       # @example
       #

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

@@ -24,6 +24,7 @@ module RuboCop
       class StructNewOverride < Base
         MSG = '`%<member_name>s` member overrides `Struct#%<method_name>s`' \
               ' and it may be unexpected.'
+        RESTRICT_ON_SEND = %i[new].freeze
 
         STRUCT_METHOD_NAMES = Struct.instance_methods
         STRUCT_MEMBER_NAME_TYPES = %i[sym str].freeze

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

@@ -9,12 +9,23 @@ module RuboCop
       # for an optional argument, your method should too.
       #
       # @example
-      #   # bad
-      #   def to_json
-      #   end
+      #   class Point
+      #     attr_reader :x, :y
+      #
+      #     # bad, incorrect arity
+      #     def to_json
+      #       JSON.generate([x, y])
+      #     end
+      #
+      #     # good, preserving args
+      #     def to_json(*args)
+      #       JSON.generate([x, y], *args)
+      #     end
       #
-      #   # good
-      #   def to_json(*_args)
+      #     # good, discarding args
+      #     def to_json(*_args)
+      #       JSON.generate([x, y])
+      #     end
       #   end
       #
       class ToJSON < Base

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

@@ -11,7 +11,7 @@ module RuboCop
       #
       #   # Detected since Ruby 2.7
       #   return 1 # 1 is always ignored.
-      class TopLevelReturnWithArgument < Cop
+      class TopLevelReturnWithArgument < Base
         # This cop works by validating the ancestors of the return node. A
         # top-level return node's ancestors should not be of block, def, or
         # defs type.

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for trailing commas in attribute declarations, such as
+      # `#attr_reader`. Leaving a trailing comma will nullify the next method
+      # definition by overriding it with a getter method.
+      #
+      # @example
+      #
+      #   # bad
+      #   class Foo
+      #     attr_reader :foo,
+      #
+      #     def bar
+      #       puts "Unreachable."
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     attr_reader :foo
+      #
+      #     def bar
+      #       puts "No problem!"
+      #     end
+      #   end
+      #
+      class TrailingCommaInAttributeDeclaration < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Avoid leaving a trailing comma in attribute declarations.'
+
+        def on_send(node)
+          return unless node.attribute_accessor? && node.arguments.last.def_type?
+
+          trailing_comma = trailing_comma_range(node)
+
+          add_offense(trailing_comma) do |corrector|
+            corrector.remove(trailing_comma)
+          end
+        end
+
+        private
+
+        def trailing_comma_range(node)
+          range_with_surrounding_space(
+            range: node.arguments[-2].source_range,
+            side: :right
+          ).end.resize(1)
+        end
+      end
+    end
+  end
+end

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

@@ -130,7 +130,8 @@ module RuboCop
           case node.type
           when :begin, :kwbegin
             statements = *node
-            statements.any? { |statement| break_statement?(statement) }
+            break_statement = statements.find { |statement| break_statement?(statement) }
+            break_statement && !preceded_by_continue_statement?(break_statement)
           when :if
             check_if(node)
           when :case
@@ -158,16 +159,12 @@ module RuboCop
         end
 
         def preceded_by_continue_statement?(break_statement)
-          left_siblings_of(break_statement).any? do |sibling|
+          break_statement.left_siblings.any? do |sibling|
             next if sibling.loop_keyword? || loop_method?(sibling)
 
             sibling.each_descendant(:next, :redo).any?
           end
         end
-
-        def left_siblings_of(node)
-          node.parent.children[0, node.sibling_index]
-        end
       end
     end
   end

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

@@ -44,10 +44,12 @@ module RuboCop
         MSG = '`%<uri_method>s` method is obsolete and should not be used. ' \
               'Instead, use %<replacements>s depending on your specific use ' \
               'case.'
+        METHOD_NAMES = %i[escape encode unescape decode].freeze
+        RESTRICT_ON_SEND = METHOD_NAMES
 
         def_node_matcher :uri_escape_unescape?, <<~PATTERN
           (send
-            (const ${nil? cbase} :URI) ${:escape :encode :unescape :decode}
+            (const ${nil? cbase} :URI) ${:#{METHOD_NAMES.join(' :')}}
             ...)
         PATTERN
 

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

@@ -16,35 +16,20 @@ module RuboCop
       class UriRegexp < Base
         extend AutoCorrector
 
-        MSG = '`%<top_level>sURI.regexp%<arg>s` is obsolete and should not ' \
-              'be used. Instead, use `%<top_level>sURI::DEFAULT_PARSER.' \
-              'make_regexp%<arg>s`.'
-
-        def_node_matcher :uri_regexp_with_argument?, <<~PATTERN
-          (send
-            (const ${nil? cbase} :URI) :regexp
-            ${(str _) (array ...)})
-        PATTERN
-
-        def_node_matcher :uri_regexp_without_argument?, <<~PATTERN
-          (send
-            (const ${nil? cbase} :URI) :regexp)
-        PATTERN
+        MSG = '`%<current>s` is obsolete and should not be used. Instead, use `%<preferred>s`.'
+        URI_CONSTANTS = ['URI', '::URI'].freeze
+        RESTRICT_ON_SEND = %i[regexp].freeze
 
         def on_send(node)
-          return unless node.method?(:regexp)
-
-          captured_values = uri_regexp_with_argument?(node) || uri_regexp_without_argument?(node)
-
-          double_colon, arg = captured_values
-
-          top_level = double_colon ? '::' : ''
-          argument = arg ? "(#{arg.source})" : ''
+          return unless node.receiver
+          return unless URI_CONSTANTS.include?(node.receiver.source)
 
-          format = format(MSG, top_level: top_level, arg: argument)
+          argument = node.first_argument ? "(#{node.first_argument.source})" : ''
+          preferred_method = "#{node.receiver.source}::DEFAULT_PARSER.make_regexp#{argument}"
+          message = format(MSG, current: node.source, preferred: preferred_method)
 
-          add_offense(node.loc.selector, message: format) do |corrector|
-            corrector.replace(node, "#{top_level}URI::DEFAULT_PARSER.make_regexp#{argument}")
+          add_offense(node.loc.selector, message: message) do |corrector|
+            corrector.replace(node, preferred_method)
           end
         end
       end