rubocop 0.72.0 → 0.76.0

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_around_operators.rb

@@ -34,14 +34,14 @@ module RuboCop
 
           return if hash_table_style? && !node.parent.pairs_on_same_line?
 
-          check_operator(node.loc.operator, node.source_range)
+          check_operator(:pair, node.loc.operator, node.source_range)
         end
 
         def on_if(node)
           return unless node.ternary?
 
-          check_operator(node.loc.question, node.if_branch.source_range)
-          check_operator(node.loc.colon, node.else_branch.source_range)
+          check_operator(:if, node.loc.question, node.if_branch.source_range)
+          check_operator(:if, node.loc.colon, node.else_branch.source_range)
         end
 
         def on_resbody(node)
@@ -49,23 +49,33 @@ module RuboCop
 
           _, variable, = *node
 
-          check_operator(node.loc.assoc, variable.source_range)
+          check_operator(:resbody, node.loc.assoc, variable.source_range)
         end
 
         def on_send(node)
           if node.setter_method?
             on_special_asgn(node)
           elsif regular_operator?(node)
-            check_operator(node.loc.selector, node.first_argument.source_range)
+            check_operator(:send,
+                           node.loc.selector,
+                           node.first_argument.source_range)
           end
         end
 
+        def on_assignment(node)
+          _, rhs, = *node
+
+          return unless rhs
+
+          check_operator(:assignment, node.loc.operator, rhs.source_range)
+        end
+
         def on_binary(node)
           _, rhs, = *node
 
           return unless rhs
 
-          check_operator(node.loc.operator, rhs.source_range)
+          check_operator(:binary, node.loc.operator, rhs.source_range)
         end
 
         def on_special_asgn(node)
@@ -73,20 +83,20 @@ module RuboCop
 
           return unless right
 
-          check_operator(node.loc.operator, right.source_range)
+          check_operator(:special_asgn, node.loc.operator, right.source_range)
         end
 
         alias on_or       on_binary
         alias on_and      on_binary
-        alias on_lvasgn   on_binary
-        alias on_masgn    on_binary
+        alias on_lvasgn   on_assignment
+        alias on_masgn    on_assignment
         alias on_casgn    on_special_asgn
-        alias on_ivasgn   on_binary
-        alias on_cvasgn   on_binary
-        alias on_gvasgn   on_binary
+        alias on_ivasgn   on_assignment
+        alias on_cvasgn   on_assignment
+        alias on_gvasgn   on_assignment
         alias on_class    on_binary
-        alias on_or_asgn  on_binary
-        alias on_and_asgn on_binary
+        alias on_or_asgn  on_assignment
+        alias on_and_asgn on_assignment
         alias on_op_asgn  on_special_asgn
 
         def autocorrect(range)
@@ -113,35 +123,44 @@ module RuboCop
             !IRREGULAR_METHODS.include?(send_node.method_name)
         end
 
-        def check_operator(operator, right_operand)
+        def check_operator(type, operator, right_operand)
           with_space = range_with_surrounding_space(range: operator)
           return if with_space.source.start_with?("\n")
 
-          offense(operator, with_space, right_operand) do |msg|
+          offense(type, operator, with_space, right_operand) do |msg|
             add_offense(with_space, location: operator, message: msg)
           end
         end
 
-        def offense(operator, with_space, right_operand)
-          msg = offense_message(operator, with_space, right_operand)
+        def offense(type, operator, with_space, right_operand)
+          msg = offense_message(type, operator, with_space, right_operand)
           yield msg if msg
         end
 
-        def offense_message(operator, with_space, right_operand)
+        def offense_message(type, operator, with_space, right_operand)
           if operator.is?('**')
             'Space around operator `**` detected.' unless with_space.is?('**')
           elsif with_space.source !~ /^\s.*\s$/
             "Surrounding space missing for operator `#{operator.source}`."
-          elsif excess_leading_space?(operator, with_space) ||
+          elsif excess_leading_space?(type, operator, with_space) ||
                 excess_trailing_space?(right_operand, with_space)
             "Operator `#{operator.source}` should be surrounded " \
             'by a single space.'
           end
         end
 
-        def excess_leading_space?(operator, with_space)
-          with_space.source.start_with?(EXCESSIVE_SPACE) &&
-            (!allow_for_alignment? || !aligned_with_operator?(operator))
+        def excess_leading_space?(type, operator, with_space)
+          return false unless allow_for_alignment?
+          return false unless with_space.source.start_with?(EXCESSIVE_SPACE)
+
+          return !aligned_with_operator?(operator) unless type == :assignment
+
+          token            = Token.new(operator, nil, operator.source)
+          align_preceding  = aligned_with_preceding_assignment(token)
+
+          return align_preceding == :no unless align_preceding == :none
+
+          aligned_with_subsequent_assignment(token) != :yes
         end
 
         def excess_trailing_space?(right_operand, with_space)

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

