rubocop-grantbirki 1.75.2

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for trailing commas in attribute declarations, such as
+      # `#attr_reader`. Leaving a trailing comma will nullify the next method
+      # definition by overriding it with a getter method.
+      #
+      # @example
+      #
+      #   # bad
+      #   class Foo
+      #     attr_reader :foo,
+      #
+      #     def bar
+      #       puts "Unreachable."
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     attr_reader :foo
+      #
+      #     def bar
+      #       puts "No problem!"
+      #     end
+      #   end
+      #
+      class TrailingCommaInAttributeDeclaration < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Avoid leaving a trailing comma in attribute declarations.'
+
+        def on_send(node)
+          return unless node.attribute_accessor? && node.last_argument.def_type?
+
+          trailing_comma = trailing_comma_range(node)
+
+          add_offense(trailing_comma) { |corrector| corrector.remove(trailing_comma) }
+        end
+
+        private
+
+        def trailing_comma_range(node)
+          range_with_surrounding_space(
+            node.arguments[-2].source_range,
+            side: :right
+          ).end.resize(1)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for "triple quotes" (strings delimited by any odd number
+      # of quotes greater than 1).
+      #
+      # Ruby allows multiple strings to be implicitly concatenated by just
+      # being adjacent in a statement (ie. `"foo""bar" == "foobar"`). This sometimes
+      # gives the impression that there is something special about triple quotes, but
+      # in fact it is just extra unnecessary quotes and produces the same string. Each
+      # pair of quotes produces an additional concatenated empty string, so the result
+      # is still only the "actual" string within the delimiters.
+      #
+      # NOTE: Although this cop is called triple quotes, the same behavior is present
+      # for strings delimited by 5, 7, etc. quotation marks.
+      #
+      # @example
+      #   # bad
+      #   """
+      #     A string
+      #   """
+      #
+      #   # bad
+      #   '''
+      #     A string
+      #   '''
+      #
+      #   # good
+      #   "
+      #     A string
+      #   "
+      #
+      #   # good
+      #   <<STRING
+      #     A string
+      #   STRING
+      #
+      #   # good (but not the same spacing as the bad case)
+      #   'A string'
+      class TripleQuotes < Base
+        extend AutoCorrector
+
+        MSG = 'Delimiting a string with multiple quotes has no effect, use a single quote instead.'
+
+        def on_dstr(node)
+          return if (empty_str_nodes = empty_str_nodes(node)).none?
+
+          opening_quotes = node.source.scan(/(?<=\A)['"]*/)[0]
+          return if opening_quotes.size < 3
+
+          # If the node is composed of only empty `str` nodes, keep one
+          empty_str_nodes.shift if empty_str_nodes.size == node.child_nodes.size
+
+          add_offense(node) do |corrector|
+            empty_str_nodes.each do |str|
+              corrector.remove(str)
+            end
+          end
+        end
+
+        private
+
+        def empty_str_nodes(node)
+          node.each_child_node(:str).select { |str| str.value == '' }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for underscore-prefixed variables that are actually
+      # used.
+      #
+      # Since block keyword arguments cannot be arbitrarily named at call
+      # sites, the `AllowKeywordBlockArguments` will allow use of underscore-
+      # prefixed block keyword arguments.
+      #
+      # @example AllowKeywordBlockArguments: false (default)
+      #
+      #   # bad
+      #
+      #   [1, 2, 3].each do |_num|
+      #     do_something(_num)
+      #   end
+      #
+      #   query(:sales) do |_id:, revenue:, cost:|
+      #     {_id: _id, profit: revenue - cost}
+      #   end
+      #
+      #   # good
+      #
+      #   [1, 2, 3].each do |num|
+      #     do_something(num)
+      #   end
+      #
+      #   [1, 2, 3].each do |_num|
+      #     do_something # not using `_num`
+      #   end
+      #
+      # @example AllowKeywordBlockArguments: true
+      #
+      #   # good
+      #
+      #   query(:sales) do |_id:, revenue:, cost:|
+      #     {_id: _id, profit: revenue - cost}
+      #   end
+      #
+      class UnderscorePrefixedVariableName < Base
+        MSG = 'Do not use prefix `_` for a variable that is used.'
+
+        def self.joining_forces
+          VariableForce
+        end
+
+        def after_leaving_scope(scope, _variable_table)
+          scope.variables.each_value { |variable| check_variable(variable) }
+        end
+
+        def check_variable(variable)
+          return unless variable.should_be_unused?
+          return if variable.references.none?(&:explicit?)
+          return if allowed_keyword_block_argument?(variable)
+
+          node = variable.declaration_node
+
+          location = if node.match_with_lvasgn_type?
+                       node.children.first.source_range
+                     else
+                       node.loc.name
+                     end
+
+          add_offense(location)
+        end
+
+        private
+
+        def allowed_keyword_block_argument?(variable)
+          variable.block_argument? &&
+            variable.keyword_argument? &&
+            cop_config['AllowKeywordBlockArguments']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for Regexpes (both literals and via `Regexp.new` / `Regexp.compile`)
+      # that contain unescaped `]` characters.
+      #
+      # It emulates the following Ruby warning:
+      #
+      # [source,ruby]
+      # ----
+      # $ ruby -e '/abc]123/'
+      # -e:1: warning: regular expression has ']' without escape: /abc]123/
+      # ----
+      #
+      # @example
+      #   # bad
+      #   /abc]123/
+      #   %r{abc]123}
+      #   Regexp.new('abc]123')
+      #   Regexp.compile('abc]123')
+      #
+      #   # good
+      #   /abc\]123/
+      #   %r{abc\]123}
+      #   Regexp.new('abc\]123')
+      #   Regexp.compile('abc\]123')
+      #
+      class UnescapedBracketInRegexp < Base
+        extend AutoCorrector
+
+        MSG = 'Regular expression has `]` without escape.'
+        RESTRICT_ON_SEND = %i[new compile].freeze
+
+        # @!method regexp_constructor(node)
+        def_node_search :regexp_constructor, <<~PATTERN
+          (send
+            (const {nil? cbase} :Regexp) {:new :compile}
+            $str
+            ...
+          )
+        PATTERN
+
+        def on_regexp(node)
+          RuboCop::Util.silence_warnings do
+            node.parsed_tree&.each_expression do |expr|
+              detect_offenses(node, expr)
+            end
+          end
+        end
+
+        def on_send(node)
+          # Ignore nodes that contain interpolation
+          return if node.each_descendant(:dstr).any?
+
+          regexp_constructor(node) do |text|
+            parse_regexp(text.value)&.each_expression do |expr|
+              detect_offenses(text, expr)
+            end
+          end
+        end
+
+        private
+
+        def detect_offenses(node, expr)
+          return unless expr.type?(:literal)
+
+          expr.text.scan(/(?<!\\)\]/) do
+            pos = Regexp.last_match.begin(0)
+            next if pos.zero? # if the unescaped bracket is the first character, Ruby does not warn
+
+            location = range_at_index(node, expr.ts, pos)
+
+            add_offense(location) do |corrector|
+              corrector.replace(location, '\]')
+            end
+          end
+        end
+
+        def range_at_index(node, index, offset)
+          adjustment = index + offset
+          node.loc.begin.end.adjust(begin_pos: adjustment, end_pos: adjustment + 1)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for a block that is known to need more positional
+      # block arguments than are given (by default this is configured for
+      # `Enumerable` methods needing 2 arguments). Optional arguments are allowed,
+      # although they don't generally make sense as the default value will
+      # be used. Blocks that have no receiver, or take splatted arguments
+      # (ie. `*args`) are always accepted.
+      #
+      # Keyword arguments (including `**kwargs`) do not get counted towards
+      # this, as they are not used by the methods in question.
+      #
+      # Method names and their expected arity can be configured like this:
+      #
+      # [source,yaml]
+      # ----
+      # Methods:
+      #   inject: 2
+      #   reduce: 2
+      # ----
+      #
+      # @safety
+      #  This cop matches for method names only and hence cannot tell apart
+      #  methods with same name in different classes, which may lead to a
+      #  false positive.
+      #
+      # @example
+      #   # bad
+      #   values.reduce {}
+      #   values.min { |a| a }
+      #   values.sort { |a; b| a + b }
+      #
+      #   # good
+      #   values.reduce { |memo, obj| memo << obj }
+      #   values.min { |a, b| a <=> b }
+      #   values.sort { |*x| x[0] <=> x[1] }
+      #
+      class UnexpectedBlockArity < Base
+        MSG = '`%<method>s` expects at least %<expected>i positional arguments, got %<actual>i.'
+
+        def on_block(node)
+          return if acceptable?(node)
+
+          expected = expected_arity(node.method_name)
+          actual = arg_count(node)
+          return if actual >= expected
+
+          message = format(MSG, method: node.method_name, expected: expected, actual: actual)
+          add_offense(node, message: message)
+        end
+
+        alias on_numblock on_block
+        alias on_itblock on_block
+
+        private
+
+        def methods
+          cop_config.fetch('Methods', [])
+        end
+
+        def acceptable?(node)
+          !(included_method?(node.method_name) && node.receiver)
+        end
+
+        def included_method?(name)
+          methods.key?(name.to_s)
+        end
+
+        def expected_arity(method)
+          cop_config['Methods'][method.to_s]
+        end
+
+        def arg_count(node)
+          return node.children[1] if node.numblock_type? # the maximum numbered param for the block
+          return 1 if node.itblock_type? # `it` block parameter is always one
+
+          # Only `arg`, `optarg` and `mlhs` (destructuring) count as arguments that
+          # can be used. Keyword arguments are not used for these methods so are
+          # ignored.
+          node.arguments.count do |arg|
+            return Float::INFINITY if arg.restarg_type?
+
+            arg.type?(:arg, :optarg, :mlhs)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for using Fixnum or Bignum constant.
+      #
+      # @example
+      #
+      #   # bad
+      #   1.is_a?(Fixnum)
+      #   1.is_a?(Bignum)
+      #
+      #   # good
+      #   1.is_a?(Integer)
+      class UnifiedInteger < Base
+        extend AutoCorrector
+
+        MSG = 'Use `Integer` instead of `%<klass>s`.'
+
+        # @!method fixnum_or_bignum_const(node)
+        def_node_matcher :fixnum_or_bignum_const, <<~PATTERN
+          (:const {nil? (:cbase)} ${:Fixnum :Bignum})
+        PATTERN
+
+        def on_const(node)
+          klass = fixnum_or_bignum_const(node)
+
+          return unless klass
+
+          add_offense(node, message: format(MSG, klass: klass)) do |corrector|
+            next if target_ruby_version <= 2.3
+
+            corrector.replace(node.loc.name, 'Integer')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Looks for `reduce` or `inject` blocks where the value returned (implicitly or
+      # explicitly) does not include the accumulator. A block is considered valid as
+      # long as at least one return value includes the accumulator.
+      #
+      # If the accumulator is not included in the return value, then the entire
+      # block will just return a transformation of the last element value, and
+      # could be rewritten as such without a loop.
+      #
+      # Also catches instances where an index of the accumulator is returned, as
+      # this may change the type of object being retained.
+      #
+      # NOTE: For the purpose of reducing false positives, this cop only flags
+      # returns in `reduce` blocks where the element is the only variable in
+      # the expression (since we will not be able to tell what other variables
+      # relate to via static analysis).
+      #
+      # @example
+      #
+      #   # bad
+      #   (1..4).reduce(0) do |acc, el|
+      #     el * 2
+      #   end
+      #
+      #   # bad, may raise a NoMethodError after the first iteration
+      #   %w(a b c).reduce({}) do |acc, letter|
+      #     acc[letter] = true
+      #   end
+      #
+      #   # good
+      #   (1..4).reduce(0) do |acc, el|
+      #     acc + el * 2
+      #   end
+      #
+      #   # good, element is returned but modified using the accumulator
+      #   values.reduce do |acc, el|
+      #     el << acc
+      #     el
+      #   end
+      #
+      #   # good, returns the accumulator instead of the index
+      #   %w(a b c).reduce({}) do |acc, letter|
+      #     acc[letter] = true
+      #     acc
+      #   end
+      #
+      #   # good, at least one branch returns the accumulator
+      #   values.reduce(nil) do |result, value|
+      #     break result if something?
+      #     value
+      #   end
+      #
+      #   # good, recursive
+      #   keys.reduce(self) { |result, key| result[key] }
+      #
+      #   # ignored as the return value cannot be determined
+      #   enum.reduce do |acc, el|
+      #     x = foo(acc, el)
+      #     bar(x)
+      #   end
+      class UnmodifiedReduceAccumulator < Base
+        MSG = 'Ensure the accumulator `%<accum>s` will be modified by `%<method>s`.'
+        MSG_INDEX = 'Do not return an element of the accumulator in `%<method>s`.'
+
+        # @!method reduce_with_block?(node)
+        def_node_matcher :reduce_with_block?, <<~PATTERN
+          {
+            (block (call _recv {:reduce :inject} ...) args ...)
+            (numblock (call _recv {:reduce :inject} ...) ...)
+          }
+        PATTERN
+
+        # @!method accumulator_index?(node, accumulator_name)
+        def_node_matcher :accumulator_index?, <<~PATTERN
+          (send (lvar %1) {:[] :[]=} ...)
+        PATTERN
+
+        # @!method element_modified?(node, element_name)
+        def_node_search :element_modified?, <<~PATTERN
+          {
+            (send _receiver !{:[] :[]=} <`(lvar %1) `_ ...>)               # method(el, ...)
+            (send (lvar %1) _message <{ivar gvar cvar lvar send} ...>)     # el.method(...)
+            (lvasgn %1 _)                                                  # el = ...
+            (%RuboCop::AST::Node::SHORTHAND_ASSIGNMENTS (lvasgn %1) ... _) # el += ...
+          }
+        PATTERN
+
+        # @!method lvar_used?(node, name)
+        def_node_matcher :lvar_used?, <<~PATTERN
+          {
+            (lvar %1)
+            (lvasgn %1 ...)
+            (send (lvar %1) :<< ...)
+            (dstr (begin (lvar %1)))
+            (%RuboCop::AST::Node::SHORTHAND_ASSIGNMENTS (lvasgn %1))
+          }
+        PATTERN
+
+        # @!method expression_values(node)
+        def_node_search :expression_values, <<~PATTERN
+          {
+            (%RuboCop::AST::Node::VARIABLES $_)
+            (%RuboCop::AST::Node::EQUALS_ASSIGNMENTS $_ ...)
+            (send (%RuboCop::AST::Node::VARIABLES $_) :<< ...)
+            $(send _ _)
+            (dstr (begin {(%RuboCop::AST::Node::VARIABLES $_)}))
+            (%RuboCop::AST::Node::SHORTHAND_ASSIGNMENTS (%RuboCop::AST::Node::EQUALS_ASSIGNMENTS $_) ...)
+          }
+        PATTERN
+
+        def on_block(node)
+          return unless node.body
+          return unless reduce_with_block?(node)
+          return unless node.argument_list.length >= 2
+
+          check_return_values(node)
+        end
+        alias on_numblock on_block
+
+        private
+
+        # Return values in a block are either the value given to next,
+        # the last line of a multiline block, or the only line of the block
+        def return_values(block_body_node)
+          nodes = [block_body_node.begin_type? ? block_body_node.child_nodes.last : block_body_node]
+
+          block_body_node.each_descendant(:next, :break) do |n|
+            # Ignore `next`/`break` inside an inner block
+            next if n.each_ancestor(:any_block).first != block_body_node.parent
+            next unless n.first_argument
+
+            nodes << n.first_argument
+          end
+
+          nodes
+        end
+
+        def check_return_values(block_node)
+          return_values = return_values(block_node.body)
+          accumulator_name = block_arg_name(block_node, 0)
+          element_name = block_arg_name(block_node, 1)
+          message_opts = { method: block_node.method_name, accum: accumulator_name }
+
+          if (node = returned_accumulator_index(return_values, accumulator_name, element_name))
+            add_offense(node, message: format(MSG_INDEX, message_opts))
+          elsif potential_offense?(return_values, block_node.body, element_name, accumulator_name)
+            return_values.each do |return_val|
+              unless acceptable_return?(return_val, element_name)
+                add_offense(return_val, message: format(MSG, message_opts))
+              end
+            end
+          end
+        end
+
+        def block_arg_name(node, index)
+          node.argument_list[index].name
+        end
+
+        # Look for an index of the accumulator being returned, except where the index
+        # is the element.
+        # This is always an offense, in order to try to catch potential exceptions
+        # due to type mismatches
+        def returned_accumulator_index(return_values, accumulator_name, element_name)
+          return_values.detect do |val|
+            next unless accumulator_index?(val, accumulator_name)
+            next true if val.method?(:[]=)
+
+            val.arguments.none? { |arg| lvar_used?(arg, element_name) }
+          end
+        end
+
+        def potential_offense?(return_values, block_body, element_name, accumulator_name)
+          !(element_modified?(block_body, element_name) ||
+            returns_accumulator_anywhere?(return_values, accumulator_name))
+        end
+
+        # If the accumulator is used in any return value, the node is acceptable since
+        # the accumulator has a chance to change each iteration
+        def returns_accumulator_anywhere?(return_values, accumulator_name)
+          return_values.any? { |node| lvar_used?(node, accumulator_name) }
+        end
+
+        # Determine if a return value is acceptable for the purposes of this cop
+        # If it is an expression containing the accumulator, it is acceptable
+        # Otherwise, it is only unacceptable if it contains the iterated element, since we
+        # otherwise do not have enough information to prevent false positives.
+        def acceptable_return?(return_val, element_name)
+          vars = expression_values(return_val).uniq
+          return true if vars.none? || (vars - [element_name]).any?
+
+          false
+        end
+
+        # Exclude `begin` nodes inside a `dstr` from being collected by `return_values`
+        def allowed_type?(parent_node)
+          !parent_node.dstr_type?
+        end
+      end
+    end
+  end
+end