rubocop 0.93.1 → 1.79.2

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,11 +29,8 @@ 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_WITH_ACCESS_MODIFIERS = %i[def defs].freeze
-        ALTERNATIVE_ACCESS_MODIFIERS = %i[public_class_method
-                                          private_class_method].freeze
+        ANCESTOR_TYPES = %i[kwbegin any_def class module any_block].freeze
+        ALTERNATIVE_ACCESS_MODIFIERS = %i[public_class_method private_class_method].freeze
 
         def on_resbody(node)
           check(node) unless modifier?(node)
@@ -63,7 +60,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)
@@ -94,32 +91,34 @@ module RuboCop
           )
         end
 
+        # rubocop:disable Metrics/AbcSize
         def alignment_source(node, starting_loc)
           ending_loc =
             case node.type
-            when :block, :kwbegin
+            when :block, :numblock, :itblock, :kwbegin
               node.loc.begin
             when :def, :defs, :class, :module,
                  :lvasgn, :ivasgn, :cvasgn, :gvasgn, :casgn
               node.loc.name
             when :masgn
-              mlhs_node, = *node
-              mlhs_node.loc.expression
+              node.lhs.source_range
             else
-              # It is a wrapper with access modifier.
-              node.child_nodes.first.loc.name
+              # It is a wrapper with receiver of object attribute or access modifier.
+              node.receiver&.source_range || node.child_nodes.first.loc.name
             end
 
           range_between(starting_loc.begin_pos, ending_loc.end_pos).source
         end
+        # rubocop:enable Metrics/AbcSize
 
         # We will use ancestor or wrapper with access modifier.
 
         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
 
-          node.each_ancestor(*ancestor_types).first
+          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)
+
+          do_keyword_line == dot.line && rescue_keyword_column == dot.column
         end
 
         def assignment_node(node)
@@ -150,8 +161,7 @@ module RuboCop
         end
 
         def access_modifier_node(node)
-          return nil unless
-            ANCESTOR_TYPES_WITH_ACCESS_MODIFIERS.include?(node.type)
+          return nil unless node.any_def_type?
 
           access_modifier_node = node.ancestors.first
           return nil unless access_modifier?(access_modifier_node)
@@ -173,8 +183,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)
@@ -186,21 +195,14 @@ 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
 
         def begin_end_alignment_style
-          # FIXME: Workaround for pending status for `Layout/BeginEndAlignment` cop
-          #        When RuboCop 1.0 is released, please replace it with the following condition.
-          #
-          # config.for_cop('Layout/BeginEndAlignment')['Enabled'] &&
-          #   config.for_cop('Layout/BeginEndAlignment')['EnforcedStyleAlignWith']
-          if config.for_all_cops['NewCops'] == 'enable' ||
-             config.for_cop('Layout/BeginEndAlignment')['Enabled'] &&
-             config.for_cop('Layout/BeginEndAlignment')['Enabled'] != 'pending'
-            config.for_cop('Layout/BeginEndAlignment')['EnforcedStyleAlignWith']
-          end
+          begin_end_alignment_conf = config.for_cop('Layout/BeginEndAlignment')
+
+          begin_end_alignment_conf['Enabled'] && begin_end_alignment_conf['EnforcedStyleAlignWith']
         end
       end
     end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # 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 self.autocorrect_incompatible_with
+          [Style::MapToHash]
+        end
+
+        def on_send(node)
+          range = offending_range(node)
+          add_offense(range) { |corrector| corrector.insert_before(range, "\n") } if range
+        end
+        alias on_csend on_send
+
+        private
+
+        def offending_range(node)
+          receiver = node.receiver
+          return unless receiver&.any_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

@@ -3,9 +3,9 @@
 module RuboCop
   module Cop
     module Layout
-      # Checks for colon (:) not followed by some kind of space.
+      # Checks for colon (`:`) not followed by some kind of space.
       # N.B. this cop does not handle spaces after a ternary operator, which are
-      # instead handled by Layout/SpaceAroundOperators.
+      # instead handled by `Layout/SpaceAroundOperators`.
       #
       # @example
       #   # bad
@@ -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
 
@@ -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_comma.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # Checks for comma (,) not followed by some kind of space.
+      # Checks for comma (`,`) not followed by some kind of space.
       #
       # @example
       #
@@ -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_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?('(')
+          return unless args.parenthesized_call?
 
           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

@@ -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)
@@ -30,7 +31,7 @@ module RuboCop
         private
 
         def whitespace_after_operator?(node)
