rubocop 0.88.0 → 0.91.1

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

@@ -31,7 +31,7 @@ module RuboCop
       #   def foo=(bar)
       #     return
       #   end
-      class ReturnInVoidContext < Cop
+      class ReturnInVoidContext < Base
         MSG = 'Do not return a value in `%<method>s`.'
 
         def on_return(return_node)
@@ -45,9 +45,7 @@ module RuboCop
 
           return unless method_name && void_context_method?(method_name)
 
-          add_offense(return_node,
-                      location: :keyword,
-                      message: format(message, method: method_name))
+          add_offense(return_node.loc.keyword, message: format(message, method: method_name))
         end
 
         private

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

@@ -23,7 +23,7 @@ module RuboCop
       #
       #   x&.foo&.bar
       #   x&.foo || bar
-      class SafeNavigationChain < Cop
+      class SafeNavigationChain < Base
         include NilMethods
 
         MSG = 'Do not chain ordinary method call' \
@@ -45,7 +45,7 @@ module RuboCop
               Parser::Source::Range.new(node.source_range.source_buffer,
                                         safe_nav.source_range.end_pos,
                                         method_chain.source_range.end_pos)
-            add_offense(node, location: location)
+            add_offense(location)
           end
         end
 
@@ -53,10 +53,7 @@ module RuboCop
 
         def method_chain(node)
           chain = node
-          while chain.send_type?
-            chain = chain.parent if chain.parent&.call_type?
-            break # FIXME: Unconditional break. Why while "loop" then?
-          end
+          chain = chain.parent if chain.send_type? && chain.parent&.call_type?
           chain
         end
       end

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

@@ -26,9 +26,10 @@ module RuboCop
       #   # good
       #   foo&.bar && (foobar.baz || foo&.baz)
       #
-      class SafeNavigationConsistency < Cop
+      class SafeNavigationConsistency < Base
         include IgnoredNode
         include NilMethods
+        extend AutoCorrector
 
         MSG = 'Ensure that safe navigation is used consistently ' \
           'inside of `&&` and `||`.'
@@ -49,24 +50,27 @@ module RuboCop
             unsafe_method_calls(method_calls, safe_nav_receiver)
 
           unsafe_method_calls.each do |unsafe_method_call|
-            location =
-              node.loc.expression.join(unsafe_method_call.loc.expression)
-            add_offense(unsafe_method_call,
-                        location: location)
+            location = location(node, unsafe_method_call)
+
+            add_offense(location) do |corrector|
+              autocorrect(corrector, unsafe_method_call)
+            end
 
             ignore_node(unsafe_method_call)
           end
         end
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, node)
           return unless node.dot?
 
-          lambda do |corrector|
-            corrector.insert_before(node.loc.dot, '&')
-          end
+          corrector.insert_before(node.loc.dot, '&')
         end
 
-        private
+        def location(node, unsafe_method_call)
+          node.loc.expression.join(unsafe_method_call.loc.expression)
+        end
 
         def top_conditional_ancestor(node)
           parent = node.parent

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

@@ -19,7 +19,9 @@ module RuboCop
       #   return if foo && foo.empty?
       #   return unless foo && foo.empty?
       #
-      class SafeNavigationWithEmpty < Cop
+      class SafeNavigationWithEmpty < Base
+        extend AutoCorrector
+
         MSG = 'Avoid calling `empty?` with the safe navigation operator ' \
           'in conditionals.'
 
@@ -30,14 +32,12 @@ module RuboCop
         def on_if(node)
           return unless safe_navigation_empty_in_conditional?(node)
 
-          add_offense(node.condition)
-        end
+          condition = node.condition
 
-        def autocorrect(node)
-          lambda do |corrector|
-            receiver = node.receiver.source
+          add_offense(condition) do |corrector|
+            receiver = condition.receiver.source
 
-            corrector.replace(node, "#{receiver} && #{receiver}.#{node.method_name}")
+            corrector.replace(condition, "#{receiver} && #{receiver}.#{condition.method_name}")
           end
         end
       end

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

@@ -30,11 +30,13 @@ module RuboCop
       #
       #   puts 'hello, world'
       #
-      class ScriptPermission < Cop
+      class ScriptPermission < Base
+        extend AutoCorrector
+
         MSG = "Script file %<file>s doesn't have execute permission."
         SHEBANG = '#!'
 
