rubocop 0.74.0 → 0.78.0

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/correctors/alignment_corrector.rb

@@ -19,10 +19,12 @@ module RuboCop
           expr = node.respond_to?(:loc) ? node.loc.expression : node
           return if block_comment_within?(expr)
 
+          taboo_ranges = inside_string_ranges(node)
+
           lambda do |corrector|
             each_line(expr) do |line_begin_pos|
               autocorrect_line(corrector, line_begin_pos, expr, column_delta,
-                               heredoc_ranges(node))
+                               taboo_ranges)
             end
           end
         end
@@ -39,27 +41,48 @@ module RuboCop
         private
 
         def autocorrect_line(corrector, line_begin_pos, expr, column_delta,
-                             heredoc_ranges)
+                             taboo_ranges)
           range = calculate_range(expr, line_begin_pos, column_delta)
-          # We must not change indentation of heredoc strings.
-          return if heredoc_ranges.any? { |h| within?(range, h) }
+          # We must not change indentation of heredoc strings or inside other
+          # string literals
+          return if taboo_ranges.any? { |t| within?(range, t) }
 
           if column_delta.positive?
-            unless range.source == "\n"
-              # TODO: Fix ranges instead of using `begin`
-              corrector.insert_before(range.begin, ' ' * column_delta)
+            unless range.resize(1).source == "\n"
+              corrector.insert_before(range, ' ' * column_delta)
             end
           elsif range.source =~ /\A[ \t]+\z/
             remove(range, corrector)
           end
         end
 
-        def heredoc_ranges(node)
+        def inside_string_ranges(node)
           return [] unless node.is_a?(Parser::AST::Node)
 
-          node.each_node(:dstr)
-              .select(&:heredoc?)
-              .map { |n| n.loc.heredoc_body.join(n.loc.heredoc_end) }
+          node.each_node(:str, :dstr, :xstr).map { |n| inside_string_range(n) }
+              .compact
+        end
+
+        def inside_string_range(node)
+          loc = node.location
+
+          if node.heredoc?
+            loc.heredoc_body.join(loc.heredoc_end)
+          elsif delimited_string_literal?(node)
+            loc.begin.end.join(loc.end.begin)
+          end
+        end
+
+        # Some special kinds of string literals are not composed of literal
+        # characters between two delimiters:
+        # - The source map of `?a` responds to :begin and :end but its end is
+        #   nil.
+        # - The source map of `__FILE__` responds to neither :begin nor :end.
+        def delimited_string_literal?(node)
+          loc = node.location
+
+          loc.respond_to?(:begin) && loc.begin &&
+            loc.respond_to?(:end) && loc.end
         end
 
         def block_comment_within?(expr)
@@ -69,15 +92,18 @@ module RuboCop
         end
 
         def calculate_range(expr, line_begin_pos, column_delta)
+          if column_delta.positive?
+            return range_between(line_begin_pos, line_begin_pos)
+          end
+
           starts_with_space =
             expr.source_buffer.source[line_begin_pos].start_with?(' ')
-          pos_to_remove = if column_delta.positive? || starts_with_space
-                            line_begin_pos
-                          else
-                            line_begin_pos - column_delta.abs
-                          end
 
-          range_between(pos_to_remove, pos_to_remove + column_delta.abs)
+          if starts_with_space
+            range_between(line_begin_pos, line_begin_pos + column_delta.abs)
+          else
+            range_between(line_begin_pos - column_delta.abs, line_begin_pos)
+          end
         end
 
         def remove(range, corrector)

data/lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb

@@ -40,8 +40,8 @@ module RuboCop
           range_with_surrounding_space(range: node.loc.end, side: :left)
         )
 
