rubocop 1.34.1 → 1.54.0

data/lib/rubocop/cop/corrector.rb

@@ -11,6 +11,20 @@ module RuboCop
     class Corrector < ::Parser::Source::TreeRewriter
       NOOP_CONSUMER = ->(diagnostic) {} # noop
 
+      # Duck typing for get to a ::Parser::Source::Buffer
+      def self.source_buffer(source)
+        source = source.processed_source if source.respond_to?(:processed_source)
+        source = source.buffer if source.respond_to?(:buffer)
+        source = source.source_buffer if source.respond_to?(:source_buffer)
+
+        unless source.is_a? ::Parser::Source::Buffer
+          raise TypeError, 'Expected argument to lead to a Parser::Source::Buffer ' \
+                           "but got #{source.inspect}"
+        end
+
+        source
+      end
+
       # @param source [Parser::Source::Buffer, or anything
       #                leading to one via `(processed_source.)buffer`]
       #
@@ -64,18 +78,24 @@ module RuboCop
         remove(to_remove)
       end
 
-      # Duck typing for get to a ::Parser::Source::Buffer
-      def self.source_buffer(source)
-        source = source.processed_source if source.respond_to?(:processed_source)
-        source = source.buffer if source.respond_to?(:buffer)
-        source = source.source_buffer if source.respond_to?(:source_buffer)
+      # Swaps sources at the given ranges.
+      #
+      # @param [Parser::Source::Range, RuboCop::AST::Node] node_or_range1
+      # @param [Parser::Source::Range, RuboCop::AST::Node] node_or_range2
+      def swap(node_or_range1, node_or_range2)
+        range1 = to_range(node_or_range1)
+        range2 = to_range(node_or_range2)
 
-        unless source.is_a? ::Parser::Source::Buffer
-          raise TypeError, 'Expected argument to lead to a Parser::Source::Buffer ' \
-                           "but got #{source.inspect}"
+        if range1.end_pos == range2.begin_pos
+          insert_before(range1, range2.source)
+          remove(range2)
+        elsif range2.end_pos == range1.begin_pos
+          insert_before(range2, range1.source)
+          remove(range1)
+        else
+          replace(range1, range2.source)
+          replace(range2, range1.source)
         end
-
-        source
       end
 
       private
@@ -84,7 +104,7 @@ module RuboCop
       def to_range(node_or_range)
         range = case node_or_range
                 when ::RuboCop::AST::Node, ::Parser::Source::Comment
-                  node_or_range.loc.expression
+                  node_or_range.source_range
                 when ::Parser::Source::Range
                   node_or_range
                 else

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

@@ -16,7 +16,7 @@ module RuboCop
           return unless node
 
           @processed_source = processed_source
-          expr = node.respond_to?(:loc) ? node.loc.expression : node
+          expr = node.respond_to?(:loc) ? node.source_range : node
           return if block_comment_within?(expr)
 
           taboo_ranges = inside_string_ranges(node)
@@ -54,7 +54,7 @@ module RuboCop
         def inside_string_ranges(node)
           return [] unless node.is_a?(Parser::AST::Node)
 
-          node.each_node(:str, :dstr, :xstr).map { |n| inside_string_range(n) }.compact
+          node.each_node(:str, :dstr, :xstr).filter_map { |n| inside_string_range(n) }
         end
 
         def inside_string_range(node)
@@ -80,7 +80,7 @@ module RuboCop
 
         def block_comment_within?(expr)
           processed_source.comments.select(&:document?).any? do |c|
-            within?(c.loc.expression, expr)
+            within?(c.source_range, expr)
           end
         end
 

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

@@ -35,15 +35,15 @@ module RuboCop
 
       def offending_range
         if block_node.arguments?
-          replacement_range(argument_node.loc.expression.end_pos)
+          replacement_range(argument_node.source_range.end_pos)
         else
           replacement_range(block_node.loc.begin.end_pos)
         end
       end
 
       def replacement_range(end_pos)
