rubocop 0.78.0 → 1.13.0

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

@@ -68,8 +68,9 @@ 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.'
@@ -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,125 @@
+# 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 < Cop
+        include CheckAssignment
+
+        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)
+
+          add_offense(node)
+          ignore_node(node)
+        end
+
+        def check_assignment(node, _rhs)
+          return unless offense?(node)
+
+          add_offense(node)
+          ignore_node(node)
+        end
+
+        def autocorrect(node)
+          ->(corrector) { corrector.replace(node.source_range, to_single_line(node.source).strip) }
+        end
+
+        private
+
+        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)
+          !cop_config['InspectBlocks'] && (node.block_type? ||
+                                           node.each_child_node(:block).any?(&:multiline?))
+        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/space_after_colon.rb

@@ -13,7 +13,9 @@ module RuboCop
       #
       #   # good
       #   def f(a:, b: 2); {a: 3}; end
-      class SpaceAfterColon < Cop
+      class SpaceAfterColon < Base
+        extend AutoCorrector
+
         MSG = 'Space missing after colon.'
 
         def on_pair(node)
@@ -21,7 +23,7 @@ module RuboCop
 
           colon = node.loc.operator
 
-          add_offense(colon, location: colon) unless followed_by_space?(colon)
+          register_offense(colon) unless followed_by_space?(colon)
         end
 
         def on_kwoptarg(node)
@@ -29,17 +31,17 @@ module RuboCop
           # optional keyword argument's name, so must construct one.
           colon = node.loc.name.end.resize(1)
 
-          add_offense(colon, location: colon) unless followed_by_space?(colon)
-        end
-
-        def autocorrect(range)
-          ->(corrector) { corrector.insert_after(range, ' ') }
+          register_offense(colon) unless followed_by_space?(colon)
         end
 
         private
 
+        def register_offense(colon)
+          add_offense(colon) { |corrector| corrector.insert_after(colon, ' ') }
+        end
+
         def followed_by_space?(colon)
-          colon.source_buffer.source[colon.end_pos] =~ /\s/
+          /\s/.match?(colon.source_buffer.source[colon.end_pos])
         end
       end
     end

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

@@ -14,12 +14,9 @@ module RuboCop
       #   # good
       #   [1, 2]
       #   { foo:bar, }
-      class SpaceAfterComma < Cop
+      class SpaceAfterComma < Base
         include SpaceAfterPunctuation
-
-        def autocorrect(comma)
-          PunctuationCorrector.add_space(comma)
-        end
+        extend AutoCorrector
 
         def space_style_before_rcurly
           cfg = config.for_cop('Layout/SpaceInsideHashLiteralBraces')

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

@@ -14,28 +14,25 @@ module RuboCop
       #   # good
       #   def func(x) end
       #   def method=(y) end
-      class SpaceAfterMethodName < Cop
+      class SpaceAfterMethodName < Base
         include RangeHelp
+        extend AutoCorrector
 
-        MSG = 'Do not put a space between a method name and the opening ' \
-              'parenthesis.'
+        MSG = 'Do not put a space between a method name and the opening parenthesis.'
 
         def on_def(node)
           args = node.arguments
           return unless args.loc.begin&.is?('(')
 
           expr = args.source_range
-          pos_before_left_paren = range_between(expr.begin_pos - 1,
-                                                expr.begin_pos)
+          pos_before_left_paren = range_between(expr.begin_pos - 1, expr.begin_pos)
           return unless pos_before_left_paren.source.start_with?(' ')
 
-          add_offense(pos_before_left_paren, location: pos_before_left_paren)
+          add_offense(pos_before_left_paren) do |corrector|
+            corrector.remove(pos_before_left_paren)
+          end
         end
         alias on_defs on_def
-
-        def autocorrect(pos_before_left_paren)
-          ->(corrector) { corrector.remove(pos_before_left_paren) }
-        end
       end
     end
   end

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

@@ -11,29 +11,27 @@ module RuboCop
       #
       #   # good
       #   !something
-      class SpaceAfterNot < Cop
+      class SpaceAfterNot < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Do not leave space between `!` and its argument.'
 
         def on_send(node)
           return unless node.prefix_bang? && whitespace_after_operator?(node)
 
-          add_offense(node)
+          add_offense(node) do |corrector|
+            corrector.remove(
+              range_between(node.loc.selector.end_pos, node.receiver.source_range.begin_pos)
+            )
+          end
         end
 
+        private
+
         def whitespace_after_operator?(node)
           node.receiver.loc.column - node.loc.column > 1
         end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.remove(
-              range_between(node.loc.selector.end_pos,
-                            node.receiver.source_range.begin_pos)
-            )
-          end
-        end
       end
     end
   end

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

@@ -11,12 +11,9 @@ module RuboCop
       #
       #   # good
       #   x = 1; y = 2
-      class SpaceAfterSemicolon < Cop
+      class SpaceAfterSemicolon < Base
         include SpaceAfterPunctuation
-
-        def autocorrect(semicolon)
-          PunctuationCorrector.add_space(semicolon)
-        end
+        extend AutoCorrector
 
         def space_style_before_rcurly
           cfg = config.for_cop('Layout/SpaceInsideBlockBraces')

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

@@ -24,9 +24,10 @@ module RuboCop
       #   # good
       #   {}.each { | x, y | puts x }
       #   ->( x, y ) { puts x }
-      class SpaceAroundBlockParameters < Cop
+      class SpaceAroundBlockParameters < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         def on_block(node)
           arguments = node.arguments
