rubocop 0.85.1 → 0.89.0

data/lib/rubocop/cop/corrector.rb

@@ -8,117 +8,25 @@ module RuboCop
     # Important!
     # The nodes modified by the corrections should be part of the
     # AST of the source_buffer.
-    class Corrector
+    class Corrector < ::Parser::Source::TreeRewriter
+      # @param source [Parser::Source::Buffer, or anything
+      #                leading to one via `(processed_source.)buffer`]
       #
-      # @param source_buffer [Parser::Source::Buffer]
-      # @param corrections [Array(#call)]
-      #   Array of Objects that respond to #call. They will receive the
-      #   corrector itself and should use its method to modify the source.
-      #
-      # @example
-      #
-      #   class AndOrCorrector
-      #     def initialize(node)
-      #       @node = node
-      #     end
-      #
-      #     def call(corrector)
-      #       replacement = (@node.type == :and ? '&&' : '||')
-      #       corrector.replace(@node.loc.operator, replacement)
-      #     end
-      #   end
-      #
-      #   corrections = [AndOrCorrector.new(node)]
-      #   corrector = Corrector.new(source_buffer, corrections)
-      def initialize(source_buffer, corrections = [])
-        @source_buffer = source_buffer
-        raise 'source_buffer should be a Parser::Source::Buffer' unless \
-          source_buffer.is_a? Parser::Source::Buffer
-
-        @corrections = corrections
-        @source_rewriter = Parser::Source::TreeRewriter.new(
-          source_buffer,
+      #   corrector = Corrector.new(cop)
+      def initialize(source)
+        source = self.class.source_buffer(source)
+        super(
+          source,
           different_replacements: :raise,
           swallowed_insertions: :raise,
           crossing_deletions: :accept
         )
 
-        @diagnostics = []
         # Don't print warnings to stderr if corrections conflict with each other
-        @source_rewriter.diagnostics.consumer = lambda do |diagnostic|
-          @diagnostics << diagnostic
-        end
-      end
-
-      attr_reader :corrections, :diagnostics
-
-      # Does the actual rewrite and returns string corresponding to
-      # the rewritten source.
-      #
-      # @return [String]
-      def rewrite
-        @corrections.each do |correction|
-          begin
-            @source_rewriter.transaction do
-              correction.call(self)
-            end
-          rescue ErrorWithAnalyzedFileLocation => e
-            raise e unless e.cause.is_a?(::Parser::ClobberingError)
-          end
-        end
-
-        @source_rewriter.process
-      end
-
-      # Removes the source range.
-      #
-      # @param [Parser::Source::Range, Rubocop::AST::Node] range or node
-      def remove(node_or_range)
-        range = to_range(node_or_range)
-        @source_rewriter.remove(range)
-      end
-
-      # Inserts new code before the given source range.
-      #
-      # @param [Parser::Source::Range, Rubocop::AST::Node] range or node
-      # @param [String] content
-      def insert_before(node_or_range, content)
-        range = to_range(node_or_range)
-        # TODO: Fix Cops using bad ranges instead
-        if range.end_pos > @source_buffer.source.size
-          range = range.with(end_pos: @source_buffer.source.size)
-        end
-
-        @source_rewriter.insert_before(range, content)
-      end
-
-      # Inserts new code after the given source range.
-      #
-      # @param [Parser::Source::Range, Rubocop::AST::Node] range or node
-      # @param [String] content
-      def insert_after(node_or_range, content)
-        range = to_range(node_or_range)
-        @source_rewriter.insert_after(range, content)
+        diagnostics.consumer = ->(diagnostic) {}
       end
 
-      # Wraps the given source range with the given before and after texts
-      #
-      # @param [Parser::Source::Range, Rubocop::AST::Node] range or node
-      # @param [String] before
-      # @param [String] after
-      def wrap(node_or_range, before, after)
-        range = to_range(node_or_range)
-        @source_rewriter.wrap(range, before, after)
-      end
-
-      # Replaces the code of the source range `range` with `content`.
-      #
-      # @param [Parser::Source::Range, Rubocop::AST::Node] range or node
-      # @param [String] content
-      def replace(node_or_range, content)
-        range = to_range(node_or_range)
-        @source_rewriter.replace(range, content)
-      end
+      alias rewrite process # Legacy
 
       # Removes `size` characters prior to the source range.
       #
@@ -126,10 +34,11 @@ module RuboCop
       # @param [Integer] size
       def remove_preceding(node_or_range, size)
         range = to_range(node_or_range)
-        to_remove = Parser::Source::Range.new(range.source_buffer,
-                                              range.begin_pos - size,
-                                              range.begin_pos)
-        @source_rewriter.remove(to_remove)
+        to_remove = range.with(
+          begin_pos: range.begin_pos - size,
+          end_pos:   range.begin_pos
+        )
+        remove(to_remove)
       end
 
       # Removes `size` characters from the beginning of the given range.
@@ -140,10 +49,8 @@ module RuboCop
       # @param [Integer] size
       def remove_leading(node_or_range, size)
         range = to_range(node_or_range)
-        to_remove = Parser::Source::Range.new(range.source_buffer,
-                                              range.begin_pos,
-                                              range.begin_pos + size)
-        @source_rewriter.remove(to_remove)
+        to_remove = range.with(end_pos: range.begin_pos + size)
+        remove(to_remove)
       end
 
       # Removes `size` characters from the end of the given range.
@@ -154,10 +61,22 @@ module RuboCop
       # @param [Integer] size
       def remove_trailing(node_or_range, size)
         range = to_range(node_or_range)
-        to_remove = Parser::Source::Range.new(range.source_buffer,
-                                              range.end_pos - size,
-                                              range.end_pos)
-        @source_rewriter.remove(to_remove)
+        to_remove = range.with(begin_pos: range.end_pos - size)
+        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)
+
+        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
 
       private
