rubocop 0.82.0 → 1.18.4

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

@@ -100,31 +100,28 @@ module RuboCop
       #   def foo(a,
       #     b)
       #   end
-      class MultilineMethodDefinitionBraceLayout < Cop
+      class MultilineMethodDefinitionBraceLayout < Base
         include MultilineLiteralBraceLayout
+        extend AutoCorrector
 
         SAME_LINE_MESSAGE = 'Closing method definition brace must be on the ' \
-          'same line as the last parameter when opening brace is on the same ' \
-          'line as the first parameter.'
+                            'same line as the last parameter when opening brace is on the same ' \
+                            'line as the first parameter.'
 
         NEW_LINE_MESSAGE = 'Closing method definition brace must be on the ' \
-          'line after the last parameter when opening brace is on a separate ' \
-          'line from the first parameter.'
+                           'line after the last parameter when opening brace is on a separate ' \
+                           'line from the first parameter.'
 
         ALWAYS_NEW_LINE_MESSAGE = 'Closing method definition brace must be ' \
-          'on the line after the last parameter.'
+                                  'on the line after the last parameter.'
 
         ALWAYS_SAME_LINE_MESSAGE = 'Closing method definition brace must be ' \
-          'on the same line as the last parameter.'
+                                   'on the same line as the last parameter.'
 
         def on_def(node)
           check_brace_layout(node.arguments)
         end
         alias on_defs on_def
-
-        def autocorrect(node)
-          MultilineLiteralBraceCorrector.new(node, processed_source)
-        end
       end
     end
   end

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

@@ -6,36 +6,46 @@ module RuboCop
       # This cop checks the indentation of the right hand side operand in
       # binary operations that span more than one line.
       #
+      # The `aligned` style checks that operators are aligned if they are part
+      # of an `if` or `while` condition, a `return` statement, etc. In other
+      # contexts, the second operand should be indented regardless of enforced
+      # style.
+      #
       # @example EnforcedStyle: aligned (default)
       #   # bad
       #   if a +
       #       b
-      #     something
+      #     something &&
+      #       something_else
       #   end
       #
       #   # good
       #   if a +
       #      b
-      #     something
+      #     something &&
+      #     something_else
       #   end
       #
       # @example EnforcedStyle: indented
       #   # bad
       #   if a +
       #      b
-      #     something
+      #     something &&
+      #     something_else
       #   end
       #
       #   # good
       #   if a +
       #       b
-      #     something
+      #     something &&
+      #       something_else
       #   end
       #
-      class MultilineOperationIndentation < Cop
+      class MultilineOperationIndentation < Base
         include ConfigurableEnforcedStyle
         include Alignment
         include MultilineExpressionIndentation
+        extend AutoCorrector
 
         def on_and(node)
           check_and_or(node)
@@ -49,17 +59,17 @@ module RuboCop
           return unless style == :aligned && cop_config['IndentationWidth']
 
           raise ValidationError, 'The `Layout/MultilineOperationIndentation`' \
-                                ' cop only accepts an `IndentationWidth` ' \
-                                'configuration parameter when ' \
-                                '`EnforcedStyle` is `indented`.'
-        end
-
-        def autocorrect(node)
-          AlignmentCorrector.correct(processed_source, node, @column_delta)
+                                 ' cop only accepts an `IndentationWidth` ' \
+                                 'configuration parameter when ' \
+                                 '`EnforcedStyle` is `indented`.'
         end
 
         private
 
+        def autocorrect(corrector, node)
+          AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
+        end
+
         def relevant_node?(node)
           return false if node.send_type? && node.unary_operation?
 
@@ -108,6 +118,10 @@ module RuboCop
               "spaces for indenting #{what} spanning multiple lines."
           end
         end
+
+        def right_hand_side(send_node)
+          send_node.first_argument.source_range
+        end
       end
     end
   end

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

@@ -68,14 +68,15 @@ module RuboCop
       #        baz)
       #     123
       #   end
