rubocop 0.89.0 → 0.89.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 220e683b0838a3b02076023d5a65ff57267b1eff2c250bb8fa65d03db9ff09ec
-  data.tar.gz: 8fd50157ec4a8a007ab30cfb5ea34dd9b30bf4d6fa8c3d475268f73e2937bd99
+  metadata.gz: 3201b273ee3a04b13a9f41d768d230a5be311881c7fd0b39f24aa0d99a8a16ad
+  data.tar.gz: 794ba4bfcadcee6a8a9aae92f88c167dc1f75122e69f4bee08baa8f22976c1bf
 SHA512:
-  metadata.gz: fb33582bad5b4b07308a11670c8fc173db0261e384160727057e8714f2dfb24d552663e0e14a5be1ad537bc269919e0182b2a1ca63f6ee13f471a422cae98fff
-  data.tar.gz: 214a09139a2a0c85438e2724d289e3fb5e8e1b4d81e6a42231143803842423795867c9da4e0347df1b26e5dfaeaf108d347a1e4758a8604484e370a3e1343a74
+  metadata.gz: c2ea28c0fbfaa2f37ef651b91f38e3084fda1d8c829ebc1aaa839c793f0b759deb692bc70482d863797ab33799af9e083ab7f274f4faa905b956b4b53fbab96b
+  data.tar.gz: 2ac4b6b2e1852c4ca1df725c6de4f6d34442633cb7dea00f27499ebae6e24ad006110dd0b473c781961d6e44819039a5e5748ac0de6ec0a1b2cbceb950c3fcf2

data/README.md

@@ -49,7 +49,7 @@ haven't reached version 1.0 yet). To prevent an unwanted RuboCop update you
 might want to use a conservative version lock in your `Gemfile`:
 
 ```rb
-gem 'rubocop', '~> 0.89.0', require: false
+gem 'rubocop', '~> 0.89.1', require: false
 ```
 
 ## Quickstart

data/lib/rubocop/cli/command/show_cops.rb

@@ -22,7 +22,7 @@ module RuboCop
         private
 
         def print_available_cops
-          registry = Cop::Cop.registry
+          registry = Cop::Registry.global
           show_all = @options[:show_cops].empty?
 
           if show_all

data/lib/rubocop/comment_config.rb

@@ -128,9 +128,7 @@ module RuboCop
     end
 
     def each_directive
-      return if processed_source.comments.nil?
-
-      processed_source.each_comment do |comment|
+      processed_source.comments.each do |comment|
         directive = directive_parts(comment)
         next unless directive
 
@@ -153,11 +151,11 @@ module RuboCop
     end
 
     def qualified_cop_name(cop_name)
-      Cop::Cop.qualified_cop_name(cop_name.strip, processed_source.file_path)
+      Cop::Registry.qualified_cop_name(cop_name.strip, processed_source.file_path)
     end
 
     def all_cop_names
-      @all_cop_names ||= Cop::Cop.registry.names - [REDUNDANT_DISABLE]
+      @all_cop_names ||= Cop::Registry.global.names - [REDUNDANT_DISABLE]
     end
 
     def comment_only_line?(line_number)

data/lib/rubocop/config.rb

@@ -24,7 +24,7 @@ module RuboCop
     def initialize(hash = {}, loaded_path = nil)
       @loaded_path = loaded_path
       @for_cop = Hash.new do |h, cop|
-        qualified_cop_name = Cop::Cop.qualified_cop_name(cop, loaded_path)
+        qualified_cop_name = Cop::Registry.qualified_cop_name(cop, loaded_path)
         cop_options = self[qualified_cop_name] || {}
         cop_options['Enabled'] = enable_cop?(qualified_cop_name, cop_options)
         h[cop] = cop_options

data/lib/rubocop/config_loader.rb

@@ -73,7 +73,7 @@ module RuboCop
         # `can't add a new key into hash during iteration` error
         hash_keys = hash.keys
         hash_keys.each do |key|
-          q = Cop::Cop.qualified_cop_name(key, path)
+          q = Cop::Registry.qualified_cop_name(key, path)
           next if q == key
 
           hash[q] = hash.delete(key)

data/lib/rubocop/config_validator.rb

@@ -84,7 +84,7 @@ module RuboCop
       unknown_cops = []
       invalid_cop_names.each do |name|
         # There could be a custom cop with this name. If so, don't warn