@@ -48,9 +48,7 @@ module RuboCop
             if style == :require_space
               corrector.insert_before(children[1].source_range, ' ')
             else
-              space_range = range_between(children[0].source_range.end_pos,
-                                          children[1].source_range.begin_pos)
-              corrector.remove(space_range)
+              corrector.remove(space_after_arrow(lambda_node))
             end
           end
         end
@@ -62,10 +60,14 @@ module RuboCop
         end
 
         def space_after_arrow?(lambda_node)
-          arrow = lambda_node.parent.children[0]
-          parentheses = lambda_node.parent.children[1]
-          (parentheses.source_range.begin_pos - arrow.source_range.end_pos)
-            .positive?
+          !space_after_arrow(lambda_node).empty?
+        end
+
+        def space_after_arrow(lambda_node)
+          arrow = lambda_node.parent.children[0].source_range
+          parentheses = lambda_node.parent.children[1].source_range
+
+          arrow.end.join(parentheses.begin)
         end
 
         def range_of_offense(node)

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)
@@ -210,18 +210,21 @@ module RuboCop
 
         def compact_corrections(corrector, node, left, right)
           if qualifies_for_compact?(node, left, side: :left)
-            range = side_space_range(range: left.pos, side: :right)
-            corrector.remove(range)
+            compact(corrector, left, :right)
           elsif !left.space_after?
             corrector.insert_after(left.pos, ' ')
           end
           if qualifies_for_compact?(node, right)
-            range = side_space_range(range: right.pos, side: :left)
-            corrector.remove(range)
+            compact(corrector, right, :left)
           elsif !right.space_before?
             corrector.insert_before(right.pos, ' ')
           end
         end
+
+        def compact(corrector, bracket, side)
+          range = side_space_range(range: bracket.pos, side: side)
+          corrector.remove(range)
+        end
       end
     end
   end

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
 
@@ -130,7 +137,8 @@ module RuboCop
           args_delimiter = node.arguments.loc.begin # Can be ( | or nil.
 
           check_left_brace(inner, node.loc.begin, args_delimiter)
-          check_right_brace(inner, node.loc.end, node.single_line?)
+          check_right_brace(inner, node.loc.begin, node.loc.end,
+                            node.single_line?)
         end
 
         def check_left_brace(inner, left_brace, args_delimiter)
@@ -141,15 +149,26 @@ module RuboCop
           end
         end
 
-        def check_right_brace(inner, right_brace, single_line)
+        def check_right_brace(inner, left_brace, right_brace, single_line)
           if single_line && inner =~ /\S$/
             no_space(right_brace.begin_pos, right_brace.end_pos,
                      'Space missing inside }.')
           else
+            return if multiline_block?(left_brace, right_brace) &&
+                      aligned_braces?(left_brace, right_brace)
+
             space_inside_right_brace(right_brace)
           end
         end
 
+        def multiline_block?(left_brace, right_brace)
+          left_brace.first_line != right_brace.first_line
+        end
+
+        def aligned_braces?(left_brace, right_brace)
+          left_brace.first_line == right_brace.last_column
+        end
+
         def no_space_inside_left_brace(left_brace, args_delimiter)
           if pipe?(args_delimiter)
             if left_brace.end_pos == args_delimiter.begin_pos &&

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

@@ -72,7 +72,7 @@ module RuboCop
             # If the second token is a comment, that means that a line break
             # follows, and that the rules for space inside don't apply.
             next if token2.comment?
-            next unless token2.line == token1.line && token1.space_after?
+            next unless same_line?(token1, token2) && token1.space_after?
 
             yield range_between(token1.end_pos, token2.begin_pos)
           end
@@ -82,17 +82,18 @@ module RuboCop
           tokens.each_cons(2) do |token1, token2|
             next if can_be_ignored?(token1, token2)
 
-            next unless token2.line == token1.line && !token1.space_after?
-
             if token1.left_parens?
               yield range_between(token2.begin_pos, token2.begin_pos + 1)
-
             elsif token2.right_parens?
               yield range_between(token2.begin_pos, token2.end_pos)
             end
           end
         end
 
+        def same_line?(token1, token2)
+          token1.line == token2.line
+        end
+
         def parens?(token1, token2)
           token1.left_parens? || token2.right_parens?
         end
@@ -104,8 +105,7 @@ module RuboCop
           # follows, and that the rules for space inside don't apply.
           return true if token2.comment?
 