-        Parser::Source::Range.new(block_node.loc.expression.source_buffer,
-                                  block_node.loc.expression.begin_pos,
+        Parser::Source::Range.new(block_node.source_range.source_buffer,
+                                  block_node.source_range.begin_pos,
                                   end_pos)
       end
     end

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

@@ -56,7 +56,7 @@ module RuboCop
         if collection_node.begin_type?
           collection_node.loc.end
         else
-          collection_node.loc.expression
+          collection_node.source_range
         end
       end
 
@@ -65,8 +65,8 @@ module RuboCop
       end
 
       def replacement_range(end_pos)
-        Parser::Source::Range.new(for_node.loc.expression.source_buffer,
-                                  for_node.loc.expression.begin_pos,
+        Parser::Source::Range.new(for_node.source_range.source_buffer,
+                                  for_node.source_range.begin_pos,
                                   end_pos)
       end
     end

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

@@ -35,7 +35,7 @@ module RuboCop
         def move_comment(eol_comment:, node:, corrector:)
           return unless eol_comment
 
-          text = eol_comment.loc.expression.source
+          text = eol_comment.source
           corrector.insert_before(node, "#{text}\n#{' ' * node.loc.keyword.column}")
           corrector.remove(eol_comment)
         end

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

@@ -28,7 +28,10 @@ module RuboCop
           # put the comment.
           return if new_line_needed_before_closing_brace?(node)
 
-          correct_next_line_brace(corrector)
+          end_range = last_element_range_with_trailing_comma(node).end
+
+          correct_next_line_brace(corrector, end_range)
+          correct_heredoc_argument_method_chain(corrector, end_range)
         end
       end
 
@@ -40,13 +43,19 @@ module RuboCop
         corrector.insert_before(node.loc.end, "\n")
       end
 
-      def correct_next_line_brace(corrector)
+      def correct_next_line_brace(corrector, end_range)
         corrector.remove(range_with_surrounding_space(node.loc.end, side: :left))
+        corrector.insert_before(end_range, content_if_comment_present(corrector, node))
+      end
 
-        corrector.insert_before(
-          last_element_range_with_trailing_comma(node).end,
-          content_if_comment_present(corrector, node)
-        )
+      def correct_heredoc_argument_method_chain(corrector, end_range)
+        return unless (parent = node.parent)
+        return unless use_heredoc_argument_method_chain?(parent)
+
+        chained_method = range_between(parent.loc.dot.begin_pos, parent.source_range.end_pos)
+
+        corrector.remove(chained_method)
+        corrector.insert_after(end_range, chained_method.source)
       end
 
       def content_if_comment_present(corrector, node)
@@ -61,10 +70,17 @@ module RuboCop
         end
       end
 
+      def use_heredoc_argument_method_chain?(parent)
+        return false unless node.respond_to?(:first_argument)
+        return false unless (first_argument = node.first_argument)
+
+        parent.call_type? && first_argument.str_type? && first_argument.heredoc?
+      end
+
       def select_content_to_be_inserted_after_last_element(corrector, node)
         range = range_between(
           node.loc.end.begin_pos,
-          range_by_whole_lines(node.loc.expression).end.end_pos
+          range_by_whole_lines(node.source_range).end.end_pos
         )
 
         remove_trailing_content_of_comment(corrector, range)

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

@@ -18,7 +18,7 @@ module RuboCop
           current_range = declaration_with_comment(node)
           previous_range = declaration_with_comment(previous_declaration)
 
-          ->(corrector) { swap_range(corrector, current_range, previous_range) }
+          ->(corrector) { corrector.swap(current_range, previous_range) }
         end
 
         private
@@ -26,17 +26,12 @@ module RuboCop
         def declaration_with_comment(node)
           buffer = processed_source.buffer
           begin_pos = range_by_whole_lines(get_source_range(node, comments_as_separators)).begin_pos
-          end_line = buffer.line_for_position(node.loc.expression.end_pos)
+          end_line = buffer.line_for_position(node.source_range.end_pos)
           end_pos = range_by_whole_lines(buffer.line_range(end_line),
                                          include_final_newline: true).end_pos
 
           range_between(begin_pos, end_pos)
         end
-
-        def swap_range(corrector, range1, range2)
-          corrector.insert_before(range2, range1.source)
-          corrector.remove(range1)
-        end
       end
     end
   end

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

@@ -7,6 +7,8 @@ module RuboCop
       class << self
         include RangeHelp
 
+        COMMA_REGEXP = /(?<=\))\s*,/.freeze
+
         def correct(corrector, node)
           corrector.remove(node.loc.begin)
           corrector.remove(node.loc.end)
@@ -39,7 +41,15 @@ module RuboCop
         def handle_orphaned_comma(corrector, node)
           return unless only_closing_paren_before_comma?(node)
 
-          range = range_with_surrounding_space(
+          range = extend_range_for_heredoc(node, parens_range(node))
+          corrector.remove(range)
+
+          add_heredoc_comma(corrector, node)
+        end
+
+        # Get a range for the closing parenthesis and all whitespace to the left of it
+        def parens_range(node)
+          range_with_surrounding_space(
             range: node.loc.end,
             buffer: node.source_range.source_buffer,
             side: :left,
@@ -47,8 +57,28 @@ module RuboCop
             whitespace: true,
             continuations: true
           )
+        end
 
-          corrector.remove(range)
+        # If the node contains a heredoc, remove the comma too
+        # It'll be added back in the right place later
+        def extend_range_for_heredoc(node, range)
+          return range unless heredoc?(node)
+
+          comma_line = range_by_whole_lines(node.loc.end, buffer: node.source_range.source_buffer)
+          offset = comma_line.source.match(COMMA_REGEXP)[0]&.size || 0
+
+          range.adjust(end_pos: offset)
+        end
+
+        # Add a comma back after the heredoc identifier
+        def add_heredoc_comma(corrector, node)
+          return unless heredoc?(node)
+
+          corrector.insert_after(node.child_nodes.last, ',')
+        end
+
+        def heredoc?(node)
+          node.child_nodes.last.loc.is_a?(Parser::Source::Map::Heredoc)
         end
       end
     end

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

@@ -66,10 +66,10 @@ module RuboCop
         end
       end
 
-      def line_breaks(node, source, previous_line_num, base_line_num, node_indx)
+      def line_breaks(node, source, previous_line_num, base_line_num, node_index)
         source_in_lines = source.split("\n")
         if first_line?(node, previous_line_num)
-          node_indx.zero? && node.first_line == base_line_num ? '' : ' '
+          node_index.zero? && node.first_line == base_line_num ? '' : ' '
         else
           process_lines(node, previous_line_num, base_line_num, source_in_lines)
         end

data/lib/rubocop/cop/gemspec/dependency_version.rb

@@ -58,8 +58,13 @@ module RuboCop
         FORBIDDEN_MSG = 'Dependency version specification is forbidden.'
         VERSION_SPECIFICATION_REGEX = /^\s*[~<>=]*\s*[0-9.]+/.freeze
 
-        # @!method add_dependency_method_declarations(node)
-        def_node_search :add_dependency_method_declarations, <<~PATTERN
+        ADD_DEPENDENCY_METHODS = %i[
+          add_dependency add_runtime_dependency add_development_dependency
+        ].freeze
+        RESTRICT_ON_SEND = ADD_DEPENDENCY_METHODS
+
+        # @!method add_dependency_method_declaration?(node)
+        def_node_matcher :add_dependency_method_declaration?, <<~PATTERN
           (send
             (lvar #match_block_variable_name?) #add_dependency_method? ...)
         PATTERN
@@ -74,25 +79,22 @@ module RuboCop
           (send _ #add_dependency_method? <(hash <(pair (sym {:branch :ref :tag}) (str _)) ...>) ...>)
         PATTERN
 
-        def on_new_investigation
-          return if processed_source.blank?
-
-          add_dependency_method_nodes.each do |node|
-            next if allowed_gem?(node)
+        def on_send(node)
+          return unless add_dependency_method_declaration?(node)
+          return if allowed_gem?(node)
 
-            if offense?(node)
-              add_offense(node)
-              opposite_style_detected
-            else
-              correct_style_detected
-            end
+          if offense?(node)
+            add_offense(node)
+            opposite_style_detected
+          else
+            correct_style_detected
           end
         end
 
         private
 
         def allowed_gem?(node)
-          allowed_gems.include?(node.first_argument.value)
+          allowed_gems.include?(node.first_argument.str_content)
         end
 
         def allowed_gems
@@ -116,11 +118,7 @@ module RuboCop
         end
 
         def add_dependency_method?(method_name)
-          method_name.to_s.end_with?('_dependency')
-        end
-
-        def add_dependency_method_nodes
-          add_dependency_method_declarations(processed_source.ast)
+          ADD_DEPENDENCY_METHODS.include?(method_name)
         end
 
         def offense?(node)
@@ -128,13 +126,13 @@ module RuboCop
         end
 
         def required_offense?(node)
-          return unless required_style?
+          return false unless required_style?
 
           !includes_version_specification?(node) && !includes_commit_reference?(node)
         end
 
         def forbidden_offense?(node)
-          return unless forbidden_style?
+          return false unless forbidden_style?
 
           includes_version_specification?(node) || includes_commit_reference?(node)
         end

data/lib/rubocop/cop/gemspec/deprecated_attribute_assignment.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Gemspec
-      # Checks that deprecated attribute attributes are not set in a gemspec file.
+      # Checks that deprecated attributes are not set in a gemspec file.
       # Removing deprecated attributes allows the user to receive smaller packed gems.
       #
       # @example

data/lib/rubocop/cop/gemspec/development_dependencies.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gemspec
+      # Enforce that development dependencies for a gem are specified in
+      # `Gemfile`, rather than in the `gemspec` using
+      # `add_development_dependency`. Alternatively, using `EnforcedStyle:
+      # gemspec`, enforce that all dependencies are specified in `gemspec`,
+      # rather than in `Gemfile`.
+      #
+      # @example EnforcedStyle: Gemfile (default)
+      #   # Specify runtime dependencies in your gemspec,
+      #   # but all other dependencies in your Gemfile.
+      #
+      #   # bad
+      #   # example.gemspec
+      #   s.add_development_dependency "foo"
+      #
+      #   # good
+      #   # Gemfile
+      #   gem "foo"
+      #
+      #   # good
+      #   # gems.rb
+      #   gem "foo"
+      #
+      #   # good (with AllowedGems: ["bar"])
+      #   # example.gemspec
+      #   s.add_development_dependency "bar"
+      #
+      # @example EnforcedStyle: gems.rb
+      #   # Specify runtime dependencies in your gemspec,
+      #   # but all other dependencies in your Gemfile.
+      #   #
+      #   # Identical to `EnforcedStyle: Gemfile`, but with a different error message.
+      #   # Rely on Bundler/GemFilename to enforce the use of `Gemfile` vs `gems.rb`.
+      #
+      #   # bad
+      #   # example.gemspec
+      #   s.add_development_dependency "foo"
+      #
+      #   # good
+      #   # Gemfile
+      #   gem "foo"
+      #
+      #   # good
+      #   # gems.rb
+      #   gem "foo"
+      #
+      #   # good (with AllowedGems: ["bar"])
+      #   # example.gemspec
+      #   s.add_development_dependency "bar"
+      #
+      # @example EnforcedStyle: gemspec
+      #   # Specify all dependencies in your gemspec.
+      #
+      #   # bad
+      #   # Gemfile
+      #   gem "foo"
+      #
+      #   # good
+      #   # example.gemspec
+      #   s.add_development_dependency "foo"
+      #
+      #   # good (with AllowedGems: ["bar"])
+      #   # Gemfile
+      #   gem "bar"
+      #
+      class DevelopmentDependencies < Base
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Specify development dependencies in %<preferred>s.'
+        RESTRICT_ON_SEND = %i[add_development_dependency gem].freeze
+
+        # @!method add_development_dependency?(node)
+        def_node_matcher :add_development_dependency?, <<~PATTERN
+          (send _ :add_development_dependency (str #forbidden_gem? ...) _? _?)
+        PATTERN
+
+        # @!method gem?(node)
+        def_node_matcher :gem?, <<~PATTERN
+          (send _ :gem (str #forbidden_gem? ...))
+        PATTERN
+
+        def on_send(node)
+          case style
+          when :Gemfile, :'gems.rb'
+            add_offense(node) if add_development_dependency?(node)
+          when :gemspec
+            add_offense(node) if gem?(node)
+          end
+        end
+
+        private
+
+        def forbidden_gem?(gem_name)
+          !cop_config['AllowedGems'].include?(gem_name)
+        end
+
+        def message(_range)
+          format(MSG, preferred: style)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/gemspec/require_mfa.rb

@@ -84,7 +84,7 @@ module RuboCop
           (str "true")
         PATTERN
 
-        def on_block(node) # rubocop:disable Metrics/MethodLength
+        def on_block(node) # rubocop:disable Metrics/MethodLength, InternalAffairs/NumblockHandler
           gem_specification(node) do |block_var|
             metadata_value = metadata(node)
             mfa_value = mfa_value(metadata_value)

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

@@ -55,8 +55,8 @@ module RuboCop
           end
         end
 
-        def require_path_fragments(require_directove)
-          path = require_directove.match(REQUIRE_PATH)
+        def require_path_fragments(require_directive)
+          path = require_directive.match(REQUIRE_PATH)
 
           path ? path.captures.first.split('/') : []
         end

data/lib/rubocop/cop/generator.rb

@@ -206,9 +206,8 @@ module RuboCop
       end
 
       def snake_case(camel_case_string)
-        return 'rspec' if camel_case_string == 'RSpec'
-
         camel_case_string
+          .gsub('RSpec', 'Rspec')
           .gsub(%r{([^A-Z/])([A-Z]+)}, '\1_\2')
           .gsub(%r{([A-Z])([A-Z][^A-Z\d/]+)}, '\1_\2')
           .downcase

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

@@ -12,6 +12,13 @@ module RuboCop
       #     ....
       #   end
       #
+      #   # bad
+      #   #
+      #   # Checks ...
+      #   class SomeCop < Base
+      #     ...
+      #   end
+      #
       #   # good
       #   # Checks ...
       #   class SomeCop < Base
@@ -21,26 +28,47 @@ module RuboCop
       class CopDescription < Base
         extend AutoCorrector
 
-        MSG = 'Description should be started with %<suggestion>s instead of `This cop ...`.'
+        MSG_STARTS_WITH_WRONG_WORD =
+          'Description should be started with %<suggestion>s instead of `This cop ...`.'
+        MSG_STARTS_WITH_EMPTY_COMMENT_LINE =
+          'Description should not start with an empty comment line.'
 
         SPECIAL_WORDS = %w[is can could should will would must may].freeze
-        COP_DESC_OFFENSE_REGEX = \
+        COP_DESC_OFFENSE_REGEX =
           /^\s+# This cop (?<special>#{SPECIAL_WORDS.join('|')})?\s*(?<word>.+?) .*/.freeze
         REPLACEMENT_REGEX = /^\s+# This cop (#{SPECIAL_WORDS.join('|')})?\s*(.+?) /.freeze
+        EMPTY_COMMENT_LINE_REGEX = /\A\s*#\s*\n\z/.freeze
 
         def on_class(node)
-          return unless (module_node = node.parent)
+          return unless (module_node = node.parent) && node.parent_class
 
           description_beginning = first_comment_line(module_node)
           return unless description_beginning
 
-          start_with_subject = description_beginning.match(COP_DESC_OFFENSE_REGEX)
-          return unless start_with_subject
+          if description_beginning.match?(EMPTY_COMMENT_LINE_REGEX)
+            register_offense_for_empty_comment_line(module_node, description_beginning)
+          else
+            start_with_subject = description_beginning.match(COP_DESC_OFFENSE_REGEX)
+            return unless start_with_subject
+
+            register_offense_for_wrong_word(module_node, description_beginning, start_with_subject)
+          end
+        end
+
+        private
 
+        def register_offense_for_empty_comment_line(module_node, description_beginning)
+          range = range(module_node, description_beginning)
+          add_offense(range, message: MSG_STARTS_WITH_EMPTY_COMMENT_LINE) do |corrector|
+            corrector.remove(range)
+          end
+        end
+
+        def register_offense_for_wrong_word(module_node, description_beginning, start_with_subject)
           suggestion = start_with_subject['word']&.capitalize
           range = range(module_node, description_beginning)
           suggestion_for_message = suggestion_for_message(suggestion, start_with_subject)
-          message = format(MSG, suggestion: suggestion_for_message)
+          message = format(MSG_STARTS_WITH_WRONG_WORD, suggestion: suggestion_for_message)
 
           add_offense(range, message: message) do |corrector|
             if suggestion && !start_with_subject['special']
@@ -49,17 +77,15 @@ module RuboCop
           end
         end
 
-        private
-
         def replace_with_suggestion(corrector, range, suggestion, description_beginning)
           replacement = description_beginning.gsub(REPLACEMENT_REGEX, "#{suggestion} ")
           corrector.replace(range, replacement)
         end
 
         def range(node, comment_line)
-          source_buffer = node.loc.expression.source_buffer
+          source_buffer = node.source_range.source_buffer
 
-          begin_pos = node.loc.expression.begin_pos
+          begin_pos = node.source_range.begin_pos
           begin_pos += comment_index(node, comment_line)
           end_pos = begin_pos + comment_body(comment_line).length
 
@@ -75,7 +101,7 @@ module RuboCop
         end
 
         def first_comment_line(node)
-          node.loc.expression.source.lines.find { |line| comment_line?(line) }
+          node.source.lines.find { |line| comment_line?(line) }
         end
 
         def comment_body(comment_line)
@@ -84,7 +110,7 @@ module RuboCop
 
         def comment_index(node, comment_line)
           body = comment_body(comment_line)
-          node.loc.expression.source.index(body)
+          node.source.index(body)
         end
 
         def relevant_file?(file)

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks for uses of `create_file` with empty string second argument.
+      #
+      # @example
+      #
+      #   # bad
+      #   create_file(path, '')
+      #
+      #   # good
+      #   create_empty_file(path)
+      #
+      class CreateEmptyFile < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<replacement>s`.'
+        RESTRICT_ON_SEND = %i[create_file].freeze
+
+        def on_send(node)
+          return if node.receiver
+          return unless (argument = node.arguments[1])
+          return unless argument.str_type? && argument.value.empty?
+
+          replacement = "create_empty_file(#{node.first_argument.source})"
+          message = format(MSG, replacement: replacement)
+
+          add_offense(node, message: message) do |corrector|
+            corrector.replace(node, replacement)
+          end
+        end
+      end
+    end
+  end
+end