rubocop 0.74.0 → 0.75.0

data/lib/rubocop/cop/generator/configuration_injector.rb

@@ -12,7 +12,6 @@ module RuboCop
             Description: 'TODO: Write a description of the cop.'
             Enabled: true
             VersionAdded: '%<version_added>s'
-
         YAML
 
         def initialize(configuration_file_path:, badge:, version_added:)
@@ -23,8 +22,13 @@ module RuboCop
         end
 
         def inject
-          configuration_entries.insert(find_target_line,
-                                       new_configuration_entry)
+          target_line = find_target_line
+          if target_line
+            configuration_entries.insert(find_target_line,
+                                         new_configuration_entry + "\n")
+          else
+            configuration_entries.push("\n" + new_configuration_entry)
+          end
 
           File.write(configuration_file_path, configuration_entries.join)
 
@@ -49,7 +53,8 @@ module RuboCop
 
             return index if badge.to_s < line
           end
-          configuration_entries.size - 1
+
+          nil
         end
 
         def cop_name_line?(yaml)

data/lib/rubocop/cop/generator/require_file_injector.rb

@@ -54,7 +54,7 @@ module RuboCop
               elsif in_the_same_department
                 break index
               end
-            end
+            end || require_entries.size
           end
         end
 

data/lib/rubocop/cop/layout/block_alignment.rb

@@ -44,8 +44,8 @@ module RuboCop
       #
       #   foo.bar
       #     .each do
-      #        baz
-      #      end
+      #       baz
+      #     end
       #
       # @example EnforcedStyleAlignWith: start_of_line
       #   # bad

data/lib/rubocop/cop/layout/closing_parenthesis_indentation.rb

@@ -191,7 +191,7 @@ module RuboCop
         end
 
         def indentation_width
-          @config.for_cop('IndentationWidth')['Width'] || 2
+          @config.for_cop('Layout/IndentationWidth')['Width'] || 2
         end
 
         def line_break_after_left_paren?(left_paren, elements)

data/lib/rubocop/cop/layout/extra_spacing.rb

@@ -82,9 +82,7 @@ module RuboCop
                           token2.text.start_with?('#')
 
           extra_space_range(token1, token2) do |range|
-            # Unary + doesn't appear as a token and needs special handling.
             next if ignored_range?(ast, range.begin_pos)
-            next if unary_plus_non_offense?(range)
 
             add_offense(range, location: range, message: MSG_UNNECESSARY)
           end
@@ -114,10 +112,6 @@ module RuboCop
           ignored_ranges(ast).any? { |r| r.include?(start_pos) }
         end
 
-        def unary_plus_non_offense?(range)
-          range.resize(range.size + 1).source =~ /^ ?\+$/
-        end
-
         # Returns an array of ranges that should not be reported. It's the
         # extra spaces between the keys and values in a multiline hash,
         # since those are handled by the Style/AlignHash cop.

data/lib/rubocop/cop/layout/indent_assignment.rb

@@ -33,13 +33,21 @@ module RuboCop
           return unless node.loc.operator
           return if node.loc.operator.line == rhs.first_line
 
-          base = display_column(node.source_range)
+          base = display_column(leftmost_multiple_assignment(node).source_range)
           check_alignment([rhs], base + configured_indentation_width)
         end
 
         def autocorrect(node)
           AlignmentCorrector.correct(processed_source, node, column_delta)
         end
+
+        def leftmost_multiple_assignment(node)
+          return node unless node.parent&.assignment?
+
+          leftmost_multiple_assignment(node.parent)
+
+          node.parent
+        end
       end
     end
   end

data/lib/rubocop/cop/layout/indent_heredoc.rb

@@ -240,7 +240,7 @@ module RuboCop
         end
 
         def indentation_width
-          @config.for_cop('IndentationWidth')['Width'] || 2
+          @config.for_cop('Layout/IndentationWidth')['Width'] || 2
         end
 
         def heredoc_body(node)

data/lib/rubocop/cop/layout/multiline_block_layout.rb

@@ -5,7 +5,9 @@ module RuboCop
     module Layout
       # This cop checks whether the multiline do end blocks have a newline
       # after the start of the block. Additionally, it checks whether the block
-      # arguments, if any, are on the same line as the start of the block.
+      # arguments, if any, are on the same line as the start of the
+      # block. Putting block arguments on separate lines, because the whole
+      # line would otherwise be too long, is accepted.
       #
       # @example
       #   # bad
@@ -35,6 +37,17 @@ module RuboCop
       #     foo(i)
       #     bar(i)
       #   }
+      #
+      #   # good
+      #   blah { |
+      #     long_list,
+      #     of_parameters,
+      #     that_would_not,
+      #     fit_on_one_line
+      #   |
+      #     foo(i)
+      #     bar(i)
+      #   }
       class MultilineBlockLayout < Cop
         include RangeHelp
 
@@ -42,11 +55,13 @@ module RuboCop
               'the block start.'
         ARG_MSG = 'Block argument expression is not on the same line as the ' \
                   'block start.'