-          # Ignore empty parens. # TODO: Could be configurable.
-          return true if token1.left_parens? && token2.right_parens?
+          return true unless same_line?(token1, token2) && !token1.space_after?
         end
       end
     end

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

@@ -19,61 +19,45 @@ module RuboCop
       #   # good
       #      var = "This is the #{ space } example"
       class SpaceInsideStringInterpolation < Cop
+        include Interpolation
+        include SurroundingSpace
         include ConfigurableEnforcedStyle
         include RangeHelp
 
         NO_SPACE_MSG = 'Space inside string interpolation detected.'
-        SPACE_MSG = 'Missing space around string interpolation detected.'
+        SPACE_MSG = 'Missing space inside string interpolation detected.'
 
-        def on_dstr(node)
-          each_style_violation(node) do |final_node|
-            add_offense(final_node)
-          end
-        end
+        def on_interpolation(begin_node)
+          return if begin_node.multiline?
 
-        def autocorrect(node)
-          new_source = style == :no_space ? node.source : " #{node.source} "
-          lambda do |corrector|
-            corrector.replace(
-              range_with_surrounding_space(range: node.source_range),
-              new_source
-            )
+          delims = delimiters(begin_node)
+          return if empty_brackets?(*delims)
+
+          if style == :no_space
+            no_space_offenses(begin_node, *delims, NO_SPACE_MSG)
+          else
+            space_offenses(begin_node, *delims, SPACE_MSG)
           end
         end
 
-        private
-
-        def each_style_violation(node)
-          node.each_child_node(:begin) do |begin_node|
-            final_node = begin_node.children.last
-            next unless final_node
+        def autocorrect(begin_node)
+          lambda do |corrector|
+            delims = delimiters(begin_node)
 
-            if style == :no_space && space_on_any_side?(final_node)
-              yield final_node
-            elsif style == :space && !space_on_each_side?(final_node)
-              yield final_node
+            if style == :no_space
+              SpaceCorrector.remove_space(processed_source, corrector, *delims)
+            else
+              SpaceCorrector.add_space(processed_source, corrector, *delims)
             end
           end
         end
 
-        def message(_node)
-          style == :no_space ? NO_SPACE_MSG : SPACE_MSG
-        end
-
-        def space_on_any_side?(node)
-          interp = node.source_range
-          interp_with_surrounding_space =
-            range_with_surrounding_space(range: interp)
-
-          interp_with_surrounding_space != interp
-        end
-
-        def space_on_each_side?(node)
-          interp = node.source_range
-          interp_with_surrounding_space =
-            range_with_surrounding_space(range: interp)
+        private
 
-          interp_with_surrounding_space.source == " #{interp.source} "
+        def delimiters(begin_node)
+          left = processed_source.tokens[index_of_first_token(begin_node)]
+          right = processed_source.tokens[index_of_last_token(begin_node)]
+          [left, right]
         end
       end
     end

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

@@ -30,16 +30,13 @@ module RuboCop
           str_ranges = string_literal_ranges(processed_source.ast)
 
           processed_source.lines.each.with_index(1) do |line, lineno|
-            match = line.match(/^([^\t]*)\t+/)
+            match = line.match(/\t+/)
             next unless match
 
-            prefix = match.captures[0]
-            col = prefix.length
-            next if in_string_literal?(str_ranges, lineno, col)
-
             range = source_range(processed_source.buffer,
                                  lineno,
-                                 col...match.end(0))
+                                 match.begin(0)...match.end(0))
+            next if in_string_literal?(str_ranges, range)
 
             add_offense(range, location: range)
           end
@@ -54,16 +51,9 @@ module RuboCop
 
         private
 
-        # rubocop:disable Metrics/CyclomaticComplexity
-        def in_string_literal?(ranges, line, col)
-          ranges.any? do |range|
-            (range.line == line && range.column <= col) ||
-              (range.line < line && line < range.last_line) ||
-              (range.line != line && range.last_line == line &&
-               range.last_column >= col)
-          end
+        def in_string_literal?(ranges, tabs_range)
+          ranges.any? { |range| range.contains?(tabs_range) }
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
 
         def string_literal_ranges(ast)
           # which lines start inside a string literal?
@@ -72,13 +62,11 @@ module RuboCop
           ast.each_node(:str, :dstr).each_with_object(Set.new) do |str, ranges|
             loc = str.location
 
-            range = if str.heredoc?
-                      loc.heredoc_body
-                    else
-                      loc.expression
-                    end
-
-            ranges << range
+            if str.heredoc?
+              ranges << loc.heredoc_body
+            elsif loc.respond_to?(:begin) && loc.begin
+              ranges << loc.expression
+            end
           end
         end
       end