rubocop-grantbirki 1.75.2

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # 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/duplicate_set_element.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for duplicate literal, constant, or variable elements in `Set` and `SortedSet`.
+      #
+      # @example
+      #
+      #   # bad
+      #   Set[:foo, :bar, :foo]
+      #
+      #   # good
+      #   Set[:foo, :bar]
+      #
+      #   # bad
+      #   Set.new([:foo, :bar, :foo])
+      #
+      #   # good
+      #   Set.new([:foo, :bar])
+      #
+      #   # bad
+      #   [:foo, :bar, :foo].to_set
+      #
+      #   # good
+      #   [:foo, :bar].to_set
+      #
+      #   # bad
+      #   SortedSet[:foo, :bar, :foo]
+      #
+      #   # good
+      #   SortedSet[:foo, :bar]
+      #
+      #   # bad
+      #   SortedSet.new([:foo, :bar, :foo])
+      #
+      #   # good
+      #   SortedSet.new([:foo, :bar])
+      class DuplicateSetElement < Base
+        extend AutoCorrector
+
+        MSG = 'Remove the duplicate element in %<class_name>s.'
+        RESTRICT_ON_SEND = %i[\[\] new to_set].freeze
+
+        # @!method set_init_elements(node)
+        def_node_matcher :set_init_elements, <<~PATTERN
+          {
+            (send (const {nil? cbase} {:Set :SortedSet}) :[] $...)
+            (send (const {nil? cbase} {:Set :SortedSet}) :new (array $...))
+            (call (array $...) :to_set)
+          }
+        PATTERN
+
+        def on_send(node)
+          return unless (set_elements = set_init_elements(node))
+
+          seen_elements = Set[]
+
+          set_elements.each_with_index do |set_element, index|
+            # NOTE: Skip due to the possibility of corner cases where Set elements
+            # may have changing return values if they are not literals, constants, or variables.
+            next if !set_element.literal? && !set_element.const_type? && !set_element.variable?
+
+            if seen_elements.include?(set_element)
+              register_offense(set_element, set_elements[index - 1], node)
+            else
+              seen_elements << set_element
+            end
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def register_offense(current_element, prev_element, node)
+          class_name = node.receiver.const_type? ? node.receiver.const_name : 'Set'
+
+          add_offense(current_element, message: format(MSG, class_name: class_name)) do |corrector|
+            range = prev_element.source_range.end.join(current_element.source_range.end)
+
+            corrector.remove(range)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks if each_with_object is called with an immutable
+      # argument. Since the argument is the object that the given block shall
+      # make calls on to build something based on the enumerable that
+      # each_with_object iterates over, an immutable argument makes no sense.
+      # It's definitely a bug.
+      #
+      # @example
+      #
+      #   # bad
+      #   sum = numbers.each_with_object(0) { |e, a| a += e }
+      #
+      #   # good
+      #   num = 0
+      #   sum = numbers.each_with_object(num) { |e, a| a += e }
+      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
+          (call _ :each_with_object $_)
+        PATTERN
+
+        def on_send(node)
+          each_with_object?(node) do |arg|
+            return unless arg.immutable_literal?
+
+            add_offense(node)
+          end
+        end
+        alias on_csend on_send
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for odd `else` block layout - like
+      # having an expression on the same line as the `else` keyword,
+      # which is usually a mistake.
+      #
+      # Its autocorrection tweaks layout to keep the syntax. So, this autocorrection
+      # 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
+      #
+      #   if something
+      #     # ...
+      #   else do_this
+      #     do_that
+      #   end
+      #
+      #   # good
+      #
+      #   # This code is compatible with the bad case. It will be autocorrected like this.
+      #   if something
+      #     # ...
+      #   else
+      #     do_this
+      #     do_that
+      #   end
+      #
+      #   # 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 Alignment
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Odd `else` layout detected. Did you mean to use `elsif`?'
+
+        def on_if(node)
+          return if node.ternary?
+
+          # If the if is on a single line, it'll be handled by `Style/OneLineConditional`
+          return if node.single_line?
+
+          check(node)
+        end
+
+        private
+
+        def check(node)
+          return unless node.else_branch
+
+          if node.else? && node.loc.else.is?('else')
+            check_else(node)
+          elsif node.if?
+            check(node.else_branch)
+          end
+        end
+
+        def check_else(node)
+          else_branch = node.else_branch
+          first_else = else_branch.begin_type? ? else_branch.children.first : else_branch
+
+          return unless first_else
+          return unless same_line?(first_else, node.loc.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.source_range.begin_pos)
+          corrector.replace(blank_range, indentation(node))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for blocks without a body.
+      # Such empty blocks are typically an oversight or we should provide a comment
+      # to clarify 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) # rubocop:disable InternalAffairs/NumblockHandler
+          return if node.body
+          return if allow_empty_lambdas? && node.lambda_or_proc?
+          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.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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for classes and metaclasses without a body.
+      # Such empty classes and metaclasses are typically an oversight or we should provide a comment
+      # to be clearer what we're aiming for.
+      #
+      # @example
+      #   # bad
+      #   class Foo
+      #   end
+      #
+      #   class Bar
+      #     class << self
+      #     end
+      #   end
+      #
+      #   class << obj
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     def do_something
+      #       # ... code
+      #     end
+      #   end
+      #
+      #   class Bar
+      #     class << self
+      #       attr_reader :bar
+      #     end
+      #   end
+      #
+      #   class << obj
+      #     attr_reader :bar
+      #   end
+      #
+      # @example AllowComments: false (default)
+      #   # bad
+      #   class Foo
+      #     # TODO: implement later
+      #   end
+      #
+      #   class Bar
+      #     class << self
+      #       # TODO: implement later
+      #     end
+      #   end
+      #
+      #   class << obj
+      #     # TODO: implement later
+      #   end
+      #
+      # @example AllowComments: true
+      #   # good
+      #   class Foo
+      #     # TODO: implement later
+      #   end
+      #
+      #   class Bar
+      #     class << self
+      #       # TODO: implement later
+      #     end
+      #   end
+      #
+      #   class << obj
+      #     # TODO: implement later
+      #   end
+      #
+      class EmptyClass < Base
+        CLASS_MSG = 'Empty class detected.'
+        METACLASS_MSG = 'Empty metaclass detected.'
+
+        def on_class(node)
+          add_offense(node, message: CLASS_MSG) unless body_or_allowed_comment_lines?(node) ||
+                                                       node.parent_class
+        end
+
+        def on_sclass(node)
+          add_offense(node, message: METACLASS_MSG) unless body_or_allowed_comment_lines?(node)
+        end
+
+        private
+
+        def body_or_allowed_comment_lines?(node)
+          return true if node.body
+
+          cop_config['AllowComments'] && processed_source.contains_comment?(node.source_range)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for the presence of `if`, `elsif` and `unless` branches without a body.
+      #
+      # NOTE: empty `else` branches are handled by `Style/EmptyElse`.
+      #
+      # @example
+      #   # bad
+      #   if condition
+      #   end
+      #
+      #   # bad
+      #   unless condition
+      #   end
+      #
+      #   # bad
+      #   if condition
+      #     do_something
+      #   elsif other_condition
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   unless condition
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     do_something
+      #   elsif other_condition
+      #     nil
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     do_something
+      #   elsif other_condition
+      #     do_something_else
+      #   end
+      #
+      # @example AllowComments: true (default)
+      #   # good
+      #   if condition
+      #     do_something
+      #   elsif other_condition
+      #     # noop
+      #   end
+      #
+      # @example AllowComments: false
+      #   # bad
+      #   if condition
+      #     do_something
+      #   elsif other_condition
+      #     # noop
+      #   end
+      #
+      class EmptyConditionalBody < Base
+        extend AutoCorrector
+        include CommentsHelp
+
+        MSG = 'Avoid `%<keyword>s` branches without a body.'
+
+        def on_if(node)
+          return if node.body || same_line?(node.loc.begin, node.loc.end)
+          return if cop_config['AllowComments'] && contains_comments?(node)
+
+          range = offense_range(node)
+
+          add_offense(range, message: format(MSG, keyword: node.keyword)) do |corrector|
+            next unless can_simplify_conditional?(node)
+
+            flip_orphaned_else(corrector, node)
+          end
+        end
+
+        private
+
+        def offense_range(node)
+          if node.loc.else
+            node.source_range.begin.join(node.loc.else.begin)
+          else
+            node.source_range
+          end
+        end
+
+        def can_simplify_conditional?(node)
+          node.else_branch && node.loc.else.source == 'else'
+        end
+
+        def remove_empty_branch(corrector, node)
+          range = if empty_if_branch?(node) && else_branch?(node)
+                    branch_range(node)
+                  else
+                    deletion_range(branch_range(node))
+                  end
+
+          corrector.remove(range)
+        end
+
+        def flip_orphaned_else(corrector, node)
+          corrector.replace(node.loc.else, "#{node.inverse_keyword} #{node.condition.source}")
+          remove_empty_branch(corrector, node)
+        end
+
+        def empty_if_branch?(node)
+          return false unless (parent = node.parent)
+          return true unless parent.if_type?
+          return true unless (if_branch = parent.if_branch)
+
+          if_branch.if_type? && !if_branch.body
+        end
+
+        def else_branch?(node)
+          node.else_branch && !node.else_branch.if_type?
+        end
+
+        def branch_range(node)
+          if empty_if_branch?(node) && else_branch?(node)
+            node.source_range.with(end_pos: node.loc.else.begin_pos)
+          elsif node.loc.else
+            node.source_range.with(end_pos: node.condition.source_range.end_pos)
+          end
+        end
+
+        def deletion_range(range)
+          # Collect a range between the start of the `if` node and the next relevant node,
+          # including final new line.
+          # Based on `RangeHelp#range_by_whole_lines` but allows the `if` to not start
+          # on the first column.
+          buffer = @processed_source.buffer
+
+          last_line = buffer.source_line(range.last_line)
+          end_offset = last_line.length - range.last_column + 1
+
+          range.adjust(end_pos: end_offset).intersect(buffer.source_range)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for empty `ensure` blocks.
+      #
+      # @example
+      #
+      #   # bad
+      #   def some_method
+      #     do_something
+      #   ensure
+      #   end
+      #
+      #   # bad
+      #   begin
+      #     do_something
+      #   ensure
+      #   end
+      #
+      #   # good
+      #   def some_method
+      #     do_something
+      #   ensure
+      #     do_something_else
+      #   end
+      #
+      #   # good
+      #   begin
+      #     do_something
+      #   ensure
+      #     do_something_else
+      #   end
+      class EmptyEnsure < Base
+        extend AutoCorrector
+
+        MSG = 'Empty `ensure` block detected.'
+
+        def on_ensure(node)
+          return if node.branch
+
+          add_offense(node.loc.keyword) { |corrector| corrector.remove(node.loc.keyword) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for the presence of empty expressions.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   foo = ()
+      #   if ()
+      #     bar
+      #   end
+      #
+      #   # good
+      #
+      #   foo = (some_expression)
+      #   if (some_expression)
+      #     bar
+      #   end
+      class EmptyExpression < Base
+        MSG = 'Avoid empty expressions.'
+
+        def on_begin(node)
+          return unless empty_expression?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        def empty_expression?(begin_node)
+          begin_node.children.empty?
+        end
+      end
+    end
+  end
+end