rubocop 1.30.1 → 1.31.2

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

@@ -70,18 +70,39 @@ module RuboCop
         def on_send(node)
           return unless node.attribute_accessor?
           return if next_line_empty?(node.last_line)
+          return if next_line_empty_or_enable_directive_comment?(node.last_line)
 
           next_line_node = next_line_node(node)
           return unless require_empty_line?(next_line_node)
 
-          add_offense(node) do |corrector|
-            range = range_by_whole_lines(node.source_range)
+          add_offense(node) { |corrector| autocorrect(corrector, node) }
+        end
+
+        private
 
-            corrector.insert_after(range, "\n")
+        def autocorrect(corrector, node)
+          node_range = range_by_whole_lines(node.source_range)
+
+          next_line = node_range.last_line + 1
+          if next_line_enable_directive_comment?(next_line)
+            node_range = processed_source.comment_at_line(next_line)
           end
+
+          corrector.insert_after(node_range, "\n")
         end
 
-        private
+        def next_line_empty_or_enable_directive_comment?(line)
+          return true if next_line_empty?(line)
+
+          next_line = line + 1
+          next_line_enable_directive_comment?(next_line) && next_line_empty?(next_line)
+        end
+
+        def next_line_enable_directive_comment?(line)
+          return false unless (comment = processed_source.comment_at_line(line))
+
+          DirectiveComment.new(comment).enabled?
+        end
 
         def next_line_empty?(line)
           processed_source[line].nil? || processed_source[line].blank?

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

@@ -120,29 +120,33 @@ module RuboCop
             check_first(first_elem, left_bracket, left_parenthesis, 0)
           end
 
-          check_right_bracket(array_node.loc.end, left_bracket, left_parenthesis)
+          check_right_bracket(array_node.loc.end, first_elem, left_bracket, left_parenthesis)
         end
 
-        def check_right_bracket(right_bracket, left_bracket, left_parenthesis)
+        def check_right_bracket(right_bracket, first_elem, left_bracket, left_parenthesis)
           # if the right bracket is on the same line as the last value, accept
           return if /\S/.match?(right_bracket.source_line[0...right_bracket.column])
 
-          expected_column = base_column(left_bracket, left_parenthesis)
+          expected_column, indent_base_type = indent_base(left_bracket, first_elem,
+                                                          left_parenthesis)
           @column_delta = expected_column - right_bracket.column
           return if @column_delta.zero?
 
-          msg = msg(left_parenthesis)
+          msg = message_for_right_bracket(indent_base_type)
           add_offense(right_bracket, message: msg) do |corrector|
             autocorrect(corrector, right_bracket)
           end
         end
 
         # Returns the description of what the correct indentation is based on.
-        def base_description(left_parenthesis)
-          if style == :align_brackets
+        def base_description(indent_base_type)
+          case indent_base_type
+          when :left_brace_or_bracket
             'the position of the opening bracket'
-          elsif left_parenthesis && style == :special_inside_parentheses
+          when :first_colmn_after_left_parenthesis
             'the first position after the preceding left parenthesis'
+          when :parent_hash_key
+            'the parent hash key'
           else
             'the start of the line where the left square bracket is'
           end
@@ -156,15 +160,18 @@ module RuboCop
           )
         end
 
-        def msg(left_parenthesis)
-          if style == :align_brackets
+        def message_for_right_bracket(indent_base_type)
+          case indent_base_type
+          when :left_brace_or_bracket
             'Indent the right bracket the same as the left bracket.'
-          elsif style == :special_inside_parentheses && left_parenthesis
+          when :first_colmn_after_left_parenthesis
             'Indent the right bracket the same as the first position ' \
-              'after the preceding left parenthesis.'
+            'after the preceding left parenthesis.'
+          when :parent_hash_key
+            'Indent the right bracket the same as the parent hash key.' \
           else
-            'Indent the right bracket the same as the start of the line' \
-              ' where the left bracket is.'
+            'Indent the right bracket the same as the start of the line ' \
+            'where the left bracket is.'
           end
         end
       end

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

@@ -32,6 +32,14 @@ module RuboCop
       #   and_in_a_method_call({
       #     no: :difference
       #                        })
+      #   takes_multi_pairs_hash(x: {
+      #     a: 1,
+      #     b: 2
+      #   },
+      #                          y: {
+      #                            c: 1,
+      #                            d: 2
+      #                          })
       #
       #   # good
       #   special_inside_parentheses
@@ -41,6 +49,14 @@ module RuboCop
       #   but_in_a_method_call({
       #                          its_like: :this
       #                        })
+      #   takes_multi_pairs_hash(x: {
+      #                            a: 1,
+      #                            b: 2
+      #                          },
+      #                          y: {
+      #                            c: 1,
+      #                            d: 2
+      #                          })
       #
       # @example EnforcedStyle: consistent
       #   # The `consistent` style enforces that the first key in a hash
