rubocop 0.82.0 → 1.18.4

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

@@ -27,26 +27,16 @@ module RuboCop
       #   when 'second'
       #     do_something_else
       #   end
-      class DuplicateCaseCondition < Cop
+      class DuplicateCaseCondition < Base
         MSG = 'Duplicate `when` condition detected.'
 
         def on_case(case_node)
-          case_node.when_branches.each_with_object([]) do |when_node, previous|
+          case_node.when_branches.each_with_object(Set.new) do |when_node, previous|
             when_node.each_condition do |condition|
-              next unless repeated_condition?(previous, condition)
-
-              add_offense(condition)
+              add_offense(condition) unless previous.add?(condition)
             end
-
-            previous.push(when_node.conditions)
           end
         end
-
-        private
-
-        def repeated_condition?(previous, condition)
-          previous.any? { |c| c.include?(condition) }
-        end
       end
     end
   end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks that there are no repeated conditions used in if 'elsif'.
+      #
+      # @example
+      #   # bad
+      #   if x == 1
+      #     do_something
+      #   elsif x == 1
+      #     do_something_else
+      #   end
+      #
+      #   # good
+      #   if x == 1
+      #     do_something
+      #   elsif x == 2
+      #     do_something_else
+      #   end
+      #
+      class DuplicateElsifCondition < Base
+        MSG = 'Duplicate `elsif` condition detected.'
+
+        def on_if(node)
+          previous = []
+          while node.if? || node.elsif?
+            condition = node.condition
+            add_offense(condition) if previous.include?(condition)
+            previous << condition
+            node = node.else_branch
+            break unless node&.if_type?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -18,7 +18,7 @@ module RuboCop
       #   # good
       #
       #   hash = { food: 'apple', other_food: 'orange' }
-      class DuplicateHashKey < Cop
+      class DuplicateHashKey < Base
         include Duplication
 
         MSG = 'Duplicated key in hash literal.'
@@ -28,9 +28,7 @@ module RuboCop
 
           return unless duplicates?(keys)
 
-          consecutive_duplicates(keys).each do |key|
-            add_offense(key)
-          end
+          consecutive_duplicates(keys).each { |key| add_offense(key) }
         end
       end
     end

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

@@ -49,9 +49,10 @@ module RuboCop
       #   end
       #
       #   alias bar foo
-      class DuplicateMethods < Cop
-        MSG = 'Method `%<method>s` is defined at both %<defined>s and ' \
-              '%<current>s.'
+      class DuplicateMethods < Base
+        MSG = 'Method `%<method>s` is defined at both %<defined>s and %<current>s.'
+
+        RESTRICT_ON_SEND = %i[alias_method attr_reader attr_writer attr_accessor attr].freeze
 
         def initialize(config = nil, options = nil)
           super
@@ -79,6 +80,7 @@ module RuboCop
           end
         end
 
+        # @!method method_alias?(node)
         def_node_matcher :method_alias?, <<~PATTERN
           (alias (sym $_name) sym)
         PATTERN
@@ -91,24 +93,20 @@ module RuboCop
           found_instance_method(node, name)
         end
 
+        # @!method alias_method?(node)
         def_node_matcher :alias_method?, <<~PATTERN
           (send nil? :alias_method (sym $_name) _)
         PATTERN
 
-        def_node_matcher :attr?, <<~PATTERN
-          (send nil? ${:attr_reader :attr_writer :attr_accessor :attr} $...)
-        PATTERN
-
+        # @!method sym_name(node)
         def_node_matcher :sym_name, '(sym $_name)'
-
         def on_send(node)
           if (name = alias_method?(node))
-            return unless name
             return if node.ancestors.any?(&:if_type?)
             return if possible_dsl?(node)
 
             found_instance_method(node, name)
-          elsif (attr = attr?(node))
+          elsif (attr = node.attribute_accessor?)
             on_attr(node, *attr)
           end
         end
@@ -130,7 +128,7 @@ module RuboCop
         end
 
         def message_for_dup(node, method_name)
