rubocop 0.51.0 → 0.87.0

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

@@ -10,48 +10,45 @@ module RuboCop
       # @example
       #
       #   # bad
-      #
       #   if 20
       #     do_something
       #   end
       #
-      # @example
-      #
       #   # bad
-      #
       #   if some_var && true
       #     do_something
       #   end
       #
-      # @example
-      #
       #   # good
-      #
       #   if some_var && some_condition
       #     do_something
       #   end
+      #
+      #   # good
+      #   # When using a boolean value for an infinite loop.
+      #   while true
+      #     break if condition
+      #   end
       class LiteralAsCondition < Cop
-        MSG = 'Literal `%s` appeared as a condition.'.freeze
+        MSG = 'Literal `%<literal>s` appeared as a condition.'
 
         def on_if(node)
           check_for_literal(node)
         end
 
         def on_while(node)
-          check_for_literal(node)
-        end
+          return if condition(node).true_type?
 
-        def on_while_post(node)
           check_for_literal(node)
         end
+        alias on_while_post on_while
 
         def on_until(node)
-          check_for_literal(node)
-        end
+          return if condition(node).false_type?
 
-        def on_until_post(node)
           check_for_literal(node)
         end
+        alias on_until_post on_until
 
         def on_case(case_node)
           if case_node.condition
@@ -67,11 +64,12 @@ module RuboCop
 
         def on_send(node)
           return unless node.negation_method?
+
           check_for_literal(node)
         end
 
         def message(node)
-          format(MSG, node.source)
+          format(MSG, literal: node.source)
         end
 
         private
@@ -98,13 +96,9 @@ module RuboCop
         end
 
         def check_node(node)
-          return unless node
-
-          if node.keyword_bang?
-            receiver, = *node
-
-            handle_node(receiver)
-          elsif LOGICAL_OPERATOR_NODES.include?(node.type)
+          if node.send_type? && node.prefix_bang?
+            handle_node(node.receiver)
+          elsif node.operator_keyword?
             node.each_child_node { |op| handle_node(op) }
           elsif node.begin_type? && node.children.one?
             handle_node(node.children.first)

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

@@ -17,25 +17,27 @@ module RuboCop
       #
       #   "result is 10"
       class LiteralInInterpolation < Cop
-        MSG = 'Literal interpolation detected.'.freeze
+        include Interpolation
+        include RangeHelp
+        include PercentLiteral
+
+        MSG = 'Literal interpolation detected.'
         COMPOSITE = %i[array hash pair irange erange].freeze
 
-        def on_dstr(node)
-          node.each_child_node(:begin) do |begin_node|
-            final_node = begin_node.children.last
-            next unless final_node
-            next if special_keyword?(final_node)
-            next unless prints_as_self?(final_node)
+        def on_interpolation(begin_node)
+          final_node = begin_node.children.last
+          return unless final_node
+          return if special_keyword?(final_node)
+          return unless prints_as_self?(final_node)
 
-            add_offense(final_node)
-          end
+          add_offense(final_node)
         end
 
         def autocorrect(node)
           return if node.dstr_type? # nested, fixed in next iteration
 
           value = autocorrected_value(node)
-          ->(corrector) { corrector.replace(node.parent.source_range, value) }
+          ->(corrector) { corrector.replace(node.parent, value) }
         end
 
         private
@@ -48,15 +50,29 @@ module RuboCop
 
         def autocorrected_value(node)
           case node.type
+          when :int
+            node.children.last.to_i.to_s
+          when :float
+            node.children.last.to_f.to_s
           when :str
-            node.children.last
+            autocorrected_value_for_string(node)
           when :sym
             autocorrected_value_for_symbol(node)
+          when :array
+            autocorrected_value_for_array(node)
           else
             node.source.gsub('"', '\"')
           end
         end
 
+        def autocorrected_value_for_string(node)
+          if node.source.start_with?("'", '%q')
+            node.children.last.inspect[1..-2]
+          else
+            node.children.last
+          end
+        end
+
         def autocorrected_value_for_symbol(node)
           end_pos =
             node.loc.end ? node.loc.end.begin_pos : node.loc.expression.end_pos
@@ -64,6 +80,12 @@ module RuboCop
           range_between(node.loc.begin.end_pos, end_pos).source
         end
 