+        PIPE_SIZE = '|'.length
 
         def on_block(node)
           return if node.single_line?
 
-          unless args_on_beginning_line?(node)
+          unless args_on_beginning_line?(node) ||
+                 line_break_necessary_in_args?(node)
             add_offense_for_expression(node, node.arguments, ARG_MSG)
           end
 
@@ -79,6 +94,13 @@ module RuboCop
             node.loc.begin.line == node.arguments.loc.last_line
         end
 
+        def line_break_necessary_in_args?(node)
+          needed_length = node.source_range.column +
+                          node.source.lines.first.length +
+                          block_arg_string(node.arguments).length + PIPE_SIZE
+          needed_length > max_line_length
+        end
+
         def add_offense_for_expression(node, expr, msg)
           expression = expr.source_range
           range = range_between(expression.begin_pos, expression.end_pos)

data/lib/rubocop/cop/layout/space_around_block_parameters.rb

@@ -3,7 +3,9 @@
 module RuboCop
   module Cop
     module Layout
-      # Checks the spacing inside and after block parameters pipes.
+      # Checks the spacing inside and after block parameters pipes. Line breaks
+      # inside parameter pipes are checked by `Layout/MultilineBlockLayout` and
+      # not by this cop.
       #
       # @example EnforcedStyleInsidePipes: no_space (default)
       #   # bad
@@ -156,6 +158,8 @@ module RuboCop
           return if space_begin_pos >= space_end_pos
 
           range = range_between(space_begin_pos, space_end_pos)
+          return if range.source.include?("\n")
+
           add_offense(range, location: range,
                              message: "#{msg} block parameter detected.")
         end

data/lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb

@@ -132,7 +132,7 @@ module RuboCop
           line, col = line_and_column_for(token)
           return true if col == -1
 
-          processed_source.lines[line][0..col].delete(' ').empty?
+          processed_source.lines[line][0..col] !~ /\S/
         end
 
         def index_for(node, token)

data/lib/rubocop/cop/layout/space_inside_block_braces.rb

@@ -84,6 +84,13 @@ module RuboCop
         def on_block(node)
           return if node.keywords?
 
+          # Do not register an offense for multi-line empty braces. That means
+          # preventing auto-correction to single-line empty braces. It will
+          # conflict with auto-correction by `Layout/SpaceInsideBlockBraces` cop
+          # if auto-corrected to a single-line empty braces.
+          # See: https://github.com/rubocop-hq/rubocop/issues/7363
+          return if node.body.nil? && node.multiline?
+
           left_brace = node.loc.begin
           right_brace = node.loc.end
 

data/lib/rubocop/cop/layout/space_inside_string_interpolation.rb

@@ -28,6 +28,8 @@ module RuboCop
         SPACE_MSG = 'Missing space inside string interpolation detected.'
 
         def on_interpolation(begin_node)
+          return if begin_node.multiline?
+
           delims = delimiters(begin_node)
           return if empty_brackets?(*delims)
 

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

@@ -6,21 +6,34 @@ module RuboCop
       # This cop checks for assignments in the conditions of
       # if/while/until.
       #
-      # @example
+      # `AllowSafeAssignment` option for safe assignment.
+      # By safe assignment we mean putting parentheses around
+      # an assignment to indicate "I know I'm using an assignment
+      # as a condition. It's not a mistake."
       #
+      # @example
       #   # bad
-      #
       #   if some_var = true
       #     do_something
       #   end
       #
-      # @example
+      #   # good
+      #   if some_var == true
+      #     do_something
+      #   end
       #
+      # @example AllowSafeAssignment: true (default)
       #   # good
+      #   if (some_var = true)
+      #     do_something
+      #   end
       #
-      #   if some_var == true
+      # @example AllowSafeAssignment: false
+      #   # bad
+      #   if (some_var = true)
       #     do_something
       #   end
+      #
       class AssignmentInCondition < Cop
         include SafeAssignment
 

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

@@ -43,7 +43,7 @@ module RuboCop
         PATTERN
 
         def_node_matcher :debugger_call?, <<~PATTERN
