rubocop 0.78.0 → 1.13.0

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

@@ -17,6 +17,11 @@ module RuboCop
       # If it's set to `start_of_line`, the `end` shall be aligned with the
       # start of the line where the matching keyword appears.
       #
+      # This `Layout/EndAlignment` cop aligns with keywords (e.g. `if`, `while`, `case`)
+      # by default. On the other hand, `Layout/BeginEndAlignment` cop aligns with
+      # `EnforcedStyleAlignWith: start_of_line` by default due to `||= begin` tends
+      # to align with the start of the line. These style can be configured by each cop.
+      #
       # @example EnforcedStyleAlignWith: keyword (default)
       #   # bad
       #
@@ -67,10 +72,11 @@ module RuboCop
       #   variable =
       #     if true
       #     end
-      class EndAlignment < Cop
+      class EndAlignment < Base
         include CheckAssignment
         include EndKeywordAlignment
         include RangeHelp
+        extend AutoCorrector
 
         def on_class(node)
           check_other_alignment(node)
@@ -100,14 +106,12 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          AlignmentCorrector.align_end(processed_source,
-                                       node,
-                                       alignment_node(node))
-        end
-
         private
 
+        def autocorrect(corrector, node)
+          AlignmentCorrector.align_end(corrector, processed_source, node, alignment_node(node))
+        end
+
         def check_assignment(node, rhs)
           # If there are method calls chained to the right hand side of the
           # assignment, we let rhs be the receiver of those method calls before
@@ -133,10 +137,10 @@ module RuboCop
         def asgn_variable_align_with(outer_node, inner_node)
           expr = outer_node.source_range
 
-          if !line_break_before_keyword?(expr, inner_node)
-            range_between(expr.begin_pos, inner_node.loc.keyword.end_pos)
-          else
+          if line_break_before_keyword?(expr, inner_node)
             inner_node.loc.keyword
+          else
+            range_between(expr.begin_pos, inner_node.loc.keyword.end_pos)
           end
         end
 
@@ -150,9 +154,10 @@ module RuboCop
         end
 
         def alignment_node(node)
-          if style == :keyword
+          case style
+          when :keyword
             node
-          elsif style == :variable
+          when :variable
             alignment_node_for_variable_style(node)
           else
             start_line_range(node)
@@ -163,8 +168,7 @@ module RuboCop
           return node.parent if node.case_type? && node.argument?
 
           assignment = node.ancestors.find(&:assignment_or_similar?)
-          if assignment && !line_break_before_keyword?(assignment.source_range,
-                                                       node)
+          if assignment && !line_break_before_keyword?(assignment.source_range, node)
             assignment
           else
             # Fall back to 'keyword' style if this node is not on the RHS of an
@@ -173,16 +177,6 @@ module RuboCop
             node
           end
         end
-
-        def start_line_range(node)
-          expr   = node.source_range
-          buffer = expr.source_buffer
-          source = buffer.source_line(expr.line)
-          range  = buffer.line_range(expr.line)
-
-          range_between(range.begin_pos + (source =~ /\S/),
-                        range.begin_pos + (source =~ /\s*\z/))
-        end
       end
     end
   end

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

@@ -37,14 +37,14 @@ module RuboCop
       #   # good
       #   puts 'Hello' # Return character is CR+LF on all platfoms.
       #
-      class EndOfLine < Cop
+      class EndOfLine < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
 
         MSG_DETECTED = 'Carriage return character detected.'
         MSG_MISSING = 'Carriage return character missing.'
 
-        def investigate(processed_source)
+        def on_new_investigation
           last_line = last_line(processed_source)
 
           processed_source.raw_source.each_line.with_index do |line, index|
@@ -54,9 +54,9 @@ module RuboCop
             next unless msg
             next if unimportant_missing_cr?(index, last_line, line)
 
-            range =
-              source_range(processed_source.buffer, index + 1, 0, line.length)
-            add_offense(nil, location: range, message: msg)
+            range = source_range(processed_source.buffer, index + 1, 0, line.length)
+
+            add_offense(range, message: msg)
             # Usually there will be carriage return characters on all or none
             # of the lines in a file, so we report only one offense.
             break
@@ -65,7 +65,7 @@ module RuboCop
 
         # If there is no LF on the last line, we don't care if there's no CR.
         def unimportant_missing_cr?(index, last_line, line)
-          style == :crlf && index == last_line - 1 && line !~ /\n$/
+          style == :crlf && index == last_line - 1 && !line.end_with?("\n")
         end
 
         def offense_message(line)
@@ -75,8 +75,8 @@ module RuboCop
                               style
                             end
           case effective_style
-          when :lf then MSG_DETECTED if line =~ /\r$/
-          else MSG_MISSING if line !~ /\r$/
+          when :lf then MSG_DETECTED if line.end_with?("\r", "\r\n")
+          else MSG_MISSING unless line.end_with?("\r\n")
           end
         end
 

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'set'
-
 module RuboCop
   module Cop
     module Layout