-          format(MSG, method: method_name, defined: @definitions[method_name],
+          format(MSG, method: method_name, defined: source_location(@definitions[method_name]),
                       current: source_location(node))
         end
 
@@ -154,9 +152,9 @@ module RuboCop
                   end
             message = message_for_dup(node, method_name)
 
-            add_offense(node, location: loc, message: message)
+            add_offense(loc, message: message)
           else
-            @definitions[method_name] = source_location(node)
+            @definitions[method_name] = node
           end
         end
 
@@ -192,9 +190,7 @@ module RuboCop
             namespace, mod_name = *ancestor.defined_module
             loop do
               if mod_name == const_name
-                return qualified_name(ancestor.parent_module_name,
-                                      namespace,
-                                      mod_name)
+                return qualified_name(ancestor.parent_module_name, namespace, mod_name)
               end
 
               break if namespace.nil?

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for duplicate elements in Regexp character classes.
+      #
+      # @example
+      #
+      #   # bad
+      #   r = /[xyx]/
+      #
+      #   # bad
+      #   r = /[0-9x0-9]/
+      #
+      #   # good
+      #   r = /[xy]/
+      #
+      #   # good
+      #   r = /[0-9x]/
+      class DuplicateRegexpCharacterClassElement < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG_REPEATED_ELEMENT = 'Duplicate element inside regexp character class'
+
+        def on_regexp(node)
+          each_repeated_character_class_element_loc(node) do |loc|
+            add_offense(loc, message: MSG_REPEATED_ELEMENT) do |corrector|
+              corrector.remove(loc)
+            end
+          end
+        end
+
+        def each_repeated_character_class_element_loc(node)
+          node.parsed_tree&.each_expression do |expr|
+            next if expr.type != :set || expr.token == :intersection
+
+            seen = Set.new
+
+            expr.expressions.each do |child|
+              next if within_interpolation?(node, child)
+
+              child_source = child.to_s
+
+              yield child.expression if seen.include?(child_source)
+
+              seen << child_source
+            end
+          end
+        end
+
+        private
+
+        # Since we blank interpolations with a space for every char of the interpolation, we would
+        # mark every space (except the first) as duplicate if we do not skip regexp_parser nodes
+        # that are within an interpolation.
+        def within_interpolation?(node, child)
+          parse_tree_child_loc = child.expression
+
+          interpolation_locs(node).any? { |il| il.overlaps?(parse_tree_child_loc) }
+        end
+
+        def interpolation_locs(node)
+          @interpolation_locs ||= {}
+
+          # Cache by loc, not by regexp content, as content can be repeated in multiple patterns
+          key = node.loc
+
+          @interpolation_locs[key] ||= node.children.select(&:begin_type?).map do |interpolation|
+            interpolation.loc.expression
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for duplicate `require`s and `require_relative`s.
+      #
+      # @example
+      #   # bad
+      #   require 'foo'
+      #   require 'bar'
+      #   require 'foo'
+      #
+      #   # good
+      #   require 'foo'
+      #   require 'bar'
+      #
+      #   # good
+      #   require 'foo'
+      #   require_relative 'foo'
+      #
+      class DuplicateRequire < Base
+        MSG = 'Duplicate `%<method>s` detected.'
+        REQUIRE_METHODS = Set.new(%i[require require_relative]).freeze
+        RESTRICT_ON_SEND = REQUIRE_METHODS
+
+        # @!method require_call?(node)
+        def_node_matcher :require_call?, <<~PATTERN
+          (send {nil? (const _ :Kernel)} %REQUIRE_METHODS _)
+        PATTERN
+
+        def on_new_investigation
+          # Holds the known required files for a given parent node (used as key)
+          @required = Hash.new { |h, k| h[k] = Set.new }.compare_by_identity
+          super
+        end
+
+        def on_send(node)
+          return unless require_call?(node)
+          return if @required[node.parent].add?("#{node.method_name}#{node.first_argument}")
+
+          add_offense(node, message: format(MSG, method: node.method_name))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks that there are no repeated exceptions
+      # used in 'rescue' expressions.
+      #
+      # @example
+      #   # bad
+      #   begin
+      #     something
+      #   rescue FirstException
+      #     handle_exception
+      #   rescue FirstException
+      #     handle_other_exception
+      #   end
+      #
+      #   # good
+      #   begin
+      #     something
+      #   rescue FirstException
+      #     handle_exception
+      #   rescue SecondException
+      #     handle_other_exception
+      #   end
+      #
+      class DuplicateRescueException < Base
+        include RescueNode
+
+        MSG = 'Duplicate `rescue` exception detected.'
+
+        def on_rescue(node)
+          return if rescue_modifier?(node)
+
+          node.resbody_branches.each_with_object(Set.new) do |resbody, previous|
+            rescued_exceptions = resbody.exceptions
+
+            rescued_exceptions.each do |exception|
+              add_offense(exception) unless previous.add?(exception)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -21,9 +21,11 @@ module RuboCop
       #
       #   num = 0
       #   sum = numbers.each_with_object(num) { |e, a| a += e }
-      class EachWithObjectArgument < Cop
+      class EachWithObjectArgument < Base
         MSG = 'The argument to each_with_object cannot be immutable.'
+        RESTRICT_ON_SEND = %i[each_with_object].freeze
 
+        # @!method each_with_object?(node)
         def_node_matcher :each_with_object?, <<~PATTERN
           ({send csend} _ :each_with_object $_)
         PATTERN

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

@@ -3,10 +3,14 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for odd else block layout - like
-      # having an expression on the same line as the else keyword,
+      # This cop checks for odd `else` block layout - like
+      # having an expression on the same line as the `else` keyword,
       # which is usually a mistake.
       #
+      # Its auto-correction tweaks layout to keep the syntax. So, this auto-correction
+      # is compatible correction for bad case syntax, but if your code makes a mistake
+      # with `elsif` and `else`, you will have to correct it manually.
+      #
       # @example
       #
       #   # bad
@@ -21,17 +25,29 @@ module RuboCop
       #
       #   # good
       #
+      #   # This code is compatible with the bad case. It will be auto-corrected like this.
       #   if something
       #     # ...
       #   else
       #     do_this
       #     do_that
       #   end
-      class ElseLayout < Cop
+      #
+      #   # This code is incompatible with the bad case.
+      #   # If `do_this` is a condition, `elsif` should be used instead of `else`.
+      #   if something
+      #     # ...
+      #   elsif do_this
+      #     do_that
+      #   end
+      class ElseLayout < Base
+        include RangeHelp
+        extend AutoCorrector
+
         MSG = 'Odd `else` layout detected. Did you mean to use `elsif`?'
 
         def on_if(node)
-          return if node.ternary? || node.elsif?
+          return if node.ternary?
 
           check(node)
         end
@@ -58,7 +74,15 @@ module RuboCop
           return unless first_else
           return unless first_else.source_range.line == node.loc.else.line
 
-          add_offense(first_else)
+          add_offense(first_else) { |corrector| autocorrect(corrector, node, first_else) }
+        end
+
+        def autocorrect(corrector, node, first_else)
+          corrector.insert_after(node.loc.else, "\n")
+
+          blank_range = range_between(node.loc.else.end_pos, first_else.loc.expression.begin_pos)
+          indentation = indent(node.else_branch.children[1])
+          corrector.replace(blank_range, indentation)
         end
       end
     end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for blocks without a body.
+      # Such empty blocks are typically an oversight or we should provide a comment
+      # be clearer what we're aiming for.
+      #
+      # Empty lambdas and procs are ignored by default.
+      #
+      # NOTE: For backwards compatibility, the configuration that allows/disallows
+      # empty lambdas and procs is called `AllowEmptyLambdas`, even though it also
+      # applies to procs.
+      #
+      # @example
+      #   # bad
+      #   items.each { |item| }
+      #
+      #   # good
+      #   items.each { |item| puts item }
+      #
+      # @example AllowComments: true (default)
+      #   # good
+      #   items.each do |item|
+      #     # TODO: implement later (inner comment)
+      #   end
+      #
+      #   items.each { |item| } # TODO: implement later (inline comment)
+      #
+      # @example AllowComments: false
+      #   # bad
+      #   items.each do |item|
+      #     # TODO: implement later (inner comment)
+      #   end
+      #
+      #   items.each { |item| } # TODO: implement later (inline comment)
+      #
+      # @example AllowEmptyLambdas: true (default)
+      #   # good
+      #   allow(subject).to receive(:callable).and_return(-> {})
+      #
+      #   placeholder = lambda do
+      #   end
+      #   (callable || placeholder).call
+      #
+      #   proc { }
+      #
+      #   Proc.new { }
+      #
+      # @example AllowEmptyLambdas: false
+      #   # bad
+      #   allow(subject).to receive(:callable).and_return(-> {})
+      #
+      #   placeholder = lambda do
+      #   end
+      #   (callable || placeholder).call
+      #
+      #   proc { }
+      #
+      #   Proc.new { }
+      #
+      class EmptyBlock < Base
+        MSG = 'Empty block detected.'
+
+        def on_block(node)
+          return if node.body
+          return if allow_empty_lambdas? && lambda_or_proc?(node)
+          return if cop_config['AllowComments'] && allow_comment?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        def allow_comment?(node)
+          return false unless processed_source.contains_comment?(node.source_range)
+
+          line_comment = processed_source.comment_at_line(node.source_range.line)
+          !line_comment || !comment_disables_cop?(line_comment.loc.expression.source)
+        end
+
+        def allow_empty_lambdas?
+          cop_config['AllowEmptyLambdas']
+        end
+
+        def comment_disables_cop?(comment)
+          regexp_pattern = "# rubocop : (disable|todo) ([^,],)* (all|#{cop_name})"
+          Regexp.new(regexp_pattern.gsub(' ', '\s*')).match?(comment)
+        end
+
+        def lambda_or_proc?(node)
+          node.lambda? || node.proc?
+        end
+      end
+    end
+  end
+end