rubocop-grantbirki 1.75.2

data/lib/rubocop/cop/mixin/uncommunicative_name.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality shared by Uncommunicative cops
+    module UncommunicativeName
+      CASE_MSG = 'Only use lowercase characters for %<name_type>s.'
+      NUM_MSG = 'Do not end %<name_type>s with a number.'
+      LENGTH_MSG = '%<name_type>s must be at least %<min>s characters long.'
+      FORBIDDEN_MSG = 'Do not use %<name>s as a name for a %<name_type>s.'
+
+      def check(node, args)
+        args.each do |arg|
+          # Argument names might be "_" or prefixed with "_" to indicate they
+          # are unused. Trim away this prefix and only analyse the basename.
+          name_child = arg.children.first
+          next if name_child.nil?
+
+          full_name = name_child.to_s
+          next if full_name == '_'
+
+          name = full_name.gsub(/\A(_+)/, '')
+          next if allowed_names.include?(name)
+
+          length = full_name.size
+          length += 1 if arg.restarg_type?
+          length += 2 if arg.kwrestarg_type?
+
+          range = arg_range(arg, length)
+          issue_offenses(node, range, name)
+        end
+      end
+
+      private
+
+      def issue_offenses(node, range, name)
+        forbidden_offense(node, range, name) if forbidden_names.include?(name)
+        case_offense(node, range) if uppercase?(name)
+        length_offense(node, range) unless long_enough?(name)
+        return if allow_nums
+
+        num_offense(node, range) if ends_with_num?(name)
+      end
+
+      def case_offense(node, range)
+        add_offense(range, message: format(CASE_MSG, name_type: name_type(node)))
+      end
+
+      def uppercase?(name)
+        /[[:upper:]]/.match?(name)
+      end
+
+      def name_type(node)
+        @name_type ||= case node.type
+                       when :block then 'block parameter'
+                       when :def, :defs then 'method parameter'
+                       end
+      end
+
+      def num_offense(node, range)
+        add_offense(range, message: format(NUM_MSG, name_type: name_type(node)))
+      end
+
+      def ends_with_num?(name)
+        /\d/.match?(name[-1])
+      end
+
+      def length_offense(node, range)
+        message = format(LENGTH_MSG, name_type: name_type(node).capitalize, min: min_length)
+
+        add_offense(range, message: message)
+      end
+
+      def long_enough?(name)
+        name.size >= min_length
+      end
+
+      def arg_range(arg, length)
+        begin_pos = arg.source_range.begin_pos
+        Parser::Source::Range.new(processed_source.buffer, begin_pos, begin_pos + length)
+      end
+
+      def forbidden_offense(node, range, name)
+        add_offense(range, message: format(FORBIDDEN_MSG, name: name, name_type: name_type(node)))
+      end
+
+      def allowed_names
+        cop_config['AllowedNames']
+      end
+
+      def forbidden_names
+        cop_config['ForbiddenNames']
+      end
+
+      def allow_nums
+        cop_config['AllowNamesEndingInNumbers']
+      end
+
+      def min_length
+        cop_config['MinNameLength']
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/unused_argument.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Common functionality for cops handling unused arguments.
+      module UnusedArgument
+        extend NodePattern::Macros
+
+        def after_leaving_scope(scope, _variable_table)
+          scope.variables.each_value { |variable| check_argument(variable) }
+        end
+
+        private
+
+        def check_argument(variable)
+          return if variable.should_be_unused?
+          return if variable.referenced?
+
+          message = message(variable)
+
+          add_offense(variable.declaration_node.loc.name, message: message) do |corrector|
+            autocorrect(corrector, variable.declaration_node)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/visibility_help.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module RuboCop
+  module Cop
+    # Help methods for determining node visibility.
+    module VisibilityHelp
+      extend NodePattern::Macros
+
+      VISIBILITY_SCOPES = ::Set[:private, :protected, :public].freeze
+
+      private
+
+      def node_visibility(node)
+        node_visibility_from_visibility_inline(node) ||
+          node_visibility_from_visibility_block(node) ||
+          :public
+      end
+
+      def node_visibility_from_visibility_inline(node)
+        return unless node.def_type?
+
+        node_visibility_from_visibility_inline_on_def(node) ||
+          node_visibility_from_visibility_inline_on_method_name(node)
+      end
+
+      def node_visibility_from_visibility_inline_on_def(node)
+        parent = node.parent
+        parent.method_name if visibility_inline_on_def?(parent)
+      end
+
+      def node_visibility_from_visibility_inline_on_method_name(node)
+        node.right_siblings.reverse.find do |sibling|
+          visibility_inline_on_method_name?(sibling, method_name: node.method_name)
+        end&.method_name
+      end
+
+      def node_visibility_from_visibility_block(node)
+        find_visibility_start(node)&.method_name
+      end
+
+      def find_visibility_start(node)
+        node.left_siblings.reverse.find { |sibling| visibility_block?(sibling) }
+      end
+
+      # Navigate to find the last protected method
+      def find_visibility_end(node)
+        possible_visibilities = VISIBILITY_SCOPES - ::Set[node_visibility(node)]
+        right = node.right_siblings
+        right.find do |child_node|
+          possible_visibilities.include?(node_visibility(child_node))
+        end || right.last
+      end
+
+      # @!method visibility_block?(node)
+      def_node_matcher :visibility_block?, <<~PATTERN
+        (send nil? VISIBILITY_SCOPES)
+      PATTERN
+
+      # @!method visibility_inline_on_def?(node)
+      def_node_matcher :visibility_inline_on_def?, <<~PATTERN
+        (send nil? VISIBILITY_SCOPES def)
+      PATTERN
+
+      # @!method visibility_inline_on_method_name?(node, method_name:)
+      def_node_matcher :visibility_inline_on_method_name?, <<~PATTERN
+        (send nil? VISIBILITY_SCOPES (sym %method_name))
+      PATTERN
+    end
+  end
+end

