rubocop 0.75.1 → 0.80.0

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

@@ -117,7 +117,7 @@ module RuboCop
         end
 
         def correct_visibility?(node, modifier, ignored_methods)
-          return true if modifier.nil? || modifier.method_name == :public
+          return true if modifier.nil? || modifier.method?(:public)
 
           ignored_methods.include?(node.method_name)
         end

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# rubocop:disable Lint/UnneededCopDisableDirective
+# rubocop:disable Lint/RedundantCopDisableDirective
 module RuboCop
   module Cop
     module Lint
@@ -81,4 +81,4 @@ module RuboCop
     end
   end
 end
-# rubocop:enable Lint/UnneededCopDisableDirective, Layout/SpaceAroundOperators
+# rubocop:enable Lint/RedundantCopDisableDirective, Layout/SpaceAroundOperators

data/lib/rubocop/cop/lint/{multiple_compare.rb → multiple_comparison.rb}

@@ -21,7 +21,7 @@ module RuboCop
       #
       #   x < y && y < z
       #   10 <= x && x <= 20
-      class MultipleCompare < Cop
+      class MultipleComparison < Cop
         MSG = 'Use the `&&` operator to compare multiple values.'
 
         def_node_matcher :multiple_compare?, <<~PATTERN

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # `Dir[...]` and `Dir.glob(...)` do not make any guarantees about
+      # the order in which files are returned. The final order is
+      # determined by the operating system and file system.
+      # This means that using them in cases where the order matters,
+      # such as requiring files, can lead to intermittent failures
+      # that are hard to debug. To ensure this doesn't happen,
+      # always sort the list.
+      #
+      # @example
+      #
+      #   # bad
+      #   Dir["./lib/**/*.rb"].each do |file|
+      #     require file
+      #   end
+      #
+      #   # good
+      #   Dir["./lib/**/*.rb"].sort.each do |file|
+      #     require file
+      #   end
+      #
+      # @example
+      #
+      #   # bad
+      #   Dir.glob(Rails.root.join(__dir__, 'test', '*.rb')) do |file|
+      #     require file
+      #   end
+      #
+      #   # good
+      #   Dir.glob(Rails.root.join(__dir__, 'test', '*.rb')).sort.each do |file|
+      #     require file
+      #   end
+      #
+      class NonDeterministicRequireOrder < Cop
+        MSG = 'Sort files before requiring them.'
+
+        def on_block(node)
+          return unless node.body
+          return unless unsorted_dir_loop?(node.send_node)
+
+          loop_variable(node.arguments) do |var_name|
+            return unless var_is_required?(node.body, var_name)
+
+            add_offense(node.send_node)
+          end
+        end
+
+        def autocorrect(node)
+          if unsorted_dir_block?(node)
+            lambda do |corrector|
+              corrector.replace(node.loc.expression, "#{node.source}.sort.each")
+            end
+          else
+            lambda do |corrector|
+              source = node.receiver.source
+              corrector.replace(node.loc.expression, "#{source}.sort.each")
+            end
+          end
+        end
+
+        private
+
+        def unsorted_dir_loop?(node)
+          unsorted_dir_block?(node) || unsorted_dir_each?(node)
+        end
+
+        def_node_matcher :unsorted_dir_block?, <<~PATTERN
+          (send (const nil? :Dir) :glob ...)
+        PATTERN
+
+        def_node_matcher :unsorted_dir_each?, <<~PATTERN
+          (send (send (const nil? :Dir) {:[] :glob} ...) :each)
+        PATTERN
+
+        def_node_matcher :loop_variable, <<~PATTERN
+          (args (arg $_))
+        PATTERN
+
+        def_node_search :var_is_required?, <<~PATTERN
+          (send nil? :require (lvar %1))
+        PATTERN
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/{unneeded_cop_disable_directive.rb → redundant_cop_disable_directive.rb}

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-# The Lint/UnneededCopDisableDirective cop needs to be disabled so as
-# to be able to provide a (bad) example of an unneeded disable.
-# rubocop:disable Lint/UnneededCopDisableDirective
+# The Lint/RedundantCopDisableDirective cop needs to be disabled so as
+# to be able to provide a (bad) example of a redundant disable.
+# rubocop:disable Lint/RedundantCopDisableDirective
 module RuboCop
   module Cop
     module Lint
