rubocop-grantbirki 1.75.2

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

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for usage of comparison operators (`==`,
+      # `>`, `<`) to test numbers as zero, positive, or negative.
+      # These can be replaced by their respective predicate methods.
+      # This cop can also be configured to do the reverse.
+      #
+      # This cop's allowed methods can be customized with `AllowedMethods`.
+      # By default, there are no allowed methods.
+      #
+      # This cop disregards `#nonzero?` as its value is truthy or falsey,
+      # but not `true` and `false`, and thus not always interchangeable with
+      # `!= 0`.
+      #
+      # This cop allows comparisons to global variables, since they are often
+      # populated with objects which can be compared with integers, but are
+      # not themselves `Integer` polymorphic.
+      #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   defines the predicates or can be compared to a number, which may lead
+      #   to a false positive for non-standard classes.
+      #
+      # @example EnforcedStyle: predicate (default)
+      #   # bad
+      #   foo == 0
+      #   0 > foo
+      #   bar.baz > 0
+      #
+      #   # good
+      #   foo.zero?
+      #   foo.negative?
+      #   bar.baz.positive?
+      #
+      # @example EnforcedStyle: comparison
+      #   # bad
+      #   foo.zero?
+      #   foo.negative?
+      #   bar.baz.positive?
+      #
+      #   # good
+      #   foo == 0
+      #   0 > foo
+      #   bar.baz > 0
+      #
+      # @example AllowedMethods: [] (default) with EnforcedStyle: predicate
+      #   # bad
+      #   foo == 0
+      #   0 > foo
+      #   bar.baz > 0
+      #
+      # @example AllowedMethods: [==] with EnforcedStyle: predicate
+      #   # good
+      #   foo == 0
+      #
+      #   # bad
+      #   0 > foo
+      #   bar.baz > 0
+      #
+      # @example AllowedPatterns: [] (default) with EnforcedStyle: comparison
+      #   # bad
+      #   foo.zero?
+      #   foo.negative?
+      #   bar.baz.positive?
+      #
+      # @example AllowedPatterns: ['zero'] with EnforcedStyle: predicate
+      #   # good
+      #   # bad
+      #   foo.zero?
+      #
+      #   # bad
+      #   foo.negative?
+      #   bar.baz.positive?
+      #
+      class NumericPredicate < Base
+        include ConfigurableEnforcedStyle
+        include AllowedMethods
+        include AllowedPattern
+        extend AutoCorrector
+
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
+
+        REPLACEMENTS = { 'zero?' => '==', 'positive?' => '>', 'negative?' => '<' }.freeze
+
+        RESTRICT_ON_SEND = %i[== > < positive? negative? zero?].freeze
+
+        def on_send(node)
+          numeric, replacement = check(node)
+          return unless numeric
+
+          return if allowed_method_name?(node.method_name) ||
+                    node.each_ancestor(:send, :block).any? do |ancestor|
+                      allowed_method_name?(ancestor.method_name)
+                    end
+
+          message = format(MSG, prefer: replacement, current: node.source)
+          add_offense(node, message: message) do |corrector|
+            corrector.replace(node, replacement)
+          end
+        end
+
+        private
+
+        def allowed_method_name?(name)
+          allowed_method?(name) || matches_allowed_pattern?(name)
+        end
+
+        def check(node)
+          numeric, operator =
+            if style == :predicate
+              comparison(node) || inverted_comparison(node, &invert)
+            else
+              predicate(node)
+            end
+
+          return unless numeric && operator && replacement_supported?(operator)
+
+          [numeric, replacement(node, numeric, operator)]
+        end
+
+        def replacement(node, numeric, operation)
+          if style == :predicate
+            [parenthesized_source(numeric), REPLACEMENTS.invert[operation.to_s]].join('.')
+          elsif negated?(node)
+            "(#{numeric.source} #{REPLACEMENTS[operation.to_s]} 0)"
+          else
+            [numeric.source, REPLACEMENTS[operation.to_s], 0].join(' ')
+          end
+        end
+
+        def parenthesized_source(node)
+          if require_parentheses?(node)
+            "(#{node.source})"
+          else
+            node.source
+          end
+        end
+
+        def require_parentheses?(node)
+          node.send_type? && node.binary_operation? && !node.parenthesized?
+        end
+
+        def replacement_supported?(operator)
+          if %i[> <].include?(operator)
+            target_ruby_version >= 2.3
+          else
+            true
+          end
+        end
+
+        def invert
+          lambda do |comparison, numeric|
+            comparison = { :> => :<, :< => :> }[comparison] || comparison
+
+            [numeric, comparison]
+          end
+        end
+
+        def negated?(node)
+          return false unless (parent = node.parent)
+
+          parent.send_type? && parent.method?(:!)
+        end
+
+        # @!method predicate(node)
+        def_node_matcher :predicate, <<~PATTERN
+          (send $(...) ${:zero? :positive? :negative?})
+        PATTERN
+
+        # @!method comparison(node)
+        def_node_matcher :comparison, <<~PATTERN
+          (send [$(...) !gvar_type?] ${:== :> :<} (int 0))
+        PATTERN
+
+        # @!method inverted_comparison(node)
+        def_node_matcher :inverted_comparison, <<~PATTERN
+          (send (int 0) ${:== :> :<} [$(...) !gvar_type?])
+        PATTERN
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces the use of consistent method names
+      # `Object#yield_self` or `Object#then`.
+      #
+      # @example EnforcedStyle: then (default)
+      #
+      #   # bad
+      #   obj.yield_self { |x| x.do_something }
+      #
+      #   # good
+      #   obj.then { |x| x.do_something }
+      #
+      # @example EnforcedStyle: yield_self
+      #
+      #   # bad
+      #   obj.then { |x| x.do_something }
+      #
+      #   # good
+      #   obj.yield_self { |x| x.do_something }
+      #
+      class ObjectThen < Base
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.6
+
+        MSG = 'Prefer `%<prefer>s` over `%<current>s`.'
+        RESTRICT_ON_SEND = %i[then yield_self].freeze
+
+        def on_block(node)
+          return unless RESTRICT_ON_SEND.include?(node.method_name)
+
+          check_method_node(node.send_node)
+        end
+        alias on_numblock on_block
+        alias on_itblock on_block
+
+        def on_send(node)
+          return unless node.arguments.one? && node.first_argument.block_pass_type?
+
+          check_method_node(node)
+        end
+        alias on_csend on_send
+
+        private
+
+        def check_method_node(node)
+          if preferred_method?(node)
+            correct_style_detected
+          else
+            opposite_style_detected
+            message = message(node)
+            add_offense(node.loc.selector, message: message) do |corrector|
+              prefer = style == :then && node.receiver.nil? ? 'self.then' : style
+
+              corrector.replace(node.loc.selector, prefer)
+            end
+          end
+        end
+
+        def preferred_method?(node)
+          node.method?(style)
+        end
+
+        def message(node)
+          format(MSG, prefer: style.to_s, current: node.method_name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for uses of if/then/else/end constructs on a single line.
+      # `AlwaysCorrectToMultiline` config option can be set to true to autocorrect all offenses to
+      # multi-line constructs. When `AlwaysCorrectToMultiline` is false (default case) the
+      # autocorrect will first try converting them to ternary operators.
+      #
+      # @example
+      #   # bad
+      #   if foo then bar else baz end
+      #
+      #   # bad
+      #   unless foo then baz else bar end
+      #
+      #   # good
+      #   foo ? bar : baz
+      #
+      #   # good
+      #   bar if foo
+      #
+      #   # good
+      #   if foo then bar end
+      #
+      #   # good
+      #   if foo
+      #     bar
+      #   else
+      #     baz
+      #   end
+      #
+      # @example AlwaysCorrectToMultiline: false (default)
+      #   # bad
+      #   if cond then run else dont end
+      #
+      #   # good
+      #   cond ? run : dont
+      #
+      # @example AlwaysCorrectToMultiline: true
+      #   # bad
+      #   if cond then run else dont end
+      #
+      #   # good
+      #   if cond
+      #     run
+      #   else
+      #     dont
+      #   end
+      #
+      class OneLineConditional < Base
+        include Alignment
+        include ConfigurableEnforcedStyle
+        include OnNormalIfUnless
+        extend AutoCorrector
+
+        MSG = 'Favor the ternary operator (`?:`) or multi-line constructs ' \
+              'over single-line `%<keyword>s/then/else/end` constructs.'
+
+        def on_normal_if_unless(node)
+          return unless node.single_line?
+          return unless node.else_branch
+          return if node.elsif? || node.if_branch&.begin_type?
+
+          message = message(node)
+          add_offense(node, message: message) do |corrector|
+            next if part_of_ignored_node?(node)
+
+            autocorrect(corrector, node)
+
+            ignore_node(node)
+          end
+        end
+
+        private
+
+        def message(node)
+          format(MSG, keyword: node.keyword)
+        end
+
+        def autocorrect(corrector, node)
+          if always_multiline? || cannot_replace_to_ternary?(node)
+            IfThenCorrector.new(node, indentation: configured_indentation_width).call(corrector)
+          else
+            corrector.replace(node, ternary_correction(node))
+          end
+        end
+
+        def ternary_correction(node)
+          replaced_node = ternary_replacement(node)
+
+          return replaced_node unless node.parent
+          return "(#{replaced_node})" if node.parent.operator_keyword?
+          return "(#{replaced_node})" if node.parent.send_type? && node.parent.operator_method?
+
+          replaced_node
+        end
+
+        def always_multiline?
+          cop_config['AlwaysCorrectToMultiline']
+        end
+
+        def cannot_replace_to_ternary?(node)
+          return true if node.elsif_conditional?
+
+          node.else_branch.begin_type? && node.else_branch.children.compact.count >= 2
+        end
+
+        def ternary_replacement(node)
+          condition, if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring
+
+          "#{expr_replacement(condition)} ? " \
+            "#{expr_replacement(if_branch)} : " \
+            "#{expr_replacement(else_branch)}"
+        end
+
+        def expr_replacement(node)
+          return 'nil' if node.nil?
+
+          requires_parentheses?(node) ? "(#{node.source})" : node.source
+        end
+
+        def requires_parentheses?(node)
+          return true if %i[and or if].include?(node.type)
+          return true if node.assignment?
+          return true if method_call_with_changed_precedence?(node)
+
+          keyword_with_changed_precedence?(node)
+        end
+
+        def method_call_with_changed_precedence?(node)
+          return false unless node.send_type? && node.arguments?
+          return false if node.parenthesized_call?
+
+          !node.operator_method?
+        end
+
+        def keyword_with_changed_precedence?(node)
+          return false unless node.keyword?
+          return true if node.respond_to?(:prefix_not?) && node.prefix_not?
+
+          node.respond_to?(:arguments?) && node.arguments? && !node.parenthesized_call?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Flags uses of `OpenStruct`, as it is now officially discouraged
+      # to be used for performance, version compatibility, and potential security issues.
+      #
+      # @safety
+      #   Note that this cop may flag false positives; for instance, the following legal
+      #   use of a hand-rolled `OpenStruct` type would be considered an offense:
+      #
+      #   [source,ruby]
+      #   -----
+      #   module MyNamespace
+      #     class OpenStruct # not the OpenStruct we're looking for
+      #     end
+      #
+      #     def new_struct
+      #       OpenStruct.new # resolves to MyNamespace::OpenStruct
+      #     end
+      #   end
+      #   -----
+      #
+      # @example
+      #
+      #   # bad
+      #   point = OpenStruct.new(x: 0, y: 1)
+      #
+      #   # good
+      #   Point = Struct.new(:x, :y)
+      #   point = Point.new(0, 1)
+      #
+      #   # also good
+      #   point = { x: 0, y: 1 }
+      #
+      #   # bad
+      #   test_double = OpenStruct.new(a: 'b')
+      #
+      #   # good (assumes test using rspec-mocks)
+      #   test_double = double
+      #   allow(test_double).to receive(:a).and_return('b')
+      #
+      class OpenStructUse < Base
+        MSG = 'Avoid using `OpenStruct`; use `Struct`, `Hash`, a class or test doubles instead.'
+
+        # @!method uses_open_struct?(node)
+        def_node_matcher :uses_open_struct?, <<~PATTERN
+          (const {nil? (cbase)} :OpenStruct)
+        PATTERN
+
+        def on_const(node)
+          return unless uses_open_struct?(node)
+          return if custom_class_or_module_definition?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        def custom_class_or_module_definition?(node)
+          parent = node.parent
+
+          parent.type?(:class, :module) && node.left_siblings.empty?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for redundant dot before operator method call.
+      # The target operator methods are `|`, `^`, `&`, ``<=>``, `==`, `===`, `=~`, `>`, `>=`, `<`,
+      # ``<=``, `<<`, `>>`, `+`, `-`, `*`, `/`, `%`, `**`, `~`, `!`, `!=`, and `!~`.
+      #
+      # @example
+      #
+      #   # bad
+      #   foo.+ bar
+      #   foo.& bar
+      #
+      #   # good
+      #   foo + bar
+      #   foo & bar
+      #
+      class OperatorMethodCall < Base
+        extend AutoCorrector
+
+        MSG = 'Redundant dot detected.'
+        RESTRICT_ON_SEND = %i[| ^ & <=> == === =~ > >= < <= << >> + - * / % ** ~ ! != !~].freeze
+        INVALID_SYNTAX_ARG_TYPES = %i[
+          splat kwsplat forwarded_args forwarded_restarg forwarded_kwrestarg block_pass
+        ].freeze
+
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        def on_send(node)
+          return unless (dot = node.loc.dot)
+          return if node.receiver.const_type? || !node.arguments.one?
+
+          return unless (rhs = node.first_argument)
+          return if method_call_with_parenthesized_arg?(rhs)
+          return if invalid_syntax_argument?(rhs)
+
+          add_offense(dot) do |corrector|
+            wrap_in_parentheses_if_chained(corrector, node)
+            corrector.replace(dot, ' ')
+
+            selector = node.loc.selector
+            corrector.insert_after(selector, ' ') if insert_space_after?(node)
+          end
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+
+        private
+
+        # Checks for an acceptable case of `foo.+(bar).baz`.
+        def method_call_with_parenthesized_arg?(argument)
+          return false unless argument.parent.parent&.send_type?
+
+          argument.children.first && argument.parent.parenthesized?
+        end
+
+        def invalid_syntax_argument?(argument)
+          type = argument.hash_type? ? argument.children.first&.type : argument.type
+
+          INVALID_SYNTAX_ARG_TYPES.include?(type)
+        end
+
+        def wrap_in_parentheses_if_chained(corrector, node)
+          return unless node.parent&.call_type?
+          return if node.parent.first_argument == node
+
+          operator = node.loc.selector
+
+          ParenthesesCorrector.correct(corrector, node)
+          corrector.insert_after(operator, ' ')
+          corrector.wrap(node, '(', ')')
+        end
+
+        def insert_space_after?(node)
+          rhs = node.first_argument
+          selector = node.loc.selector
+
+          return true if selector.end_pos == rhs.source_range.begin_pos
+          return false if node.parent&.call_type? # if chained, a space is already added
+
+          # For `/` operations, if the RHS starts with a `(` without space,
+          # add one to avoid a syntax error.
+          range = selector.end.join(rhs.source_range.begin)
+          return true if node.method?(:/) && range.source == '('
+
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for options hashes and discourages them if the
+      # current Ruby version supports keyword arguments.
+      #
+      # @example
+      #
+      #   # bad
+      #   def fry(options = {})
+      #     temperature = options.fetch(:temperature, 300)
+      #     # ...
+      #   end
+      #
+      #
+      #   # good
+      #   def fry(temperature: 300)
+      #     # ...
+      #   end
+      class OptionHash < Base
+        MSG = 'Prefer keyword arguments to options hashes.'
+
+        # @!method option_hash(node)
+        def_node_matcher :option_hash, <<~PATTERN
+          (args ... $(optarg [#suspicious_name? _] (hash)))
+        PATTERN
+
+        def on_args(node)
+          return if super_used?(node)
+          return if allowlist.include?(node.parent.method_name.to_s)
+
+          option_hash(node) { |options| add_offense(options) }
+        end
+
+        private
+
+        def allowlist
+          cop_config['Allowlist'] || []
+        end
+
+        def suspicious_name?(arg_name)
+          cop_config.key?('SuspiciousParamNames') &&
+            cop_config['SuspiciousParamNames'].include?(arg_name.to_s)
+        end
+
+        def super_used?(node)
+          node.parent.each_node(:zsuper).any?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for optional arguments to methods
+      # that do not come at the end of the argument list.
+      #
+      # @safety
+      #   This cop is unsafe because changing a method signature will
+      #   implicitly change behavior.
+      #
+      # @example
+      #   # bad
+      #   def foo(a = 1, b, c)
+      #   end
+      #
+      #   # good
+      #   def baz(a, b, c = 1)
+      #   end
+      #
+      #   def foobar(a = 1, b = 2, c = 3)
+      #   end
+      class OptionalArguments < Base
+        MSG = 'Optional arguments should appear at the end of the argument list.'
+
+        def on_def(node)
+          each_misplaced_optional_arg(node.arguments) { |argument| add_offense(argument) }
+        end
+
+        private
+
+        def each_misplaced_optional_arg(arguments)
+          optarg_positions, arg_positions = argument_positions(arguments)
+          return if optarg_positions.empty? || arg_positions.empty?
+
+          optarg_positions.each do |optarg_position|
+            # there can only be one group of optional arguments
+            break if optarg_position > arg_positions.max
+
+            yield arguments[optarg_position]
+          end
+        end
+
+        def argument_positions(arguments)
+          optarg_positions = []
+          arg_positions = []
+
+          arguments.each_with_index do |argument, index|
+            optarg_positions << index if argument.optarg_type?
+            arg_positions << index if argument.arg_type?
+          end
+
+          [optarg_positions, arg_positions]
+        end
+      end
+    end
+  end
+end