-          {(send {nil? #kernel?} {:debugger :byebug} ...)
+          {(send {nil? #kernel?} {:debugger :byebug :remote_byebug} ...)
            (send (send {#kernel? nil?} :binding)
              {:pry :remote_pry :pry_remote} ...)
            (send (const {nil? (cbase)} :Pry) :rescue ...)

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

@@ -22,16 +22,10 @@ module RuboCop
         # http://rubular.com/r/CvpbxkcTzy
         MSG = "Number of arguments (%<arg_num>i) to `%<method>s` doesn't " \
               'match the number of fields (%<field_num>i).'
-        FIELD_REGEX =
-          /(%(([\s#+-0\*]*)(\d*)?(\.\d+)?[bBdiouxXeEfgGaAcps]|%))/.freeze
-        NAMED_FIELD_REGEX = /%\{[_a-zA-Z][_a-zA-Z]+\}/.freeze
+
         KERNEL = 'Kernel'
         SHOVEL = '<<'
-        PERCENT = '%'
-        PERCENT_PERCENT = '%%'
-        DIGIT_DOLLAR_FLAG = /%(\d+)\$/.freeze
         STRING_TYPES = %i[str dstr].freeze
-        NAMED_INTERPOLATION = /%(?:<\w+>|\{\w+\})/.freeze
 
         def on_send(node)
           return unless offending_node?(node)
@@ -44,7 +38,7 @@ module RuboCop
         def offending_node?(node)
           return false unless called_on_string?(node)
           return false unless method_with_format_args?(node)
-          return false if named_mode?(node) || splat_args?(node)
+          return false if splat_args?(node)
 
           num_of_format_args, num_of_expected_fields = count_matches(node)
 
@@ -70,16 +64,6 @@ module RuboCop
           sprintf?(node) || format?(node) || percent?(node)
         end
 
-        def named_mode?(node)
-          relevant_node = if sprintf?(node) || format?(node)
-                            node.first_argument
-                          elsif percent?(node)
-                            node.receiver
-                          end
-
-          !relevant_node.source.scan(NAMED_FIELD_REGEX).empty?
-        end
-
         def splat_args?(node)
           return false if percent?(node)
 
@@ -127,27 +111,17 @@ module RuboCop
 
         def expected_fields_count(node)
           return :unknown unless node.str_type?
-          return 1 if node.source =~ NAMED_INTERPOLATION
 
-          max_digit_dollar_num = max_digit_dollar_num(node)
-          return max_digit_dollar_num if max_digit_dollar_num&.nonzero?
+          format_string = RuboCop::Cop::Utils::FormatString.new(node.source)
+          return 1 if format_string.named_interpolation?
 
-          node
-            .source
-            .scan(FIELD_REGEX)
-            .reject { |x| x.first == PERCENT_PERCENT }
-            .reduce(0) { |acc, elem| acc + arguments_count(elem[2]) }
-        end
-
-        def max_digit_dollar_num(node)
-          node.source.scan(DIGIT_DOLLAR_FLAG).map do |digit_dollar_num|
-            digit_dollar_num.first.to_i
-          end.max
-        end
+          max_digit_dollar_num = format_string.max_digit_dollar_num
+          return max_digit_dollar_num if max_digit_dollar_num&.nonzero?
 
-        # number of arguments required for the format sequence
-        def arguments_count(format)
-          format.scan('*').count + 1
+          format_string
+            .format_sequences
+            .reject(&:percent?)
+            .reduce(0) { |acc, seq| acc + seq.arity }
         end
 
         def format?(node)

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

@@ -41,7 +41,7 @@ module RuboCop
 
         def on_send(node)
           to_method(node) do |receiver, to_method|
-            next if date_time_object?(receiver)
+            next if receiver.nil? || date_time_object?(receiver)
 
             message = format(
               MSG,

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      #
+      # This cop checks for `send`, `public_send`, and `__send__` methods
+      # when using mix-in.
+      #
+      # `include` and `prepend` methods were private methods until Ruby 2.0,
+      # they were mixed-in via `send` method. This cop uses Ruby 2.1 or
+      # higher style that can be called by public methods.
+      # And `extend` method that was originally a public method is also targeted
+      # for style unification.
+      #
+      # @example
+      #   # bad
+      #   Foo.send(:include, Bar)
+      #   Foo.send(:prepend, Bar)
+      #   Foo.send(:extend, Bar)
+      #
+      #   # bad
+      #   Foo.public_send(:include, Bar)
+      #   Foo.public_send(:prepend, Bar)
+      #   Foo.public_send(:extend, Bar)
+      #
+      #   # bad
+      #   Foo.__send__(:include, Bar)
+      #   Foo.__send__(:prepend, Bar)
+      #   Foo.__send__(:extend, Bar)
+      #
+      #   # good
+      #   Foo.include Bar
+      #   Foo.prepend Bar
+      #   Foo.extend Bar
+      #
+      class SendWithMixinArgument < Cop
+        include RangeHelp
+
+        MSG = 'Use `%<method>s %<module_name>s` instead of `%<bad_method>s`.'
+        MIXIN_METHODS = %i[include prepend extend].freeze
+
+        def_node_matcher :send_with_mixin_argument?, <<~PATTERN
+          (send
+            (const _ _) {:send :public_send :__send__}
+            ({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
+            )
+
+            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}"
+              )
+            end
+          end
+        end
+
+        private
+
+        def bad_location(node)
+          loc = node.loc
+
+          range_between(loc.selector.begin_pos, loc.expression.end_pos)
+        end
+
+        def message(method, module_name, bad_method)
+          format(
+            MSG,
+            method: method, module_name: module_name, bad_method: bad_method
+          )
+        end
+
+        def mixin_method?(node)
+          MIXIN_METHODS.include?(node.to_sym)
+        end
+      end
+    end
+  end
+end