rubocop 1.13.0 → 1.17.0

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

@@ -3,10 +3,10 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks how the ``when``s of a `case` expression
+      # This cop checks how the `when` and `in`s of a `case` expression
       # are indented in relation to its `case` or `end` keyword.
       #
-      # It will register a separate offense for each misaligned `when`.
+      # It will register a separate offense for each misaligned `when` and `in`.
       #
       # @example
       #   # If Layout/EndAlignment is set to keyword style (default)
@@ -22,6 +22,13 @@ module RuboCop
       #       y / 3
       #   end
       #
+      #   case n
+      #     in pattern
+      #       x * 2
+      #     else
+      #       y / 3
+      #   end
+      #
       #   # good for all styles
       #   case n
       #   when 0
@@ -30,6 +37,13 @@ module RuboCop
       #     y / 3
       #   end
       #
+      #   case n
+      #   in pattern
+      #     x * 2
+      #   else
+      #     y / 3
+      #   end
+      #
       # @example EnforcedStyle: case (default)
       #   # if EndAlignment is set to other style such as
       #   # start_of_line (as shown below), then *when* alignment
@@ -43,6 +57,13 @@ module RuboCop
       #     y / 3
       #   end
       #
+      #   a = case n
+      #   in pattern
+      #     x * 2
+      #   else
+      #     y / 3
+      #   end
+      #
       #   # good
       #   a = case n
       #       when 0
@@ -51,6 +72,13 @@ module RuboCop
       #         y / 3
       #   end
       #
+      #   a = case n
+      #       in pattern
+      #         x * 2
+      #       else
+      #         y / 3
+      #   end
+      #
       # @example EnforcedStyle: end
       #   # bad
       #   a = case n
@@ -60,6 +88,13 @@ module RuboCop
       #         y / 3
       #   end
       #
+      #   a = case n
+      #       in pattern
+      #         x * 2
+      #       else
+      #         y / 3
+      #   end
+      #
       #   # good
       #   a = case n
       #   when 0
@@ -67,30 +102,43 @@ module RuboCop
       #   else
       #     y / 3
       #   end
+      #
+      #   a = case n
+      #   in pattern
+      #     x * 2
+      #   else
+      #     y / 3
+      #   end
       class CaseIndentation < Base
         include Alignment
         include ConfigurableEnforcedStyle
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Indent `when` %<depth>s `%<base>s`.'
+        MSG = 'Indent `%<branch_type>s` %<depth>s `%<base>s`.'
 
         def on_case(case_node)
           return if case_node.single_line?
 
-          case_node.each_when { |when_node| check_when(when_node) }
+          case_node.each_when { |when_node| check_when(when_node, 'when') }
+        end
+
+        def on_case_match(case_match_node)
+          return if case_match_node.single_line?
+
+          case_match_node.each_in_pattern { |in_pattern_node| check_when(in_pattern_node, 'in') }
         end
 
         private
 
-        def check_when(when_node)
+        def check_when(when_node, branch_type)
           when_column = when_node.loc.keyword.column
           base_column = base_column(when_node.parent, style)
 
           if when_column == base_column + indentation_width
             correct_style_detected
           else
-            incorrect_style(when_node)
+            incorrect_style(when_node, branch_type)
           end
         end
 
@@ -102,9 +150,9 @@ module RuboCop
           indent_one_step? ? configured_indentation_width : 0
         end
 
-        def incorrect_style(when_node)
+        def incorrect_style(when_node, branch_type)
           depth = indent_one_step? ? 'one step more than' : 'as deep as'
-          message = format(MSG, depth: depth, base: style)
+          message = format(MSG, branch_type: branch_type, depth: depth, base: style)
 
           add_offense(when_node.loc.keyword, message: message) do |corrector|
             detect_incorrect_style(when_node)
@@ -141,7 +189,7 @@ module RuboCop
         end
 
         def replacement(node)
-          case_node = node.each_ancestor(:case).first
+          case_node = node.each_ancestor(:case, :case_match).first
           base_type = cop_config[style_parameter_name] == 'end' ? :end : :case
 
           column = base_column(case_node, base_type)

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_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
@@ -182,6 +184,16 @@ module RuboCop
             '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/hash_alignment.rb

@@ -185,7 +185,9 @@ module RuboCop
                      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
+                       '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 +202,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 +216,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 +251,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 +286,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 +368,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/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/redundant_line_break.rb

@@ -42,8 +42,9 @@ module RuboCop
       #   # good
       #   foo(a) { |x| puts x }
       #
-      class RedundantLineBreak < Cop
+      class RedundantLineBreak < Base
         include CheckAssignment
+        extend AutoCorrector
 
         MSG = 'Redundant line break detected.'
 
@@ -55,23 +56,24 @@ module RuboCop
 
           return unless offense?(node) && !part_of_ignored_node?(node)
 
-          add_offense(node)
-          ignore_node(node)
+          register_offense(node)
         end
 
+        private
+
         def check_assignment(node, _rhs)
           return unless offense?(node)
 
-          add_offense(node)
-          ignore_node(node)
+          register_offense(node)
         end
 
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.source_range, to_single_line(node.source).strip) }
+        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
 
-        private
-
         def offense?(node)
           return false if configured_to_not_be_inspected?(node)
 
@@ -79,8 +81,20 @@ module RuboCop
         end
 
         def configured_to_not_be_inspected?(node)
+          return true if other_cop_takes_precedence?(node)
+
           !cop_config['InspectBlocks'] && (node.block_type? ||
-                                           node.each_child_node(:block).any?(&:multiline?))
+                                           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)

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

@@ -0,0 +1,53 @@
+# 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_number = receiver_location.end.line
+          return if receiver_location.begin.line < closing_block_delimiter_line_number
+
+          node_location = node.loc
+          dot_range = node_location.dot
+          return unless dot_range
+          return if dot_range.line > closing_block_delimiter_line_number
+
+          range_between(dot_range.begin_pos, node_location.selector.end_pos)
+        end
+      end
+    end
+  end
+end