rubocop 0.75.1 → 0.76.0

data/lib/rubocop/cop/commissioner.rb

@@ -64,17 +64,25 @@ module RuboCop
       end
 
       def remove_irrelevant_cops(filename)
-        @cops.reject! { |cop| cop.excluded_file?(filename) }
         @cops.reject! do |cop|
-          cop.class.respond_to?(:support_target_ruby_version?) &&
-            !cop.class.support_target_ruby_version?(cop.target_ruby_version)
-        end
-        @cops.reject! do |cop|
-          cop.class.respond_to?(:support_target_rails_version?) &&
-            !cop.class.support_target_rails_version?(cop.target_rails_version)
+          cop.excluded_file?(filename) ||
+            !support_target_ruby_version?(cop) ||
+            !support_target_rails_version?(cop)
         end
       end
 
+      def support_target_ruby_version?(cop)
+        return true unless cop.class.respond_to?(:support_target_ruby_version?)
+
+        cop.class.support_target_ruby_version?(cop.target_ruby_version)
+      end
+
+      def support_target_rails_version?(cop)
+        return true unless cop.class.respond_to?(:support_target_rails_version?)
+
+        cop.class.support_target_rails_version?(cop.target_rails_version)
+      end
+
       def reset_callbacks
         @callbacks.clear
       end

data/lib/rubocop/cop/cop.rb

@@ -123,23 +123,19 @@ module RuboCop
         self.class::MSG
       end
 
-      # rubocop:disable Metrics/CyclomaticComplexity
       def add_offense(node, location: :expression, message: nil, severity: nil)
         loc = find_location(node, location)
 
         return if duplicate_location?(loc)
 
-        severity = custom_severity || severity || default_severity
-
-        message ||= message(node)
-        message = annotate(message)
+        severity = find_severity(node, severity)
+        message = find_message(node, message)
 
         status = enabled_line?(loc.line) ? correct(node) : :disabled
 
         @offenses << Offense.new(severity, loc, message, name, status)
         yield if block_given? && status != :disabled
       end
-      # rubocop:enable Metrics/CyclomaticComplexity
 
       def find_location(node, loc)
         # Location can be provided as a symbol, e.g.: `:keyword`
@@ -223,6 +219,10 @@ module RuboCop
 
       private
 
