rubocop 0.85.0 → 0.88.0

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

@@ -30,6 +30,19 @@ module RuboCop
           add_offense(node)
         end
 
+        def autocorrect(node)
+          lambda do |corrector|
+            starting_token, ending_token = if node.source.include?('"')
+                                             ['%{', '}']
+                                           else
+                                             ['"', '"']
+                                           end
+
+            corrector.replace(node.loc.begin, starting_token)
+            corrector.replace(node.loc.end, ending_token)
+          end
+        end
+
         def heredoc?(node)
           node.loc.is_a?(Parser::Source::Map::Heredoc) ||
             (node.parent && heredoc?(node.parent))

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

@@ -30,6 +30,8 @@ module RuboCop
       #     break if condition
       #   end
       class LiteralAsCondition < Cop
+        include RangeHelp
+
         MSG = 'Literal `%<literal>s` appeared as a condition.'
 
         def on_if(node)
@@ -57,7 +59,8 @@ module RuboCop
             case_node.each_when do |when_node|
               next unless when_node.conditions.all?(&:literal?)
 
-              add_offense(when_node)
+              range = when_conditions_range(when_node)
+              add_offense(when_node, location: range, message: message(range))
             end
           end
         end
@@ -129,6 +132,13 @@ module RuboCop
             node.condition
           end
         end
+
+        def when_conditions_range(when_node)
+          range_between(
+            when_node.conditions.first.source_range.begin_pos,
+            when_node.conditions.last.source_range.end_pos
+          )
+        end
       end
     end
   end

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

@@ -27,7 +27,14 @@ module RuboCop
         def on_regexp(node)
           return if contain_non_literal?(node)
 
-          tree = Regexp::Parser.parse(node.content)
+          begin
+            tree = Regexp::Parser.parse(node.content)
+          # Returns if a regular expression that cannot be processed by regexp_parser gem.
+          # https://github.com/rubocop-hq/rubocop/issues/8083
+          rescue Regexp::Scanner::ScannerError
+            return
+          end
+
           return unless named_capture?(tree)
           return unless numbered_capture?(tree)
 

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

@@ -59,31 +59,25 @@ module RuboCop
               'Use `lambda` instead.'
 
         def on_def(node)
-          find_nested_defs(node) do |nested_def_node|
-            add_offense(nested_def_node)
-          end
-        end
-        alias on_defs on_def
-
-        private
+          subject, = *node
+          return if node.defs_type? && subject.lvar_type?
 
-        def find_nested_defs(node, &block)
-          node.each_child_node do |child|
-            if child.def_type?
-              yield child
-            elsif child.defs_type?
-              subject, = *child
-              next if subject.lvar_type?
+          def_ancestor = node.each_ancestor(:def, :defs).first
+          return unless def_ancestor
 
-              yield child
-            elsif !scoping_method_call?(child)
-              find_nested_defs(child, &block)
+          within_scoping_def =
+            node.each_ancestor(:block, :sclass).any? do |ancestor|
+              scoping_method_call?(ancestor)
             end
-          end
+
+          add_offense(node) if def_ancestor && !within_scoping_def
         end
+        alias on_defs on_def
+
+        private
 
         def scoping_method_call?(child)
-          eval_call?(child) || exec_call?(child) || child.sclass_type? ||
+          child.sclass_type? || eval_call?(child) || exec_call?(child) ||
             class_or_module_or_struct_new_call?(child)
         end
 
@@ -96,7 +90,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
       end
     end

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

@@ -35,6 +35,22 @@ module RuboCop
       #     require file
       #   end
       #
+      # @example
+      #
+      #   # bad
+      #   Dir['./lib/**/*.rb'].each(&method(:require))
+      #
+      #   # good
+      #   Dir['./lib/**/*.rb'].sort.each(&method(:require))
+      #
+      # @example
+      #
+      #   # bad
+      #   Dir.glob(Rails.root.join('test', '*.rb'), &method(:require))
+      #
+      #   # good
+      #   Dir.glob(Rails.root.join('test', '*.rb')).sort.each(&method(:require))
+      #
       class NonDeterministicRequireOrder < Cop
         MSG = 'Sort files before requiring them.'
 
@@ -49,7 +65,16 @@ module RuboCop
           end
         end
 
+        def on_block_pass(node)
+          return unless method_require?(node)
+          return unless unsorted_dir_pass?(node.parent)
+
+          add_offense(node.parent)
+        end
+
         def autocorrect(node)
+          return correct_block_pass(node) if node.arguments.last&.block_pass_type?
+
           if unsorted_dir_block?(node)
             lambda do |corrector|
               corrector.replace(node, "#{node.source}.sort.each")
@@ -64,16 +89,58 @@ module RuboCop
 
         private
 