@@ -178,8 +97,12 @@ module RuboCop
         range
       end
 
+      def check_range_validity(node_or_range)
+        super(to_range(node_or_range))
+      end
+
       def validate_buffer(buffer)
-        return if buffer == @source_buffer
+        return if buffer == source_buffer
 
         unless buffer.is_a?(::Parser::Source::Buffer)
           # actually this should be enforced by parser gem

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

@@ -29,8 +29,8 @@ module RuboCop
                               configured_width:)
           corrector.insert_before(
             range,
-            "\n" + ' ' * (node.loc.keyword.column +
-                          indent_steps * configured_width)
+            "\n#{' ' * (node.loc.keyword.column +
+                          indent_steps * configured_width)}"
           )
         end
 
@@ -39,7 +39,7 @@ module RuboCop
 
           text = eol_comment.loc.expression.source
           corrector.insert_before(node,
-                                  text + "\n" + (' ' * node.loc.keyword.column))
+                                  "#{text}\n#{' ' * node.loc.keyword.column}")
           corrector.remove(eol_comment)
         end
 

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

@@ -42,8 +42,34 @@ module RuboCop
 
         corrector.insert_before(
           last_element_range_with_trailing_comma(node).end,
+          content_if_comment_present(corrector, node)
+        )
+      end
+
+      def content_if_comment_present(corrector, node)
+        range = range_with_surrounding_space(
+          range: children(node).last.source_range,
+          side: :right
+        ).end.resize(1)
+        if range.source == '#'
+          select_content_to_be_inserted_after_last_element(corrector, node)
+        else
           node.loc.end.source
+        end
+      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
         )
+
+        remove_trailing_content_of_comment(corrector, range)
+        range.source
+      end
+
+      def remove_trailing_content_of_comment(corrector, range)
+        corrector.remove(range)
       end
 
       def last_element_range_with_trailing_comma(node)

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

@@ -110,7 +110,7 @@ module RuboCop
 
       def end_content(source)
         result = /\A(\s*)\]/.match(source.split("\n").last)
-        ("\n" + result[1]) if result
+        "\n#{result[1]}" if result
       end
     end
   end

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

@@ -10,7 +10,7 @@ module RuboCop
         end
 
         def add_space(token)
-          ->(corrector) { corrector.replace(token.pos, token.pos.source + ' ') }
+          ->(corrector) { corrector.replace(token.pos, "#{token.pos.source} ") }
         end
 
         def swap_comma(range)

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

@@ -9,33 +9,30 @@ module RuboCop
       class << self
         attr_reader :processed_source
 
-        def correct(processed_source, node)
+        def correct(corrector, processed_source, node)
           return if %i[kwarg kwoptarg].include?(node.type)
 
           @processed_source = processed_source
 
           if node.blockarg_type?
-            correct_for_blockarg_type(node)
+            correct_for_blockarg_type(corrector, node)
           else
-            lambda do |corrector|
-              variable_name = if node.optarg_type?
-                                node.node_parts[0]
-                              else
-                                # Extract only a var name without splat (`*`)
-                                node.source.gsub(/\A\*+/, '')
-                              end
-              corrector.replace(node.loc.name, "_#{variable_name}")
-            end
+            variable_name = if node.optarg_type?
+                              node.node_parts[0]
+                            else
+                              # Extract only a var name without splat (`*`)
+                              node.source.gsub(/\A\*+/, '')
+                            end
+
+            corrector.replace(node.loc.name, "_#{variable_name}")
           end
         end
 
-        def correct_for_blockarg_type(node)
-          lambda do |corrector|
-            range = range_with_surrounding_space(range: node.source_range,
-                                                 side: :left)
-            range = range_with_surrounding_comma(range, :left)
-            corrector.remove(range)
-          end
+        def correct_for_blockarg_type(corrector, node)
+          range = range_with_surrounding_space(range: node.source_range, side: :left)
+          range = range_with_surrounding_comma(range, :left)
+
+          corrector.remove(range)
         end
       end
     end

data/lib/rubocop/cop/force.rb

@@ -11,6 +11,7 @@ module RuboCop
       end
 
       def self.inherited(subclass)
+        super
         all << subclass
       end
 

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

@@ -3,8 +3,8 @@
 module RuboCop
   module Cop
     module Gemspec