-        next if Cop::Cop.registry.contains_cop_matching?([name])
+        next if Cop::Registry.global.contains_cop_matching?([name])
 
         # Special case for inherit_mode, which is a directive that we keep in
         # the configuration (even though it's not a cop), because it's easier

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

@@ -16,7 +16,7 @@ module RuboCop
                                   processed_source:)
           @processed_source = processed_source
           range = first_part_of(node.to_a.last)
-          eol_comment = end_of_line_comment(node.source_range.line)
+          eol_comment = processed_source.comment_at_line(node.source_range.line)
 
           break_line_before(range: range, node: node, corrector: corrector,
                             configured_width: configured_width)

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

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

@@ -40,6 +40,7 @@ module RuboCop
         def on_new_investigation
           return if processed_source.blank?
 
+          @aligned_comments = aligned_locations(processed_source.comments.map(&:loc))
           @corrected = Set.new if force_equal_sign_alignment?
 
           processed_source.tokens.each_cons(2) do |token1, token2|
@@ -49,6 +50,18 @@ module RuboCop
 
         private
 
+        def aligned_locations(locs)
+          return [] if locs.empty?
+
+          aligned = Set[locs.first.line, locs.last.line]
+          locs.each_cons(3) do |before, loc, after|
+            col = loc.column
+            aligned << loc.line if col == before.column || # rubocop:disable Style/MultipleComparison
+                                   col == after.column
+          end
+          aligned
+        end
+
         def check_tokens(ast, token1, token2)
           return if token2.type == :tNL
 
@@ -95,7 +108,7 @@ module RuboCop
 
         def aligned_tok?(token)
           if token.comment?
-            aligned_comments?(token)
+            @aligned_comments.include?(token.line)
           else
             aligned_with_something?(token.pos)
           end
@@ -119,26 +132,6 @@ module RuboCop
           end.compact
         end
 
-        def aligned_comments?(comment_token)
-          ix = processed_source.comments.index do |comment|
-            comment.loc.expression.begin_pos == comment_token.begin_pos
-          end
-          aligned_with_previous_comment?(ix) || aligned_with_next_comment?(ix)
-        end
-
-        def aligned_with_previous_comment?(index)
-          index.positive? && comment_column(index - 1) == comment_column(index)
-        end
-
-        def aligned_with_next_comment?(index)
-          index < processed_source.comments.length - 1 &&
-            comment_column(index + 1) == comment_column(index)
-        end
-
-        def comment_column(index)
-          processed_source.comments[index].loc.column
-        end
-
         def force_equal_sign_alignment?
           cop_config['ForceEqualSignAlignment']
         end

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

@@ -55,7 +55,7 @@ module RuboCop
         MSG = 'Missing space after `#`.'
 
         def investigate(processed_source)
-          processed_source.each_comment do |comment|
+          processed_source.comments.each do |comment|
             next unless /\A#+[^#\s=:+-]/.match?(comment.text)
             next if comment.loc.line == 1 && allowed_on_first_line?(comment)
             next if doxygen_comment_style?(comment)

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

@@ -29,12 +29,13 @@ module RuboCop
       #
       class BinaryOperatorWithIdenticalOperands < Base
         MSG = 'Binary operator `%<op>s` has identical operands.'
+        MATH_OPERATORS = %i[+ - * / % ** << >> | ^].to_set.freeze
 
         def on_send(node)
           return unless node.binary_operation?
 
           lhs, operation, rhs = *node
-          return if node.arithmetic_operation? && lhs.basic_literal? && rhs.basic_literal?
+          return if MATH_OPERATORS.include?(node.method_name) && rhs.basic_literal?
 
           add_offense(node, message: format(MSG, op: operation)) if lhs == rhs
         end

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

@@ -45,7 +45,13 @@ module RuboCop
 
         OBJECT_LIFECYCLE_CALLBACKS  = %i[method_missing respond_to_missing?].freeze
         CLASS_LIFECYCLE_CALLBACKS   = %i[inherited].freeze
-        MODULE_LIFECYCLE_CALLBACKS  = %i[included extended prepended].freeze
+        METHOD_LIFECYCLE_CALLBACKS  = %i[method_added method_removed method_undefined
+                                         singleton_method_added singleton_method_removed
+                                         singleton_method_undefined].freeze
+
+        CALLBACKS = (OBJECT_LIFECYCLE_CALLBACKS +
+                      CLASS_LIFECYCLE_CALLBACKS +
+                      METHOD_LIFECYCLE_CALLBACKS).to_set.freeze
 
         def on_def(node)
           return unless offender?(node)
