rubocop 0.85.1 → 0.89.1

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for top level return with arguments. If there is a
+      # top-level return statement with an argument, then the argument is
+      # always ignored. This is detected automatically since Ruby 2.7.
+      #
+      # @example
+      #
+      #   # Detected since Ruby 2.7
+      #   return 1 # 1 is always ignored.
+      class TopLevelReturnWithArgument < Cop
+        # 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.
+
+        MSG = 'Top level return with argument detected.'
+
+        def on_return(return_node)
+          add_offense(return_node) if return_node.arguments? && ancestors_valid?(return_node)
+        end
+
+        private
+
+        def ancestors_valid?(return_node)
+          prohibited_ancestors = return_node.each_ancestor(:block, :def, :defs)
+          prohibited_ancestors.none?
+        end
+      end
+    end
+  end
+end

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

@@ -40,11 +40,11 @@ module RuboCop
       #     {_id: _id, profit: revenue - cost}
       #   end
       #
-      class UnderscorePrefixedVariableName < Cop
+      class UnderscorePrefixedVariableName < Base
         MSG = 'Do not use prefix `_` for a variable that is used.'
 
-        def join_force?(force_class)
-          force_class == VariableForce
+        def self.joining_forces
+          VariableForce
         end
 
         def after_leaving_scope(scope, _variable_table)
@@ -66,7 +66,7 @@ module RuboCop
                        node.loc.name
                      end
 
-          add_offense(nil, location: location)
+          add_offense(location)
         end
 
         private

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

@@ -17,7 +17,9 @@ module RuboCop
       #   # good
       #
       #   1.is_a?(Integer)
-      class UnifiedInteger < Cop
+      class UnifiedInteger < Base
+        extend AutoCorrector
+
         MSG = 'Use `Integer` instead of `%<klass>s`.'
 
         def_node_matcher :fixnum_or_bignum_const, <<~PATTERN
@@ -29,11 +31,7 @@ module RuboCop
 
           return unless klass
 
-          add_offense(node, message: format(MSG, klass: klass))
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(node, message: format(MSG, klass: klass)) do |corrector|
             corrector.replace(node.loc.name, 'Integer')
           end
         end

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

@@ -34,7 +34,7 @@ module RuboCop
       #   def some_method
       #     do_something
       #   end
-      class UnreachableCode < Cop
+      class UnreachableCode < Base
         MSG = 'Unreachable code detected.'
 
         def on_begin(node)

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

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for loops that will have at most one iteration.
+      #
+      # A loop that can never reach the second iteration is a possible error in the code.
+      # In rare cases where only one iteration (or at most one iteration) is intended behavior,
+      # the code should be refactored to use `if` conditionals.
+      #
+      # @example
+      #   # bad
+      #   while node
+      #     do_something(node)
+      #     node = node.parent
+      #     break
+      #   end
+      #
+      #   # good
+      #   while node
+      #     do_something(node)
+      #     node = node.parent
+      #   end
+      #
+      #   # bad
+      #   def verify_list(head)
+      #     item = head
+      #     begin
+      #       if verify(item)
+      #         return true
+      #       else
+      #         return false
+      #       end
+      #     end while(item)
+      #   end
+      #
+      #   # good
+      #   def verify_list(head)
+      #     item = head
+      #     begin
+      #       if verify(item)
+      #         item = item.next
+      #       else
+      #         return false
+      #       end
+      #     end while(item)
+      #
+      #     true
+      #   end
+      #
+      #   # bad
+      #   def find_something(items)
+      #     items.each do |item|
+      #       if something?(item)
+      #         return item
+      #       else
+      #         raise NotFoundError
+      #       end
+      #     end
+      #   end
+      #
+      #   # good
+      #   def find_something(items)
+      #     items.each do |item|
+      #       if something?(item)
+      #         return item
+      #       end
+      #     end
+      #     raise NotFoundError
+      #   end
+      #
+      class UnreachableLoop < Base
+        MSG = 'This loop will have at most one iteration.'
+
+        def on_while(node)
+          check(node)
+        end
+        alias on_until on_while
+        alias on_while_post on_while
+        alias on_until_post on_while
+        alias on_for on_while
+
+        def on_block(node)
+          check(node) if loop_method?(node)
+        end
+
+        private
+
+        def loop_method?(node)
+          return false unless node.block_type?
+
+          send_node = node.send_node
+          send_node.enumerable_method? || send_node.enumerator_method? || send_node.method?(:loop)
+        end
+
+        def check(node)
+          statements = statements(node)
+          break_statement = statements.find { |statement| break_statement?(statement) }
+          return unless break_statement
+
+          add_offense(node) unless preceded_by_continue_statement?(break_statement)
+        end
+
+        def statements(node)
+          body = node.body
+
+          if body.nil?
+            []
+          elsif body.begin_type?
+            body.children
+          else
+            [body]
+          end
+        end
+
+        def_node_matcher :break_command?, <<~PATTERN
+          {
+            return break
+            (send
+             {nil? (const {nil? cbase} :Kernel)}
+             {:raise :fail :throw :exit :exit! :abort}
+             ...)
+          }
+        PATTERN
+
+        def break_statement?(node)
+          return true if break_command?(node)
+
+          case node.type
+          when :begin, :kwbegin
+            statements = *node
+            statements.any? { |statement| break_statement?(statement) }
+          when :if
+            check_if(node)
+          when :case
+            check_case(node)
+          else
+            false
+          end
+        end
+
+        def check_if(node)
+          if_branch = node.if_branch
+          else_branch = node.else_branch
+          if_branch && else_branch &&
+            break_statement?(if_branch) && break_statement?(else_branch)
+        end
+
+        def check_case(node)
+          else_branch = node.else_branch
+          return false unless else_branch
+          return false unless break_statement?(else_branch)
+
+          node.when_branches.all? do |branch|
+            branch.body && break_statement?(branch.body)
+          end
+        end
+
+        def preceded_by_continue_statement?(break_statement)
+          left_siblings_of(break_statement).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
+end

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

