rubocop 1.14.0 → 1.18.0

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

@@ -155,7 +155,13 @@ module RuboCop
         end
 
         def all_elements_aligned?(elements)
-          elements.map { |e| e.loc.column }.uniq.count == 1
+          elements.flat_map do |e|
+            if e.hash_type?
+              e.each_pair.map { |pair| pair.loc.column }
+            else
+              e.loc.column
+            end
+          end.uniq.count == 1
         end
 
         def first_argument_line(elements)

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

@@ -37,7 +37,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Incorrect indentation detected (column %<column>d ' \
-          'instead of %<correct_comment_indentation>d).'
+              'instead of %<correct_comment_indentation>d).'
 
         def on_new_investigation
           processed_source.comments.each { |comment| check(comment) }

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

@@ -24,6 +24,7 @@ module RuboCop
       #     method
       class DotPosition < Base
         include ConfigurableEnforcedStyle
+        include RangeHelp
         extend AutoCorrector
 
         def on_send(node)
@@ -42,7 +43,12 @@ module RuboCop
         private
 
         def autocorrect(corrector, dot, node)
-          corrector.remove(dot)
+          dot_range = if processed_source[dot.line - 1].strip == '.'
+                        range_by_whole_lines(dot, include_final_newline: true)
+                      else
+                        dot
+                      end
+          corrector.remove(dot_range)
           case style
           when :leading
             corrector.insert_before(selector_range(node), dot.source)

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

@@ -45,8 +45,7 @@ module RuboCop
         def on_if(node)
           return if correct_style?(node)
 
-          if node.modifier_form? && last_argument_is_heredoc?(node)
-            heredoc_node = last_heredoc_argument(node)
+          if node.modifier_form? && (heredoc_node = last_heredoc_argument(node))
             return if next_line_empty_or_enable_directive_comment?(heredoc_line(node, heredoc_node))
 
             add_offense(heredoc_node.loc.heredoc_end) do |corrector|
@@ -62,7 +61,7 @@ module RuboCop
         private
 
         def autocorrect(corrector, node)
-          node_range = if node.respond_to?(:heredoc?) && node.heredoc?
+          node_range = if heredoc?(node)
                          range_by_whole_lines(node.loc.heredoc_body)
                        else
                          range_by_whole_lines(node.source_range)
@@ -125,19 +124,8 @@ module RuboCop
           next_sibling.if_type? && contains_guard_clause?(next_sibling)
         end
 
-        def last_argument_is_heredoc?(node)
-          last_children = node.if_branch
-          return false unless last_children&.send_type?
-
-          heredoc?(last_heredoc_argument(node))
-        end
-
         def last_heredoc_argument(node)
-          n = if node.respond_to?(:if_branch)
-                node.if_branch.children.last
-              else
-                node
-              end
+          n = last_heredoc_argument_node(node)
 
           return n if heredoc?(n)
           return unless n.respond_to?(:arguments)
@@ -150,6 +138,16 @@ module RuboCop
           return last_heredoc_argument(n.receiver) if n.respond_to?(:receiver)
         end
 
+        def last_heredoc_argument_node(node)
+          return node unless node.respond_to?(:if_branch)
+
+          if node.if_branch.and_type?
+            node.if_branch.children.first
+          else
+            node.if_branch.children.last
+          end
+        end
+
         def heredoc_line(node, heredoc_node)
           heredoc_body = heredoc_node.loc.heredoc_body
           num_of_heredoc_lines = heredoc_body.last_line - heredoc_body.first_line

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

@@ -161,10 +161,10 @@ module RuboCop
             'Indent the right bracket the same as the left bracket.'
           elsif style == :special_inside_parentheses && left_parenthesis
             'Indent the right bracket the same as the first position ' \
-            'after the preceding left parenthesis.'
+              'after the preceding left parenthesis.'
           else
             'Indent the right bracket the same as the start of the line' \
-            ' where the left bracket is.'
+              ' where the left bracket is.'
           end
         end
       end

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

@@ -91,6 +91,8 @@ module RuboCop
         end
 
         def on_send(node)
+          return if enforce_first_argument_with_fixed_indentation?
+
           each_argument_node(node, :hash) do |hash_node, left_parenthesis|
             check(hash_node, left_parenthesis)
           end
@@ -176,12 +178,22 @@ module RuboCop
             'Indent the right brace the same as the left brace.'
           elsif style == :special_inside_parentheses && left_parenthesis
             'Indent the right brace the same as the first position ' \
