rubocop 1.9.1 → 1.22.3

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

@@ -68,14 +68,15 @@ module RuboCop
       #        baz)
       #     123
       #   end
-      class ParameterAlignment < Cop
+      class ParameterAlignment < Base
         include Alignment
+        extend AutoCorrector
 
         ALIGN_PARAMS_MSG = 'Align the parameters of a method definition if ' \
-          'they span more than one line.'
+                           'they span more than one line.'
 
         FIXED_INDENT_MSG = 'Use one level of indentation for parameters ' \
-          'following the first line of a multi-line method definition.'
+                           'following the first line of a multi-line method definition.'
 
         def on_def(node)
           return if node.arguments.size < 2
@@ -84,12 +85,12 @@ module RuboCop
         end
         alias on_defs on_def
 
-        def autocorrect(node)
-          AlignmentCorrector.correct(processed_source, node, column_delta)
-        end
-
         private
 
+        def autocorrect(corrector, node)
+          AlignmentCorrector.correct(corrector, processed_source, node, column_delta)
+        end
+
         def message(_node)
           fixed_indentation? ? FIXED_INDENT_MSG : ALIGN_PARAMS_MSG
         end

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

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop 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
+      #   # bad
+      #   foo(
+      #     a,
+      #     b
+      #   )
+      #
+      #   puts 'string that fits on ' \
+      #        'a single line'
+      #
+      #   things
+      #     .select { |thing| thing.cond? }
+      #     .join('-')
+      #
+      #   # good
+      #   foo(a, b)
+      #
+      #   puts 'string that fits on a single line'
+      #
+      #   things.select { |thing| thing.cond? }.join('-')
+      #
+      # @example InspectBlocks: false (default)
+      #   # good
+      #   foo(a) do |x|
+      #     puts x
+      #   end
+      #
+      # @example InspectBlocks: true
+      #   # bad
+      #   foo(a) do |x|
+      #     puts x
+      #   end
+      #
+      #   # good
+      #   foo(a) { |x| puts x }
+      #
+      class RedundantLineBreak < Base
+        include CheckAssignment
+        extend AutoCorrector
+
+        MSG = 'Redundant line break detected.'
+
+        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?
+
+          return unless offense?(node) && !part_of_ignored_node?(node)
+
+          register_offense(node)
+        end
+
+        private
+
+        def check_assignment(node, _rhs)
+          return unless offense?(node)
+
+          register_offense(node)
+        end
+
+        def register_offense(node)
+          add_offense(node) do |corrector|
+            corrector.replace(node.source_range, 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)
+        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?))
+        end
+
+        def other_cop_takes_precedence?(node)
+          single_line_block_chain_enabled? && node.each_descendant(:block).any? do |block_node|
+            block_node.parent.send_type? && block_node.parent.loc.dot && !block_node.multiline?
+          end
+        end
+
+        def single_line_block_chain_enabled?
+          @config.for_cop('Layout/SingleLineBlockChain')['Enabled']
+        end
+
+        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 }
+        end
+
+        def convertible_block?(node)
+          return false unless node.parent&.block_type?
+
+          send_node = node.parent&.send_node
+          send_node.parenthesized? || !send_node.arguments?
+        end
+
+        def comment_within?(node)
+          processed_source.comments.map(&:loc).map(&:line).any? do |comment_line_number|
+            comment_line_number >= node.first_line && comment_line_number <= node.last_line
+          end
+        end
+
+        def too_long?(node)
+          lines = processed_source.lines[(node.first_line - 1)...node.last_line]
+          to_single_line(lines.join("\n")).length > max_line_length
+        end
+
+        def to_single_line(source)
+          source
+            .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
+
+        def max_line_length
+          config.for_cop('Layout/LineLength')['Max']
+        end
+      end
+    end
+  end
+end

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

@@ -29,11 +29,9 @@ 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
+        ALTERNATIVE_ACCESS_MODIFIERS = %i[public_class_method private_class_method].freeze
 
         def on_resbody(node)
           check(node) unless modifier?(node)
@@ -63,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)
@@ -118,8 +116,9 @@ module RuboCop
         def alignment_node(node)
           ancestor_node = ancestor_node(node)
 
-          return ancestor_node if ancestor_node.nil? ||
-                                  ancestor_node.kwbegin_type?
+          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)
@@ -131,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)
@@ -173,8 +184,7 @@ module RuboCop
         end
 
         def access_modifier?(node)
