rubocop 0.82.0 → 1.18.4

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,35 +34,30 @@ 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
 
+        # @!method send_with_mixin_argument?(node)
         def_node_matcher :send_with_mixin_argument?, <<~PATTERN
           (send
-            (const _ _) {:send :public_send :__send__}
+            (const _ _) {:#{SEND_METHODS.join(' :')}}
             ({sym str} $#mixin_method?)
               $(const _ _))
         PATTERN
 
         def on_send(node)
           send_with_mixin_argument?(node) do |method, module_name|
-            message = message(
-              method, module_name.source, bad_location(node).source
-            )
+            message = message(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
@@ -76,10 +71,7 @@ module RuboCop
         end
 
         def message(method, module_name, bad_method)
-          format(
-            MSG,
-            method: method, module_name: module_name, bad_method: bad_method
-          )
+          format(MSG, method: method, module_name: module_name, bad_method: bad_method)
         end
 
         def mixin_method?(node)

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

@@ -63,20 +63,18 @@ module RuboCop
       #     bar
       #   end
       #
-      class ShadowedArgument < Cop
-        MSG = 'Argument `%<argument>s` was shadowed by a local variable ' \
-              'before it was used.'
+      class ShadowedArgument < Base
+        MSG = 'Argument `%<argument>s` was shadowed by a local variable before it was used.'
 
+        # @!method uses_var?(node)
         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)
-          scope.variables.each_value do |variable|
-            check_argument(variable)
-          end
+          scope.variables.each_value { |variable| check_argument(variable) }
         end
 
         private
@@ -127,8 +125,7 @@ module RuboCop
             next false if assignment_node.shorthand_asgn?
 
             node_within_block_or_conditional =
-              node_within_block_or_conditional?(assignment_node.parent,
-                                                argument.scope.node)
+              node_within_block_or_conditional?(assignment_node.parent, argument.scope.node)
 
             unless uses_var?(assignment_node, argument.name)
               # It's impossible to decide whether a branch or block is executed,
@@ -161,10 +158,7 @@ module RuboCop
         # Get argument references without assignments' references
         #
         def argument_references(argument)
-          assignment_references = argument
-                                  .assignments
-                                  .flat_map(&:references)
-                                  .map(&:source_range)
+          assignment_references = argument.assignments.flat_map(&:references).map(&:source_range)
 
           argument.references.reject do |ref|
             next false unless ref.explicit?

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
 
@@ -59,10 +59,9 @@ module RuboCop
             contains_multiple_levels_of_exceptions?(group)
           end
 
-          return if !rescue_group_rescues_multiple_levels &&
-                    sorted?(rescued_groups)
+          return if !rescue_group_rescues_multiple_levels && sorted?(rescued_groups)
 
-          add_offense(node, location: offense_range(rescues))
+          add_offense(offense_range(rescues))
         end
 
         private
@@ -74,19 +73,14 @@ module RuboCop
         end
 
         def rescued_groups_for(rescues)
-          rescues.map do |group|
-            rescue_group, = *group
-            evaluate_exceptions(rescue_group)
-          end
+          rescues.map { |group| evaluate_exceptions(group) }
         end
 
         def contains_multiple_levels_of_exceptions?(group)
           # Always treat `Exception` as the highest level exception.
           return true if group.size > 1 && group.include?(Exception)
 
-          group.combination(2).any? do |a, b|
-            compare_exceptions(a, b)
-          end
+          group.combination(2).any? { |a, b| compare_exceptions(a, b) }
         end
 
         def compare_exceptions(exception, other_exception)
@@ -107,28 +101,23 @@ module RuboCop
           error && error.ancestors[1] == SystemCallError
         end
 
-        def silence_warnings
-          # Replaces Kernel::silence_warnings since it hides any warnings,
-          # including the RuboCop ones
-          old_verbose = $VERBOSE
-          $VERBOSE = nil
-          yield
-        ensure
-          $VERBOSE = old_verbose
-        end
+        def evaluate_exceptions(group)
+          rescued_exceptions = group.exceptions
 
-        def evaluate_exceptions(rescue_group)
-          if rescue_group
-            rescued_exceptions = rescued_exceptions(rescue_group)
+          if rescued_exceptions.any?
             rescued_exceptions.each_with_object([]) do |exception, converted|
+              # FIXME: Workaround `rubocop:disable` comment for JRuby.
+              #        https://github.com/jruby/jruby/issues/6642
+              # rubocop:disable Style/RedundantBegin
               begin
-                silence_warnings do
+                RuboCop::Util.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
               end
+              # rubocop:enable Style/RedundantBegin
             end
           else
             # treat an empty `rescue` as `rescue StandardError`
@@ -140,11 +129,10 @@ module RuboCop
           rescued_groups.each_cons(2).all? do |x, y|
             if x.include?(Exception)
               false
-            elsif y.include?(Exception)
-              true
-            elsif x.none? || y.none?
-              # consider sorted if a group is empty or only contains
-              # `nil`s
+            elsif y.include?(Exception) ||
+                  # consider sorted if a group is empty or only contains
+                  # `nil`s
+                  x.none? || y.none?
               true
             else
               (x <=> y || 0) <= 0

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

@@ -3,10 +3,18 @@
 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".
+      #
+      # NOTE: Shadowing of variables in block passed to `Ractor.new` is allowed
+      # because `Ractor` should not access outer variables.
+      # eg. following syle is encouraged:
+      #
+      #   worker_id, pipe = env
+      #   Ractor.new(worker_id, pipe) do |worker_id, pipe|
+      #   end
       #
       # @example
       #
@@ -31,15 +39,21 @@ 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
+        # @!method ractor_block?(node)
+        def_node_matcher :ractor_block?, <<~PATTERN
+          (block (send (const nil? :Ractor) :new ...) ...)
+        PATTERN
+
+        def self.joining_forces
+          VariableForce
         end
 
         def before_declaring_variable(variable, variable_table)
           return if variable.should_be_unused?
+          return if ractor_block?(variable.scope.node)
 
           outer_local_variable = variable_table.find_variable(variable.name)
           return unless outer_local_variable

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

@@ -21,13 +21,15 @@ 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
 
+        # @!method struct_new(node)
         def_node_matcher :struct_new, <<~PATTERN
           (send
             (const ${nil? cbase} :Struct) :new ...)
@@ -46,8 +48,7 @@ module RuboCop
 
               next unless STRUCT_METHOD_NAMES.include?(member_name.to_sym)
 
-              message = format(MSG, member_name: member_name.inspect,
-                                    method_name: member_name.to_s)
+              message = format(MSG, member_name: member_name.inspect, method_name: member_name.to_s)
               add_offense(arg, message: message)
             end
           end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for *rescue* blocks with no body.
+      # This cop checks for `rescue` blocks with no body.
       #
       # @example
       #
@@ -64,20 +64,67 @@ module RuboCop
       #   rescue
       #     # do nothing
       #   end
-      class SuppressedException < Cop
+      #
+      # @example AllowNil: true (default)
+      #
+      #   # good
+      #   def some_method
+      #     do_something
+      #   rescue
+      #     nil
+      #   end
+      #
+      #   # good
+      #   begin
+      #     do_something
+      #   rescue
+      #     # do nothing
+      #   end
+      #
+      #   # good
+      #   do_something rescue nil
+      #
+      # @example AllowNil: false
+      #
+      #   # bad
+      #   def some_method
+      #     do_something
+      #   rescue
+      #     nil
+      #   end
+      #
+      #   # bad
+      #   begin
+      #     do_something
+      #   rescue
+      #     nil
+      #   end
+      #
+      #   # bad
+      #   do_something rescue nil
+      class SuppressedException < Base
         MSG = 'Do not suppress exceptions.'
 
         def on_resbody(node)
-          return if node.body
-          return if cop_config['AllowComments'] && comment_lines?(node)
+          return if node.body && !nil_body?(node)
+          return if cop_config['AllowComments'] && comment_between_rescue_and_end?(node)
+          return if cop_config['AllowNil'] && nil_body?(node)
 
           add_offense(node)
         end
 
         private
 
-        def comment_lines?(node)
-          processed_source[line_range(node)].any? { |line| comment_line?(line) }
+        def comment_between_rescue_and_end?(node)
+          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
+
+        def nil_body?(node)
+          node.body&.nil_type?
         end
       end
     end