data/lib/rubocop/cop/naming/accessor_method_name.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # Avoid prefixing accessor method names with `get_` or `set_`.
+      # Applies to both instance and class methods.
+      #
+      # NOTE: Method names starting with `get_` or `set_` only register an offense
+      # when the methods match the expected arity for getters and setters respectively.
+      # Getters (`get_attribute`) must have no arguments to be registered,
+      # and setters (`set_attribute(value)`) must have exactly one.
+      #
+      # @example
+      #   # bad
+      #   def set_attribute(value)
+      #   end
+      #
+      #   # good
+      #   def attribute=(value)
+      #   end
+      #
+      #   # bad
+      #   def get_attribute
+      #   end
+      #
+      #   # good
+      #   def attribute
+      #   end
+      #
+      #   # accepted, incorrect arity for getter
+      #   def get_value(attr)
+      #   end
+      #
+      #   # accepted, incorrect arity for setter
+      #   def set_value
+      #   end
+      class AccessorMethodName < Base
+        MSG_READER = 'Do not prefix reader method names with `get_`.'
+        MSG_WRITER = 'Do not prefix writer method names with `set_`.'
+
+        def on_def(node)
+          return unless proper_attribute_name?(node)
+          return unless bad_reader_name?(node) || bad_writer_name?(node)
+
+          message = message(node)
+
+          add_offense(node.loc.name, message: message)
+        end
+        alias on_defs on_def
+
+        private
+
+        def message(node)
+          if bad_reader_name?(node)
+            MSG_READER
+          elsif bad_writer_name?(node)
+            MSG_WRITER
+          end
+        end
+
+        def proper_attribute_name?(node)
+          !node.method_name.to_s.end_with?('!', '?', '=')
+        end
+
+        def bad_reader_name?(node)
+          node.method_name.to_s.start_with?('get_') && !node.arguments?
+        end
+
+        def bad_writer_name?(node)
+          node.method_name.to_s.start_with?('set_') &&
+            node.arguments.one? &&
+            node.first_argument.arg_type?
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/naming/ascii_identifiers.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # Checks for non-ascii characters in identifier and constant names.
+      # Identifiers are always checked and whether constants are checked
+      # can be controlled using AsciiConstants config.
+      #
+      # @example
+      #   # bad
+      #   def καλημερα # Greek alphabet (non-ascii)
+      #   end
+      #
+      #   # bad
+      #   def こんにちはと言う # Japanese character (non-ascii)
+      #   end
+      #
+      #   # bad
+      #   def hello_🍣 # Emoji (non-ascii)
+      #   end
+      #
+      #   # good
+      #   def say_hello
+      #   end
+      #
+      #   # bad
+      #   신장 = 10 # Hangul character (non-ascii)
+      #
+      #   # good
+      #   height = 10
+      #
+      #   # bad
+      #   params[:عرض_gteq] # Arabic character (non-ascii)
+      #
+      #   # good
+      #   params[:width_gteq]
+      #
+      # @example AsciiConstants: true (default)
+      #   # bad
+      #   class Foö
+      #   end
+      #
+      #   FOÖ = "foo"
+      #
+      # @example AsciiConstants: false
+      #   # good
+      #   class Foö
+      #   end
+      #
+      #   FOÖ = "foo"
+      #
+      class AsciiIdentifiers < Base
+        include RangeHelp
+
+        IDENTIFIER_MSG = 'Use only ascii symbols in identifiers.'
+        CONSTANT_MSG   = 'Use only ascii symbols in constants.'
+
+        def on_new_investigation
+          processed_source.tokens.each do |token|
+            next if !should_check?(token) || token.text.ascii_only?
+
+            message = token.type == :tIDENTIFIER ? IDENTIFIER_MSG : CONSTANT_MSG
+            add_offense(first_offense_range(token), message: message)
+          end
+        end
+
+        private
+
+        def should_check?(token)
+          token.type == :tIDENTIFIER || (token.type == :tCONSTANT && cop_config['AsciiConstants'])
+        end
+
+        def first_offense_range(identifier)
+          expression    = identifier.pos
+          first_offense = first_non_ascii_chars(identifier.text)
+
+          start_position = expression.begin_pos + identifier.text.index(first_offense)
+          end_position   = start_position + first_offense.length
+
+          range_between(start_position, end_position)
+        end
+
+        def first_non_ascii_chars(string)
+          string.match(/[^[:ascii:]]+/).to_s
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/naming/binary_operator_parameter_name.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # Makes sure that certain binary operator methods have their
+      # sole  parameter named `other`.
+      #
+      # @example
+      #
+      #   # bad
+      #   def +(amount); end
+      #
+      #   # good
+      #   def +(other); end
+      class BinaryOperatorParameterName < Base
+        extend AutoCorrector
+
+        MSG = 'When defining the `%<opr>s` operator, name its argument `other`.'
+
+        OP_LIKE_METHODS = %i[eql? equal?].freeze
+        EXCLUDED = %i[+@ -@ [] []= << === ` =~].freeze
+
+        # @!method op_method_candidate?(node)
+        def_node_matcher :op_method_candidate?, <<~PATTERN
+          (def [#op_method? $_] (args $(arg [!:other !:_other])) _)
+        PATTERN
+
+        def on_def(node)
+          op_method_candidate?(node) do |name, arg|
+            add_offense(arg, message: format(MSG, opr: name)) do |corrector|
+              corrector.replace(arg, 'other')
+              node.each_descendant(:lvar, :lvasgn) do |lvar|
+                lvar_location = lvar.loc.name
+                next unless lvar_location.source == arg.source
+
+                corrector.replace(lvar_location, 'other')
+              end
+            end
+          end
+        end
+
+        private
+
+        def op_method?(name)
+          return false if EXCLUDED.include?(name)
+
+          !/\A[[:word:]]/.match?(name) || OP_LIKE_METHODS.include?(name)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/naming/block_forwarding.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # In Ruby 3.1, anonymous block forwarding has been added.
+      #
+      # This cop identifies places where `do_something(&block)` can be replaced
+      # by `do_something(&)`.
+      #
+      # It also supports the opposite style by alternative `explicit` option.
+      # You can specify the block variable name for autocorrection with `BlockForwardingName`.
+      # The default variable name is `block`. If the name is already in use, it will not be
+      # autocorrected.
+      #
+      # [NOTE]
+      # ====
+      # Because of a bug in Ruby 3.3.0, when a block is referenced inside of another block,
+      # no offense will be registered until Ruby 3.4:
+      #
+      # [source,ruby]
+      # ----
+      # def foo(&block)
+      #   # Using an anonymous block would be a syntax error on Ruby 3.3.0
+      #   block_method { bar(&block) }
+      # end
+      # ----
+      # ====
+      #
+      # @example EnforcedStyle: anonymous (default)
+      #
+      #   # bad
+      #   def foo(&block)
+      #     bar(&block)
+      #   end
+      #
+      #   # good
+      #   def foo(&)
+      #     bar(&)
+      #   end
+      #
+      # @example EnforcedStyle: explicit
+      #
+      #   # bad
+      #   def foo(&)
+      #     bar(&)
+      #   end
+      #
+      #   # good
+      #   def foo(&block)
+      #     bar(&block)
+      #   end
+      #
+      class BlockForwarding < Base
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 3.1
+
+        MSG = 'Use %<style>s block forwarding.'
+
+        def self.autocorrect_incompatible_with
+          [Lint::AmbiguousOperator, Style::ArgumentsForwarding, Style::ExplicitBlockArgument]
+        end
+
+        def on_def(node)
+          return if node.arguments.empty?
+
+          last_argument = node.last_argument
+          return if expected_block_forwarding_style?(node, last_argument)
+
+          forwarded_args = node.each_descendant(:block_pass).with_object([]) do |block_pass, result|
+            return nil if invalidates_syntax?(block_pass)
+            next unless block_argument_name_matched?(block_pass, last_argument)
+
+            result << block_pass
+          end
+
+          forwarded_args.each do |forwarded_arg|
+            register_offense(forwarded_arg, node)
+          end
+
+          register_offense(last_argument, node)
+        end
+        alias on_defs on_def
+
+        private
+
+        def expected_block_forwarding_style?(node, last_argument)
+          if style == :anonymous
+            !explicit_block_argument?(last_argument) ||
+              use_kwarg_in_method_definition?(node) ||
+              use_block_argument_as_local_variable?(node, last_argument.source[1..])
+          else
+            !anonymous_block_argument?(last_argument)
+          end
+        end
+
+        def block_argument_name_matched?(block_pass_node, last_argument)
+          return false if block_pass_node.children.first&.sym_type?
+
+          last_argument.source == block_pass_node.source
+        end
+
+        # Ruby 3.3.0 had a bug where accessing an anonymous block argument inside of a block
+        # was a syntax error in unambiguous cases: https://bugs.ruby-lang.org/issues/20090
+        # We disallow this also for earlier Ruby versions so that code is forwards compatible.
+        def invalidates_syntax?(block_pass_node)
+          target_ruby_version <= 3.3 && block_pass_node.each_ancestor(:any_block).any?
+        end
+
+        def use_kwarg_in_method_definition?(node)
+          node.arguments.each_descendant(:kwarg, :kwoptarg).any?
+        end
+
+        def anonymous_block_argument?(node)
+          node.blockarg_type? && node.name.nil?
+        end
+
+        def explicit_block_argument?(node)
+          node.blockarg_type? && !node.name.nil?
+        end
+
+        def register_offense(block_argument, node)
+          add_offense(block_argument, message: format(MSG, style: style)) do |corrector|
+            if style == :anonymous
+              corrector.replace(block_argument, '&')
+
+              arguments = block_argument.parent
+
+              add_parentheses(arguments, corrector) unless arguments.parenthesized_call?
+            else
+              unless use_block_argument_as_local_variable?(node, block_forwarding_name)
+                corrector.replace(block_argument, "&#{block_forwarding_name}")
+              end
+            end
+          end
+        end
+
+        def use_block_argument_as_local_variable?(node, last_argument)
+          return false if node.body.nil?
+
+          node.body.each_node(:lvar, :lvasgn).any? do |lvar|
+            !lvar.parent.block_pass_type? && lvar.node_parts[0].to_s == last_argument
+          end
+        end
+
+        def block_forwarding_name
+          cop_config.fetch('BlockForwardingName', 'block')
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/naming/block_parameter_name.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # Checks block parameter names for how descriptive they
+      # are. It is highly configurable.
+      #
+      # The `MinNameLength` config option takes an integer. It represents
+      # the minimum amount of characters the name must be. Its default is 1.
+      # The `AllowNamesEndingInNumbers` config option takes a boolean. When
+      # set to false, this cop will register offenses for names ending with
+      # numbers. Its default is false. The `AllowedNames` config option
+      # takes an array of permitted names that will never register an
+      # offense. The `ForbiddenNames` config option takes an array of
+      # restricted names that will always register an offense.
+      #
+      # @example
+      #   # bad
+      #   bar do |varOne, varTwo|
+      #     varOne + varTwo
+      #   end
+      #
+      #   # With `AllowNamesEndingInNumbers` set to false
+      #   foo { |num1, num2| num1 * num2 }
+      #
+      #   # With `MinNameLength` set to number greater than 1
+      #   baz { |a, b, c| do_stuff(a, b, c) }
+      #
+      #   # good
+      #   bar do |thud, fred|
+      #     thud + fred
+      #   end
+      #
+      #   foo { |speed, distance| speed * distance }
+      #
+      #   baz { |age, height, gender| do_stuff(age, height, gender) }
+      class BlockParameterName < Base
+        include UncommunicativeName
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          return unless node.arguments?
+
+          check(node, node.arguments)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/naming/class_and_module_camel_case.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # Checks for class and module names with
+      # an underscore in them.
+      #
+      # `AllowedNames` config takes an array of permitted names.
+      # Its default value is `['module_parent']`.
+      # These names can be full class/module names or part of the name.
+      # eg. Adding `my_class` to the `AllowedNames` config will allow names like
+      # `my_class`, `my_class::User`, `App::my_class`, `App::my_class::User`, etc.
+      #
+      # @example
+      #   # bad
+      #   class My_Class
+      #   end
+      #   module My_Module
+      #   end
+      #
+      #   # good
+      #   class MyClass
+      #   end
+      #   module MyModule
+      #   end
+      #   class module_parent::MyModule
+      #   end
+      class ClassAndModuleCamelCase < Base
+        MSG = 'Use CamelCase for classes and modules.'
+
+        def on_class(node)
+          return unless node.loc.name.source.include?('_')
+
+          allowed = /#{cop_config['AllowedNames'].join('|')}/
+          name = node.loc.name.source.gsub(allowed, '')
+          return unless name.include?('_')
+
+          add_offense(node.loc.name)
+        end
+        alias on_module on_class
+      end
+    end
+  end
+end