@@ -52,15 +52,20 @@ module RuboCop
       #     foo
       #   end
       #
-      class UnusedBlockArgument < Cop
+      class UnusedBlockArgument < Base
         include UnusedArgument
+        extend AutoCorrector
 
-        def autocorrect(node)
-          UnusedArgCorrector.correct(processed_source, node)
+        def self.joining_forces
+          VariableForce
         end
 
         private
 
+        def autocorrect(corrector, node)
+          UnusedArgCorrector.correct(corrector, processed_source, node)
+        end
+
         def check_argument(variable)
           return if allowed_block?(variable) ||
                     allowed_keyword_argument?(variable)

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

@@ -58,20 +58,25 @@ module RuboCop
       #     fail "TODO"
       #   end
       #
-      class UnusedMethodArgument < Cop
+      class UnusedMethodArgument < Base
         include UnusedArgument
+        extend AutoCorrector
 
         def_node_matcher :not_implemented?, <<~PATTERN
-          {(send nil? :raise (const nil? :NotImplementedError))
+          {(send nil? :raise (const {nil? cbase} :NotImplementedError))
            (send nil? :fail ...)}
         PATTERN
 
-        def autocorrect(node)
-          UnusedArgCorrector.correct(processed_source, node)
+        def self.joining_forces
+          VariableForce
         end
 
         private
 
+        def autocorrect(corrector, node)
+          UnusedArgCorrector.correct(corrector, processed_source, node)
+        end
+
         def check_argument(variable)
           return unless variable.method_argument?
           return if variable.keyword_argument? &&

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

@@ -29,7 +29,7 @@ module RuboCop
       #   CGI.unescape(enc_uri)
       #   URI.decode_www_form(enc_uri)
       #   URI.decode_www_form_component(enc_uri)
-      class UriEscapeUnescape < Cop
+      class UriEscapeUnescape < Base
         ALTERNATE_METHODS_OF_URI_ESCAPE = %w[
           CGI.escape
           URI.encode_www_form

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

@@ -13,60 +13,24 @@ module RuboCop
       #   # good
       #   URI::DEFAULT_PARSER.make_regexp('http://example.com')
       #
-      class UriRegexp < Cop
-        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`.'
+      class UriRegexp < Base
+        extend AutoCorrector
 
-        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
 
         def on_send(node)
-          uri_regexp_with_argument?(node) do |double_colon, arg|
-            register_offense(
-              node, top_level: double_colon ? '::' : '', arg: "(#{arg.source})"
-            )
-          end
-
-          uri_regexp_without_argument?(node) do |double_colon|
-            register_offense(node, top_level: double_colon ? '::' : '')
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            if (captured_values = uri_regexp_with_argument?(node))
-            else
-              captured_values = uri_regexp_without_argument?(node)
-            end
+          return unless node.method?(:regexp) && node.receiver
+          return unless URI_CONSTANTS.include?(node.receiver.source)
 
-            double_colon, arg = captured_values
+          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)
 
-            top_level = double_colon ? '::' : ''
-            argument = arg ? "(#{arg.source})" : ''
-
-            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
-
-        private
-
-        def register_offense(node, top_level: '', arg: '')
-          format = format(MSG, top_level: top_level, arg: arg)
-
-          add_offense(node, location: :selector, message: format)
-        end
       end
     end
   end

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

@@ -124,8 +124,9 @@ module RuboCop
       #
       #     delegate :method_a, to: :method_b
       #   end
-      class UselessAccessModifier < Cop
+      class UselessAccessModifier < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Useless `%<current>s` access modifier.'
 
@@ -147,17 +148,13 @@ module RuboCop
           check_node(node.children[1]) # singleton class body
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            range = range_by_whole_lines(
-              node.source_range, include_final_newline: true
-            )
+        private
 
-            corrector.remove(range)
-          end
-        end
+        def autocorrect(corrector, node)
+          range = range_by_whole_lines(node.source_range, include_final_newline: true)
 
-        private
+          corrector.remove(range)
+        end
 
         def_node_matcher :static_method_definition?, <<~PATTERN
           {def (send nil? {:attr :attr_reader :attr_writer :attr_accessor} ...)}
@@ -172,7 +169,7 @@ module RuboCop
         PATTERN
 
         def_node_matcher :class_or_module_or_struct_new_call?, <<~PATTERN
-          (block (send (const nil? {:Class :Module :Struct}) :new ...) ...)
+          (block (send (const {nil? cbase} {:Class :Module :Struct}) :new ...) ...)
         PATTERN
 
         def check_node(node)
@@ -181,7 +178,9 @@ module RuboCop
           if node.begin_type?
             check_scope(node)
           elsif node.send_type? && node.bare_access_modifier?
-            add_offense(node, message: format(MSG, current: node.method_name))
+            add_offense(node, message: format(MSG, current: node.method_name)) do |corrector|
+              autocorrect(corrector, node)
+            end
           end
         end
 
@@ -192,8 +191,11 @@ module RuboCop
 
         def check_scope(node)
           cur_vis, unused = check_child_nodes(node, nil, :public)
+          return unless unused
 
-          add_offense(unused, message: format(MSG, current: cur_vis)) if unused
+          add_offense(unused, message: format(MSG, current: cur_vis)) do |corrector|
+            autocorrect(corrector, unused)
+          end
         end
 
         def check_child_nodes(node, unused, cur_vis)
@@ -216,7 +218,9 @@ module RuboCop
           if node.bare_access_modifier?
             check_new_visibility(node, unused, node.method_name, cur_vis)
           elsif node.method?(:private_class_method) && !node.arguments?
-            add_offense(node, message: format(MSG, current: node.method_name))
+            add_offense(node, message: format(MSG, current: node.method_name)) do |corrector|
+              autocorrect(corrector, node)
+            end
             [cur_vis, unused]
           end
         end
@@ -224,10 +228,16 @@ module RuboCop
         def check_new_visibility(node, unused, new_vis, cur_vis)
           # does this modifier just repeat the existing visibility?
           if new_vis == cur_vis
-            add_offense(node, message: format(MSG, current: cur_vis))
+            add_offense(node, message: format(MSG, current: cur_vis)) do |corrector|
+              autocorrect(corrector, node)
+            end
           else
             # was the previous modifier never applied to any defs?
-            add_offense(unused, message: format(MSG, current: cur_vis)) if unused
+            if unused
+              add_offense(unused, message: format(MSG, current: cur_vis)) do |corrector|
+                autocorrect(corrector, unused)
+              end
+            end
             # once we have already warned about a certain modifier, don't
             # warn again even if it is never applied to any method defs
             unused = node

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

@@ -30,11 +30,11 @@ module RuboCop
       #     some_var = 1
       #     do_something(some_var)
       #   end
-      class UselessAssignment < Cop
+      class UselessAssignment < Base
         MSG = 'Useless assignment to variable - `%<variable>s`.'
 
-        def join_force?(force_class)
-          force_class == VariableForce
+        def self.joining_forces
+          VariableForce
         end
 
         def after_leaving_scope(scope, _variable_table)
@@ -57,7 +57,7 @@ module RuboCop
                          assignment.node.loc.name
                        end
 
-            add_offense(nil, location: location, message: message)
+            add_offense(location, message: message)
           end
         end
 

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

@@ -29,24 +29,15 @@ module RuboCop
       #   else
       #     do_something_else
       #   end
-      class UselessElseWithoutRescue < Cop
-        include ParserDiagnostic
-
+      class UselessElseWithoutRescue < Base
         MSG = '`else` without `rescue` is useless.'
 
-        private
-
-        def relevant_diagnostic?(diagnostic)
-          diagnostic.reason == :useless_else
-        end
-
-        def find_offense_node_by(diagnostic)
-          # TODO: When implementing auto-correction, this method should return
-          # an offense node passed as first argument of `add_offense` method.
-        end
+        def on_new_investigation
+          processed_source.diagnostics.each do |diagnostic|
+            next unless diagnostic.reason == :useless_else
 
-        def alternative_message(_diagnostic)
-          MSG
+            add_offense(diagnostic.location, severity: diagnostic.level)
+          end
         end
       end
     end

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

@@ -28,7 +28,7 @@ module RuboCop
       #     x.attr = 5
       #     x
       #   end
-      class UselessSetterCall < Cop
+      class UselessSetterCall < Base
         MSG = 'Useless setter call to local variable `%<variable>s`.'
         ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn].freeze
 
@@ -43,11 +43,9 @@ module RuboCop
           variable_name, = *receiver
           return unless tracker.contain_local_object?(variable_name)
 
-          add_offense(
-            receiver,
-            location: :name,
-            message: format(MSG, variable: receiver.loc.name.source)
-          )
+          loc_name = receiver.loc.name
+
+          add_offense(loc_name, message: format(MSG, variable: loc_name.source))
         end
         alias on_defs on_def
 

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

@@ -40,7 +40,7 @@ module RuboCop
       #     some_array.sort!
       #     do_something(some_array)
       #   end
-      class Void < Cop
+      class Void < Base
         OP_MSG = 'Operator `%<op>s` used in void context.'
         VAR_MSG = 'Variable `%<var>s` used in void context.'
         LIT_MSG = 'Literal `%<lit>s` used in void context.'
@@ -97,17 +97,13 @@ module RuboCop
         def check_void_op(node)
           return unless node.send_type? && OPERATORS.include?(node.method_name)
 
-          add_offense(node,
-                      location: :selector,
-                      message: format(OP_MSG, op: node.method_name))
+          add_offense(node.loc.selector, message: format(OP_MSG, op: node.method_name))
         end
 
         def check_var(node)
           return unless node.variable? || node.const_type?
 
-          add_offense(node,
-                      location: :name,
-                      message: format(VAR_MSG, var: node.loc.name.source))
+          add_offense(node.loc.name, message: format(VAR_MSG, var: node.loc.name.source))
         end
 
         def check_literal(node)

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

@@ -7,7 +7,7 @@ module RuboCop
       # configured maximum. The ABC size is based on assignments, branches
       # (method calls), and conditions. See http://c2.com/cgi/wiki?AbcMetric
       # and https://en.wikipedia.org/wiki/ABC_Software_Metric.
-      class AbcSize < Cop
+      class AbcSize < Base
         include MethodComplexity
 
         MSG = 'Assignment Branch Condition size for %<method>s is too high. ' \

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

@@ -7,8 +7,30 @@ module RuboCop
       # Comment lines can optionally be ignored.
       # The maximum allowed length is configurable.
       # The cop can be configured to ignore blocks passed to certain methods.
-      class BlockLength < Cop
-        include TooManyLines
+      #
+      # You can set literals you want to fold with `CountAsOne`.
+      # Available are: 'array', 'hash', and 'heredoc'. Each literal
+      # will be counted as one line regardless of its actual size.
+      #
+      # @example CountAsOne: ['array', 'heredoc']
+      #
+      #   something do
+      #     array = [         # +1
+      #       1,
+      #       2
+      #     ]
+      #
+      #     hash = {          # +3
+      #       key: 'value'
+      #     }
+      #
+      #     msg = <<~HEREDOC  # +1
+      #       Heredoc
+      #       content.
+      #     HEREDOC
+      #   end                 # 5 points
+      class BlockLength < Base
+        include CodeLength
 
         LABEL = 'Block'
 

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

@@ -11,7 +11,7 @@ module RuboCop
       # towards the nesting level. Set to `true` to count blocks as well.
       #
       # The maximum level of nesting allowed is configurable.
-      class BlockNesting < Cop
+      class BlockNesting < Base
         include ConfigurableMax
 
         NESTING_BLOCKS = %i[
@@ -19,7 +19,7 @@ module RuboCop
           until until_post for resbody
         ].freeze
 
-        def investigate(processed_source)
+        def on_new_investigation
           return if processed_source.blank?
 
           max = cop_config['Max']