-          node.receiver.loc.column - node.loc.column > 1
+          node.receiver.source_range.begin_pos - node.source_range.begin_pos > 1
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # Checks for semicolon (;) not followed by some kind of space.
+      # Checks for semicolon (`;`) not followed by some kind of space.
       #
       # @example
       #   # bad
@@ -23,6 +23,16 @@ module RuboCop
         def kind(token)
           'semicolon' if token.semicolon?
         end
+
+        def space_missing?(token1, token2)
+          super && !semicolon_sequence?(token1, token2)
+        end
+
+        private
+
+        def semicolon_sequence?(token, next_token)
+          token.semicolon? && next_token.semicolon?
+        end
       end
     end
   end

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)
@@ -54,17 +54,11 @@ module RuboCop
         end
 
         def check_inside_pipes(arguments)
-          opening_pipe, closing_pipe = pipes(arguments)
-
           case style
           when :no_space
-            check_no_space_style_inside_pipes(arguments.children,
-                                              opening_pipe,
-                                              closing_pipe)
+            check_no_space_style_inside_pipes(arguments)
           when :space
-            check_space_style_inside_pipes(arguments.children,
-                                           opening_pipe,
-                                           closing_pipe)
+            check_space_style_inside_pipes(arguments)
           end
         end
 
@@ -76,50 +70,56 @@ module RuboCop
                       closing_pipe, 'after closing `|`')
         end
 
-        def check_no_space_style_inside_pipes(args, opening_pipe, closing_pipe)
+        def check_no_space_style_inside_pipes(arguments)
+          args = arguments.children
+          opening_pipe, closing_pipe = pipes(arguments)
+
           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(last_end_pos_inside_pipes(last),
+          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
 
-        def check_space_style_inside_pipes(args, opening_pipe, closing_pipe)
-          check_opening_pipe_space(args, opening_pipe)
-          check_closing_pipe_space(args, closing_pipe)
+        def check_space_style_inside_pipes(arguments)
+          opening_pipe, closing_pipe = pipes(arguments)
+
+          check_opening_pipe_space(arguments, opening_pipe)
+          check_closing_pipe_space(arguments, closing_pipe)
         end
 
-        def check_opening_pipe_space(args, opening_pipe)
+        def check_opening_pipe_space(arguments, opening_pipe)
+          args = arguments.children
+
           first_arg = args.first
           range = first_arg.source_range
 
           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(args, closing_pipe)
+        def check_closing_pipe_space(arguments, closing_pipe)
+          args = arguments.children
+
           last         = args.last.source_range
-          last_end_pos = last_end_pos_inside_pipes(last)
+          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(range)
+        def last_end_pos_inside_pipes(arguments, range)
           pos = range.end_pos
-          range.source_buffer.source[pos] == ',' ? pos + 1 : pos
+          num = pos - arguments.source_range.begin_pos
+          trailing_comma_index = arguments.source[num..].index(',')
+
+          trailing_comma_index ? pos + trailing_comma_index + 1 : pos
         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)
@@ -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'
           )
@@ -154,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)
@@ -60,6 +60,7 @@ module RuboCop
 
           add_offense(range) do |corrector|
             autocorrect(corrector, range)
+            opposite_style_detected
           end
         end
 

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

@@ -16,6 +16,8 @@ module RuboCop
       #
       #   something = 123if test
       #
+      #   return(foo + bar)
+      #
       #   # good
       #   something 'test' do |x|
       #   end
@@ -24,6 +26,9 @@ module RuboCop
       #   end
       #
       #   something = 123 if test
+      #
+      #   return (foo + bar)
+      #
       class SpaceAroundKeyword < Base
         extend AutoCorrector
 
@@ -33,17 +38,16 @@ 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 super yield].freeze
+        ACCEPT_LEFT_SQUARE_BRACKET = %w[super yield].freeze
         ACCEPT_NAMESPACE_OPERATOR = 'super'
+        RESTRICT_ON_SEND = %i[!].freeze
 
         def on_and(node)
           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
 
@@ -55,6 +59,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 +75,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 +139,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 +226,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 +234,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)
@@ -216,7 +247,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)
@@ -231,7 +262,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.operator_keyword? || 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
@@ -51,7 +51,7 @@ module RuboCop
         alias on_csend on_send
 
         def on_const(node)
-          return unless node.loc.double_colon
+          return unless node.loc?(:double_colon)
 
           check_space_after_double_colon(node)
         end