+        def correct_block_pass(node)
+          if unsorted_dir_glob_pass?(node)
+            lambda do |corrector|
+              block_arg = node.arguments.last
+              corrector.remove(last_arg_range(node))
+              corrector.insert_after(node, ".sort.each(#{block_arg.source})")
+            end
+          else
+            lambda do |corrector|
+              corrector.replace(node.loc.selector, 'sort.each')
+            end
+          end
+        end
+
+        # Returns range of last argument including comma and whitespace.
+        #
+        # @return [Parser::Source::Range]
+        #
+        def last_arg_range(node)
+          node.arguments.last.source_range.with(
+            begin_pos: node.arguments[-2].source_range.end_pos
+          )
+        end
+
         def unsorted_dir_loop?(node)
           unsorted_dir_block?(node) || unsorted_dir_each?(node)
         end
 
+        def unsorted_dir_pass?(node)
+          unsorted_dir_glob_pass?(node) || unsorted_dir_each_pass?(node)
+        end
+
         def_node_matcher :unsorted_dir_block?, <<~PATTERN
-          (send (const nil? :Dir) :glob ...)
+          (send (const {nil? cbase} :Dir) :glob ...)
         PATTERN
 
         def_node_matcher :unsorted_dir_each?, <<~PATTERN
-          (send (send (const nil? :Dir) {:[] :glob} ...) :each)
+          (send (send (const {nil? cbase} :Dir) {:[] :glob} ...) :each)
+        PATTERN
+
+        def_node_matcher :method_require?, <<~PATTERN
+          (block-pass (send nil? :method (sym :require)))
+        PATTERN
+
+        def_node_matcher :unsorted_dir_glob_pass?, <<~PATTERN
+          (send (const {nil? cbase} :Dir) :glob ...
+            (block-pass (send nil? :method (sym :require))))
+        PATTERN
+
+        def_node_matcher :unsorted_dir_each_pass?, <<~PATTERN
+          (send (send (const {nil? cbase} :Dir) {:[] :glob} ...) :each
+            (block-pass (send nil? :method (sym :require))))
         PATTERN
 
         def_node_matcher :loop_variable, <<~PATTERN

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

@@ -48,17 +48,22 @@ module RuboCop
             return true
           end
 
-          node.operator_method? || node.setter_method? || grouped_parentheses?(node)
+          node.operator_method? || node.setter_method? || chained_calls?(node) ||
+            operator_keyword?(node)
         end
 
         def first_argument_starts_with_left_parenthesis?(node)
           node.first_argument.source.start_with?('(')
         end
 
-        def grouped_parentheses?(node)
+        def chained_calls?(node)
           first_argument = node.first_argument
+          first_argument.send_type? && (node.children.last&.children&.count || 0) > 1
+        end
 
-          first_argument.send_type? && first_argument.receiver&.begin_type?
+        def operator_keyword?(node)
+          first_argument = node.first_argument
+          first_argument.operator_keyword?
         end
 
         def spaces_before_left_parenthesis(node)

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

@@ -62,7 +62,7 @@ module RuboCop
             # To avoid likely false positives (e.g. a single ' or ")
             next if literal.gsub(/[^[[:alnum:]]]/, '').empty?
 
-            QUOTES_AND_COMMAS.any? { |pat| literal =~ pat }
+            QUOTES_AND_COMMAS.any? { |pat| literal.match?(pat) }
           end
         end
       end

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

@@ -61,7 +61,7 @@ module RuboCop
         end
 
         def non_alphanumeric_literal?(literal)
-          literal !~ /[[:alnum:]]/
+          !/[[:alnum:]]/.match?(literal)
         end
       end
     end

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

@@ -31,12 +31,12 @@ module RuboCop
         MSG = 'Use `StandardError` over `Exception`.'
 
         def_node_matcher :exception?, <<~PATTERN
-          (send nil? {:raise :fail} (const ${cbase nil?} :Exception) ... )
+          (send nil? {:raise :fail} $(const ${cbase nil?} :Exception) ... )
         PATTERN
 
         def_node_matcher :exception_new_with_message?, <<~PATTERN
           (send nil? {:raise :fail}
-            (send (const ${cbase nil?} :Exception) :new ... ))
+            (send $(const ${cbase nil?} :Exception) :new ... ))
         PATTERN
 
         def on_send(node)
@@ -44,13 +44,21 @@ module RuboCop
             exception_new_with_message?(node, &check(node))
         end
 
+        def autocorrect(node)
+          lambda do |corrector|
+            exception_class = node.children.first&.cbase_type? ? '::StandardError' : 'StandardError'
+
+            corrector.replace(node, exception_class)
+          end
+        end
+
         private
 
         def check(node)