+        def autocorrected_value_for_array(node)
+          return node.source.gsub('"', '\"') unless node.percent_literal?
+
+          contents_range(node).source.split(' ').to_s.gsub('"', '\"')
+        end
+
         # Does node print its own source when converted to a string?
         def prints_as_self?(node)
           node.basic_literal? ||

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for uses of *begin...end while/until something*.
+      # This cop checks for uses of `begin...end while/until something`.
       #
       # @example
       #
@@ -27,22 +27,24 @@ module RuboCop
       #
       #   # good
       #
-      #   # using while
-      #   while some_condition
+      #   # while replacement
+      #   loop do
       #     do_something
+      #     break unless some_condition
       #   end
       #
       # @example
       #
       #   # good
       #
-      #   # using until
-      #   until some_condition
+      #   # until replacement
+      #   loop do
       #     do_something
+      #     break if some_condition
       #   end
       class Loop < Cop
         MSG = 'Use `Kernel#loop` with `break` rather than ' \
-              '`begin/end/until`(or `while`).'.freeze
+              '`begin/end/until`(or `while`).'
 
         def on_while_post(node)
           register_offense(node)

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+# rubocop:disable Lint/RedundantCopDisableDirective
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks that there is an `# rubocop:enable ...` statement
+      # after a `# rubocop:disable ...` statement. This will prevent leaving
+      # cop disables on wide ranges of code, that latter contributors to
+      # a file wouldn't be aware of.
+      #
+      # @example
+      #   # Lint/MissingCopEnableDirective:
+      #   #   MaximumRangeSize: .inf
+      #
+      #   # good
+      #   # rubocop:disable Layout/SpaceAroundOperators
+      #   x= 0
+      #   # rubocop:enable Layout/SpaceAroundOperators
+      #   # y = 1
+      #   # EOF
+      #
+      #   # bad
+      #   # rubocop:disable Layout/SpaceAroundOperators
+      #   x= 0
+      #   # EOF
+      #
+      # @example
+      #   # Lint/MissingCopEnableDirective:
+      #   #   MaximumRangeSize: 2
+      #
+      #   # good
+      #   # rubocop:disable Layout/SpaceAroundOperators
+      #   x= 0
+      #   # With the previous, there are 2 lines on which cop is disabled.
+      #   # rubocop:enable Layout/SpaceAroundOperators
+      #
+      #   # bad
+      #   # rubocop:disable Layout/SpaceAroundOperators
+      #   x= 0
+      #   x += 1
+      #   # Including this, that's 3 lines on which the cop is disabled.
+      #   # rubocop:enable Layout/SpaceAroundOperators
+      #
+      class MissingCopEnableDirective < Cop
+        include RangeHelp
+
+        MSG = 'Re-enable %<cop>s cop with `# rubocop:enable` after ' \
+              'disabling it.'
+        MSG_BOUND = 'Re-enable %<cop>s cop within %<max_range>s lines after ' \
+                    'disabling it.'
+
+        def investigate(processed_source)
+          max_range = cop_config['MaximumRangeSize']
+          processed_source.disabled_line_ranges.each do |cop, line_ranges|
+            line_ranges.each do |line_range|
+              # This has to remain a strict inequality to handle
+              # the case when max_range is Float::INFINITY
+              next if line_range.max - line_range.min < max_range + 2
+
+              range = source_range(processed_source.buffer,
+                                   line_range.min,
+                                   (0..0))
+              add_offense(range,
+                          location: range,
+                          message: message(max_range: max_range, cop: cop))
+            end
+          end
+        end
+
+        private
+
+        def message(max_range:, cop:)
+          if max_range == Float::INFINITY
+            format(MSG, cop: cop)
+          else
+            format(MSG_BOUND, cop: cop, max_range: max_range)
+          end
+        end
+      end
+    end
+  end
+end
+# rubocop:enable Lint/RedundantCopDisableDirective, Layout/SpaceAroundOperators

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Do not mix named captures and numbered captures in a Regexp literal
+      # because numbered capture is ignored if they're mixed.
+      # Replace numbered captures with non-capturing groupings or
+      # named captures.
+      #
+      #   # bad
+      #   /(?<foo>FOO)(BAR)/
+      #
+      #   # good
+      #   /(?<foo>FOO)(?<bar>BAR)/
+      #
+      #   # good
+      #   /(?<foo>FOO)(?:BAR)/
+      #
+      #   # good
+      #   /(FOO)(BAR)/
+      #
+      class MixedRegexpCaptureTypes < Cop
+        MSG = 'Do not mix named captures and numbered captures ' \
+              'in a Regexp literal.'
+
+        def on_regexp(node)
+          return if contain_non_literal?(node)
+
+          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)
+
+          add_offense(node)
+        end
+
+        private
+
+        def contain_non_literal?(node)
+          if node.respond_to?(:type) && (node.variable? || node.send_type? || node.const_type?)
+            return true
+          end
+          return false unless node.respond_to?(:children)
+
+          node.children.any? { |child| contain_non_literal?(child) }
+        end
+
+        def named_capture?(tree)
+          tree.each_expression.any? do |e|
+            e.instance_of?(Regexp::Expression::Group::Capture)
+          end
+        end
+
+        def numbered_capture?(tree)
+          tree.each_expression.any? do |e|
+            e.instance_of?(Regexp::Expression::Group::Named)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -21,10 +21,10 @@ module RuboCop
       #
       #   x < y && y < z
       #   10 <= x && x <= 20
