rubocop 1.18.0 → 1.56.0

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks whether certain expressions, e.g. method calls, that could fit
+      # Checks whether certain expressions, e.g. method calls, that could fit
       # completely on a single line, are broken up into multiple lines unnecessarily.
       #
       # @example any configuration
@@ -48,11 +48,15 @@ module RuboCop
 
         MSG = 'Redundant line break detected.'
 
+        def on_lvasgn(node)
+          super unless end_with_percent_blank_string?(processed_source)
+        end
+
         def on_send(node)
           # Include "the whole expression".
-          node = node.parent while convertible_block?(node) ||
-                                   node.parent.is_a?(RuboCop::AST::BinaryOperatorNode) ||
-                                   node.parent&.send_type?
+          node = node.parent while node.parent&.send_type? ||
+                                   convertible_block?(node) ||
+                                   node.parent.is_a?(RuboCop::AST::BinaryOperatorNode)
 
           return unless offense?(node) && !part_of_ignored_node?(node)
 
@@ -61,6 +65,10 @@ module RuboCop
 
         private
 
+        def end_with_percent_blank_string?(processed_source)
+          processed_source.buffer.source.end_with?("%\n\n")
+        end
+
         def check_assignment(node, _rhs)
           return unless offense?(node)
 
@@ -69,26 +77,25 @@ module RuboCop
 
         def register_offense(node)
           add_offense(node) do |corrector|
-            corrector.replace(node.source_range, to_single_line(node.source).strip)
+            corrector.replace(node, to_single_line(node.source).strip)
           end
           ignore_node(node)
         end
 
         def offense?(node)
-          return false if configured_to_not_be_inspected?(node)
-
-          node.multiline? && !too_long?(node) && suitable_as_single_line?(node)
+          node.multiline? && !too_long?(node) && suitable_as_single_line?(node) &&
+            !configured_to_not_be_inspected?(node)
         end
 
         def configured_to_not_be_inspected?(node)
           return true if other_cop_takes_precedence?(node)
 
           !cop_config['InspectBlocks'] && (node.block_type? ||
-                                           node.each_descendant(:block).any?(&:multiline?))
+                                           any_descendant?(node, :block, &:multiline?))
         end
 
         def other_cop_takes_precedence?(node)
-          single_line_block_chain_enabled? && node.each_descendant(:block).any? do |block_node|
+          single_line_block_chain_enabled? && any_descendant?(node, :block) do |block_node|
             block_node.parent.send_type? && block_node.parent.loc.dot && !block_node.multiline?
           end
         end
@@ -100,15 +107,14 @@ module RuboCop
         def suitable_as_single_line?(node)
           !comment_within?(node) &&
             node.each_descendant(:if, :case, :kwbegin, :def).none? &&
-            node.each_descendant(:dstr, :str).none?(&:heredoc?) &&
-            node.each_descendant(:begin).none? { |b| b.first_line != b.last_line }
+            node.each_descendant(:dstr, :str).none? { |n| n.heredoc? || n.value.include?("\n") } &&
+            node.each_descendant(:begin).none? { |b| !b.single_line? }
         end
 
         def convertible_block?(node)
-          return false unless node.parent&.block_type?
-
-          send_node = node.parent&.send_node
-          send_node.parenthesized? || !send_node.arguments?
+          parent = node.parent
+          parent&.block_type? && node == parent.send_node &&
+            (node.parenthesized? || !node.arguments?)
         end
 
         def comment_within?(node)
