rubocop 0.87.1 → 0.91.0

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

@@ -63,14 +63,14 @@ module RuboCop
       #     bar
       #   end
       #
-      class ShadowedArgument < Cop
+      class ShadowedArgument < Base
         MSG = 'Argument `%<argument>s` was shadowed by a local variable ' \
               'before it was used.'
 
         def_node_search :uses_var?, '(lvar %)'
 
-        def join_force?(force_class)
-          force_class == VariableForce
+        def self.joining_forces
+          VariableForce
         end
 
         def after_leaving_scope(scope, _variable_table)

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

@@ -43,7 +43,7 @@ module RuboCop
       #     handle_standard_error
       #   end
       #
-      class ShadowedException < Cop
+      class ShadowedException < Base
         include RescueNode
         include RangeHelp
 
@@ -62,7 +62,7 @@ module RuboCop
           return if !rescue_group_rescues_multiple_levels &&
                     sorted?(rescued_groups)
 
-          add_offense(node, location: offense_range(rescues))
+          add_offense(offense_range(rescues))
         end
 
         private

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
       #
@@ -31,11 +31,11 @@ module RuboCop
       #       do_something(bar)
       #     end
       #   end
-      class ShadowingOuterLocalVariable < Cop
+      class ShadowingOuterLocalVariable < Base
         MSG = 'Shadowing outer local variable - `%<variable>s`.'
 
-        def join_force?(force_class)
-          force_class == VariableForce
+        def self.joining_forces
+          VariableForce
         end
 
         def before_declaring_variable(variable, variable_table)

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

@@ -21,9 +21,10 @@ module RuboCop
       #   g.clone #=> #<struct Good id=1, name="foo">
       #   g.count #=> 2
       #
-      class StructNewOverride < Cop
+      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/suppressed_exception.rb

@@ -64,7 +64,7 @@ module RuboCop
       #   rescue
       #     # do nothing
       #   end
-      class SuppressedException < Cop
+      class SuppressedException < Base
         MSG = 'Do not suppress exceptions.'
 
         def on_resbody(node)
@@ -77,13 +77,10 @@ module RuboCop
         private
 
         def comment_between_rescue_and_end?(node)
-          end_line = nil
-          node.each_ancestor(:kwbegin, :def, :defs, :block) do |ancestor|
-            end_line = ancestor.loc.end.line
-            break
-          end
-          return false unless end_line
+          ancestor = node.each_ancestor(:kwbegin, :def, :defs, :block).first
+          return unless ancestor
 
+          end_line = ancestor.loc.end.line
           processed_source[node.first_line...end_line].any? { |line| comment_line?(line) }
         end
       end

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

@@ -9,26 +9,35 @@ 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 < Cop
+      class ToJSON < Base
+        extend AutoCorrector
+
         MSG = ' `#to_json` requires an optional argument to be parsable ' \
           'via JSON.generate(obj).'
 
         def on_def(node)
           return unless node.method?(:to_json) && node.arguments.empty?
 
-          add_offense(node)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(node) do |corrector|
             # The following used `*_args` because `to_json(*args)` has
             # an offense of `Lint/UnusedMethodArgument` cop if `*args`
             # is not used.

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 < 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.
+
+        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/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/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,175 @@
+# 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
+            break_statement = statements.find { |statement| break_statement?(statement) }
+            break_statement && !preceded_by_continue_statement?(break_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