-      class ParameterAlignment < Cop
+      class ParameterAlignment < Base
         include Alignment
+        extend AutoCorrector
 
         ALIGN_PARAMS_MSG = 'Align the parameters of a method definition if ' \
-          'they span more than one line.'
+                           'they span more than one line.'
 
         FIXED_INDENT_MSG = 'Use one level of indentation for parameters ' \
-          'following the first line of a multi-line method definition.'
+                           'following the first line of a multi-line method definition.'
 
         def on_def(node)
           return if node.arguments.size < 2
@@ -84,12 +85,12 @@ module RuboCop
         end
         alias on_defs on_def
 
-        def autocorrect(node)
-          AlignmentCorrector.correct(processed_source, node, column_delta)
-        end
-
         private
 
+        def autocorrect(corrector, node)
+          AlignmentCorrector.correct(corrector, processed_source, node, column_delta)
+        end
+
         def message(_node)
           fixed_indentation? ? FIXED_INDENT_MSG : ALIGN_PARAMS_MSG
         end

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

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks whether certain expressions, e.g. method calls, that could fit
+      # completely on a single line, are broken up into multiple lines unnecessarily.
+      #
+      # @example any configuration
+      #   # bad
+      #   foo(
+      #     a,
+      #     b
+      #   )
+      #
+      #   puts 'string that fits on ' \
+      #        'a single line'
+      #
+      #   things
+      #     .select { |thing| thing.cond? }
+      #     .join('-')
+      #
+      #   # good
+      #   foo(a, b)
+      #
+      #   puts 'string that fits on a single line'
+      #
+      #   things.select { |thing| thing.cond? }.join('-')
+      #
+      # @example InspectBlocks: false (default)
+      #   # good
+      #   foo(a) do |x|
+      #     puts x
+      #   end
+      #
+      # @example InspectBlocks: true
+      #   # bad
+      #   foo(a) do |x|
+      #     puts x
+      #   end
+      #
+      #   # good
+      #   foo(a) { |x| puts x }
+      #
+      class RedundantLineBreak < Base
+        include CheckAssignment
+        extend AutoCorrector
+
+        MSG = 'Redundant line break detected.'
+
+        def on_send(node)
+          # Include "the whole expression".
+          node = node.parent while convertible_block?(node) ||
+                                   node.parent.is_a?(RuboCop::AST::BinaryOperatorNode) ||
+                                   node.parent&.send_type?
+
+          return unless offense?(node) && !part_of_ignored_node?(node)
+
+          register_offense(node)
+        end
+
+        private
+
+        def check_assignment(node, _rhs)
+          return unless offense?(node)
+
+          register_offense(node)
+        end
+
+        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
+
+        def offense?(node)
+          return false if configured_to_not_be_inspected?(node)
+
+          node.multiline? && !too_long?(node) && suitable_as_single_line?(node)
+        end
+
+        def configured_to_not_be_inspected?(node)
+          return true if other_cop_takes_precedence?(node)
+
+          !cop_config['InspectBlocks'] && (node.block_type? ||
+                                           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)
+          !comment_within?(node) &&
+            node.each_descendant(:if, :case, :kwbegin, :def).none? &&
+            node.each_descendant(:dstr, :str).none?(&:heredoc?) &&
+            node.each_descendant(:begin).none? { |b| b.first_line != b.last_line }
+        end
+
+        def convertible_block?(node)
+          return false unless node.parent&.block_type?
+
+          send_node = node.parent&.send_node
+          send_node.parenthesized? || !send_node.arguments?
+        end
+
+        def comment_within?(node)
+          processed_source.comments.map(&:loc).map(&:line).any? do |comment_line_number|
+            comment_line_number >= node.first_line && comment_line_number <= node.last_line
+          end
+        end
+
+        def too_long?(node)
+          lines = processed_source.lines[(node.first_line - 1)...node.last_line]
+          to_single_line(lines.join("\n")).length > max_line_length
+        end
+
+        def to_single_line(source)
+          source
+            .gsub(/" *\\\n\s*'/, %q(" + ')) # Double quote, backslash, and then single quote
+            .gsub(/' *\\\n\s*"/, %q(' + ")) # Single quote, backslash, and then double quote
+            .gsub(/(["']) *\\\n\s*\1/, '')  # Double or single quote, backslash, then same quote
+            .gsub(/\s*\\?\n\s*/, ' ')       # Any other line break, with or without backslash
+        end
+
+        def max_line_length
+          config.for_cop('Layout/LineLength')['Max']
+        end
+      end
+    end
+  end
+end

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

@@ -21,8 +21,10 @@ module RuboCop
       #   rescue
       #     puts 'error'
       #   end
-      class RescueEnsureAlignment < Cop
+      class RescueEnsureAlignment < Base
         include RangeHelp
+        include EndKeywordAlignment
+        extend AutoCorrector
 
         MSG = '`%<kw_loc>s` at %<kw_loc_line>d, %<kw_loc_column>d is not ' \
               'aligned with `%<beginning>s` at ' \
@@ -30,8 +32,7 @@ module RuboCop
         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
+        ALTERNATIVE_ACCESS_MODIFIERS = %i[public_class_method private_class_method].freeze
 
         def on_resbody(node)
           check(node) unless modifier?(node)
@@ -41,19 +42,7 @@ module RuboCop
           check(node)
         end
 
-        def autocorrect(node)
-          whitespace = whitespace_range(node)
-          # Some inline node is sitting before current node.
-          return nil unless whitespace.source.strip.empty?
-
-          alignment_node = alignment_node(node)
-          return false if alignment_node.nil?
-
-          new_column = alignment_node.loc.column
-          ->(corrector) { corrector.replace(whitespace, ' ' * new_column) }
-        end
-
-        def investigate(processed_source)
+        def on_new_investigation
           @modifier_locations =
             processed_source.tokens.each_with_object([]) do |token, locations|
               next unless token.rescue_modifier?
@@ -70,18 +59,26 @@ module RuboCop
           alignment_node = alignment_node(node)
           return if alignment_node.nil?
 
-          alignment_loc = alignment_node.loc.expression
+          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 || alignment_loc.line == kw_loc.line
 
           add_offense(
-            node,
-            location: kw_loc,
-            message: format_message(alignment_node, alignment_loc, kw_loc)
-          )
+            kw_loc, message: format_message(alignment_node, alignment_loc, kw_loc)
+          ) do |corrector|
+            autocorrect(corrector, node, alignment_loc)
+          end
+        end
+
+        def autocorrect(corrector, node, alignment_location)
+          whitespace = whitespace_range(node)
+          # Some inline node is sitting before current node.
+          return nil unless whitespace.source.strip.empty?
+
+          new_column = alignment_location.column
+
+          corrector.replace(whitespace, ' ' * new_column)
         end
 
         def format_message(alignment_node, alignment_loc, kw_loc)
@@ -96,7 +93,6 @@ module RuboCop
           )
         end
 
-        # rubocop:disable Metrics/AbcSize
         def alignment_source(node, starting_loc)
           ending_loc =
             case node.type
@@ -115,15 +111,13 @@ module RuboCop
 
           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?
 
           assignment_node = assignment_node(ancestor_node)
           return assignment_node if same_line?(ancestor_node, assignment_node)
@@ -177,14 +171,27 @@ 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)
 
           false
         end
+
+        def alignment_location(alignment_node)
+          if begin_end_alignment_style == 'start_of_line'
+            start_line_range(alignment_node)
+          else
+            alignment_node.loc.expression
+          end
+        end
+
+        def begin_end_alignment_style
+          begin_end_alignment_conf = config.for_cop('Layout/BeginEndAlignment')
+
+          begin_end_alignment_conf['Enabled'] && begin_end_alignment_conf['EnforcedStyleAlignWith']
+        end
       end
     end
   end

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