-      class MultipleCompare < Cop
-        MSG = 'Use the `&&` operator to compare multiple values.'.freeze
+      class MultipleComparison < Cop
+        MSG = 'Use the `&&` operator to compare multiple values.'
 
-        def_node_matcher :multiple_compare?, <<-PATTERN
+        def_node_matcher :multiple_compare?, <<~PATTERN
           (send (send _ {:< :> :<= :>=} $_) {:< :> :<= :>=} _)
         PATTERN
 
@@ -39,7 +39,7 @@ module RuboCop
           new_center = "#{center.source} && #{center.source}"
 
           lambda do |corrector|
-            corrector.replace(center.source_range, new_center)
+            corrector.replace(center, new_center)
           end
         end
       end

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

@@ -31,14 +31,14 @@ module RuboCop
       #   # good
       #
       #   def foo
-      #     self.class_eval do
+      #     self.class.class_eval do
       #       def bar
       #       end
       #     end
       #   end
       #
       #   def foo
-      #     self.module_exec do
+      #     self.class.module_exec do
       #       def bar
       #       end
       #     end
@@ -56,7 +56,7 @@ module RuboCop
       #   end
       class NestedMethodDefinition < Cop
         MSG = 'Method definitions must not be nested. ' \
-              'Use `lambda` instead.'.freeze
+              'Use `lambda` instead.'
 
         def on_def(node)
           find_nested_defs(node) do |nested_def_node|
@@ -74,6 +74,7 @@ module RuboCop
             elsif child.defs_type?
               subject, = *child
               next if subject.lvar_type?
+
               yield child
             elsif !scoping_method_call?(child)
               find_nested_defs(child, &block)
@@ -86,16 +87,16 @@ module RuboCop
             class_or_module_or_struct_new_call?(child)
         end
 
-        def_node_matcher :eval_call?, <<-PATTERN
+        def_node_matcher :eval_call?, <<~PATTERN
           (block (send _ {:instance_eval :class_eval :module_eval} ...) ...)
         PATTERN
 
-        def_node_matcher :exec_call?, <<-PATTERN
+        def_node_matcher :exec_call?, <<~PATTERN
           (block (send _ {:instance_exec :class_exec :module_exec} ...) ...)
         PATTERN
 
-        def_node_matcher :class_or_module_or_struct_new_call?, <<-PATTERN
-          (block (send (const nil? {:Class :Module :Struct}) :new ...) ...)
+        def_node_matcher :class_or_module_or_struct_new_call?, <<~PATTERN
+          (block (send (const {nil? cbase} {:Class :Module :Struct}) :new ...) ...)
         PATTERN
       end
     end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for nested percent literals.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   # The percent literal for nested_attributes is parsed as four tokens,
