rubocop-grantbirki 1.75.2

data/lib/rubocop/cop/style/method_call_without_args_parentheses.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for unwanted parentheses in parameterless method calls.
+      #
+      # This cop's allowed methods can be customized with `AllowedMethods`.
+      # By default, there are no allowed methods.
+      #
+      # NOTE: This cop allows the use of `it()` without arguments in blocks,
+      # as in `0.times { it() }`, following `Lint/ItWithoutArgumentsInBlock` cop.
+      #
+      # @example
+      #   # bad
+      #   object.some_method()
+      #
+      #   # good
+      #   object.some_method
+      #
+      # @example AllowedMethods: [] (default)
+      #   # bad
+      #   object.foo()
+      #
+      # @example AllowedMethods: [foo]
+      #   # good
+      #   object.foo()
+      #
+      class MethodCallWithoutArgsParentheses < Base
+        include AllowedMethods
+        include AllowedPattern
+        extend AutoCorrector
+
+        MSG = 'Do not use parentheses for method calls with no arguments.'
+
+        # rubocop:disable Metrics/CyclomaticComplexity
+        def on_send(node)
+          return unless !node.arguments? && node.parenthesized?
+          return if ineligible_node?(node)
+          return if default_argument?(node)
+          return if allowed_method_name?(node.method_name)
+          return if same_name_assignment?(node)
+          return if parenthesized_it_method_in_block?(node)
+
+          register_offense(node)
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+        alias on_csend on_send
+
+        private
+
+        def register_offense(node)
+          add_offense(offense_range(node)) do |corrector|
+            corrector.remove(node.loc.begin)
+            corrector.remove(node.loc.end)
+          end
+        end
+
+        def ineligible_node?(node)
+          node.camel_case_method? || node.implicit_call? || node.prefix_not?
+        end
+
+        def default_argument?(node)
+          node.parent&.optarg_type?
+        end
+
+        def allowed_method_name?(name)
+          allowed_method?(name) || matches_allowed_pattern?(name)
+        end
+
+        def same_name_assignment?(node)
+          return false if node.receiver
+
+          any_assignment?(node) do |asgn_node|
+            if asgn_node.masgn_type?
+              variable_in_mass_assignment?(node.method_name, asgn_node)
+            else
+              asgn_node.loc.name.source == node.method_name.to_s
+            end
+          end
+        end
+
+        # Respects `Lint/ItWithoutArgumentsInBlock` cop and the following Ruby 3.3's warning:
+        #
+        # $ ruby -e '0.times { begin; it; end }'
+        # -e:1: warning: `it` calls without arguments will refer to the first block param in
+        # Ruby 3.4; use it() or self.it
+        #
+        def parenthesized_it_method_in_block?(node)
+          return false unless node.method?(:it)
+          return false unless (block_node = node.each_ancestor(:block).first)
+          return false unless block_node.arguments.empty_and_without_delimiters?
+
+          !node.receiver && node.arguments.empty? && !node.block_literal?
+        end
+
+        def any_assignment?(node)
+          node.each_ancestor(*AST::Node::ASSIGNMENTS).any? do |asgn_node|
+            # `obj.method = value` parses as (send ... :method= ...), and will
+            # not be returned as an `asgn_node` here, however,
+            # `obj.method ||= value` parses as (or-asgn (send ...) ...)
+            # which IS an `asgn_node`. Similarly, `obj.method += value` parses
+            # as (op-asgn (send ...) ...), which is also an `asgn_node`.
+            next if asgn_node.shorthand_asgn? && asgn_node.lhs.call_type?
+
+            yield asgn_node
+          end
+        end
+
+        def variable_in_mass_assignment?(variable_name, node)
+          node.assignments.reject(&:send_type?).any? { |n| n.name == variable_name }
+        end
+
+        def offense_range(node)
+          node.loc.begin.join(node.loc.end)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/method_called_on_do_end_block.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for methods called on a do...end block. The point of
+      # this check is that it's easy to miss the call tacked on to the block
+      # when reading code.
+      #
+      # @example
+      #   # bad
+      #   a do
+      #     b
+      #   end.c
+      #
+      #   # good
+      #   a { b }.c
+      #
+      #   # good
+      #   foo = a do
+      #     b
+      #   end
+      #   foo.c
+      class MethodCalledOnDoEndBlock < Base
+        include RangeHelp
+
+        MSG = 'Avoid chaining a method call on a do...end block.'
+
+        def on_block(node)
+          # If the method that is chained on the do...end block is itself a
+          # method with a block, we allow it. It's pretty safe to assume that
+          # these calls are not missed by anyone reading code. We also want to
+          # avoid double reporting of offenses checked by the
+          # MultilineBlockChain cop.
+          ignore_node(node.send_node)
+        end
+
+        alias on_numblock on_block
+        alias on_itblock on_block
+
+        def on_send(node)
+          return if ignored_node?(node)
+
+          return unless (receiver = node.receiver)
+          return unless receiver.any_block_type? && receiver.keywords?
+
+          range = range_between(receiver.loc.end.begin_pos, node.source_range.end_pos)
+
+          add_offense(range)
+        end
+        alias on_csend on_send
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/method_def_parentheses.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for parentheses around the arguments in method
+      # definitions. Both instance and class/singleton methods are checked.
+      #
+      # Regardless of style, parentheses are necessary for:
+      #
+      # 1. Endless methods
+      # 2. Argument lists containing a `forward-arg` (`...`)
+      # 3. Argument lists containing an anonymous rest arguments forwarding (`*`)
+      # 4. Argument lists containing an anonymous keyword rest arguments forwarding (`**`)
+      # 5. Argument lists containing an anonymous block forwarding (`&`)
+      #
+      # Removing the parens would be a syntax error here.
+      #
+      # @example EnforcedStyle: require_parentheses (default)
+      #   # The `require_parentheses` style requires method definitions
+      #   # to always use parentheses
+      #
+      #   # bad
+      #   def bar num1, num2
+      #     num1 + num2
+      #   end
+      #
+      #   def foo descriptive_var_name,
+      #           another_descriptive_var_name,
+      #           last_descriptive_var_name
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   def bar(num1, num2)
+      #     num1 + num2
+      #   end
+      #
+      #   def foo(descriptive_var_name,
+      #           another_descriptive_var_name,
+      #           last_descriptive_var_name)
+      #     do_something
+      #   end
+      #
+      # @example EnforcedStyle: require_no_parentheses
+      #   # The `require_no_parentheses` style requires method definitions
+      #   # to never use parentheses
+      #
+      #   # bad
+      #   def bar(num1, num2)
+      #     num1 + num2
+      #   end
+      #
+      #   def foo(descriptive_var_name,
+      #           another_descriptive_var_name,
+      #           last_descriptive_var_name)
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   def bar num1, num2
+      #     num1 + num2
+      #   end
+      #
+      #   def foo descriptive_var_name,
+      #           another_descriptive_var_name,
+      #           last_descriptive_var_name
+      #     do_something
+      #   end
+      #
+      # @example EnforcedStyle: require_no_parentheses_except_multiline
+      #   # The `require_no_parentheses_except_multiline` style prefers no
+      #   # parentheses when method definition arguments fit on single line,
+      #   # but prefers parentheses when arguments span multiple lines.
+      #
+      #   # bad
+      #   def bar(num1, num2)
+      #     num1 + num2
+      #   end
+      #
+      #   def foo descriptive_var_name,
+      #           another_descriptive_var_name,
+      #           last_descriptive_var_name
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   def bar num1, num2
+      #     num1 + num2
+      #   end
+      #
+      #   def foo(descriptive_var_name,
+      #           another_descriptive_var_name,
+      #           last_descriptive_var_name)
+      #     do_something
+      #   end
+      class MethodDefParentheses < Base
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG_PRESENT = 'Use def without parentheses.'
+        MSG_MISSING = 'Use def with parentheses when there are parameters.'
+
+        def on_def(node)
+          return if forced_parentheses?(node)
+
+          args = node.arguments
+
+          if require_parentheses?(args)
+            if arguments_without_parentheses?(node)
+              missing_parentheses(node)
+            else
+              correct_style_detected
+            end
+          elsif parentheses?(args)
+            unwanted_parentheses(args)
+          else
+            correct_style_detected
+          end
+        end
+        alias on_defs on_def
+
+        private
+
+        def correct_arguments(arg_node, corrector)
+          corrector.replace(arg_node.loc.begin, ' ')
+          corrector.remove(arg_node.loc.end)
+        end
+
+        def forced_parentheses?(node)
+          # Regardless of style, parentheses are necessary for:
+          # 1. Endless methods
+          # 2. Argument lists containing a `forward-arg` (`...`)
+          # 3. Argument lists containing an anonymous rest arguments forwarding (`*`)
+          # 4. Argument lists containing an anonymous keyword rest arguments forwarding (`**`)
+          # 5. Argument lists containing an anonymous block forwarding (`&`)
+          # Removing the parens would be a syntax error here.
+          node.endless? || anonymous_arguments?(node)
+        end
+
+        def require_parentheses?(args)
+          style == :require_parentheses ||
+            (style == :require_no_parentheses_except_multiline && args.multiline?)
+        end
+
+        def arguments_without_parentheses?(node)
+          node.arguments? && !parentheses?(node.arguments)
+        end
+
+        def missing_parentheses(node)
+          location = node.arguments.source_range
+
+          add_offense(location, message: MSG_MISSING) do |corrector|
+            add_parentheses(node.arguments, corrector)
+
+            unexpected_style_detected 'require_no_parentheses'
+          end
+        end
+
+        def unwanted_parentheses(args)
+          add_offense(args, message: MSG_PRESENT) do |corrector|
+            # offense is registered on args node when parentheses are unwanted
+            correct_arguments(args, corrector)
+            unexpected_style_detected 'require_parentheses'
+          end
+        end
+
+        def anonymous_arguments?(node)
+          return true if node.arguments.any? do |arg|
+            arg.type?(:forward_arg, :restarg, :kwrestarg)
+          end
+          return false unless (last_argument = node.last_argument)
+
+          last_argument.blockarg_type? && last_argument.name.nil?
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/min_max.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for potential uses of `Enumerable#minmax`.
+      #
+      # @example
+      #
+      #   # bad
+      #   bar = [foo.min, foo.max]
+      #   return foo.min, foo.max
+      #
+      #   # good
+      #   bar = foo.minmax
+      #   return foo.minmax
+      class MinMax < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<receiver>s.minmax` instead of `%<offender>s`.'
+
+        def on_array(node)
+          min_max_candidate(node) do |receiver|
+            offender = offending_range(node)
+
+            add_offense(offender, message: message(offender, receiver)) do |corrector|
+              receiver = node.children.first.receiver
+
+              corrector.replace(offending_range(node), "#{receiver.source}.minmax")
+            end
+          end
+        end
+        alias on_return on_array
+
+        private
+
+        # @!method min_max_candidate(node)
+        def_node_matcher :min_max_candidate, <<~PATTERN
+          ({array return} (send [$_receiver !nil?] :min) (send [$_receiver !nil?] :max))
+        PATTERN
+
+        def message(offender, receiver)
+          format(MSG, offender: offender.source, receiver: receiver.source)
+        end
+
+        def offending_range(node)
+          case node.type
+          when :return
+            argument_range(node)
+          else
+            node.source_range
+          end
+        end
+
+        def argument_range(node)
+          first_argument_range = node.children.first.source_range
+          last_argument_range  = node.children.last.source_range
+
+          first_argument_range.join(last_argument_range)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/min_max_comparison.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces the use of `max` or `min` instead of comparison for greater or less.
+      #
+      # NOTE: It can be used if you want to present limit or threshold in Ruby 2.7+.
+      # That it is slow though. So autocorrection will apply generic `max` or `min`:
+      #
+      # [source,ruby]
+      # ----
+      # a.clamp(b..) # Same as `[a, b].max`
+      # a.clamp(..b) # Same as `[a, b].min`
+      # ----
+      #
+      # @safety
+      #   This cop is unsafe because even if a value has `<` or `>` method,
+      #   it is not necessarily `Comparable`.
+      #
+      # @example
+      #
+      #   # bad
+      #   a > b ? a : b
+      #   a >= b ? a : b
+      #
+      #   # good
+      #   [a, b].max
+      #
+      #   # bad
+      #   a < b ? a : b
+      #   a <= b ? a : b
+      #
+      #   # good
+      #   [a, b].min
+      #
+      class MinMaxComparison < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Use `%<prefer>s` instead.'
+        GRATER_OPERATORS = %i[> >=].freeze
+        LESS_OPERATORS = %i[< <=].freeze
+        COMPARISON_OPERATORS = GRATER_OPERATORS + LESS_OPERATORS
+
+        def on_if(node)
+          lhs, operator, rhs = *node.condition
+          return unless COMPARISON_OPERATORS.include?(operator)
+
+          if_branch = node.if_branch
+          else_branch = node.else_branch
+          preferred_method = preferred_method(operator, lhs, rhs, if_branch, else_branch)
+          return unless preferred_method
+
+          replacement = "[#{lhs.source}, #{rhs.source}].#{preferred_method}"
+
+          add_offense(node, message: format(MSG, prefer: replacement)) do |corrector|
+            autocorrect(corrector, node, replacement)
+          end
+        end
+
+        private
+
+        def preferred_method(operator, lhs, rhs, if_branch, else_branch)
+          if lhs == if_branch && rhs == else_branch
+            GRATER_OPERATORS.include?(operator) ? 'max' : 'min'
+          elsif lhs == else_branch && rhs == if_branch
+            LESS_OPERATORS.include?(operator) ? 'max' : 'min'
+          end
+        end
+
+        def autocorrect(corrector, node, replacement)
+          if node.elsif?
+            corrector.remove(range_between(node.parent.loc.else.begin_pos, node.loc.else.begin_pos))
+            corrector.replace(node.else_branch, replacement)
+          else
+            corrector.replace(node, replacement)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/missing_else.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for `if` expressions that do not have an `else` branch.
+      #
+      # NOTE: Pattern matching is allowed to have no `else` branch because unlike `if` and `case`,
+      # it raises `NoMatchingPatternError` if the pattern doesn't match and without having `else`.
+      #
+      # Supported styles are: if, case, both.
+      #
+      # @example EnforcedStyle: both (default)
+      #   # warn when an `if` or `case` expression is missing an `else` branch.
+      #
+      #   # bad
+      #   if condition
+      #     statement
+      #   end
+      #
+      #   # bad
+      #   case var
+      #   when condition
+      #     statement
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     statement
+      #   else
+      #     # the content of `else` branch will be determined by Style/EmptyElse
+      #   end
+      #
+      #   # good
+      #   case var
+      #   when condition
+      #     statement
+      #   else
+      #     # the content of `else` branch will be determined by Style/EmptyElse
+      #   end
+      #
+      # @example EnforcedStyle: if
+      #   # warn when an `if` expression is missing an `else` branch.
+      #
+      #   # bad
+      #   if condition
+      #     statement
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     statement
+      #   else
+      #     # the content of `else` branch will be determined by Style/EmptyElse
+      #   end
+      #
+      #   # good
+      #   case var
+      #   when condition
+      #     statement
+      #   end
+      #
+      #   # good
+      #   case var
+      #   when condition
+      #     statement
+      #   else
+      #     # the content of `else` branch will be determined by Style/EmptyElse
+      #   end
+      #
+      # @example EnforcedStyle: case
+      #   # warn when a `case` expression is missing an `else` branch.
+      #
+      #   # bad
+      #   case var
+      #   when condition
+      #     statement
+      #   end
+      #
+      #   # good
+      #   case var
+      #   when condition
+      #     statement
+      #   else
+      #     # the content of `else` branch will be determined by Style/EmptyElse
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     statement
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     statement
+      #   else
+      #     # the content of `else` branch will be determined by Style/EmptyElse
+      #   end
+      class MissingElse < Base
+        include OnNormalIfUnless
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        MSG = '`%<type>s` condition requires an `else`-clause.'
+        MSG_NIL = '`%<type>s` condition requires an `else`-clause with `nil` in it.'
+        MSG_EMPTY = '`%<type>s` condition requires an empty `else`-clause.'
+
+        def on_normal_if_unless(node)
+          return if case_style?
+          return if unless_else_cop_enabled? && node.unless?
+
+          check(node)
+        end
+
+        def on_case(node)
+          return if if_style?
+
+          check(node)
+        end
+
+        def on_case_match(node)
+          # do nothing.
+        end
+
+        private
+
+        def check(node)
+          return if node.else?
+
+          add_offense(node, message: format(message_template, type: node.type)) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        def message_template
+          case empty_else_style
+          when :empty
+            MSG_NIL
+          when :nil
+            MSG_EMPTY
+          else
+            MSG
+          end
+        end
+
+        def autocorrect(corrector, node)
+          node = node.ancestors.find { |ancestor| ancestor.loc.end } unless node.loc.end
+
+          case empty_else_style
+          when :empty
+            corrector.insert_before(node.loc.end, 'else; nil; ')
+          when :nil
+            corrector.insert_before(node.loc.end, 'else; ')
+          end
+        end
+
+        def if_style?
+          style == :if
+        end
+
+        def case_style?
+          style == :case
+        end
+
+        def unless_else_cop_enabled?
+          unless_else_config.fetch('Enabled')
+        end
+
+        def unless_else_config
+          config.for_cop('Style/UnlessElse')
+        end
+
+        def empty_else_style
+          return unless empty_else_config.key?('EnforcedStyle')
+
+          empty_else_config['EnforcedStyle'].to_sym
+        end
+
+        def empty_else_config
+          config.for_cop('Style/EmptyElse')
+        end
+      end
+    end
+  end
+end