@@ -70,15 +76,9 @@ module RuboCop
         end
 
         def callback_method_def?(node)
-          method_name = node.method_name
-
-          if OBJECT_LIFECYCLE_CALLBACKS.include?(method_name) ||
-             CLASS_LIFECYCLE_CALLBACKS.include?(method_name)
+          return unless CALLBACKS.include?(node.method_name)
 
-            node.each_ancestor(:class, :sclass, :module).first
-          elsif MODULE_LIFECYCLE_CALLBACKS.include?(method_name)
-            node.each_ancestor(:module).first
-          end
+          node.each_ancestor(:class, :sclass, :module).first
         end
 
         def contains_super?(node)

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

@@ -21,16 +21,38 @@ module RuboCop
       class OutOfRangeRegexpRef < Base
         MSG = 'Do not use out of range reference for the Regexp.'
 
+        REGEXP_RECEIVER_METHODS = %i[=~ === match].to_set.freeze
+        REGEXP_ARGUMENT_METHODS = %i[=~ match grep gsub gsub! sub sub! [] slice slice! index rindex
+                                     scan partition rpartition start_with? end_with?].to_set.freeze
+        REGEXP_CAPTURE_METHODS = (REGEXP_RECEIVER_METHODS + REGEXP_ARGUMENT_METHODS).freeze
+
         def on_new_investigation
           @valid_ref = 0
         end
 
-        def on_regexp(node)
+        def on_match_with_lvasgn(node)
+          check_regexp(node.children.first)
+        end
+
+        def on_send(node)
+          return unless REGEXP_CAPTURE_METHODS.include?(node.method_name)
+
           @valid_ref = nil
-          return if contain_non_literal?(node)
 
-          tree = Regexp::Parser.parse(node.content)
-          @valid_ref = regexp_captures(tree)
+          if node.receiver&.regexp_type?
+            check_regexp(node.receiver)
+          elsif node.first_argument&.regexp_type? \
+            && REGEXP_ARGUMENT_METHODS.include?(node.method_name)
+            check_regexp(node.first_argument)
+          end
+        end
+
+        def on_when(node)
+          regexp_conditions = node.conditions.select(&:regexp_type?)
+
+          @valid_ref = regexp_conditions.map do |condition|
+            check_regexp(condition)
+          end.compact.max
         end
 
         def on_nth_ref(node)
@@ -42,6 +64,13 @@ module RuboCop
 
         private
 
+        def check_regexp(regexp)
+          return if contain_non_literal?(regexp)
+
+          tree = Regexp::Parser.parse(regexp.content)
+          @valid_ref = regexp_captures(tree)
+        end
+
         def contain_non_literal?(node)
           node.children.size != 2 || !node.children.first.str_type?
         end

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

@@ -41,13 +41,12 @@ module RuboCop
         def on_new_investigation
           return unless offenses_to_check
 
-          comments = processed_source.comments
           cop_disabled_line_ranges = processed_source.disabled_line_ranges
 
           redundant_cops = Hash.new { |h, k| h[k] = Set.new }
 
           each_redundant_disable(cop_disabled_line_ranges,
-                                 offenses_to_check, comments) do |comment, redundant_cop|
+                                 offenses_to_check) do |comment, redundant_cop|
             redundant_cops[comment].add(redundant_cop)
           end
 
@@ -88,25 +87,25 @@ module RuboCop
                                        newlines: false)
         end
 
-        def each_redundant_disable(cop_disabled_line_ranges, offenses, comments,
+        def each_redundant_disable(cop_disabled_line_ranges, offenses,
                                    &block)
           disabled_ranges = cop_disabled_line_ranges[COP_NAME] || [0..0]
 
           cop_disabled_line_ranges.each do |cop, line_ranges|
             each_already_disabled(line_ranges,
-                                  disabled_ranges, comments) do |comment|
+                                  disabled_ranges) do |comment|
               yield comment, cop
             end
 