+      #   # yielding the array [:name, :content, :"%i[incorrectly", :"nested]"].
+      #   attributes = {
+      #     valid_attributes: %i[name content],
+      #     nested_attributes: %i[name content %i[incorrectly nested]]
+      #   }
+      class NestedPercentLiteral < Cop
+        include PercentLiteral
+
+        MSG = 'Within percent literals, nested percent literals do not ' \
+          'function and may be unwanted in the result.'
+
+        # The array of regular expressions representing percent literals that,
+        # if found within a percent literal expression, will cause a
+        # NestedPercentLiteral violation to be emitted.
+        PERCENT_LITERAL_TYPES = PreferredDelimiters::PERCENT_LITERAL_TYPES
+        REGEXES = PERCENT_LITERAL_TYPES.map do |percent_literal|
+          /\A#{percent_literal}\W/
+        end.freeze
+
+        def on_array(node)
+          process(node, *PERCENT_LITERAL_TYPES)
+        end
+
+        def on_percent_literal(node)
+          add_offense(node) if contains_percent_literals?(node)
+        end
+
+        private
+
+        def contains_percent_literals?(node)
+          node.each_child_node.any? do |child|
+            literal = child.children.first.to_s.scrub
+            REGEXES.any? { |regex| literal.match?(regex) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -23,9 +23,9 @@ module RuboCop
       #     acc + i
       #   end
       class NextWithoutAccumulator < Cop
-        MSG = 'Use `next` with an accumulator argument in a `reduce`.'.freeze
+        MSG = 'Use `next` with an accumulator argument in a `reduce`.'
 
-        def_node_matcher :on_body_of_reduce, <<-PATTERN
+        def_node_matcher :on_body_of_reduce, <<~PATTERN
           (block (send _recv {:reduce :inject} !sym) _blockargs $(begin ...))
         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, "#{node.source}.sort.each")
+            end
+          else
+            lambda do |corrector|
+              source = node.receiver.source
+              corrector.replace(node, "#{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? cbase} :Dir) :glob ...)
+        PATTERN
+
+        def_node_matcher :unsorted_dir_each?, <<~PATTERN
+          (send (send (const {nil? cbase} :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/non_local_exit_from_iterator.rb

@@ -6,25 +6,25 @@ module RuboCop
       # This cop checks for non-local exits from iterators without a return
       # value. It registers an offense under these conditions:
       #
-      #  - No value is returned,
-      #  - the block is preceded by a method chain,
-      #  - the block has arguments,
-      #  - the method which receives the block is not `define_method`
-      #    or `define_singleton_method`,
-      #  - the return is not contained in an inner scope, e.g. a lambda or a
-      #    method definition.
+      # * No value is returned,
+      # * the block is preceded by a method chain,
+      # * the block has arguments,
+      # * the method which receives the block is not `define_method`
+      # or `define_singleton_method`,
+      # * the return is not contained in an inner scope, e.g. a lambda or a
+      # method definition.
       #
       # @example
       #
       #   class ItemApi
       #     rescue_from ValidationError do |e| # non-iteration block with arg
-      #       return message: 'validation error' unless e.errors # allowed
+      #       return { message: 'validation error' } unless e.errors # allowed
       #       error_array = e.errors.map do |error| # block with method chain
       #         return if error.suppress? # warned
       #         return "#{error.param}: invalid" unless error.message # allowed
       #         "#{error.param}: #{error.message}"
       #       end
-      #       message: 'validation error', errors: error_array
+      #       { message: 'validation error', errors: error_array }
       #     end
       #
       #     def update_items
@@ -41,7 +41,7 @@ module RuboCop
       class NonLocalExitFromIterator < Cop
         MSG = 'Non-local exit from iterator, without return value. ' \
               '`next`, `break`, `Array#find`, `Array#any?`, etc. ' \
-              'is preferred.'.freeze
+              'is preferred.'
 
         def on_return(return_node)
           return if return_value?(return_node)
@@ -49,16 +49,14 @@ module RuboCop
           return_node.each_ancestor(:block, :def, :defs) do |node|
             break if scoped_node?(node)
 
-            send_node, args_node, _body_node = *node
-
             # if a proc is passed to `Module#define_method` or
             # `Object#define_singleton_method`, `return` will not cause a
             # non-local exit error
-            break if define_method?(send_node)
+            break if define_method?(node.send_node)
 
-            next if args_node.children.empty?
+            next unless node.arguments?
 
-            if chained_send?(send_node)
+            if chained_send?(node.send_node)
               add_offense(return_node, location: :keyword)
               break
             end
@@ -76,7 +74,7 @@ module RuboCop
         end
 
         def_node_matcher :chained_send?, '(send !nil? ...)'
-        def_node_matcher :define_method?, <<-PATTERN
+        def_node_matcher :define_method?, <<~PATTERN
           (send _ {:define_method :define_singleton_method} _)
         PATTERN
       end