@@ -64,6 +80,7 @@ module RuboCop
       #     no: :difference
       #   })
       #
+      #
       # @example EnforcedStyle: align_braces
       #   # The `align_brackets` style enforces that the opening and closing
       #   # braces are indented to the same position.
@@ -72,11 +89,27 @@ module RuboCop
       #   and_now_for_something = {
       #                             completely: :different
       #   }
+      #   takes_multi_pairs_hash(x: {
+      #     a: 1,
+      #     b: 2
+      #   },
+      #                           y: {
+      #                                c: 1,
+      #                                d: 2
+      #                              })
       #
       #   # good
       #   and_now_for_something = {
       #                             completely: :different
       #                           }
+      #   takes_multi_pairs_hash(x: {
+      #                               a: 1,
+      #                               b: 2
+      #                             },
+      #                          y: {
+      #                               c: 1,
+      #                               d: 2
+      #                             })
       class FirstHashElementIndentation < Base
         include Alignment
         include ConfigurableEnforcedStyle
@@ -125,18 +158,18 @@ module RuboCop
             end
           end
 
-          check_right_brace(hash_node.loc.end, left_brace, left_parenthesis)
+          check_right_brace(hash_node.loc.end, first_pair, left_brace, left_parenthesis)
         end
 
-        def check_right_brace(right_brace, left_brace, left_parenthesis)
+        def check_right_brace(right_brace, first_pair, left_brace, left_parenthesis)
           # if the right brace is on the same line as the last value, accept
           return if /\S/.match?(right_brace.source_line[0...right_brace.column])
 
-          expected_column = base_column(left_brace, left_parenthesis)
+          expected_column, indent_base_type = indent_base(left_brace, first_pair, left_parenthesis)
           @column_delta = expected_column - right_brace.column
           return if @column_delta.zero?
 
-          message = message_for_right_brace(left_parenthesis)
+          message = message_for_right_brace(indent_base_type)
           add_offense(right_brace, message: message) do |corrector|
             autocorrect(corrector, right_brace)
           end
@@ -155,11 +188,14 @@ module RuboCop
         end
 
         # Returns the description of what the correct indentation is based on.
-        def base_description(left_parenthesis)
-          if style == :align_braces
+        def base_description(indent_base_type)
+          case indent_base_type
+          when :left_brace_or_bracket
             'the position of the opening brace'
-          elsif left_parenthesis && style == :special_inside_parentheses
+          when :first_colmn_after_left_parenthesis
             'the first position after the preceding left parenthesis'
+          when :parent_hash_key
+            'the parent hash key'
           else
             'the start of the line where the left curly brace is'
           end
@@ -173,15 +209,18 @@ module RuboCop
           )
         end
 
-        def message_for_right_brace(left_parenthesis)
-          if style == :align_braces
+        def message_for_right_brace(indent_base_type)
+          case indent_base_type
+          when :left_brace_or_bracket
             'Indent the right brace the same as the left brace.'
-          elsif style == :special_inside_parentheses && left_parenthesis
+          when :first_colmn_after_left_parenthesis
             'Indent the right brace the same as the first position ' \
-              'after the preceding left parenthesis.'
+            'after the preceding left parenthesis.'
+          when :parent_hash_key
+            'Indent the right brace the same as the parent hash key.'
           else
             'Indent the right brace the same as the start of the line ' \
-              'where the left brace is.'
+            'where the left brace is.'
           end
         end
 

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

@@ -41,7 +41,7 @@ module RuboCop
           return unless token
           return if token.column.zero?
 
