rubocop 1.18.0 → 1.56.0

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks for indentation that doesn't use the specified number
+      # Checks for indentation that doesn't use the specified number
       # of spaces.
       #
       # See also the IndentationConsistency cop which is the companion to this
@@ -24,7 +24,7 @@ module RuboCop
       #     end
       #   end
       #
-      # @example IgnoredPatterns: ['^\s*module']
+      # @example AllowedPatterns: ['^\s*module']
       #   # bad
       #   module A
       #   class B
@@ -46,7 +46,7 @@ module RuboCop
         include EndKeywordAlignment
         include Alignment
         include CheckAssignment
-        include IgnoredPattern
+        include AllowedPattern
         include RangeHelp
         extend AutoCorrector
 
@@ -90,8 +90,13 @@ module RuboCop
           check_members(end_loc, [node.body])
         end
 
+        alias on_numblock on_block
+
         def on_class(node)
-          check_members(node.loc.keyword, [node.body])
+          base = node.loc.keyword
+          return if same_line?(base, node.body)
+
+          check_members(base, [node.body])
         end
         alias on_sclass on_class
         alias on_module on_class
@@ -143,7 +148,9 @@ module RuboCop
             check_indentation(in_pattern_node.loc.keyword, in_pattern_node.body)
           end
 
-          check_indentation(case_match.in_pattern_branches.last.loc.keyword, case_match.else_branch)
+          else_branch = case_match.else_branch&.empty_else_type? ? nil : case_match.else_branch
+
+          check_indentation(case_match.in_pattern_branches.last.loc.keyword, else_branch)
         end
 
         def on_if(node, base = node)
@@ -185,8 +192,7 @@ module RuboCop
 
         def check_members_for_indented_internal_methods_style(members)
           each_member(members) do |member, previous_modifier|
-            check_indentation(previous_modifier, member,
-                              indentation_consistency_style)
+            check_indentation(previous_modifier, member, indentation_consistency_style)
           end
         end
 
@@ -270,12 +276,12 @@ module RuboCop
         end
 
         def offense(body_node, indentation, style)
-          # This cop only auto-corrects the first statement in a def body, for
+          # This cop only autocorrects the first statement in a def body, for
           # example.
           body_node = body_node.children.first if body_node.begin_type? && !parentheses?(body_node)
 
           # Since autocorrect changes a number of lines, and not only the line
-          # where the reported offending range is, we avoid auto-correction if
+          # where the reported offending range is, we avoid autocorrection if
           # this cop has already found other offenses is the same
           # range. Otherwise, two corrections can interfere with each other,
           # resulting in corrupted code.
@@ -303,7 +309,7 @@ module RuboCop
         end
 
         # Returns true if the given node is within another node that has
-        # already been marked for auto-correction by this cop.
+        # already been marked for autocorrection by this cop.
         def other_offense_in_same_range?(node)
           expr = node.source_range
           @offense_ranges ||= []
@@ -337,18 +343,18 @@ module RuboCop
         end
 
         def skip_check?(base_loc, body_node)
-          return true if ignored_line?(base_loc)
+          return true if allowed_line?(base_loc)
           return true unless body_node
 
           # Don't check if expression is on same line as "then" keyword, etc.
-          return true if body_node.loc.line == base_loc.line
+          return true if same_line?(body_node, base_loc)
 
           return true if starts_with_access_modifier?(body_node)
 
           # Don't check indentation if the line doesn't start with the body.
           # For example, lines like "else do_something".
           first_char_pos_on_line = body_node.source_range.source_line =~ /\S/
-          return true unless body_node.loc.column == first_char_pos_on_line
+          true unless body_node.loc.column == first_char_pos_on_line
         end
 
         def offending_range(body_node, indentation)
@@ -360,10 +366,10 @@ module RuboCop
         end
 
         def starts_with_access_modifier?(body_node)
-          return unless body_node.begin_type?
+          return false unless body_node.begin_type?
 
           starting_node = body_node.children.first
-          return unless starting_node
+          return false unless starting_node
 
           starting_node.send_type? && starting_node.bare_access_modifier?
         end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks for indentation of the first non-blank non-comment
+      # Checks for indentation of the first non-blank non-comment
       # line in a file.
       #
       # @example
@@ -34,14 +34,14 @@ module RuboCop
         private
 
         def first_token
-          processed_source.find_token { |t| !t.text.start_with?('#') }
+          processed_source.tokens.find { |t| !t.text.start_with?('#') }
         end
 
         def space_before(token)
           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/leading_comment_space.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks whether comments have a leading space after the
+      # Checks whether comments have a leading space after the
       # `#` denoting the start of the comment. The leading space is not
       # required for some RDoc special syntax, like `#++`, `#--`,
       # `#:nodoc`, `=begin`- and `=end` comments, "shebang" directives,
@@ -57,13 +57,13 @@ module RuboCop
 
         def on_new_investigation
           processed_source.comments.each do |comment|