-            'after the preceding left parenthesis.'
+              'after the preceding left parenthesis.'
           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
+
+        def enforce_first_argument_with_fixed_indentation?
+          return false unless argument_alignment_config['Enabled']
+
+          argument_alignment_config['EnforcedStyle'] == 'with_fixed_indentation'
+        end
+
+        def argument_alignment_config
+          config.for_cop('Layout/ArgumentAlignment')
+        end
       end
     end
   end

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

@@ -48,7 +48,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use %<configured_indentation_width>d spaces for indentation ' \
-             'in method args, relative to %<base_description>s.'
+              'in method args, relative to %<base_description>s.'
 
         def on_def(node)
           return if node.arguments.empty?

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

@@ -180,12 +180,15 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MESSAGES = { KeyAlignment => 'Align the keys of a hash literal if ' \
-                      'they span more than one line.',
-                     SeparatorAlignment => 'Align the separators of a hash ' \
-                       'literal if they span more than one line.',
-                     TableAlignment => 'Align the keys and values of a hash ' \
-                       'literal if they span more than one line.' }.freeze
+        MESSAGES = {
+          KeyAlignment => 'Align the keys of a hash literal if they span more than one line.',
+          SeparatorAlignment => 'Align the separators of a hash literal if they span more than ' \
+                                'one line.',
+          TableAlignment => 'Align the keys and values of a hash literal if they span more than ' \
+                            'one line.',
+          KeywordSplatAlignment => 'Align keyword splats with the rest of the hash if it spans ' \
+                                   'more than one line.'
+        }.freeze
 
         def on_send(node)
           return if double_splat?(node)
@@ -200,14 +203,12 @@ module RuboCop
         alias on_super on_send
         alias on_yield on_send
 
-        def on_hash(node) # rubocop:todo Metrics/CyclomaticComplexity
-          return if ignored_node?(node)
-          return if node.pairs.empty? || node.single_line?
+        def on_hash(node)
+          return if autocorrect_incompatible_with_other_cops?(node) || ignored_node?(node) ||
+                    node.pairs.empty? || node.single_line?
 
-          return unless alignment_for_hash_rockets
-                        .any? { |a| a.checkable_layout?(node) } &&
-                        alignment_for_colons
-                        .any? { |a| a.checkable_layout?(node) }
+          proc = ->(a) { a.checkable_layout?(node) }
+          return unless alignment_for_hash_rockets.any?(proc) && alignment_for_colons.any?(proc)
 
           check_pairs(node)
         end
@@ -216,6 +217,12 @@ module RuboCop
 
         private
 
+        def autocorrect_incompatible_with_other_cops?(node)
+          enforce_first_argument_with_fixed_indentation? &&
+            node.pairs.any? &&
+            node.parent&.call_type? && node.parent.loc.line == node.pairs.first.loc.line
+        end
+
         def reset!
           self.offences_by = {}
           self.column_deltas = Hash.new { |hash, key| hash[key] = {} }
@@ -245,7 +252,14 @@ module RuboCop
         end
 
         def add_offences
+          kwsplat_offences = offences_by.delete(KeywordSplatAlignment)
+          register_offences_with_format(kwsplat_offences, KeywordSplatAlignment)
+
           format, offences = offences_by.min_by { |_, v| v.length }
+          register_offences_with_format(offences, format)
+        end
+
+        def register_offences_with_format(offences, format)
           (offences || []).each do |offence|
             add_offense(offence, message: MESSAGES[format]) do |corrector|
               delta = column_deltas[alignment_for(offence).first.class][offence]
@@ -273,7 +287,9 @@ module RuboCop
         end
 
         def alignment_for(pair)
-          if pair.hash_rocket?
+          if pair.kwsplat_type?
+            [KeywordSplatAlignment.new]
+          elsif pair.hash_rocket?
             alignment_for_hash_rockets
           else
             alignment_for_colons
@@ -353,6 +369,16 @@ module RuboCop
         def good_alignment?(column_deltas)
           column_deltas.values.all?(&:zero?)
         end
+
+        def enforce_first_argument_with_fixed_indentation?
+          return false unless argument_alignment_config['Enabled']
+
+          argument_alignment_config['EnforcedStyle'] == 'with_fixed_indentation'
+        end
+
+        def argument_alignment_config
+          config.for_cop('Layout/ArgumentAlignment')
+        end
       end
     end
   end

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