@@ -13,12 +11,12 @@ module RuboCop
       #   name      = "RuboCop"
       #   # Some comment and an empty line
       #
-      #   website  += "/rubocop-hq/rubocop" unless cond
+      #   website  += "/rubocop/rubocop" unless cond
       #   puts        "rubocop"          if     debug
       #
       #   # bad for any configuration
       #   set_app("RuboCop")
-      #   website  = "https://github.com/rubocop-hq/rubocop"
+      #   website  = "https://github.com/rubocop/rubocop"
       #
       #   # good only if AllowBeforeTrailingComments is true
       #   object.method(arg)  # this is a comment
@@ -30,17 +28,18 @@ module RuboCop
       #   object.method(arg)         # this is a comment
       #   another_object.method(arg) # this is another comment
       #   some_object.method(arg)    # this is some comment
-      class ExtraSpacing < Cop
+      class ExtraSpacing < Base
+        extend AutoCorrector
         include PrecedingFollowingAlignment
         include RangeHelp
 
         MSG_UNNECESSARY = 'Unnecessary spacing detected.'
-        MSG_UNALIGNED_ASGN = '`=` is not aligned with the %<location>s ' \
-                             'assignment.'
+        MSG_UNALIGNED_ASGN = '`=` is not aligned with the %<location>s assignment.'
 
-        def investigate(processed_source)
+        def on_new_investigation
           return if processed_source.blank?
 
+          @aligned_comments = aligned_locations(processed_source.comments.map(&:loc))
           @corrected = Set.new if force_equal_sign_alignment?
 
           processed_source.tokens.each_cons(2) do |token1, token2|
@@ -48,18 +47,19 @@ module RuboCop
           end
         end
 
-        def autocorrect(range)
-          lambda do |corrector|
-            if range.source.end_with?('=')
-              align_equal_signs(range, corrector)
-            else
-              corrector.remove(range)
-            end
+        private
+
+        def aligned_locations(locs)
+          return [] if locs.empty?
+
+          aligned = Set[locs.first.line, locs.last.line]
+          locs.each_cons(3) do |before, loc, after|
+            col = loc.column
+            aligned << loc.line if col == before.column || col == after.column
           end
+          aligned
         end
 
-        private
-
         def check_tokens(ast, token1, token2)
           return if token2.type == :tNL
 
@@ -74,17 +74,18 @@ module RuboCop
           return unless aligned_with_preceding_assignment(token) == :no
 
           message = format(MSG_UNALIGNED_ASGN, location: 'preceding')
-          add_offense(token.pos, location: token.pos, message: message)
+          add_offense(token.pos, message: message) do |corrector|
+            align_equal_signs(token.pos, corrector)
+          end
         end
 
         def check_other(token1, token2, ast)
-          return false if allow_for_trailing_comments? &&
-                          token2.text.start_with?('#')
+          return false if allow_for_trailing_comments? && token2.text.start_with?('#')
 
           extra_space_range(token1, token2) do |range|
             next if ignored_range?(ast, range.begin_pos)
 
-            add_offense(range, location: range, message: MSG_UNNECESSARY)
+            add_offense(range, message: MSG_UNNECESSARY) { |corrector| corrector.remove(range) }
           end
         end
 
@@ -102,7 +103,7 @@ module RuboCop
 
         def aligned_tok?(token)
           if token.comment?
-            aligned_comments?(token)
+            @aligned_comments.include?(token.line)
           else
             aligned_with_something?(token.pos)
           end
@@ -126,26 +127,6 @@ module RuboCop
           end.compact
         end
 
-        def aligned_comments?(comment_token)
-          ix = processed_source.comments.index do |comment|
-            comment.loc.expression.begin_pos == comment_token.begin_pos
-          end
-          aligned_with_previous_comment?(ix) || aligned_with_next_comment?(ix)
-        end
-
-        def aligned_with_previous_comment?(index)
-          index.positive? && comment_column(index - 1) == comment_column(index)
-        end
-
-        def aligned_with_next_comment?(index)
-          index < processed_source.comments.length - 1 &&
-            comment_column(index + 1) == comment_column(index)
-        end
-
-        def comment_column(index)
-          processed_source.comments[index].loc.column
-        end
-
         def force_equal_sign_alignment?
           cop_config['ForceEqualSignAlignment']
         end

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

@@ -2,14 +2,16 @@
 
 module RuboCop
   module Cop
-    # rubocop:disable Layout/LineLength
     module Layout
       # This cop checks the indentation of the first argument in a method call.
-      # Arguments after the first one are checked by Layout/ArgumentAlignment,
+      # Arguments after the first one are checked by `Layout/ArgumentAlignment`,
       # not by this cop.
       #
-      # For indenting the first parameter of method *definitions*, check out
-      # Layout/FirstParameterIndentation.
+      # For indenting the first parameter of method _definitions_, check out
+      # `Layout/FirstParameterIndentation`.
+      #
+      # This cop will respect `Layout/ArgumentAlignment` and will not work when
+      # `EnforcedStyle: with_fixed_indentation` is specified for `Layout/ArgumentAlignment`.
       #
       # @example
       #