@@ -19,27 +19,27 @@ module RuboCop
       #
       # @example
       #   # bad
-      #   # rubocop:disable Metrics/LineLength
+      #   # rubocop:disable Layout/LineLength
       #   x += 1
-      #   # rubocop:enable Metrics/LineLength
+      #   # rubocop:enable Layout/LineLength
       #
       #   # good
       #   x += 1
-      class UnneededCopDisableDirective < Cop
+      class RedundantCopDisableDirective < Cop
         include NameSimilarity
         include RangeHelp
 
-        COP_NAME = 'Lint/UnneededCopDisableDirective'
+        COP_NAME = 'Lint/RedundantCopDisableDirective'
 
         def check(offenses, cop_disabled_line_ranges, comments)
-          unneeded_cops = Hash.new { |h, k| h[k] = Set.new }
+          redundant_cops = Hash.new { |h, k| h[k] = Set.new }
 
-          each_unneeded_disable(cop_disabled_line_ranges,
-                                offenses, comments) do |comment, unneeded_cop|
-            unneeded_cops[comment].add(unneeded_cop)
+          each_redundant_disable(cop_disabled_line_ranges,
+                                 offenses, comments) do |comment, redundant_cop|
+            redundant_cops[comment].add(redundant_cop)
           end
 
-          add_offenses(unneeded_cops)
+          add_offenses(redundant_cops)
         end
 
         def autocorrect(args)
@@ -89,8 +89,8 @@ module RuboCop
                                        newlines: false)
         end
 
-        def each_unneeded_disable(cop_disabled_line_ranges, offenses, comments,
-                                  &block)
+        def each_redundant_disable(cop_disabled_line_ranges, offenses, comments,
+                                   &block)
           disabled_ranges = cop_disabled_line_ranges[COP_NAME] || [0..0]
 
           cop_disabled_line_ranges.each do |cop, line_ranges|
@@ -110,9 +110,9 @@ module RuboCop
             comment = comments.find { |c| c.loc.line == line_range.begin }
             next if ignore_offense?(disabled_ranges, line_range)
 
-            unneeded_cop = find_unneeded(comment, offenses, cop, line_range,
-                                         line_ranges[ix + 1])
-            yield comment, unneeded_cop if unneeded_cop
+            redundant_cop = find_redundant(comment, offenses, cop, line_range,
+                                           line_ranges[ix + 1])
+            yield comment, redundant_cop if redundant_cop
           end
         end
 
@@ -123,24 +123,24 @@ module RuboCop
 
             # If a cop is disabled in a range that begins on the same line as
             # the end of the previous range, it means that the cop was
-            # already disabled by an earlier comment. So it's unneeded
+            # already disabled by an earlier comment. So it's redundant
             # whether there are offenses or not.
-            unneeded_comment = comments.find do |c|
+            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 unneeded_comment if unneeded_comment
+            yield redundant_comment if redundant_comment
           end
         end
 
-        def find_unneeded(comment, offenses, cop, line_range, next_line_range)
+        def find_redundant(comment, offenses, cop, line_range, next_line_range)
           if all_disabled?(comment)
             # If there's a disable all comment followed by a comment
             # specifically disabling `cop`, we don't report the `all`