-            each_line_range(line_ranges, disabled_ranges, offenses, comments,
+            each_line_range(line_ranges, disabled_ranges, offenses,
                             cop, &block)
           end
         end
 
-        def each_line_range(line_ranges, disabled_ranges, offenses, comments,
+        def each_line_range(line_ranges, disabled_ranges, offenses,
                             cop)
           line_ranges.each_with_index do |line_range, ix|
-            comment = comments.find { |c| c.loc.line == line_range.begin }
+            comment = processed_source.comment_at_line(line_range.begin)
             next if ignore_offense?(disabled_ranges, line_range)
 
             redundant_cop = find_redundant(comment, offenses, cop, line_range,
@@ -115,7 +114,7 @@ module RuboCop
           end
         end
 
-        def each_already_disabled(line_ranges, disabled_ranges, comments)
+        def each_already_disabled(line_ranges, disabled_ranges)
           line_ranges.each_cons(2) do |previous_range, range|
             next if ignore_offense?(disabled_ranges, range)
             next if previous_range.end != range.begin
@@ -124,14 +123,12 @@ module RuboCop
             # the end of the previous range, it means that the cop was
             # already disabled by an earlier comment. So it's redundant
             # whether there are offenses or not.
-            redundant_comment = comments.find do |c|
-              c.loc.line == range.begin &&
-                # Comments disabling all cops don't count since it's reasonable
-                # to disable a few select cops first and then all cops further
-                # down in the code.
-                !all_disabled?(c)
-            end
-            yield redundant_comment if redundant_comment
+            comment = processed_source.comment_at_line(range.begin)
+
+            # Comments disabling all cops don't count since it's reasonable
+            # to disable a few select cops first and then all cops further
+            # down in the code.
+            yield comment if comment && !all_disabled?(comment)
           end
         end
 
@@ -250,7 +247,7 @@ module RuboCop
         end
 
         def all_cop_names
-          @all_cop_names ||= Cop.registry.names
+          @all_cop_names ||= Registry.global.names
         end
 
         def ends_its_line?(range)

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

@@ -16,35 +16,19 @@ module RuboCop
       class UriRegexp < Base
         extend AutoCorrector
 
-        MSG = '`%<top_level>sURI.regexp%<arg>s` is obsolete and should not ' \
-              'be used. Instead, use `%<top_level>sURI::DEFAULT_PARSER.' \
-              'make_regexp%<arg>s`.'
-
-        def_node_matcher :uri_regexp_with_argument?, <<~PATTERN
-          (send
-            (const ${nil? cbase} :URI) :regexp
-            ${(str _) (array ...)})
-        PATTERN
-
-        def_node_matcher :uri_regexp_without_argument?, <<~PATTERN
-          (send
-            (const ${nil? cbase} :URI) :regexp)
-        PATTERN
+        MSG = '`%<current>s` is obsolete and should not be used. Instead, use `%<preferred>s`.'
+        URI_CONSTANTS = ['URI', '::URI'].freeze
 
         def on_send(node)
-          return unless node.method?(:regexp)
-
-          captured_values = uri_regexp_with_argument?(node) || uri_regexp_without_argument?(node)
-
-          double_colon, arg = captured_values
-
-          top_level = double_colon ? '::' : ''
-          argument = arg ? "(#{arg.source})" : ''
+          return unless node.method?(:regexp) && node.receiver
+          return unless URI_CONSTANTS.include?(node.receiver.source)
 
-          format = format(MSG, top_level: top_level, arg: argument)
+          argument = node.first_argument ? "(#{node.first_argument.source})" : ''
+          preferred_method = "#{node.receiver.source}::DEFAULT_PARSER.make_regexp#{argument}"
+          message = format(MSG, current: node.source, preferred: preferred_method)
 
-          add_offense(node.loc.selector, message: format) do |corrector|
-            corrector.replace(node, "#{top_level}URI::DEFAULT_PARSER.make_regexp#{argument}")
+          add_offense(node.loc.selector, message: message) do |corrector|
+            corrector.replace(node, preferred_method)
           end
         end
       end

data/lib/rubocop/cop/migration/department_name.rb

@@ -20,7 +20,7 @@ module RuboCop
         DISABLING_COPS_CONTENT_TOKEN = %r{[A-z]+/[A-z]+|all}.freeze
 
         def on_new_investigation
-          processed_source.each_comment do |comment|
+          processed_source.comments.each do |comment|
             next if comment.text !~ DISABLE_COMMENT_FORMAT
 
             offset = Regexp.last_match(1).length
@@ -51,7 +51,7 @@ module RuboCop
 
           add_offense(range) do |corrector|
             cop_name = range.source
-            qualified_cop_name = Cop.registry.qualified_cop_name(cop_name, nil, warn: false)
+            qualified_cop_name = Registry.global.qualified_cop_name(cop_name, nil, warn: false)
 
             unless qualified_cop_name.include?('/')
               qualified_cop_name = qualified_legacy_cop_name(cop_name)