-        def investigate(processed_source)
+        def on_new_investigation
           return if @options.key?(:stdin)
           return if Platform.windows?
           return unless processed_source.start_with?(SHEBANG)
@@ -42,17 +44,18 @@ module RuboCop
 
           comment = processed_source.comments[0]
           message = format_message_from(processed_source)
-          add_offense(comment, message: message)
-        end
 
-        def autocorrect(node)
-          lambda do |_corrector|
-            FileUtils.chmod('+x', node.loc.expression.source_buffer.name)
+          add_offense(comment, message: message) do
+            autocorrect(comment) if autocorrect_requested?
           end
         end
 
         private
 
+        def autocorrect(comment)
+          FileUtils.chmod('+x', comment.loc.expression.source_buffer.name)
+        end
+
         def executable?(processed_source)
           # Returns true if stat is executable or if the operating system
           # doesn't distinguish executable files from nonexecutable files.

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for self-assignments.
+      #
+      # @example
+      #   # bad
+      #   foo = foo
+      #   foo, bar = foo, bar
+      #   Foo = Foo
+      #
+      #   # good
+      #   foo = bar
+      #   foo, bar = bar, foo
+      #   Foo = Bar
+      #
+      class SelfAssignment < Base
+        MSG = 'Self-assignment detected.'
+
+        ASSIGNMENT_TYPE_TO_RHS_TYPE = {
+          lvasgn: :lvar,
+          ivasgn: :ivar,
+          cvasgn: :cvar,
+          gvasgn: :gvar
+        }.freeze
+
+        def on_lvasgn(node)
+          lhs, rhs = *node
+          return unless rhs
+
+          rhs_type = ASSIGNMENT_TYPE_TO_RHS_TYPE[node.type]
+
+          add_offense(node) if rhs.type == rhs_type && rhs.source == lhs.to_s
+        end
+        alias on_ivasgn on_lvasgn
+        alias on_cvasgn on_lvasgn
+        alias on_gvasgn on_lvasgn
+
+        def on_casgn(node)
+          lhs_scope, lhs_name, rhs = *node
+          return unless rhs&.const_type?
+
+          rhs_scope, rhs_name = *rhs
+          add_offense(node) if lhs_scope == rhs_scope && lhs_name == rhs_name
+        end
+
+        def on_masgn(node)
+          add_offense(node) if multiple_self_assignment?(node)
+        end
+
+        def on_or_asgn(node)
+          lhs, rhs = *node
+          add_offense(node) if rhs_matches_lhs?(rhs, lhs)
+        end
+        alias on_and_asgn on_or_asgn
+
+        private
+
+        def multiple_self_assignment?(node)
+          lhs, rhs = *node
+          return false unless rhs.array_type?
+          return false unless lhs.children.size == rhs.children.size
+
+          lhs.children.zip(rhs.children).all? do |lhs_item, rhs_item|
+            rhs_matches_lhs?(rhs_item, lhs_item)
+          end
+        end
+
+        def rhs_matches_lhs?(rhs, lhs)
+          rhs.type == ASSIGNMENT_TYPE_TO_RHS_TYPE[lhs.type] &&
+            rhs.children.first == lhs.children.first
+        end
+      end
+    end
+  end
+end

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

@@ -34,15 +34,18 @@ module RuboCop
       #   Foo.prepend Bar
       #   Foo.extend Bar
       #
-      class SendWithMixinArgument < Cop
+      class SendWithMixinArgument < Base
         include RangeHelp
+        extend AutoCorrector
 
         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
@@ -53,16 +56,9 @@ module RuboCop
               method, module_name.source, bad_location(node).source
             )
 
-            add_offense(node, location: bad_location(node), message: message)
-          end
-        end
-
-        def autocorrect(node)
-          send_with_mixin_argument?(node) do |method, module_name|
-            lambda do |corrector|
-              corrector.replace(
-                bad_location(node), "#{method} #{module_name.source}"
-              )
+            bad_location = bad_location(node)
+            add_offense(bad_location, message: message) do |corrector|
+              corrector.replace(bad_location, "#{method} #{module_name.source}")
             end
           end
         end

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
@@ -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
       #
@@ -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.