-        corrector.insert_after(
-          last_element_range_with_trailing_comma(node),
+        corrector.insert_before(
+          last_element_range_with_trailing_comma(node).end,
           node.loc.end.source
         )
       end

data/lib/rubocop/cop/correctors/percent_literal_corrector.rb

@@ -98,7 +98,7 @@ module RuboCop
       end
 
       def fix_escaped_content(word_node, escape, delimiters)
-        content = word_node.children.first.to_s
+        content = +word_node.children.first.to_s
         content = escape_string(content) if escape
         substitute_escaped_delimiters(content, delimiters)
         content

data/lib/rubocop/cop/correctors/space_corrector.rb

@@ -12,12 +12,11 @@ module RuboCop
         def empty_corrections(processed_source, corrector, empty_config,
                               left_token, right_token)
           @processed_source = processed_source
+          range = range_between(left_token.end_pos, right_token.begin_pos)
           if offending_empty_space?(empty_config, left_token, right_token)
-            range = side_space_range(range: left_token.pos, side: :right)
             corrector.remove(range)
             corrector.insert_after(left_token.pos, ' ')
           elsif offending_empty_no_space?(empty_config, left_token, right_token)
-            range = side_space_range(range: left_token.pos, side: :right)
             corrector.remove(range)
           end
         end

data/lib/rubocop/cop/generator.rb

@@ -10,10 +10,10 @@ module RuboCop
       # Note: RDoc 5.1.0 or lower has the following issue.
       # https://github.com/rubocop-hq/rubocop/issues/7043
       #
-      # The following `String#strip_indent` can be replaced with
+      # The following `String#gsub` can be replaced with
       # squiggly heredoc when RuboCop supports Ruby 2.5 or higher
       # (RDoc 6.0 or higher).
-      SOURCE_TEMPLATE = <<-RUBY.strip_indent
+      SOURCE_TEMPLATE = <<-RUBY.gsub(/^ {8}/, '')
         # frozen_string_literal: true
 
         # TODO: when finished, run `rake generate_cops_documentation` to update the docs
@@ -61,7 +61,7 @@ module RuboCop
                 # See https://github.com/rubocop-hq/rubocop/blob/master/lib/rubocop/node_pattern.rb
                 #
                 # For example
-                MSG = 'Use `#good_method` instead of `#bad_method`.'.freeze
+                MSG = 'Use `#good_method` instead of `#bad_method`.'
 
                 def_node_matcher :bad_method?, <<~PATTERN
                   (send nil? :bad_method ...)

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

@@ -12,7 +12,6 @@ module RuboCop
             Description: 'TODO: Write a description of the cop.'
             Enabled: true
             VersionAdded: '%<version_added>s'
-
         YAML
 
         def initialize(configuration_file_path:, badge:, version_added:)
@@ -23,8 +22,13 @@ module RuboCop
         end
 
         def inject
-          configuration_entries.insert(find_target_line,
-                                       new_configuration_entry)
+          target_line = find_target_line
+          if target_line
+            configuration_entries.insert(target_line,
+                                         new_configuration_entry + "\n")
+          else
+            configuration_entries.push("\n" + new_configuration_entry)
+          end
 
           File.write(configuration_file_path, configuration_entries.join)
 
@@ -49,7 +53,8 @@ module RuboCop
 
             return index if badge.to_s < line
           end
-          configuration_entries.size - 1
+
+          nil
         end
 
         def cop_name_line?(yaml)

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

@@ -54,7 +54,7 @@ module RuboCop
               elsif in_the_same_department
                 break index
               end
-            end
+            end || require_entries.size
           end
         end
 

data/lib/rubocop/cop/internal_affairs.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative 'internal_affairs/method_name_equal'
 require_relative 'internal_affairs/node_destructuring'
 require_relative 'internal_affairs/node_type_predicate'
 require_relative 'internal_affairs/offense_location_keyword'

data/lib/rubocop/cop/internal_affairs/method_name_equal.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks that method names are checked using `method?` method.
+      #
+      # @example
+      #   # bad
+      #   node.method_name == :do_something
+      #
+      #   # good
+      #   node.method?(:do_something)
+      #
+      class MethodNameEqual < Cop
+        include RangeHelp
+
+        MSG = 'Use `method?(%<method_name>s)` instead of ' \
+              '`method_name == %<method_name>s`.'
+
+        def_node_matcher :method_name?, <<~PATTERN
+          (send
+            $(send
+              (...) :method_name) :==
+            $...)
+        PATTERN
+
+        def on_send(node)
+          method_name?(node) do |method_name_node, method_name_arg|
+            message = format(MSG, method_name: method_name_arg.first.source)
+
+            range = range(method_name_node, node)
+
+            add_offense(node, location: range, message: message)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            method_name?(node) do |method_name_node, method_name_arg|
+              corrector.replace(
+                range(method_name_node, node),
+                "method?(#{method_name_arg.first.source})"
+              )
+            end
+          end
+        end
+
+        private
+
+        def range(method_name_node, node)
+          range_between(
+            method_name_node.loc.selector.begin_pos, node.source_range.end_pos
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/layout/{align_arguments.rb → argument_alignment.rb}

@@ -37,7 +37,7 @@ module RuboCop
       #
       #   foo :bar,
       #       :baz
-      class AlignArguments < Cop
+      class ArgumentAlignment < Cop
         include Alignment
 
         ALIGN_PARAMS_MSG = 'Align the arguments of a method call if ' \

data/lib/rubocop/cop/layout/{align_array.rb → array_alignment.rb}

@@ -20,7 +20,7 @@ module RuboCop
       #   a = ['run',
       #        'forrest',
       #        'run']
-      class AlignArray < Cop
+      class ArrayAlignment < Cop
         include Alignment
 
         MSG = 'Align the elements of an array literal if they span more ' \

data/lib/rubocop/cop/layout/{indent_assignment.rb → assignment_indentation.rb}

@@ -21,7 +21,7 @@ module RuboCop
       #
       # The indentation of the remaining lines can be corrected with
       # other cops such as `IndentationConsistency` and `EndAlignment`.
-      class IndentAssignment < Cop
+      class AssignmentIndentation < Cop
         include CheckAssignment
         include Alignment
 
@@ -33,13 +33,22 @@ module RuboCop
           return unless node.loc.operator
           return if node.loc.operator.line == rhs.first_line
 
-          base = display_column(node.source_range)
+          base = display_column(leftmost_multiple_assignment(node).source_range)
           check_alignment([rhs], base + configured_indentation_width)
         end
 
         def autocorrect(node)
           AlignmentCorrector.correct(processed_source, node, column_delta)
         end
+
+        def leftmost_multiple_assignment(node)
+          return node unless same_line?(node, node.parent) &&
+                             node.parent.assignment?
+
+          leftmost_multiple_assignment(node.parent)
+
+          node.parent
+        end
       end
     end
   end

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

@@ -44,8 +44,8 @@ module RuboCop
       #
       #   foo.bar
       #     .each do
-      #        baz
-      #      end
+      #       baz
+      #     end
       #
       # @example EnforcedStyleAlignWith: start_of_line
       #   # bad

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

@@ -191,7 +191,7 @@ module RuboCop
         end
 
         def indentation_width
-          @config.for_cop('IndentationWidth')['Width'] || 2
+          @config.for_cop('Layout/IndentationWidth')['Width'] || 2
         end
 
         def line_break_after_left_paren?(left_paren, elements)

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/empty_line_after_guard_clause.rb

@@ -45,7 +45,7 @@ module RuboCop
           return if correct_style?(node)
 
           if node.modifier_form? && last_argument_is_heredoc?(node)
-            heredoc_node = last_argument(node)
+            heredoc_node = last_heredoc_argument(node)
 
             return if next_line_empty?(heredoc_line(node, heredoc_node))
 
@@ -109,16 +109,27 @@ module RuboCop
 
         def last_argument_is_heredoc?(node)
           last_children = node.if_branch
-
           return false unless last_children&.send_type?
 
-          last_argument = last_argument(node)
-
-          last_argument.respond_to?(:heredoc?) && last_argument.heredoc?
+          heredoc?(last_heredoc_argument(node))
         end
 
-        def last_argument(node)
-          node.if_branch.children.last
+        def last_heredoc_argument(node)
+          n = if node.respond_to?(:if_branch)
+                node.if_branch.children.last
+              else
+                node
+              end
+
+          return n if heredoc?(n)
+          return unless n.respond_to?(:arguments)
+
+          n.arguments.each do |argument|
+            node = last_heredoc_argument(argument)
+            return node if node
+          end
+
+          return last_heredoc_argument(n.receiver) if n.respond_to?(:receiver)
         end
 
         def heredoc_line(node, heredoc_node)
@@ -129,6 +140,10 @@ module RuboCop
           node.last_line + num_of_heredoc_lines + END_OF_HEREDOC_LINE
         end
 
+        def heredoc?(node)
+          node.respond_to?(:heredoc?) && node.heredoc?
+        end
+
         def offense_location(node)
           if node.loc.respond_to?(:end) && node.loc.end
             :end