@@ -38,23 +39,6 @@ module RuboCop
           check_each_arg(arguments)
         end
 
-        # @param target [RuboCop::AST::Node,Parser::Source::Range]
-        def autocorrect(target)
-          lambda do |corrector|
-            if target.is_a?(RuboCop::AST::Node)
-              if target.parent.children.first == target
-                corrector.insert_before(target.source_range, ' ')
-              else
-                corrector.insert_after(target.source_range, ' ')
-              end
-            elsif target.source =~ /^\s+$/
-              corrector.remove(target)
-            else
-              corrector.insert_after(target, ' ')
-            end
-          end
-        end
-
         private
 
         def pipes(arguments)
@@ -70,16 +54,11 @@ module RuboCop
         end
 
         def check_inside_pipes(arguments)
-          opening_pipe, closing_pipe = pipes(arguments)
-
-          if style == :no_space
-            check_no_space_style_inside_pipes(arguments.children,
-                                              opening_pipe,
-                                              closing_pipe)
-          elsif style == :space
-            check_space_style_inside_pipes(arguments.children,
-                                           opening_pipe,
-                                           closing_pipe)
+          case style
+          when :no_space
+            check_no_space_style_inside_pipes(arguments)
+          when :space
+            check_space_style_inside_pipes(arguments)
           end
         end
 
@@ -91,49 +70,56 @@ module RuboCop
                       closing_pipe, 'after closing `|`')
         end
 
-        def check_no_space_style_inside_pipes(args, opening_pipe, closing_pipe)
+        def check_no_space_style_inside_pipes(arguments)
+          args = arguments.children
+          opening_pipe, closing_pipe = pipes(arguments)
+
           first = args.first.source_range
           last = args.last.source_range
 
-          check_no_space(opening_pipe.end_pos, first.begin_pos,
-                         'Space before first')
-          check_no_space(last_end_pos_inside_pipes(last.end_pos),
+          check_no_space(opening_pipe.end_pos, first.begin_pos, 'Space before first')
+          check_no_space(last_end_pos_inside_pipes(arguments, last),
                          closing_pipe.begin_pos, 'Space after last')
         end
 
-        def check_space_style_inside_pipes(args, opening_pipe, closing_pipe)
-          check_opening_pipe_space(args, opening_pipe)
-          check_closing_pipe_space(args, closing_pipe)
+        def check_space_style_inside_pipes(arguments)
+          opening_pipe, closing_pipe = pipes(arguments)
+
+          check_opening_pipe_space(arguments, opening_pipe)
+          check_closing_pipe_space(arguments, closing_pipe)
         end
 
-        def check_opening_pipe_space(args, opening_pipe)
+        def check_opening_pipe_space(arguments, opening_pipe)
+          args = arguments.children
+
           first_arg = args.first
           range = first_arg.source_range
 
           check_space(opening_pipe.end_pos, range.begin_pos, range,
                       'before first block parameter', first_arg)
-          check_no_space(opening_pipe.end_pos, range.begin_pos - 1,
-                         'Extra space before first')
+          check_no_space(opening_pipe.end_pos, range.begin_pos - 1, 'Extra space before first')
         end
 
-        def check_closing_pipe_space(args, closing_pipe)
+        def check_closing_pipe_space(arguments, closing_pipe)
+          args = arguments.children
+
           last         = args.last.source_range
-          last_end_pos = last_end_pos_inside_pipes(last.end_pos)
+          last_end_pos = last_end_pos_inside_pipes(arguments, last)
 
-          check_space(last_end_pos, closing_pipe.begin_pos, last,
-                      'after last block parameter')
-          check_no_space(last_end_pos + 1, closing_pipe.begin_pos,
-                         'Extra space after last')
+          check_space(last_end_pos, closing_pipe.begin_pos, last, 'after last block parameter')
+          check_no_space(last_end_pos + 1, closing_pipe.begin_pos, 'Extra space after last')
         end
 
-        def last_end_pos_inside_pipes(pos)
-          processed_source.buffer.source[pos] == ',' ? pos + 1 : pos
+        def last_end_pos_inside_pipes(arguments, range)
+          pos = range.end_pos
+          num = pos - arguments.source_range.begin_pos
+          trailing_comma_index = arguments.source[num..-1].index(',')
+
+          trailing_comma_index ? pos + trailing_comma_index + 1 : pos
         end
 
         def check_each_arg(args)
-          args.children.each do |arg|
-            check_arg(arg)
-          end
+          args.children.each { |arg| check_arg(arg) }
         end
 
         def check_arg(arg)
@@ -151,7 +137,14 @@ module RuboCop
           return if space_begin_pos != space_end_pos
 
           target = node || range
-          add_offense(target, location: range, message: "Space #{msg} missing.")
+          message = "Space #{msg} missing."
+          add_offense(target, message: message) do |corrector|
+            if node
+              corrector.insert_before(node, ' ')
+            else
+              corrector.insert_after(target, ' ')
+            end
+          end
         end
 
         def check_no_space(space_begin_pos, space_end_pos, msg)
@@ -160,8 +153,8 @@ module RuboCop
           range = range_between(space_begin_pos, space_end_pos)
           return if range.source.include?("\n")
 
-          add_offense(range, location: range,
-                             message: "#{msg} block parameter detected.")
+          message = "#{msg} block parameter detected."
+          add_offense(range, message: message) { |corrector| corrector.remove(range) }
         end
       end
     end