-          lambda do |cbase|
+          lambda do |exception_class, cbase|
             return if cbase.nil? && implicit_namespace?(node)
 
-            add_offense(node)
+            add_offense(exception_class)
           end
         end
 

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

@@ -25,7 +25,7 @@ module RuboCop
               'Perhaps you meant `rand(2)` or `rand`?'
 
         def_node_matcher :rand_one?, <<~PATTERN
-          (send {(const nil? :Kernel) nil?} :rand {(int {-1 1}) (float {-1.0 1.0})})
+          (send {(const {nil? cbase} :Kernel) nil?} :rand {(int {-1 1}) (float {-1.0 1.0})})
         PATTERN
 
         def on_send(node)

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

@@ -25,34 +25,34 @@ module RuboCop
       #
       #   # good
       #   x += 1
-      class RedundantCopDisableDirective < Cop
+      class RedundantCopDisableDirective < Base
         include RangeHelp
+        extend AutoCorrector
 
         COP_NAME = 'Lint/RedundantCopDisableDirective'
 
-        def check(offenses, cop_disabled_line_ranges, comments)
+        attr_accessor :offenses_to_check
+
+        def initialize(config = nil, options = nil, offenses = nil)
+          @offenses_to_check = offenses
+          super(config, options)
+        end
+
+        def on_new_investigation
+          return unless offenses_to_check
+
+          comments = processed_source.comments
+          cop_disabled_line_ranges = processed_source.disabled_line_ranges
+
           redundant_cops = Hash.new { |h, k| h[k] = Set.new }
 
           each_redundant_disable(cop_disabled_line_ranges,
-                                 offenses, comments) do |comment, redundant_cop|
+                                 offenses_to_check, comments) do |comment, redundant_cop|
             redundant_cops[comment].add(redundant_cop)
           end
 
           add_offenses(redundant_cops)
-        end
-
-        def autocorrect(args)
-          lambda do |corrector|
-            ranges, range = *args # Ranges are sorted by position.
-
-            range = if range.source.start_with?('#')
-                      comment_range_with_surrounding_space(range)
-                    else
-                      directive_range_in_list(range, ranges)
-                    end
-
-            corrector.remove(range)
-          end
+          super
         end
 
         private
@@ -135,6 +135,7 @@ module RuboCop
           end
         end
 
+        # rubocop:todo Metrics/CyclomaticComplexity
         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
@@ -152,9 +153,10 @@ module RuboCop
             cop if cop_offenses.none? { |o| line_range.cover?(o.line) }
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def all_disabled?(comment)
-          comment.text =~ /rubocop\s*:\s*(?:disable|todo)\s+all\b/
+          /rubocop\s*:\s*(?:disable|todo)\s+all\b/.match?(comment.text)
         end
 
         def ignore_offense?(disabled_ranges, line_range)
@@ -185,10 +187,12 @@ module RuboCop
           cop_list = cops.sort.map { |c| describe(c) }
 
           add_offense(
-            [[location], location],
-            location: location,
+            location,
             message: "Unnecessary disabling of #{cop_list.join(', ')}."
-          )
+          ) do |corrector|
+            range = comment_range_with_surrounding_space(location)
+            corrector.remove(range)
+          end
         end
 
         def add_offense_for_some_cops(comment, cops)
@@ -198,10 +202,12 @@ module RuboCop
 
           cop_ranges.each do |cop, range|
             add_offense(
-              [ranges, range],
-              location: range,
+              range,
               message: "Unnecessary disabling of #{describe(cop)}."
-            )
+            ) do |corrector|
+              range = directive_range_in_list(range, ranges)
+              corrector.remove(range)
+            end
           end
         end
 
@@ -225,7 +231,7 @@ module RuboCop
             .drop_while { |r| !r.equal?(range) }
             .each_cons(2)
             .map { |range1, range2| range1.end.join(range2.begin).source }
-            .all? { |intervening| intervening =~ /\A\s*,\s*\Z/ }
+            .all? { |intervening| /\A\s*,\s*\Z/.match?(intervening) }
         end
 
         def describe(cop)

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

@@ -60,8 +60,8 @@ module RuboCop
 
         def_node_matcher :array_new?, <<~PATTERN
           {
-            $(send (const nil? :Array) :new ...)
-            $(block (send (const nil? :Array) :new ...) ...)
+            $(send (const {nil? cbase} :Array) :new ...)
+            $(block (send (const {nil? cbase} :Array) :new ...) ...)
           }
         PATTERN
 

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

@@ -23,6 +23,12 @@ module RuboCop
         def on_match_current_line(node)
           add_offense(node)
         end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node, "#{node.source} =~ $_")
+          end
+        end
       end
     end
   end