@@ -142,16 +144,17 @@ module RuboCop
       #     nested_first_param),
       #   second_param
       #
-      class FirstArgumentIndentation < Cop
-        # rubocop:enable Layout/LineLength
+      class FirstArgumentIndentation < Base
         include Alignment
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Indent the first argument one step more than %<base>s.'
 
         def on_send(node)
-          return if !node.arguments? || node.operator_method?
+          return if style != :consistent && enforce_first_argument_with_fixed_indentation?
+          return if !node.arguments? || bare_operator?(node)
 
           indent = base_indentation(node) + configured_indentation_width
 
@@ -159,18 +162,22 @@ module RuboCop
         end
         alias on_csend on_send
 
-        def autocorrect(node)
-          AlignmentCorrector.correct(processed_source, node, column_delta)
+        private
+
+        def autocorrect(corrector, node)
+          AlignmentCorrector.correct(corrector, processed_source, node, column_delta)
         end
 
-        private
+        def bare_operator?(node)
+          node.operator_method? && !node.dot?
+        end
 
         def message(arg_node)
           return 'Bad indentation of the first argument.' unless arg_node
 
           send_node = arg_node.parent
           text = base_range(send_node, arg_node).source.strip
-          base = if text !~ /\n/ && special_inner_call_indentation?(send_node)
+          base = if !/\n/.match?(text) && special_inner_call_indentation?(send_node)
                    "`#{text}`"
                  elsif comment_line?(text.lines.reverse_each.first)
                    'the start of the previous line (not counting the comment)'
@@ -204,13 +211,19 @@ module RuboCop
           node.source_range.begin_pos > parent.source_range.begin_pos
         end
 
+        # @!method eligible_method_call?(node)
         def_node_matcher :eligible_method_call?, <<~PATTERN
           (send _ !:[]= ...)
         PATTERN
 
         def base_range(send_node, arg_node)
-          range_between(send_node.source_range.begin_pos,
-                        arg_node.source_range.begin_pos)
+          parent = send_node.parent
+          start_node = if parent && (parent.splat_type? || parent.kwsplat_type?)
+                         send_node.parent
+                       else
+                         send_node
+                       end
+          range_between(start_node.source_range.begin_pos, arg_node.source_range.begin_pos)
         end
 
         # Returns the column of the given range. For single line ranges, this
@@ -243,6 +256,20 @@ module RuboCop
             .select { |c| begins_its_line?(c.loc.expression) }
             .map { |c| c.loc.line }
         end
+
+        def on_new_investigation
+          @comment_lines = nil
+        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_array_element_indentation.rb

@@ -79,10 +79,11 @@ module RuboCop
       #   and_now_for_something = [
       #                             :completely_different
       #                           ]
-      class FirstArrayElementIndentation < Cop
+      class FirstArrayElementIndentation < Base
         include Alignment
         include ConfigurableEnforcedStyle
         include MultilineElementIndentation
+        extend AutoCorrector
 
         MSG = 'Use %<configured_indentation_width>d spaces for indentation ' \
               'in an array, relative to %<base_description>s.'
@@ -98,12 +99,12 @@ module RuboCop
         end
         alias on_csend on_send
 
-        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 brace_alignment_style
           :align_brackets
         end
@@ -119,28 +120,21 @@ module RuboCop
             check_first(first_elem, left_bracket, left_parenthesis, 0)
           end
 
-          check_right_bracket(array_node.loc.end, left_bracket,
-                              left_parenthesis)
+          check_right_bracket(array_node.loc.end, left_bracket, left_parenthesis)
         end
 
         def check_right_bracket(right_bracket, left_bracket, left_parenthesis)
           # if the right bracket is on the same line as the last value, accept
-          return if right_bracket.source_line[0...right_bracket.column] =~ /\S/
+          return if /\S/.match?(right_bracket.source_line[0...right_bracket.column])
 
           expected_column = base_column(left_bracket, left_parenthesis)
           @column_delta = expected_column - right_bracket.column
           return if @column_delta.zero?
 
-          msg = if style == :align_brackets
-                  '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.'
-                else
-                  'Indent the right bracket the same as the start of the line' \
-                  ' where the left bracket is.'
-                end
-          add_offense(right_bracket, location: right_bracket, message: msg)
+          msg = msg(left_parenthesis)
+          add_offense(right_bracket, message: msg) do |corrector|
+            autocorrect(corrector, right_bracket)
+          end
         end
 
         # Returns the description of what the correct indentation is based on.
@@ -161,6 +155,18 @@ module RuboCop
             base_description: base_description
           )
         end
+
+        def msg(left_parenthesis)
+          if style == :align_brackets
+            '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.'
+          else
+            'Indent the right bracket the same as the start of the line' \
+            ' where the left bracket is.'
+          end
+        end
       end
     end
   end