@@ -127,6 +133,7 @@ module RuboCop
             .gsub(/" *\\\n\s*'/, %q(" + ')) # Double quote, backslash, and then single quote
             .gsub(/' *\\\n\s*"/, %q(' + ")) # Single quote, backslash, and then double quote
             .gsub(/(["']) *\\\n\s*\1/, '')  # Double or single quote, backslash, then same quote
+            .gsub(/\n\s*(?=\.\w)/, '')      # Extra space within method chaining
             .gsub(/\s*\\?\n\s*/, ' ')       # Any other line break, with or without backslash
         end
 

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks whether the rescue and ensure keywords are aligned
+      # Checks whether the rescue and ensure keywords are aligned
       # properly.
       #
       # @example
@@ -29,8 +29,7 @@ module RuboCop
         MSG = '`%<kw_loc>s` at %<kw_loc_line>d, %<kw_loc_column>d is not ' \
               'aligned with `%<beginning>s` at ' \
               '%<begin_loc_line>d, %<begin_loc_column>d.'
-        ANCESTOR_TYPES = %i[kwbegin def defs class module].freeze
-        RUBY_2_5_ANCESTOR_TYPES = (ANCESTOR_TYPES + %i[block]).freeze
+        ANCESTOR_TYPES = %i[kwbegin def defs class module block].freeze
         ANCESTOR_TYPES_WITH_ACCESS_MODIFIERS = %i[def defs].freeze
         ALTERNATIVE_ACCESS_MODIFIERS = %i[public_class_method private_class_method].freeze
 
@@ -62,7 +61,7 @@ module RuboCop
           alignment_loc = alignment_location(alignment_node)
           kw_loc        = node.loc.keyword
 
-          return if alignment_loc.column == kw_loc.column || alignment_loc.line == kw_loc.line
+          return if alignment_loc.column == kw_loc.column || same_line?(alignment_loc, kw_loc)
 
           add_offense(
             kw_loc, message: format_message(alignment_node, alignment_loc, kw_loc)
@@ -103,7 +102,7 @@ module RuboCop
               node.loc.name
             when :masgn
               mlhs_node, = *node
-              mlhs_node.loc.expression
+              mlhs_node.source_range
             else
               # It is a wrapper with access modifier.
               node.child_nodes.first.loc.name
@@ -118,6 +117,8 @@ module RuboCop
           ancestor_node = ancestor_node(node)
 
           return ancestor_node if ancestor_node.nil? || ancestor_node.kwbegin_type?
+          return if ancestor_node.respond_to?(:send_node) &&
+                    aligned_with_line_break_method?(ancestor_node, node)
 
           assignment_node = assignment_node(ancestor_node)
           return assignment_node if same_line?(ancestor_node, assignment_node)
@@ -129,14 +130,26 @@ module RuboCop
         end
 
         def ancestor_node(node)
-          ancestor_types =
-            if target_ruby_version >= 2.5
-              RUBY_2_5_ANCESTOR_TYPES
-            else
-              ANCESTOR_TYPES
-            end
+          node.each_ancestor(*ANCESTOR_TYPES).first
+        end
+
+        def aligned_with_line_break_method?(ancestor_node, node)
+          send_node_loc = ancestor_node.send_node.loc
+          do_keyword_line = ancestor_node.loc.begin.line
+          rescue_keyword_column = node.loc.keyword.column
+          selector = send_node_loc.respond_to?(:selector) ? send_node_loc.selector : send_node_loc
+
+          if aligned_with_leading_dot?(do_keyword_line, send_node_loc, rescue_keyword_column)
+            return true
+          end
+
+          do_keyword_line == selector&.line && rescue_keyword_column == selector.column
+        end
+
+        def aligned_with_leading_dot?(do_keyword_line, send_node_loc, rescue_keyword_column)
+          return false unless send_node_loc.respond_to?(:dot) && (dot = send_node_loc.dot)
 
-          node.each_ancestor(*ancestor_types).first
+          do_keyword_line == dot.line && rescue_keyword_column == dot.column
         end
 
         def assignment_node(node)
@@ -183,7 +196,7 @@ module RuboCop
           if begin_end_alignment_style == 'start_of_line'
             start_line_range(alignment_node)
           else
-            alignment_node.loc.expression
+            alignment_node.source_range
           end
         end
 

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks if method calls are chained onto single line blocks. It considers that a
+      # Checks if method calls are chained onto single line blocks. It considers that a
       # line break before the dot improves the readability of the code.
       #
       # @example
@@ -37,15 +37,26 @@ module RuboCop
           return unless receiver&.block_type?
 
           receiver_location = receiver.loc
-          closing_block_delimiter_line_number = receiver_location.end.line
-          return if receiver_location.begin.line < closing_block_delimiter_line_number
+          closing_block_delimiter_line_num = receiver_location.end.line
+          return if receiver_location.begin.line < closing_block_delimiter_line_num
 
           node_location = node.loc
           dot_range = node_location.dot
           return unless dot_range
-          return if dot_range.line > closing_block_delimiter_line_number
+          return unless call_method_after_block?(node, dot_range, closing_block_delimiter_line_num)
 
-          range_between(dot_range.begin_pos, node_location.selector.end_pos)
+          range_between(dot_range.begin_pos, selector_range(node).end_pos)
+        end
+
+        def call_method_after_block?(node, dot_range, closing_block_delimiter_line_num)
+          return false if dot_range.line > closing_block_delimiter_line_num
+
+          dot_range.column < selector_range(node).column
+        end
+
+        def selector_range(node)
+          # l.(1) has no selector, so we use the opening parenthesis instead
+          node.loc.selector || node.loc.begin
         end
       end
     end

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

@@ -19,7 +19,7 @@ module RuboCop
         MSG = 'Space missing after colon.'
 
         def on_pair(node)
-          return unless node.colon?
+          return if !node.colon? || node.value_omission?
 
           colon = node.loc.operator
 

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

@@ -24,7 +24,15 @@ module RuboCop
         end
 
         def kind(token)
-          'comma' if token.comma?
+          'comma' if token.comma? && !before_semicolon?(token)
+        end
+
+        private
+
+        def before_semicolon?(token)
+          tokens = processed_source.tokens
+
+          tokens[tokens.index(token) + 1].semicolon?
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks for space after `!`.
+      # Checks for space after `!`.
       #
       # @example
       #   # bad
@@ -16,6 +16,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Do not leave space between `!` and its argument.'
+        RESTRICT_ON_SEND = %i[!].freeze
 
         def on_send(node)
           return unless node.prefix_bang? && whitespace_after_operator?(node)

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

@@ -29,7 +29,7 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           arguments = node.arguments
 
           return unless node.arguments? && pipes?(arguments)
@@ -113,7 +113,7 @@ module RuboCop
         def last_end_pos_inside_pipes(arguments, range)
           pos = range.end_pos
           num = pos - arguments.source_range.begin_pos
-          trailing_comma_index = arguments.source[num..-1].index(',')
+          trailing_comma_index = arguments.source[num..].index(',')
 
           trailing_comma_index ? pos + trailing_comma_index + 1 : pos
         end
@@ -127,7 +127,7 @@ module RuboCop
 
           expr = arg.source_range
           check_no_space(
-            range_with_surrounding_space(range: expr, side: :left).begin_pos,
+            range_with_surrounding_space(expr, side: :left).begin_pos,
             expr.begin_pos - 1,
             'Extra space before'
           )

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

@@ -47,7 +47,8 @@ module RuboCop
           space_on_both_sides = space_on_both_sides?(arg, equals)
           no_surrounding_space = no_surrounding_space?(arg, equals)
 
-          if style == :space && space_on_both_sides || style == :no_space && no_surrounding_space
+          if (style == :space && space_on_both_sides) ||
+             (style == :no_space && no_surrounding_space)
             correct_style_detected
           else
             incorrect_style_detected(arg, value)

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

@@ -41,7 +41,7 @@ module RuboCop
           check(node, [:operator].freeze) if node.keyword?
         end
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           check(node, %i[begin end].freeze)
         end
 
@@ -228,8 +228,8 @@ module RuboCop
         def accepted_opening_delimiter?(range, char)
           return true unless char
 
-          accept_left_square_bracket?(range) && char == '[' ||
-            accept_left_parenthesis?(range) && char == '('
+          (accept_left_square_bracket?(range) && char == '[') ||
+            (accept_left_parenthesis?(range) && char == '(')
         end
 
         def accept_left_parenthesis?(range)
@@ -241,7 +241,7 @@ module RuboCop
         end
 
         def accept_namespace_operator?(range)
-          ACCEPT_NAMESPACE_OPERATOR == range.source
+          range.source == ACCEPT_NAMESPACE_OPERATOR
         end
 
         def safe_navigation_call?(range, pos)
@@ -256,7 +256,7 @@ module RuboCop
           # regular dotted method calls bind more tightly than operators
           # so we need to climb up the AST past them
           node.each_ancestor do |ancestor|
-            return true if ancestor.and_type? || ancestor.or_type?
+            return true if ancestor.and_type? || ancestor.or_type? || ancestor.range_type?
             return false unless ancestor.send_type?
             return true if ancestor.operator_method?
           end

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

@@ -19,7 +19,7 @@ module RuboCop
       #   foo &. bar
       #   foo &. bar&. buzz
       #   RuboCop:: Cop
-      #   RuboCop:: Cop:: Cop
+      #   RuboCop:: Cop:: Base
       #   :: RuboCop::Cop
       #
       #   # good
@@ -31,7 +31,7 @@ module RuboCop
       #   foo&.bar
       #   foo&.bar&.buzz
       #   RuboCop::Cop
-      #   RuboCop::Cop::Cop
+      #   RuboCop::Cop::Base
       #   ::RuboCop::Cop
       #
       class SpaceAroundMethodCallOperator < Base

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

@@ -63,6 +63,10 @@ module RuboCop
           [Style::SelfAssignment]
         end
 
+        def on_sclass(node)
+          check_operator(:sclass, node.loc.operator, node.source_range)
+        end
+
         def on_pair(node)
           return unless node.hash_rocket?
 
@@ -104,6 +108,14 @@ module RuboCop
           check_operator(:assignment, node.loc.operator, rhs.source_range)
         end
 
+        def on_casgn(node)
+          _, _, right, = *node
+
+          return unless right
+
+          check_operator(:assignment, node.loc.operator, right.source_range)
+        end
+
         def on_binary(node)
           _, rhs, = *node
 
@@ -130,7 +142,6 @@ module RuboCop
         alias on_and      on_binary
         alias on_lvasgn   on_assignment
         alias on_masgn    on_assignment
-        alias on_casgn    on_special_asgn
         alias on_ivasgn   on_assignment
         alias on_cvasgn   on_assignment
         alias on_gvasgn   on_assignment
@@ -142,7 +153,9 @@ module RuboCop
         private
 
         def regular_operator?(send_node)
-          !send_node.unary_operation? && !send_node.dot? && operator_with_regular_syntax?(send_node)
+          return false if send_node.unary_operation? || send_node.dot? || send_node.double_colon?
+
+          operator_with_regular_syntax?(send_node)
         end
 
         def operator_with_regular_syntax?(send_node)
@@ -150,7 +163,7 @@ module RuboCop
         end
 
         def check_operator(type, operator, right_operand)
-          with_space = range_with_surrounding_space(range: operator)
+          with_space = range_with_surrounding_space(operator)
           return if with_space.source.start_with?("\n")
 
           offense(type, operator, with_space, right_operand) do |msg|
@@ -166,7 +179,7 @@ module RuboCop
         end
 
         def autocorrect(corrector, range)
-          if /\*\*/.match?(range.source) && !space_around_exponent_operator?
+          if range.source.include?('**') && !space_around_exponent_operator?
             corrector.replace(range, '**')
           elsif range.source.end_with?("\n")
             corrector.replace(range, " #{range.source.strip}\n")

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

@@ -57,15 +57,15 @@ module RuboCop
           return if node.keywords?
 
           # Do not register an offense for multi-line braces when specifying
-          # `EnforcedStyle: no_space`. It will conflict with auto-correction
+          # `EnforcedStyle: no_space`. It will conflict with autocorrection
           # by `EnforcedStyle: line_count_based` of `Style/BlockDelimiters` cop.
-          # That means preventing auto-correction to incorrect auto-corrected
+          # That means preventing autocorrection to incorrect autocorrected
           # code.
           # See: https://github.com/rubocop/rubocop/issues/7534
           return if conflict_with_block_delimiters?(node)
 
           left_brace = node.loc.begin
-          space_plus_brace = range_with_surrounding_space(range: left_brace)
+          space_plus_brace = range_with_surrounding_space(left_brace)
           used_style =
             space_plus_brace.source.start_with?('{') ? :no_space : :space
 
@@ -76,6 +76,8 @@ module RuboCop
           end
         end
 
+        alias on_numblock on_block
+
         private
 
         def check_empty(left_brace, space_plus_brace, used_style)

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

@@ -19,6 +19,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Remove the space before the opening brackets.'
+        RESTRICT_ON_SEND = %i[[] []=].freeze
 
         def on_send(node)
           return unless (first_argument = node.first_argument)
@@ -36,6 +37,7 @@ module RuboCop
             receiver_end_pos = node.receiver.source_range.end_pos
             selector_begin_pos = node.loc.selector.begin_pos
             return if receiver_end_pos >= selector_begin_pos
+            return if dot_before_brackets?(node, receiver_end_pos, selector_begin_pos)
 
             range_between(receiver_end_pos, selector_begin_pos)
           elsif node.method?(:[]=)
@@ -43,6 +45,12 @@ module RuboCop
           end
         end
 
+        def dot_before_brackets?(node, receiver_end_pos, selector_begin_pos)
+          return false unless node.loc.respond_to?(:dot) && (dot = node.loc.dot)
+
+          dot.begin_pos == receiver_end_pos && dot.end_pos == selector_begin_pos
+        end
+
         def offense_range_for_assignment(node, begin_pos)
           end_pos = node.receiver.source_range.end_pos
 

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks for missing space between a token and a comment on the
+      # Checks for missing space between a token and a comment on the
       # same line.
       #
       # @example
@@ -18,9 +18,9 @@ module RuboCop
         MSG = 'Put a space before an end-of-line comment.'
 
         def on_new_investigation
-          processed_source.tokens.each_cons(2) do |token1, token2|
+          processed_source.sorted_tokens.each_cons(2) do |token1, token2|
             next unless token2.comment?
-            next unless token1.line == token2.line
+            next unless same_line?(token1, token2)
             next unless token1.pos.end == token2.pos.begin
 
             range = token2.pos

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

@@ -28,11 +28,16 @@ module RuboCop
 
         MSG = 'Put one space between the method name and the first argument.'
 
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses]
+        end
+
         def on_send(node)
           return unless regular_method_call_with_arguments?(node)
+          return if node.parenthesized?
 
           first_arg = node.first_argument.source_range
-          first_arg_with_space = range_with_surrounding_space(range: first_arg, side: :left)
+          first_arg_with_space = range_with_surrounding_space(first_arg, side: :left)
           space = range_between(first_arg_with_space.begin_pos, first_arg.begin_pos)
           return if space.length == 1
           return unless expect_params_after_method_name?(node)
@@ -48,7 +53,6 @@ module RuboCop
         end
 
         def expect_params_after_method_name?(node)
-          return false if node.parenthesized?
           return true if no_space_between_method_name_and_first_argument?(node)
 
           first_arg = node.first_argument

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks for spaces between `->` and opening parameter
+      # Checks for spaces between `->` and opening parameter
       # parenthesis (`(`) in lambda literals.
       #
       # @example EnforcedStyle: require_no_space (default)
@@ -30,15 +30,17 @@ module RuboCop
         def on_send(node)
           return unless arrow_lambda_with_args?(node)
 
-          lambda_node = range_of_offense(node)
-
           if style == :require_space && !space_after_arrow?(node)
+            lambda_node = range_of_offense(node)
+
             add_offense(lambda_node, message: MSG_REQUIRE_SPACE) do |corrector|
-              corrector.insert_before(node.parent.children[1], ' ')
+              corrector.insert_before(lambda_arguments(node), ' ')
             end
           elsif style == :require_no_space && space_after_arrow?(node)
-            add_offense(lambda_node, message: MSG_REQUIRE_NO_SPACE) do |corrector|
-              corrector.remove(space_after_arrow(node))
+            space = space_after_arrow(node)
+
+            add_offense(space, message: MSG_REQUIRE_NO_SPACE) do |corrector|
+              corrector.remove(space)
             end
           end
         end
@@ -62,10 +64,14 @@ module RuboCop
 
         def range_of_offense(node)
           range_between(
-            node.parent.loc.expression.begin_pos,
-            node.parent.arguments.loc.expression.end_pos
+            node.parent.source_range.begin_pos,
+            node.parent.arguments.source_range.end_pos
           )
         end
+
+        def lambda_arguments(node)
+          node.parent.children[1]
+        end
       end
     end
   end