-            next unless /\A#+[^#\s=:+-]/.match?(comment.text)
+            next unless /\A#+[^#\s=+-]/.match?(comment.text)
             next if comment.loc.line == 1 && allowed_on_first_line?(comment)
             next if doxygen_comment_style?(comment)
             next if gemfile_ruby_comment?(comment)
 
             add_offense(comment) do |corrector|
-              expr = comment.loc.expression
+              expr = comment.source_range
 
               corrector.insert_after(hash_mark(expr), ' ')
             end
@@ -77,7 +77,7 @@ module RuboCop
         end
 
         def allowed_on_first_line?(comment)
-          shebang?(comment) || rackup_config_file? && rackup_options?(comment)
+          shebang?(comment) || (rackup_config_file? && rackup_options?(comment))
         end
 
         def shebang?(comment)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks for unnecessary leading blank lines at the beginning
+      # Checks for unnecessary leading blank lines at the beginning
       # of a file.
       #
       # @example

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

@@ -0,0 +1,136 @@
+# 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 (default) or leading spaces
+      # instead of trailing spaces.
+      #
+      # @example EnforcedStyle: trailing (default)
+      #   # 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'
+      #
+      # @example EnforcedStyle: leading
+      #   # 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
+        extend AutoCorrector
+
+        LINE_1_ENDING = /['"]\s*\\\n/.freeze
+        LINE_2_BEGINNING = /\A\s*['"]/.freeze
+        LEADING_STYLE_OFFENSE = /(?<trailing_spaces>\s+)(?<ending>#{LINE_1_ENDING})/.freeze
+        TRAILING_STYLE_OFFENSE = /(?<beginning>#{LINE_2_BEGINNING})(?<leading_spaces>\s+)/.freeze
+        private_constant :LINE_1_ENDING, :LINE_2_BEGINNING,
+                         :LEADING_STYLE_OFFENSE, :TRAILING_STYLE_OFFENSE
+
+        def on_dstr(node)
+          # Quick check if we possibly have line continuations.
+          return unless node.source.include?('\\')
+
+          end_of_first_line = node.source_range.begin_pos - node.source_range.column
+
+          raw_lines(node).each_cons(2) do |raw_line_one, raw_line_two|
+            end_of_first_line += raw_line_one.length
+
+            next unless continuation?(raw_line_one)
+
+            if enforced_style_leading?
+              investigate_leading_style(raw_line_one, raw_line_two, end_of_first_line)
+            else
+              investigate_trailing_style(raw_line_one, raw_line_two, end_of_first_line)
+            end
+          end
+        end
+
+        private
+
+        def raw_lines(node)
+          processed_source.raw_source.lines[node.first_line - 1, line_range(node).size]
+        end
+
+        def investigate_leading_style(first_line, second_line, end_of_first_line)
+          matches = first_line.match(LEADING_STYLE_OFFENSE)
+          return if matches.nil?
+
+          offense_range = leading_offense_range(end_of_first_line, matches)
+          add_offense(offense_range) do |corrector|
+            insert_pos = end_of_first_line + second_line[LINE_2_BEGINNING].length
+            autocorrect(corrector, offense_range, insert_pos, matches[:trailing_spaces])
+          end
+        end
+
+        def investigate_trailing_style(first_line, second_line, end_of_first_line)
+          matches = second_line.match(TRAILING_STYLE_OFFENSE)
+          return if matches.nil?
+
+          offense_range = trailing_offense_range(end_of_first_line, matches)
+          add_offense(offense_range) do |corrector|
+            insert_pos = end_of_first_line - first_line[LINE_1_ENDING].length
+            autocorrect(corrector, offense_range, insert_pos, matches[:leading_spaces])
+          end
+        end
+
+        def continuation?(line)
+          line.end_with?("\\\n")
+        end
+
+        def autocorrect(corrector, offense_range, insert_pos, spaces)
+          corrector.remove(offense_range)
+          corrector.replace(range_between(insert_pos, insert_pos), spaces)
+        end
+
+        def leading_offense_range(end_of_first_line, matches)
+          end_pos = end_of_first_line - matches[:ending].length
+          begin_pos = end_pos - matches[:trailing_spaces].length
+          range_between(begin_pos, end_pos)
+        end
+
+        def trailing_offense_range(end_of_first_line, matches)
+          begin_pos = end_of_first_line + matches[:beginning].length
+          end_pos = begin_pos + matches[:leading_spaces].length
+          range_between(begin_pos, end_pos)
+        end
+
+        def message(_range)
+          if enforced_style_leading?
+            'Move trailing spaces to the start of next line.'
+          else
+            'Move leading spaces to the end of previous line.'
+          end
+        end
+
+        def enforced_style_leading?
+          cop_config['EnforcedStyle'] == 'leading'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,140 @@
+# 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
+          return unless processed_source.raw_source.include?('\\')
+
+          last_line = last_line(processed_source)
+
+          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
+
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def ignored_literal_ranges(ast)
+          # which lines start inside a string literal?
+          return [] if ast.nil?
+
+          ast.each_node(:str, :dstr, :array).with_object(Set.new) do |literal, ranges|
+            loc = literal.location
+
+            if literal.array_type?
+              next unless literal.percent_literal?
+
+              ranges << loc.expression
+            elsif literal.heredoc?
+              ranges << loc.heredoc_body
+            elsif loc.respond_to?(:begin) && loc.begin
+              ranges << loc.expression
+            end
+          end
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        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 ignored_ranges
+          @ignored_ranges ||= ignored_literal_ranges(processed_source.ast) +
+                              comment_ranges(processed_source.comments)
+        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/line_end_string_concatenation_indentation.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks the indentation of the next line after a line that ends with a string
+      # Checks the indentation of the next line after a line that ends with a string
       # literal and a backslash.
       #
       # If `EnforcedStyle: aligned` is set, the concatenated string parts shall be aligned with the
@@ -11,8 +11,7 @@ module RuboCop
       # concatenated string parts shall be indented regardless of `EnforcedStyle` configuration.
       #
       # If `EnforcedStyle: indented` is set, it's the second line that shall be indented one step
-      # more than the first line. Lines 3 and forward shall be aligned with line 2. Here too there
-      # are exceptions. Values in a hash literal are always aligned.
+      # more than the first line. Lines 3 and forward shall be aligned with line 2.
       #
       # @example
       #   # bad
@@ -34,29 +33,44 @@ module RuboCop
       #       'z'
       #   end
       #
-      #   my_hash = {
-      #     first: 'a message' \
-      #            'in two parts'
-      #   }
-      #
       # @example EnforcedStyle: aligned (default)
       #   # bad
       #   puts 'x' \
       #     'y'
       #
+      #   my_hash = {
+      #     first: 'a message' \
+      #       'in two parts'
+      #   }
+      #
       #   # good
       #   puts 'x' \
       #        'y'
       #
+      #   my_hash = {
+      #     first: 'a message' \
+      #            'in two parts'
+      #   }
+      #
       # @example EnforcedStyle: indented
       #   # bad
       #   result = 'x' \
       #            'y'
       #
+      #   my_hash = {
+      #     first: 'a message' \
+      #            'in two parts'
+      #   }
+      #
       #   # good
       #   result = 'x' \
       #     'y'
       #
+      #   my_hash = {
+      #     first: 'a message' \
+      #       'in two parts'
+      #   }
+      #
       class LineEndStringConcatenationIndentation < Base
         include ConfigurableEnforcedStyle
         include Alignment
@@ -70,7 +84,9 @@ module RuboCop
           return unless strings_concatenated_with_backslash?(node)
 
           children = node.children
-          if style == :aligned && !always_indented?(node) || always_aligned?(node)
+          return if children.empty?
+
+          if style == :aligned && !always_indented?(node)
             check_aligned(children, 1)
           else
             check_indented(children)
@@ -85,22 +101,18 @@ module RuboCop
         private
 
         def strings_concatenated_with_backslash?(dstr_node)
-          !dstr_node.heredoc? &&
-            dstr_node.children.length > 1 &&
-            dstr_node.children.all? { |c| c.str_type? || c.dstr_type? }
+          dstr_node.multiline? &&
+            dstr_node.children.all? { |c| c.str_type? || c.dstr_type? } &&
+            dstr_node.children.none?(&:multiline?)
         end
 
         def always_indented?(dstr_node)
           PARENT_TYPES_FOR_INDENTED.include?(dstr_node.parent&.type)
         end
 
-        def always_aligned?(dstr_node)
-          dstr_node.parent&.pair_type?
-        end
-
         def check_aligned(children, start_index)
           base_column = children[start_index - 1].loc.column
-          children[start_index..-1].each do |child|
+          children[start_index..].each do |child|
             @column_delta = base_column - child.loc.column
             add_offense_and_correction(child, MSG_ALIGN) if @column_delta != 0
             base_column = child.loc.column
@@ -108,11 +120,20 @@ module RuboCop
         end
 
         def check_indented(children)
-          base_column = children[0].source_range.source_line =~ /\S/
-          @column_delta = base_column + configured_indentation_width - children[1].loc.column
+          @column_delta = base_column(children[0]) + configured_indentation_width -
+                          children[1].loc.column
           add_offense_and_correction(children[1], MSG_INDENT) if @column_delta != 0
         end
 
+        def base_column(child)
+          grandparent = child.parent.parent
+          if grandparent&.type == :pair
+            grandparent.loc.column
+          else
+            child.source_range.source_line =~ /\S/
+          end
+        end
+
         def add_offense_and_correction(node, message)
           add_offense(node, message: message) { |corrector| autocorrect(corrector, node) }
         end