-      # Checks that `required_ruby_version` of gemspec and `TargetRubyVersion`
-      # of .rubocop.yml are equal.
+      # Checks that `required_ruby_version` of gemspec is specified and
+      # equal to `TargetRubyVersion` of .rubocop.yml.
       # Thereby, RuboCop to perform static analysis working on the version
       # required by gemspec.
       #
@@ -13,6 +13,11 @@ module RuboCop
       #
       #   # bad
       #   Gem::Specification.new do |spec|
+      #     # no `required_ruby_version` specified
+      #   end
+      #
+      #   # bad
+      #   Gem::Specification.new do |spec|
       #     spec.required_ruby_version = '>= 2.4.0'
       #   end
       #
@@ -35,18 +40,35 @@ module RuboCop
       #   Gem::Specification.new do |spec|
       #     spec.required_ruby_version = ['>= 2.5.0', '< 2.7.0']
       #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.required_ruby_version = '~> 2.5'
+      #   end
       class RequiredRubyVersion < Cop
-        MSG = '`required_ruby_version` (%<required_ruby_version>s, ' \
-              'declared in %<gemspec_filename>s) and `TargetRubyVersion` ' \
-              '(%<target_ruby_version>s, which may be specified in ' \
-              '.rubocop.yml) should be equal.'
+        include RangeHelp
+
+        NOT_EQUAL_MSG = '`required_ruby_version` (%<required_ruby_version>s, ' \
+                        'declared in %<gemspec_filename>s) and `TargetRubyVersion` ' \
+                        '(%<target_ruby_version>s, which may be specified in ' \
+                        '.rubocop.yml) should be equal.'
+        MISSING_MSG = '`required_ruby_version` should be specified.'
 
         def_node_search :required_ruby_version, <<~PATTERN
-          (send _ :required_ruby_version= ${(str _) (array (str _))})
+          (send _ :required_ruby_version= $_)
+        PATTERN
+
+        def_node_matcher :string_version?, <<~PATTERN
+          {(str _) (array (str _))}
         PATTERN
 
+        # rubocop:disable Metrics/AbcSize
         def investigate(processed_source)
-          required_ruby_version(processed_source.ast) do |version|
+          version = required_ruby_version(processed_source.ast).first
+
+          if version
+            return unless string_version?(version)
+
             ruby_version = extract_ruby_version(version)
 
             return if ruby_version == target_ruby_version.to_s
@@ -54,26 +76,30 @@ module RuboCop
             add_offense(
               processed_source.ast,
               location: version.loc.expression,
-              message: message(ruby_version, target_ruby_version)
+              message: not_equal_message(ruby_version, target_ruby_version)
             )
+          else
+            range = source_range(processed_source.buffer, 1, 0)
+            add_offense(nil, location: range, message: MISSING_MSG)
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         private
 
         def extract_ruby_version(required_ruby_version)
           if required_ruby_version.array_type?
             required_ruby_version = required_ruby_version.children.detect do |v|
-              v.str_content =~ /[>=]/
+              /[>=]/.match?(v.str_content)
             end
           end
 
-          required_ruby_version.str_content.match(/(\d\.\d)/)[1]
+          required_ruby_version.str_content.scan(/\d/).first(2).join('.')
         end
 
-        def message(required_ruby_version, target_ruby_version)
+        def not_equal_message(required_ruby_version, target_ruby_version)
           format(
-            MSG,
+            NOT_EQUAL_MSG,
             required_ruby_version: required_ruby_version,
             gemspec_filename: File.basename(processed_source.file_path),
             target_ruby_version: target_ruby_version

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

@@ -28,7 +28,7 @@ module RuboCop
       class RubyVersionGlobalsUsage < Cop
         MSG = 'Do not use `RUBY_VERSION` in gemspec file.'
 
-        def_node_matcher :ruby_version?, '(const nil? :RUBY_VERSION)'
+        def_node_matcher :ruby_version?, '(const {cbase nil?} :RUBY_VERSION)'
 
         def_node_search :gem_specification?, <<~PATTERN
           (block

data/lib/rubocop/cop/generator.rb

@@ -54,7 +54,7 @@ module RuboCop
               #   # good
               #   good_foo_method(args)
               #
-              class %<cop_name>s < Cop
+              class %<cop_name>s < Base
                 # TODO: Implement the cop in here.
                 #
                 # In many cases, you can use a node matcher for matching node pattern.

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

@@ -25,9 +25,9 @@ module RuboCop
           target_line = find_target_line
           if target_line
             configuration_entries.insert(target_line,
-                                         new_configuration_entry + "\n")
+                                         "#{new_configuration_entry}\n")
           else
-            configuration_entries.push("\n" + new_configuration_entry)
+            configuration_entries.push("\n#{new_configuration_entry}")
           end
 
           File.write(configuration_file_path, configuration_entries.join)
@@ -58,7 +58,7 @@ module RuboCop
         end
 
         def cop_name_line?(yaml)
-          yaml !~ /^[\s#]/
+          !/^[\s#]/.match?(yaml)
         end
       end
     end