rubocop 0.87.1 → 0.89.1

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

@@ -71,7 +71,7 @@ module RuboCop
                                     prev_line_num,
                                     base_line_num,
                                     index)
-          prev_line_num = word_node.first_line
+          prev_line_num = word_node.last_line
           content = fix_escaped_content(word_node, escape, delimiters)
           line_breaks + content
         end
@@ -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,10 +76,14 @@ 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
 
@@ -68,12 +94,12 @@ module RuboCop
             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/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)

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

@@ -12,8 +12,9 @@ module RuboCop
       #   # good
       #   node.method?(:do_something)
       #
-      class MethodNameEqual < Cop
+      class MethodNameEqual < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `method?(%<method_name>s)` instead of ' \
               '`method_name == %<method_name>s`.'
@@ -31,17 +32,8 @@ module RuboCop
 
             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})"
-              )
+            add_offense(range, message: message) do |corrector|
+              corrector.replace(range, "method?(#{method_name_arg.first.source})")
             end
           end
         end

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

@@ -15,7 +15,7 @@ module RuboCop
       #
       #   # good
       #   method_name = send_node.method_name
-      class NodeDestructuring < Cop
+      class NodeDestructuring < Base
         MSG = 'Use the methods provided with the node extensions instead ' \
               'of manually destructuring nodes.'
 

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

@@ -13,24 +13,24 @@ module RuboCop
       #
       #   # good
       #   add_offense(node, location: :selector)
-      class OffenseLocationKeyword < Cop
+      class OffenseLocationKeyword < Base
+        extend AutoCorrector
+
         MSG = 'Use `:%<keyword>s` as the location argument to ' \
               '`#add_offense`.'
 
         def on_send(node)
           node_type_check(node) do |node_arg, kwargs|
             find_offending_argument(node_arg, kwargs) do |location, keyword|
-              add_offense(location, message: format(MSG, keyword: keyword))
+              add_offense(location, message: format(MSG, keyword: keyword)) do |corrector|
+                (*, keyword) = offending_location_argument(location.parent)
+
+                corrector.replace(location, ":#{keyword}")
+              end
             end
           end
         end
 
-        def autocorrect(node)
-          (*, keyword) = offending_location_argument(node.parent)
-
-          ->(corrector) { corrector.replace(node, ":#{keyword}") }
-        end
-
         private
 
         def_node_matcher :node_type_check, <<~PATTERN

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

@@ -16,8 +16,9 @@ module RuboCop
       #   add_offense(node)
       #   add_offense(node, location: :selector)
       #
-      class RedundantLocationArgument < Cop
+      class RedundantLocationArgument < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Redundant location argument to `#add_offense`.'
 
@@ -28,15 +29,17 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          redundant_location_argument(node) { |argument| add_offense(argument) }
-        end
-
-        def autocorrect(node)
-          range = offending_range(node)
+          redundant_location_argument(node) do |argument|
+            add_offense(argument) do |corrector|
+              range = offending_range(argument)
 
-          ->(corrector) { corrector.remove(range) }
+              corrector.remove(range)
+            end
+          end
         end
 
+        private
+
         def offending_range(node)
           with_space = range_with_surrounding_space(range: node.loc.expression)
 

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

@@ -19,8 +19,9 @@ module RuboCop
       #   add_offense(node, message: CUSTOM_MSG)
       #   add_offense(node, message: message(other_node))
       #
-      class RedundantMessageArgument < Cop
+      class RedundantMessageArgument < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Redundant message argument to `#add_offense`.'
 
@@ -39,17 +40,15 @@ module RuboCop
         def on_send(node)
           node_type_check(node) do |node_arg, kwargs|
             find_offending_argument(node_arg, kwargs) do |pair|
-              add_offense(pair)
+              add_offense(pair) do |corrector|
+                range = offending_range(pair)
+
+                corrector.remove(range)
+              end
             end
           end
         end
 
-        def autocorrect(node)
-          range = offending_range(node)
-
-          ->(corrector) { corrector.remove(range) }
-        end
-
         private
 
         def offending_range(node)

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

@@ -13,7 +13,7 @@ module RuboCop
       #     # good
       #     expect(cop.messages).to eq(['Do not write bad code like that.'])
       #
-      class UselessMessageAssertion < Cop
+      class UselessMessageAssertion < Base
         MSG = 'Do not specify cop behavior using `described_class::MSG`.'
 
         def_node_search :described_class_msg, <<~PATTERN
@@ -24,7 +24,7 @@ module RuboCop
           (send (send nil? :expect #contains_described_class_msg?) :to ...)
         PATTERN
 
-        def investigate(_processed_source)
+        def on_new_investigation
           assertions_using_described_class_msg.each do |node|
             add_offense(node)
           end

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

@@ -213,7 +213,7 @@ module RuboCop
                 start_loc.column == source_line_column[:column]
             ''
           else
-            ' or ' + format_source_line_column(source_line_column)
+            " or #{format_source_line_column(source_line_column)}"
           end
         end
 

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

@@ -269,15 +269,11 @@ module RuboCop
         end
 
         def begin_pos_with_comment(node)
-          annotation_line = node.first_line - 1
           first_comment = nil
+          (node.first_line - 1).downto(1) do |annotation_line|
+            break unless (comment = processed_source.comment_at_line(annotation_line))
 
-          processed_source.comments_before_line(annotation_line)
-                          .reverse_each do |comment|
-            if comment.location.line == annotation_line
-              first_comment = comment
-              annotation_line -= 1
-            end
+            first_comment = comment
           end
 
           start_line_position(first_comment || node)

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

@@ -39,7 +39,7 @@ module RuboCop
           'instead of %<correct_comment_indentation>d).'
 
         def investigate(processed_source)
-          processed_source.each_comment { |comment| check(comment) }
+          processed_source.comments.each { |comment| check(comment) }
         end
 
         def autocorrect(comment)

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'set'
-
 module RuboCop
   module Cop
     module Layout

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

@@ -109,6 +109,7 @@ module RuboCop
 
         def allowed_only_before_style?(node)
           if node.special_modifier?
+            return true if processed_source[node.last_line] == 'end'
             return false if next_line_empty?(node.last_line)
           end