@@ -55,7 +55,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Put the closing parenthesis for a method call with a ' \
-        'HEREDOC parameter on the same line as the HEREDOC opening.'
+              'HEREDOC parameter on the same line as the HEREDOC opening.'
 
         def self.autocorrect_incompatible_with
           [Style::TrailingCommaInArguments]

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

@@ -138,6 +138,14 @@ module RuboCop
           check_indentation(case_node.when_branches.last.loc.keyword, case_node.else_branch)
         end
 
+        def on_case_match(case_match)
+          case_match.each_in_pattern do |in_pattern_node|
+            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)
+        end
+
         def on_if(node, base = node)
           return if ignored_node?(node)
           return if node.ternary? || node.modifier_form?
@@ -313,9 +321,12 @@ module RuboCop
             check_rescue?(body_node)
           elsif body_node.ensure_type?
             block_body, = *body_node
-            return unless block_body
 
-            check_rescue?(block_body) if block_body.rescue_type?
+            if block_body&.rescue_type?
+              check_rescue?(block_body)
+            else
+              !block_body.nil?
+            end
           else
             true
           end

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

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop 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
+      # first part. There are some exceptions, such as implicit return values, where the
+      # 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.
+      #
+      # @example
+      #   # bad
+      #   def some_method
+      #     'x' \
+      #     'y' \
+      #     'z'
+      #   end
+      #
+      #   my_hash = {
+      #     first: 'a message' \
+      #       'in two parts'
+      #   }
+      #
+      #   # good
+      #   def some_method
+      #     'x' \
+      #       'y' \
+      #       'z'
+      #   end
+      #
+      #   my_hash = {
+      #     first: 'a message' \
+      #            'in two parts'
+      #   }
+      #
+      # @example EnforcedStyle: aligned (default)
+      #   # bad
+      #   puts 'x' \
+      #     'y'
+      #
+      #   # good
+      #   puts 'x' \
+      #        'y'
+      #
+      # @example EnforcedStyle: indented
+      #   # bad
+      #   result = 'x' \
+      #            'y'
+      #
+      #   # good
+      #   result = 'x' \
+      #     'y'
+      #
+      class LineEndStringConcatenationIndentation < Base
+        include ConfigurableEnforcedStyle
+        include Alignment
+        extend AutoCorrector
+
+        MSG_ALIGN = 'Align parts of a string concatenated with backslash.'
+        MSG_INDENT = 'Indent the first part of a string concatenated with backslash.'
+        PARENT_TYPES_FOR_INDENTED = [nil, :block, :begin, :def, :defs, :if].freeze
+
+        def on_dstr(node)
+          return unless strings_concatenated_with_backslash?(node)
+
+          children = node.children
+          if style == :aligned && !always_indented?(node) || always_aligned?(node)
+            check_aligned(children, 1)
+          else
+            check_indented(children)
+            check_aligned(children, 2)
+          end
+        end
+
+        def autocorrect(corrector, node)
+          AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
+        end
+
+        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? }
+        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|
+            @column_delta = base_column - child.loc.column
+            add_offense_and_correction(child, MSG_ALIGN) if @column_delta != 0
+            base_column = child.loc.column
+          end
+        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
+          add_offense_and_correction(children[1], MSG_INDENT) if @column_delta != 0
+        end
+
+        def add_offense_and_correction(node, message)
+          add_offense(node, message: message) { |corrector| autocorrect(corrector, node) }
+        end
+      end
+    end
+  end
+end

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

@@ -93,18 +93,18 @@ module RuboCop
         extend AutoCorrector
 
         SAME_LINE_MESSAGE = 'The closing array brace must be on the same ' \
-          'line as the last array element when the opening brace is on the ' \
-          'same line as the first array element.'
+                            'line as the last array element when the opening brace is on the ' \
+                            'same line as the first array element.'
 
         NEW_LINE_MESSAGE = 'The closing array brace must be on the line ' \
-          'after the last array element when the opening brace is on a ' \
-          'separate line from the first array element.'
+                           'after the last array element when the opening brace is on a ' \
+                           'separate line from the first array element.'
 
         ALWAYS_NEW_LINE_MESSAGE = 'The closing array brace must be on the ' \
-          'line after the last array element.'
+                                  'line after the last array element.'
 
         ALWAYS_SAME_LINE_MESSAGE = 'The closing array brace must be on the ' \
-          'same line as the last array element.'
+                                   'same line as the last array element.'
 
         def on_array(node)
           check_brace_layout(node)