-          return true if node.respond_to?(:access_modifier?) &&
-                         node.access_modifier?
+          return true if node.respond_to?(:access_modifier?) && node.access_modifier?
 
           return true if node.respond_to?(:method_name) &&
                          ALTERNATIVE_ACCESS_MODIFIERS.include?(node.method_name)

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop 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
+      #   # bad
+      #   example.select { |item| item.cond? }.join('-')
+      #
+      #   # good
+      #   example.select { |item| item.cond? }
+      #          .join('-')
+      #
+      #   # good (not a concern for this cop)
+      #   example.select do |item|
+      #     item.cond?
+      #   end.join('-')
+      #
+      class SingleLineBlockChain < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Put method call on a separate line if chained to a single line block.'
+
+        def on_send(node)
+          range = offending_range(node)
+          add_offense(range) { |corrector| corrector.insert_before(range, "\n") } if range
+        end
+
+        private
+
+        def offending_range(node)
+          receiver = node.receiver
+          return unless receiver&.block_type?
+
+          receiver_location = receiver.loc
+          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 unless call_method_after_block?(node, dot_range, closing_block_delimiter_line_num)
+
+          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
+  end
+end

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

@@ -37,9 +37,7 @@ module RuboCop
         private
 
         def register_offense(colon)
-          add_offense(colon) do |corrector|
-            corrector.insert_after(colon, ' ')
-          end
+          add_offense(colon) { |corrector| corrector.insert_after(colon, ' ') }
         end
 
         def followed_by_space?(colon)

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

@@ -18,16 +18,14 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Do not put a space between a method name and the opening ' \
-              'parenthesis.'
+        MSG = 'Do not put a space between a method name and the opening parenthesis.'
 
         def on_def(node)
           args = node.arguments
           return unless args.loc.begin&.is?('(')
 
           expr = args.source_range
-          pos_before_left_paren = range_between(expr.begin_pos - 1,
-                                                expr.begin_pos)
+          pos_before_left_paren = range_between(expr.begin_pos - 1, expr.begin_pos)
           return unless pos_before_left_paren.source.start_with?(' ')
 
           add_offense(pos_before_left_paren) do |corrector|

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

@@ -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

@@ -77,8 +77,7 @@ module RuboCop
           first = args.first.source_range
           last = args.last.source_range
 
-          check_no_space(opening_pipe.end_pos, first.begin_pos,
-                         'Space before first')
+          check_no_space(opening_pipe.end_pos, first.begin_pos, 'Space before first')
           check_no_space(last_end_pos_inside_pipes(arguments, last),
                          closing_pipe.begin_pos, 'Space after last')
         end
@@ -98,8 +97,7 @@ module RuboCop
 
           check_space(opening_pipe.end_pos, range.begin_pos, range,
                       'before first block parameter', first_arg)
-          check_no_space(opening_pipe.end_pos, range.begin_pos - 1,
-                         'Extra space before first')
+          check_no_space(opening_pipe.end_pos, range.begin_pos - 1, 'Extra space before first')
         end
 
         def check_closing_pipe_space(arguments, closing_pipe)
@@ -108,10 +106,8 @@ module RuboCop
           last         = args.last.source_range
           last_end_pos = last_end_pos_inside_pipes(arguments, last)
 
-          check_space(last_end_pos, closing_pipe.begin_pos, last,
-                      'after last block parameter')
-          check_no_space(last_end_pos + 1, closing_pipe.begin_pos,
-                         'Extra space after last')
+          check_space(last_end_pos, closing_pipe.begin_pos, last, 'after last block parameter')
+          check_no_space(last_end_pos + 1, closing_pipe.begin_pos, 'Extra space after last')
         end
 
         def last_end_pos_inside_pipes(arguments, range)
@@ -123,9 +119,7 @@ module RuboCop
         end
 
         def check_each_arg(args)
-          args.children.each do |arg|
-            check_arg(arg)
-          end
+          args.children.each { |arg| check_arg(arg) }
         end
 
         def check_arg(arg)
@@ -160,9 +154,7 @@ module RuboCop
           return if range.source.include?("\n")
 
           message = "#{msg} block parameter detected."
-          add_offense(range, message: message) do |corrector|
-            corrector.remove(range)
-          end
+          add_offense(range, message: message) { |corrector| corrector.remove(range) }
         end
       end
     end

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

@@ -47,8 +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

@@ -33,10 +33,8 @@ module RuboCop
         DO = 'do'
         SAFE_NAVIGATION = '&.'
         NAMESPACE_OPERATOR = '::'
-        ACCEPT_LEFT_PAREN =
-          %w[break defined? next not rescue return super yield].freeze
-        ACCEPT_LEFT_SQUARE_BRACKET =
-          %w[super yield].freeze
+        ACCEPT_LEFT_PAREN = %w[break defined? next not rescue return super yield].freeze
+        ACCEPT_LEFT_SQUARE_BRACKET = %w[super yield].freeze
         ACCEPT_NAMESPACE_OPERATOR = 'super'
 
         def on_and(node)
@@ -55,6 +53,10 @@ module RuboCop
           check(node, %i[keyword else].freeze)
         end
 
+        def on_case_match(node)
+          check(node, %i[keyword else].freeze)
+        end
+
         def on_ensure(node)
           check(node, [:keyword].freeze)
         end
@@ -67,10 +69,30 @@ module RuboCop
           check(node, %i[keyword else begin end].freeze, 'then')
         end
 