+      def find_message(node, message)
+        annotate(message || message(node))
+      end
+
       def annotate(message)
         RuboCop::Cop::MessageAnnotator.new(
           config, cop_name, cop_config, @options
@@ -250,6 +250,10 @@ module RuboCop
         @processed_source.comment_config.cop_enabled_at_line?(self, line_number)
       end
 
+      def find_severity(_node, severity)
+        custom_severity || severity || default_severity
+      end
+
       def default_severity
         self.class.lint? ? :warning : :convention
       end

data/lib/rubocop/cop/corrector.rb

@@ -154,16 +154,17 @@ module RuboCop
 
       # :nodoc:
       def validate_range(range)
-        return if range.source_buffer == @source_buffer
+        buffer = range.source_buffer
+        return if buffer == @source_buffer
 
-        unless range.source_buffer.is_a?(Parser::Source::Buffer)
+        unless buffer.is_a?(Parser::Source::Buffer)
           # actually this should be enforced by parser gem
-          raise 'Corrector expected range source buffer to be a '\
-                "Parser::Source::Buffer, but got #{range.source_buffer.class}"
+          raise 'Corrector expected range source buffer to be a ' \
+                "Parser::Source::Buffer, but got #{buffer.class}"
         end
-        raise "Correction target buffer #{range.source_buffer.object_id} "\
-              "name:#{range.source_buffer.name.inspect}"\
-              " is not current #{@source_buffer.object_id} "\
+        raise "Correction target buffer #{buffer.object_id} " \
+              "name:#{buffer.name.inspect}" \
+              " is not current #{@source_buffer.object_id} " \
               "name:#{@source_buffer.name.inspect} under investigation"
       end
     end

data/lib/rubocop/cop/generator/configuration_injector.rb

@@ -24,7 +24,7 @@ module RuboCop
         def inject
           target_line = find_target_line
           if target_line
-            configuration_entries.insert(find_target_line,
+            configuration_entries.insert(target_line,
                                          new_configuration_entry + "\n")
           else
             configuration_entries.push("\n" + new_configuration_entry)

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

@@ -220,14 +220,18 @@ module RuboCop
 
         private
 
+        def reset!
+          self.offences_by = {}
+          self.column_deltas = Hash.new { |hash, key| hash[key] = {} }
+        end
+
         def double_splat?(node)
           node.children.last.is_a?(Symbol)
         end
 
         def check_pairs(node)
           first_pair = node.pairs.first
-          self.offences_by = {}
-          self.column_deltas = Hash.new { |hash, key| hash[key] = {} }
+          reset!
 
           alignment_for(first_pair).each do |alignment|
             delta = alignment.deltas_for_first_pair(first_pair, node)

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

@@ -55,23 +55,20 @@ module RuboCop
         # of correcting, saving the file, parsing and inspecting again, and
         # then correcting one more line, and so on.
         def autocorrect_preceding_comments(comment)
-          corrections = []
-          line_no = comment.loc.line
-          column = comment.loc.column
           comments = processed_source.comments
-          (comments.index(comment) - 1).downto(0) do |ix|
-            previous_comment = comments[ix]
-            break unless should_correct?(previous_comment, column, line_no - 1)
+          index = comments.index(comment)
 
-            corrections << autocorrect_one(previous_comment)
-            line_no -= 1
-          end
-          corrections
+          comments[0..index]
+            .reverse_each
+            .each_cons(2)
+            .take_while { |below, above| should_correct?(above, below) }
+            .map { |_, above| autocorrect_one(above) }
         end
 
-        def should_correct?(comment, column, line_no)
-          loc = comment.loc
-          loc.line == line_no && loc.column == column
+        def should_correct?(preceding_comment, reference_comment)
+          loc = preceding_comment.loc
+          ref_loc = reference_comment.loc
+          loc.line == ref_loc.line - 1 && loc.column == ref_loc.column
         end
 
         def autocorrect_one(comment)

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

@@ -103,19 +103,12 @@ module RuboCop
         private
 
         def concat_consecutive_comments(comments)
-          prev_line = nil
+          consecutive_comments =
+            comments.chunk_while { |i, j| i.loc.line.succ == j.loc.line }
 
-          comments.each_with_object([]) do |comment, concatenated_comments|
-            if prev_line && comment.loc.line == prev_line.next
-              last_concatenated_comment = concatenated_comments.last
-
-              last_concatenated_comment[0] << comment_text(comment)
-              last_concatenated_comment[1] << comment
-            else
-              concatenated_comments << [comment_text(comment).dup, [comment]]
-            end
-
-            prev_line = comment.loc.line
+          consecutive_comments.map do |chunk|
+            joined_text = chunk.map { |c| comment_text(c) }.join
+            [joined_text, chunk]
           end
         end
 
@@ -141,11 +134,9 @@ module RuboCop
           cop_config['AllowMarginComment']
         end
 
-        def current_token(node)
+        def current_token(comment)
           processed_source.find_token do |token|
-            token.pos.column == node.loc.column &&
-              token.pos.last_column == node.loc.last_column &&
-              token.line == node.loc.line
+            token.pos == comment.loc.expression
           end
         end
 

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

@@ -45,9 +45,7 @@ module RuboCop
         MSG_MISSING = 'Carriage return character missing.'
 
         def investigate(processed_source)
-          last_token = processed_source.tokens.last
-          last_line =
-            last_token ? last_token.line : processed_source.lines.length
+          last_line = last_line(processed_source)
 
           processed_source.raw_source.each_line.with_index do |line, index|
             break if index >= last_line
@@ -81,6 +79,13 @@ module RuboCop
           else MSG_MISSING if line !~ /\r$/
           end
         end
+
+        private
+
+        def last_line(processed_source)
+          last_token = processed_source.tokens.last
+          last_token ? last_token.line : processed_source.lines.length
+        end
       end
     end
   end

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

@@ -228,19 +228,21 @@ module RuboCop
         # containing the previous line that's not a comment line or a blank
         # line.
         def previous_code_line(line_number)
-          @comment_lines ||=
-            processed_source
-            .comments
-            .select { |c| begins_its_line?(c.loc.expression) }
-            .map { |c| c.loc.line }
-
           line = ''
-          while line.blank? || @comment_lines.include?(line_number)
+          while line.blank? || comment_lines.include?(line_number)
             line_number -= 1
             line = processed_source.lines[line_number - 1]
           end
           line
         end
+
+        def comment_lines
+          @comment_lines ||=
+            processed_source
+            .comments
+            .select { |c| begins_its_line?(c.loc.expression) }
+            .map { |c| c.loc.line }
+        end
       end
     end
   end

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

@@ -113,7 +113,7 @@ module RuboCop
           first_pair = hash_node.pairs.first
 
           if first_pair
-            return if first_pair.source_range.line == left_brace.line
+            return if first_pair.first_line == left_brace.line
 
             if separator_style?(first_pair)
               check_based_on_longest_key(hash_node, left_brace,

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

@@ -43,7 +43,7 @@ module RuboCop
           'on the same line as the assignment operator `=`.'
 
         def check_assignment(node, rhs)
-          return if node.send_type?
+          return if node.send_type? && node.loc.operator&.source != '='
           return unless rhs
           return unless supported_types.include?(rhs.type)
           return if rhs.first_line == rhs.last_line

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

@@ -96,6 +96,7 @@ module RuboCop
           )
         end
 
+        # rubocop:disable Metrics/AbcSize
         def alignment_source(node, starting_loc)
           ending_loc =
             case node.type
@@ -114,6 +115,7 @@ 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.
 

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

@@ -48,9 +48,7 @@ module RuboCop
             if style == :require_space
               corrector.insert_before(children[1].source_range, ' ')
             else
-              space_range = range_between(children[0].source_range.end_pos,
-                                          children[1].source_range.begin_pos)
-              corrector.remove(space_range)
+              corrector.remove(space_after_arrow(lambda_node))
             end
           end
         end
@@ -62,10 +60,14 @@ module RuboCop
         end
 
         def space_after_arrow?(lambda_node)
-          arrow = lambda_node.parent.children[0]
-          parentheses = lambda_node.parent.children[1]
-          (parentheses.source_range.begin_pos - arrow.source_range.end_pos)
-            .positive?
+          !space_after_arrow(lambda_node).empty?
+        end
+
+        def space_after_arrow(lambda_node)
+          arrow = lambda_node.parent.children[0].source_range
+          parentheses = lambda_node.parent.children[1].source_range
+
+          arrow.end.join(parentheses.begin)
         end
 
         def range_of_offense(node)

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

@@ -210,18 +210,21 @@ module RuboCop
 
         def compact_corrections(corrector, node, left, right)
           if qualifies_for_compact?(node, left, side: :left)
-            range = side_space_range(range: left.pos, side: :right)
-            corrector.remove(range)
+            compact(corrector, left, :right)
           elsif !left.space_after?
             corrector.insert_after(left.pos, ' ')
           end
           if qualifies_for_compact?(node, right)
-            range = side_space_range(range: right.pos, side: :left)
-            corrector.remove(range)
+            compact(corrector, right, :left)
           elsif !right.space_before?
             corrector.insert_before(right.pos, ' ')
           end
         end
+
+        def compact(corrector, bracket, side)
+          range = side_space_range(range: bracket.pos, side: side)
+          corrector.remove(range)
+        end
       end
     end
   end

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

@@ -72,7 +72,7 @@ module RuboCop
             # If the second token is a comment, that means that a line break
             # follows, and that the rules for space inside don't apply.
             next if token2.comment?
-            next unless token2.line == token1.line && token1.space_after?
+            next unless same_line?(token1, token2) && token1.space_after?
 
             yield range_between(token1.end_pos, token2.begin_pos)
           end
@@ -82,17 +82,18 @@ module RuboCop
           tokens.each_cons(2) do |token1, token2|
             next if can_be_ignored?(token1, token2)
 
-            next unless token2.line == token1.line && !token1.space_after?
-
             if token1.left_parens?
               yield range_between(token2.begin_pos, token2.begin_pos + 1)
-
             elsif token2.right_parens?
               yield range_between(token2.begin_pos, token2.end_pos)
             end
           end
         end
 
+        def same_line?(token1, token2)
+          token1.line == token2.line
+        end
+
         def parens?(token1, token2)
           token1.left_parens? || token2.right_parens?
         end
@@ -104,8 +105,7 @@ module RuboCop
           # follows, and that the rules for space inside don't apply.
           return true if token2.comment?
 
-          # Ignore empty parens. # TODO: Could be configurable.
-          return true if token1.left_parens? && token2.right_parens?
+          return true unless same_line?(token1, token2) && !token1.space_after?
         end
       end
     end

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

@@ -14,6 +14,20 @@ module RuboCop
       #   # good
       #   x = 0
       #
+      # @example AllowInHeredoc: false (default)
+      #   # The line in this example contains spaces after the 0.
+      #   # bad
+      #   code = <<~RUBY
+      #     x = 0
+      #   RUBY
+      #
+      # @example AllowInHeredoc: true
+      #   # The line in this example contains spaces after the 0.
+      #   # good
+      #   code = <<~RUBY
+      #     x = 0
+      #   RUBY
+      #
       class TrailingWhitespace < Cop
         include RangeHelp
 
@@ -22,11 +36,13 @@ module RuboCop
         def investigate(processed_source)
           heredoc_ranges = extract_heredoc_ranges(processed_source.ast)
           processed_source.lines.each_with_index do |line, index|
+            lineno = index + 1
+
             next unless line.end_with?(' ', "\t")
-            next if skip_heredoc? && inside_heredoc?(heredoc_ranges, index + 1)
+            next if skip_heredoc? && inside_heredoc?(heredoc_ranges, lineno)
 
             range = source_range(processed_source.buffer,
-                                 index + 1,
+                                 lineno,
                                  (line.rstrip.length)...(line.length))
 
             add_offense(range, location: range)

data/lib/rubocop/cop/lint/erb_new_arguments.rb

@@ -86,13 +86,13 @@ module RuboCop
           erb_new_with_non_keyword_arguments(node) do |arguments|
             return if correct_arguments?(arguments)
 
-            1.upto(3) do |i|
-              next if !arguments[i] || arguments[i].hash_type?
+            arguments[1..3].each_with_index do |argument, i|
+              next if !argument || argument.hash_type?
 
-              message = format(MESSAGES[i - 1], arg_value: arguments[i].source)
+              message = format(MESSAGES[i], arg_value: argument.source)
 
               add_offense(
-                node, location: arguments[i].source_range, message: message
+                node, location: argument.source_range, message: message
               )
             end
           end
@@ -138,14 +138,15 @@ module RuboCop
         end
 
         def override_by_legacy_args(kwargs, node)
+          arguments = node.arguments
           overridden_kwargs = kwargs.dup
 
-          if node.arguments[2]
-            overridden_kwargs[0] = "trim_mode: #{node.arguments[2].source}"
+          if arguments[2]
+            overridden_kwargs[0] = "trim_mode: #{arguments[2].source}"
           end
 
-          if node.arguments[3] && !node.arguments[3].hash_type?
-            overridden_kwargs[1] = "eoutvar: #{node.arguments[3].source}"
+          if arguments[3] && !arguments[3].hash_type?
+            overridden_kwargs[1] = "eoutvar: #{arguments[3].source}"
           end
 
           overridden_kwargs