-            # comment. If the disable all comment is truly unneeded, we will
+            # comment. If the disable all comment is truly redundant, we will
             # detect that when examining the comments of another cop, and we
             # get the full line range for the disable all.
             if (next_line_range.nil? ||
@@ -170,8 +170,8 @@ module RuboCop
           cops_string.split(/,\s*/).size
         end
 
-        def add_offenses(unneeded_cops)
-          unneeded_cops.each do |comment, cops|
+        def add_offenses(redundant_cops)
+          redundant_cops.each do |comment, cops|
             if all_disabled?(comment) ||
                directive_count(comment) == cops.size
               add_offense_for_entire_comment(comment, cops)
@@ -213,7 +213,7 @@ module RuboCop
         end
 
         def matching_range(haystack, needle)
-          offset = (haystack.source =~ Regexp.new(Regexp.escape(needle)))
+          offset = haystack.source.index(needle)
           return unless offset
 
           offset += haystack.begin_pos
@@ -260,4 +260,4 @@ module RuboCop
     end
   end
 end
-# rubocop:enable Lint/UnneededCopDisableDirective
+# rubocop:enable Lint/RedundantCopDisableDirective

data/lib/rubocop/cop/lint/{unneeded_cop_enable_directive.rb → redundant_cop_enable_directive.rb}

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
-# The Lint/UnneededCopEnableDirective cop needs to be disabled so as
-# to be able to provide a (bad) example of an unneeded enable.
+# The Lint/RedundantCopEnableDirective and Lint/RedundantCopDisableDirective
+# cops need to be disabled so as to be able to provide a (bad) example of an
+# unneeded enable.
 
-# rubocop:disable Lint/UnneededCopEnableDirective
+# rubocop:disable Lint/RedundantCopEnableDirective
+# rubocop:disable Lint/RedundantCopDisableDirective
 module RuboCop
   module Cop
     module Lint
@@ -15,24 +17,24 @@ module RuboCop
       # @example
       #   # bad
       #   foo = 1
-      #   # rubocop:enable Metrics/LineLength
+      #   # rubocop:enable Layout/LineLength
       #
       #   # good
       #   foo = 1
       # @example
       #   # bad
-      #   # rubocop:disable Metrics/LineLength
-      #   baaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaarrrrrrrrrrrrr
-      #   # rubocop:enable Metrics/LineLength
+      #   # rubocop:disable Style/StringLiterals
+      #   foo = "1"
+      #   # rubocop:enable Style/StringLiterals
       #   baz
       #   # rubocop:enable all
       #
       #   # good
-      #   # rubocop:disable Metrics/LineLength
-      #   baaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaarrrrrrrrrrrrr
+      #   # rubocop:disable Style/StringLiterals
+      #   foo = "1"
       #   # rubocop:enable all
       #   baz
-      class UnneededCopEnableDirective < Cop
+      class RedundantCopEnableDirective < Cop
         include RangeHelp
         include SurroundingSpace
 
@@ -94,16 +96,14 @@ module RuboCop
 
         def range_to_remove(begin_pos, end_pos, comma_pos, comment)
           start = comment_start(comment)
-          buffer = processed_source.buffer
-          range_class = Parser::Source::Range
 
           case comma_pos
           when :before
-            range_class.new(buffer, start + begin_pos - 1, start + end_pos)
+            range_between(start + begin_pos - 1, start + end_pos)
           when :after
-            range_class.new(buffer, start + begin_pos, start + end_pos + 1)
+            range_between(start + begin_pos, start + end_pos + 1)
           else
-            range_class.new(buffer, start, comment.loc.expression.end_pos)
+            range_between(start, comment.loc.expression.end_pos)
           end
         end
 
@@ -114,3 +114,6 @@ module RuboCop
     end
   end
 end
+
+# rubocop:enable Lint/RedundantCopDisableDirective
+# rubocop:enable Lint/RedundantCopEnableDirective

data/lib/rubocop/cop/lint/{unneeded_require_statement.rb → redundant_require_statement.rb}

@@ -21,7 +21,7 @@ module RuboCop
       #
       #   # good
       #   require 'unloaded_feature'
-      class UnneededRequireStatement < Cop
+      class RedundantRequireStatement < Cop
         include RangeHelp
 
         MSG = 'Remove unnecessary `require` statement.'

data/lib/rubocop/cop/lint/{unneeded_splat_expansion.rb → redundant_splat_expansion.rb}

@@ -49,7 +49,7 @@ module RuboCop
       #   else
       #     baz
       #   end
-      class UnneededSplatExpansion < Cop
+      class RedundantSplatExpansion < Cop
         MSG = 'Replace splat expansion with comma separated values.'
         ARRAY_PARAM_MSG = 'Pass array contents as separate arguments.'
         PERCENT_W = '%w'
@@ -70,7 +70,7 @@ module RuboCop
         PATTERN
 
         def on_splat(node)
-          unneeded_splat_expansion(node) do
+          redundant_splat_expansion(node) do
             if array_splat?(node) &&
                (method_argument?(node) || part_of_an_array?(node))
               add_offense(node, message: ARRAY_PARAM_MSG)
@@ -90,7 +90,7 @@ module RuboCop
 
         private
 
-        def unneeded_splat_expansion(node)
+        def redundant_splat_expansion(node)
           literal_expansion(node) do |expanded_item|
             if expanded_item.send_type?
               return if array_new_inside_array_literal?(expanded_item)
@@ -119,7 +119,7 @@ module RuboCop
             [node.parent.loc.expression, variable.source]
           elsif !variable.array_type?
             [loc.expression, "[#{variable.source}]"]
-          elsif unneeded_brackets?(node)
+          elsif redundant_brackets?(node)
             [loc.expression, remove_brackets(variable)]
           else
             [loc.operator, '']
@@ -141,12 +141,12 @@ module RuboCop
           parent.array_type? && parent.loc.begin && parent.loc.end
         end
 
-        def unneeded_brackets?(node)
+        def redundant_brackets?(node)
           parent = node.parent
           grandparent = node.parent.parent
 
           parent.when_type? || parent.send_type? || part_of_an_array?(node) ||
-            (grandparent&.resbody_type?)
+            grandparent&.resbody_type?
         end
 
         def remove_brackets(array)

data/lib/rubocop/cop/lint/{string_conversion_in_interpolation.rb → redundant_string_coercion.rb}

@@ -17,7 +17,7 @@ module RuboCop
       #   # good
       #
       #   "result is #{something}"
-      class StringConversionInInterpolation < Cop
+      class RedundantStringCoercion < Cop
         include Interpolation
 
         MSG_DEFAULT = 'Redundant use of `Object#to_s` in interpolation.'

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

@@ -50,7 +50,7 @@ module RuboCop
         def autocorrect(node)
           lambda do |corrector|
             redundant_with_index?(node) do |send|
-              if send.method_name == :each_with_index
+              if send.method?(:each_with_index)
                 corrector.replace(send.loc.selector, 'each')
               else
                 corrector.remove(with_index_range(send))
@@ -63,7 +63,7 @@ module RuboCop
         private
 
         def message(node)
-          if node.method_name == :each_with_index
+          if node.method?(:each_with_index)
             MSG_EACH_WITH_INDEX
           else
             MSG_WITH_INDEX

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

@@ -51,7 +51,7 @@ module RuboCop
         def autocorrect(node)
           lambda do |corrector|
             redundant_with_object?(node) do |send|
-              if send.method_name == :each_with_object
+              if send.method?(:each_with_object)
                 corrector.replace(with_object_range(send), 'each')
               else
                 corrector.remove(with_object_range(send))
@@ -64,7 +64,7 @@ module RuboCop
         private
 
         def message(node)
-          if node.method_name == :each_with_object
+          if node.method?(:each_with_object)
             MSG_EACH_WITH_OBJECT
           else
             MSG_WITH_OBJECT

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

@@ -42,9 +42,9 @@ module RuboCop
 
             method_chain = method_chain(node)
             location =
-              Parser::Source::Range.new(node.loc.expression.source_buffer,
-                                        safe_nav.loc.expression.end_pos,
-                                        method_chain.loc.expression.end_pos)
+              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)
           end
         end
@@ -54,9 +54,8 @@ module RuboCop
         def method_chain(node)
           chain = node
           while chain.send_type?
-            chain = chain.parent if chain.parent &&
-                                    %i[send csend].include?(chain.parent.type)
-            break
+            chain = chain.parent if chain.parent&.call_type?
+            break # FIXME: Unconditional break. Why while "loop" then?
           end
           chain
         end