+        def on_if_guard(node)
+          check(node, [:keyword].freeze)
+        end
+
+        def on_in_pattern(node)
+          check(node, [:keyword].freeze)
+        end
+
         def on_kwbegin(node)
           check(node, %i[begin end].freeze, nil)
         end
 
+        # Handle one-line pattern matching syntax (`in`) with `Parser::Ruby27`.
+        def on_match_pattern(node)
+          return if target_ruby_version >= 3.0
+
+          check(node, [:operator].freeze)
+        end
+
+        # Handle one-line pattern matching syntax (`in`) with `Parser::Ruby30`.
+        def on_match_pattern_p(node)
+          check(node, [:operator].freeze)
+        end
+
         def on_next(node)
           check(node, [:keyword].freeze)
         end
@@ -111,6 +133,10 @@ module RuboCop
           check(node, [:keyword].freeze)
         end
 
+        def on_unless_guard(node)
+          check(node, [:keyword].freeze)
+        end
+
         def on_until(node)
           check(node, %i[begin end keyword].freeze)
         end
@@ -194,8 +220,7 @@ module RuboCop
 
           return false if accepted_opening_delimiter?(range, char)
           return false if safe_navigation_call?(range, pos)
-          return false if accept_namespace_operator?(range) &&
-                          namespace_operator?(range, pos)
+          return false if accept_namespace_operator?(range) && namespace_operator?(range, pos)
 
           !/[\s;,#\\)}\].]/.match?(char)
         end
@@ -203,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)

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?
 
@@ -92,9 +96,7 @@ module RuboCop
           if node.setter_method?
             on_special_asgn(node)
           elsif regular_operator?(node)
-            check_operator(:send,
-                           node.loc.selector,
-                           node.first_argument.source_range)
+            check_operator(:send, node.loc.selector, node.first_argument.source_range)
           end
         end
 
@@ -106,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
 
@@ -122,11 +132,16 @@ module RuboCop
           check_operator(:special_asgn, node.loc.operator, right.source_range)
         end
 
+        def on_match_pattern(node)
+          return if target_ruby_version < 3.0
+
+          check_operator(:match_pattern, node.loc.operator, node.source_range)
+        end
+
         alias on_or       on_binary
         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
@@ -138,13 +153,11 @@ module RuboCop
         private
 
         def regular_operator?(send_node)
-          !send_node.unary_operation? && !send_node.dot? &&
-            operator_with_regular_syntax?(send_node)
+          !send_node.unary_operation? && !send_node.dot? && operator_with_regular_syntax?(send_node)
         end
 
         def operator_with_regular_syntax?(send_node)
-          send_node.operator_method? &&
-            !IRREGULAR_METHODS.include?(send_node.method_name)
+          send_node.operator_method? && !IRREGULAR_METHODS.include?(send_node.method_name)
         end
 
         def check_operator(type, operator, right_operand)
@@ -196,7 +209,7 @@ module RuboCop
           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.'
+              'by a single space.'
           end
         end
 
@@ -225,8 +238,7 @@ module RuboCop
         end
 
         def hash_table_style?
-          align_hash_cop_config &&
-            align_hash_cop_config['EnforcedHashRocketStyle'] == 'table'
+          align_hash_cop_config && align_hash_cop_config['EnforcedHashRocketStyle'] == 'table'
         end
 
         def space_around_exponent_operator?

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

@@ -61,7 +61,7 @@ module RuboCop
           # by `EnforcedStyle: line_count_based` of `Style/BlockDelimiters` cop.
           # That means preventing auto-correction to incorrect auto-corrected
           # code.
-          # See: https://github.com/rubocop-hq/rubocop/issues/7534
+          # See: https://github.com/rubocop/rubocop/issues/7534
           return if conflict_with_block_delimiters?(node)
 
           left_brace = node.loc.begin
@@ -136,8 +136,7 @@ module RuboCop
         end
 
         def conflict_with_block_delimiters?(node)
-          block_delimiters_style == 'line_count_based' &&
-            style == :no_space && node.multiline?
+          block_delimiters_style == 'line_count_based' && style == :no_space && node.multiline?
         end
 
         def block_delimiters_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)
@@ -47,15 +48,13 @@ module RuboCop
           end_pos = node.receiver.source_range.end_pos
 
           return if begin_pos - end_pos == 1 ||
-                    (range = range_between(end_pos, begin_pos - 1)).source == '['
+                    (range = range_between(end_pos, begin_pos - 1)).source.start_with?('[')
 
           range
         end
 
         def register_offense(range)
-          add_offense(range) do |corrector|
-            corrector.remove(range)
-          end
+          add_offense(range) { |corrector| corrector.remove(range) }
         end
 
         def reference_variable_with_brackets?(node)

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

@@ -18,16 +18,14 @@ 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
 
-            add_offense(range) do |corrector|
-              corrector.insert_before(range, ' ')
-            end
+            add_offense(range) { |corrector| corrector.insert_before(range, ' ') }
           end
         end
       end