-          space_range = range_with_surrounding_space(range: token.pos, side: :left, newlines: false)
+          space_range = range_with_surrounding_space(token.pos, side: :left, newlines: false)
           # If the file starts with a byte order mark (BOM), the column can be
           # non-zero, but then we find out here if there's no space to the left
           # of the first token.

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks that strings broken over multiple lines (by a backslash) contain
+      # trailing spaces instead of leading spaces.
+      #
+      # @example
+      #   # bad
+      #   'this text contains a lot of' \
+      #   '               spaces'
+      #
+      #   # good
+      #   'this text contains a lot of               ' \
+      #   'spaces'
+      #
+      #   # bad
+      #   'this text is too' \
+      #   ' long'
+      #
+      #   # good
+      #   'this text is too ' \
+      #   'long'
+      #
+      class LineContinuationLeadingSpace < Base
+        include RangeHelp
+
+        MSG = 'Move leading spaces to the end of previous line.'
+
+        def on_dstr(node)
+          range_start = node.loc.expression.begin_pos - node.loc.expression.column
+
+          raw_lines(node).each_cons(2) do |raw_line_one, raw_line_two|
+            range_start += raw_line_one.length
+
+            investigate(raw_line_one, raw_line_two, range_start)
+          end
+        end
+
+        private
+
+        def raw_lines(node)
+          processed_source.raw_source.lines[node.first_line - 1, line_range(node).size]
+        end
+
+        def investigate(first_line, second_line, range_start)
+          return unless continuation?(first_line)
+
+          matches = second_line.match(/\A(?<indent>\s*['"])(?<leading_spaces>\s+)/)
+          return if matches.nil?
+
+          add_offense(offense_range(range_start, matches))
+        end
+
+        def continuation?(line)
+          line.end_with?("\\\n")
+        end
+
+        def offense_range(range_start, matches)
+          begin_pos = range_start + matches[:indent].length
+          end_pos = begin_pos + matches[:leading_spaces].length
+          range_between(begin_pos, end_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks that the backslash of a line continuation is separated from
+      # preceding text by exactly one space (default) or zero spaces.
+      #
+      # @example EnforcedStyle: space (default)
+      #   # bad
+      #   'a'\
+      #   'b'  \
+      #   'c'
+      #
+      #   # good
+      #   'a' \
+      #   'b' \
+      #   'c'
+      #
+      # @example EnforcedStyle: no_space
+      #   # bad
+      #   'a' \
+      #   'b'  \
+      #   'c'
+      #
+      #   # good
+      #   'a'\
+      #   'b'\
+      #   'c'
+      class LineContinuationSpacing < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        def on_new_investigation
+          last_line = last_line(processed_source)
+
+          @ignored_ranges = string_literal_ranges(processed_source.ast) +
+                            comment_ranges(processed_source.comments)
+
+          processed_source.raw_source.lines.each_with_index do |line, index|
+            break if index >= last_line
+
+            line_number = index + 1
+            investigate(line, line_number)
+          end
+        end
+
+        private
+
+        def investigate(line, line_number)
+          offensive_spacing = find_offensive_spacing(line)
+          return unless offensive_spacing
+
+          range = source_range(
+            processed_source.buffer,
+            line_number,
+            line.length - offensive_spacing.length - 1,
+            offensive_spacing.length
+          )
+
+          return if ignore_range?(range)
+
+          add_offense(range) { |corrector| autocorrect(corrector, range) }
+        end
+
+        def find_offensive_spacing(line)
+          if no_space_style?
+            line[/\s+\\$/, 0]
+          elsif space_style?
+            line[/((?<!\s)|\s{2,})\\$/, 0]
+          end
+        end
+
+        def message(_range)
+          if no_space_style?
+            'Use zero spaces in front of backslash.'
+          elsif space_style?
+            'Use one space in front of backslash.'
+          end
+        end
+
+        def autocorrect(corrector, range)
+          correction = if no_space_style?
+                         '\\'
+                       elsif space_style?
+                         ' \\'
+                       end
+          corrector.replace(range, correction)
+        end
+
+        def string_literal_ranges(ast)
+          # which lines start inside a string literal?
+          return [] if ast.nil?
+
+          ast.each_node(:str, :dstr).each_with_object(Set.new) do |str, ranges|
+            loc = str.location
+
+            if str.heredoc?
+              ranges << loc.heredoc_body
+            elsif loc.respond_to?(:begin) && loc.begin
+              ranges << loc.expression
+            end
+          end
+        end
+
+        def comment_ranges(comments)
+          comments.map(&:loc).map(&:expression)
+        end
+
+        def last_line(processed_source)
+          last_token = processed_source.tokens.last
+
+          last_token ? last_token.line : processed_source.lines.length
+        end
+
+        def ignore_range?(backtick_range)
+          @ignored_ranges.any? { |range| range.contains?(backtick_range) }
+        end
+
+        def no_space_style?
+          cop_config['EnforcedStyle'] == 'no_space'
+        end
+
+        def space_style?
+          cop_config['EnforcedStyle'] == 'space'
+        end
+      end
+    end
+  end
+end

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

@@ -117,7 +117,7 @@ module RuboCop
 
         def autocorrect_arguments(corrector, node)
           end_pos = range_with_surrounding_space(
-            range: node.arguments.source_range,
+            node.arguments.source_range,
             side: :right,
             newlines: false
           ).end_pos

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

@@ -56,8 +56,8 @@ module RuboCop
           return unless style == :aligned && cop_config['IndentationWidth']
 
           raise ValidationError,
-                'The `Layout/MultilineMethodCallIndentation`' \
-                ' cop only accepts an `IndentationWidth` ' \
+                'The `Layout/MultilineMethodCallIndentation` ' \
+                'cop only accepts an `IndentationWidth` ' \
                 'configuration parameter when ' \
                 '`EnforcedStyle` is `indented`.'
         end

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

@@ -57,8 +57,8 @@ module RuboCop
         def validate_config
           return unless style == :aligned && cop_config['IndentationWidth']
 
-          raise ValidationError, 'The `Layout/MultilineOperationIndentation`' \
-                                 ' cop only accepts an `IndentationWidth` ' \
+          raise ValidationError, 'The `Layout/MultilineOperationIndentation` ' \
+                                 'cop only accepts an `IndentationWidth` ' \
                                  'configuration parameter when ' \
                                  '`EnforcedStyle` is `indented`.'
         end

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

@@ -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_operators.rb

@@ -161,7 +161,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|

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

@@ -65,7 +65,7 @@ module RuboCop
           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
 

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

@@ -36,7 +36,7 @@ module RuboCop
           return unless regular_method_call_with_arguments?(node)
 
           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)

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

@@ -98,6 +98,8 @@ module RuboCop
           check_inside(node, left_brace, right_brace)
         end
 
+        alias on_numblock on_block
+
         private
 
         def check_inside(node, left_brace, right_brace)
@@ -126,7 +128,7 @@ module RuboCop
         end
 
         def braces_with_contents_inside(node, inner)
-          args_delimiter = node.arguments.loc.begin # Can be ( | or nil.
+          args_delimiter = node.arguments.loc.begin if node.block_type? # Can be ( | or nil.
 
           check_left_brace(inner, node.loc.begin, args_delimiter)
           check_right_brace(inner, node.loc.begin, node.loc.end, node.single_line?)
@@ -185,7 +187,7 @@ module RuboCop
                       'Space between { and | detected.')
             end
           else
-            brace_with_space = range_with_surrounding_space(range: left_brace, side: :right)
+            brace_with_space = range_with_surrounding_space(left_brace, side: :right)
             space(brace_with_space.begin_pos + 1, brace_with_space.end_pos,
                   'Space inside { detected.')
           end
@@ -196,7 +198,7 @@ module RuboCop
         end
 
         def space_inside_right_brace(right_brace)
-          brace_with_space = range_with_surrounding_space(range: right_brace, side: :left)
+          brace_with_space = range_with_surrounding_space(right_brace, side: :left)
           space(brace_with_space.begin_pos, brace_with_space.end_pos - 1,
                 'Space inside } detected.')
         end

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

@@ -89,7 +89,7 @@ module RuboCop
         end
 
         def whitespace_only?(range)
-          source = range_with_surrounding_space(range: range).source
+          source = range_with_surrounding_space(range).source
           source.start_with?("\n") && source.end_with?("\n")
         end
 

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for overwriting an exception with an exception result by use `rescue =>`.
+      #
+      # You intended to write as `rescue StandardError`.
+      # However, you have written `rescue => StandardError`.
+      # In that case, the result of `rescue` will overwrite `StandardError`.
+      #
+      # @example
+      #
+      #   # bad
+      #   begin
+      #     something
+      #   rescue => StandardError
+      #   end
+      #
+      #   # good
+      #   begin
+      #     something
+      #   rescue StandardError
+      #   end
+      #
+      class ConstantOverwrittenInRescue < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = '`%<constant>s` is overwritten by `rescue =>`.'
+
+        # @!method overwritten_constant(node)
+        def_node_matcher :overwritten_constant, <<~PATTERN
+          (resbody nil? (casgn nil? $_) nil?)
+        PATTERN
+
+        def self.autocorrect_incompatible_with
+          [Naming::RescuedExceptionsVariableName, Style::RescueStandardError]
+        end
+
+        def on_resbody(node)
+          return unless (constant = overwritten_constant(node))
+
+          add_offense(node.loc.assoc, message: format(MSG, constant: constant)) do |corrector|
+            corrector.remove(range_between(node.loc.keyword.end_pos, node.loc.assoc.end_pos))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -24,7 +24,7 @@ module RuboCop
       class InterpolationCheck < Base
         extend AutoCorrector
 
-        MSG = 'Interpolation in single quoted string detected. '\
+        MSG = 'Interpolation in single quoted string detected. ' \
               'Use double quoted strings if you need interpolation.'
 
         def on_str(node)

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

@@ -7,6 +7,9 @@ module RuboCop
       # operands in and/or expressions serving as the conditions of
       # if/while/until/case-when/case-in.
       #
+      # NOTE: Literals in `case-in` condition where the match variable is used in
+      # `in` are accepted as a pattern matching.
+      #
       # @example
       #
       #   # bad
@@ -69,6 +72,8 @@ module RuboCop
 
         def on_case_match(case_match_node)
           if case_match_node.condition
+            return if case_match_node.descendants.any?(&:match_var_type?)
+
             check_case(case_match_node)
           else
             case_match_node.each_in_pattern do |in_pattern_node|