rubocop-grantbirki 1.75.2

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for `in;` uses in `case` expressions.
+      #
+      # @example
+      #   # bad
+      #   case expression
+      #   in pattern_a; foo
+      #   in pattern_b; bar
+      #   end
+      #
+      #   # good
+      #   case expression
+      #   in pattern_a then foo
+      #   in pattern_b then bar
+      #   end
+      #
+      class InPatternThen < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.7
+
+        MSG = 'Do not use `in %<pattern>s;`. Use `in %<pattern>s then` instead.'
+
+        def on_in_pattern(node)
+          return if node.multiline? || node.then? || !node.body
+
+          pattern = node.pattern
+          pattern_source = if pattern.match_alt_type?
+                             alternative_pattern_source(pattern)
+                           else
+                             pattern.source
+                           end
+
+          add_offense(node.loc.begin, message: format(MSG, pattern: pattern_source)) do |corrector|
+            corrector.replace(node.loc.begin, ' then')
+          end
+        end
+
+        private
+
+        def alternative_pattern_source(pattern)
+          collect_alternative_patterns(pattern).join(' | ')
+        end
+
+        def collect_alternative_patterns(pattern)
+          return pattern.children.map(&:source) unless pattern.children.first.match_alt_type?
+
+          pattern_sources = collect_alternative_patterns(pattern.children.first)
+
+          pattern_sources << pattern.children[1].source
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Use `Kernel#loop` for infinite loops.
+      #
+      # @safety
+      #   This cop is unsafe as the rule should not necessarily apply if the loop
+      #   body might raise a `StopIteration` exception; contrary to other infinite
+      #   loops, `Kernel#loop` silently rescues that and returns `nil`.
+      #
+      # @example
+      #   # bad
+      #   while true
+      #     work
+      #   end
+      #
+      #   # good
+      #   loop do
+      #     work
+      #   end
+      class InfiniteLoop < Base
+        include Alignment
+        extend AutoCorrector
+
+        LEADING_SPACE = /\A(\s*)/.freeze
+
+        MSG = 'Use `Kernel#loop` for infinite loops.'
+
+        def self.joining_forces
+          VariableForce
+        end
+
+        def after_leaving_scope(scope, _variable_table)
+          @variables ||= []
+          @variables.concat(scope.variables.values)
+        end
+
+        def on_while(node)
+          while_or_until(node) if node.condition.truthy_literal?
+        end
+
+        def on_until(node)
+          while_or_until(node) if node.condition.falsey_literal?
+        end
+
+        alias on_while_post on_while
+        alias on_until_post on_until
+
+        private
+
+        def while_or_until(node)
+          range = node.source_range
+          # Not every `while true` and `until false` can be turned into a
+          # `loop do` without further modification. The reason is that a
+          # variable that's introduced inside a while/until loop is in scope
+          # outside of that loop too, but a variable that's assigned for the
+          # first time inside a block cannot be accessed after the block. In
+          # those more complicated cases we don't report an offense.
+          return if @variables.any? do |var|
+            assigned_inside_loop?(var, range) &&
+            !assigned_before_loop?(var, range) &&
+            referenced_after_loop?(var, range)
+          end
+
+          add_offense(node.loc.keyword) { |corrector| autocorrect(corrector, node) }
+        end
+
+        def autocorrect(corrector, node)
+          if node.type?(:while_post, :until_post)
+            replace_begin_end_with_modifier(corrector, node)
+          elsif node.modifier_form?
+            replace_source(corrector, node.source_range, modifier_replacement(node))
+          else
+            replace_source(corrector, non_modifier_range(node), 'loop do')
+          end
+        end
+
+        def assigned_inside_loop?(var, range)
+          var.assignments.any? { |a| range.contains?(a.node.source_range) }
+        end
+
+        def assigned_before_loop?(var, range)
+          b = range.begin_pos
+          var.assignments.any? { |a| a.node.source_range.end_pos < b }
+        end
+
+        def referenced_after_loop?(var, range)
+          e = range.end_pos
+          var.references.any? { |r| r.node.source_range.begin_pos > e }
+        end
+
+        def replace_begin_end_with_modifier(corrector, node)
+          corrector.replace(node.body.loc.begin, 'loop do')
+          corrector.remove(node.body.loc.end.end.join(node.source_range.end))
+        end
+
+        def replace_source(corrector, range, replacement)
+          corrector.replace(range, replacement)
+        end
+
+        def modifier_replacement(node)
+          body = node.body
+          if node.single_line?
+            "loop { #{body.source} }"
+          else
+            indentation = body.source_range.source_line[LEADING_SPACE]
+
+            ['loop do', body.source.gsub(/^/, indentation(node)), 'end'].join("\n#{indentation}")
+          end
+        end
+
+        def non_modifier_range(node)
+          start_range = node.loc.keyword.begin
+          end_range = if node.do?
+                        node.loc.begin.end
+                      else
+                        node.condition.source_range.end
+                      end
+
+          start_range.join(end_range)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for trailing inline comments.
+      #
+      # @example
+      #
+      #   # good
+      #   foo.each do |f|
+      #     # Standalone comment
+      #     f.bar
+      #   end
+      #
+      #   # bad
+      #   foo.each do |f|
+      #     f.bar # Trailing inline comment
+      #   end
+      class InlineComment < Base
+        MSG = 'Avoid trailing inline comments.'
+
+        def on_new_investigation
+          processed_source.comments.each do |comment|
+            next if comment_line?(processed_source[comment.loc.line - 1]) ||
+                    comment.text.match?(/\A# rubocop:(enable|disable)/)
+
+            add_offense(comment)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Check for usages of not (`not` or `!`) called on a method
+      # when an inverse of that method can be used instead.
+      #
+      # Methods that can be inverted by a not (`not` or `!`) should be defined
+      # in `InverseMethods`.
+      #
+      # Methods that are inverted by inverting the return
+      # of the block that is passed to the method should be defined in
+      # `InverseBlocks`.
+      #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the method
+      #   and its inverse method are both defined on receiver, and also are
+      #   actually inverse of each other.
+      #
+      # @example
+      #   # bad
+      #   !foo.none?
+      #   !foo.any? { |f| f.even? }
+      #   !foo.blank?
+      #   !(foo == bar)
+      #   foo.select { |f| !f.even? }
+      #   foo.reject { |f| f != 7 }
+      #
+      #   # good
+      #   foo.none?
+      #   foo.blank?
+      #   foo.any? { |f| f.even? }
+      #   foo != bar
+      #   foo == bar
+      #   !!('foo' =~ /^\w+$/)
+      #   !(foo.class < Numeric) # Checking class hierarchy is allowed
+      #   # Blocks with guard clauses are ignored:
+      #   foo.select do |f|
+      #     next if f.zero?
+      #     f != 1
+      #   end
+      class InverseMethods < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use `%<inverse>s` instead of inverting `%<method>s`.'
+        CLASS_COMPARISON_METHODS = %i[<= >= < >].freeze
+        SAFE_NAVIGATION_INCOMPATIBLE_METHODS = (CLASS_COMPARISON_METHODS + %i[any? none?]).freeze
+        EQUALITY_METHODS = %i[== != =~ !~ <= >= < >].freeze
+        NEGATED_EQUALITY_METHODS = %i[!= !~].freeze
+        CAMEL_CASE = /[A-Z]+[a-z]+/.freeze
+
+        RESTRICT_ON_SEND = [:!].freeze
+
+        def self.autocorrect_incompatible_with
+          [Style::Not, Style::SymbolProc]
+        end
+
+        # @!method inverse_candidate?(node)
+        def_node_matcher :inverse_candidate?, <<~PATTERN
+          {
+            (send $(call $(...) $_ $...) :!)
+            (send (any_block $(call $(...) $_) $...) :!)
+            (send (begin $(call $(...) $_ $...)) :!)
+          }
+        PATTERN
+
+        # @!method inverse_block?(node)
+        def_node_matcher :inverse_block?, <<~PATTERN
+          (any_block $(call (...) $_) ... { $(call ... :!)
+                                            $(send (...) {:!= :!~} ...)
+                                            (begin ... $(call ... :!))
+                                            (begin ... $(send (...) {:!= :!~} ...))
+                                          })
+        PATTERN
+
+        def on_send(node)
+          inverse_candidate?(node) do |method_call, lhs, method, rhs|
+            return unless inverse_methods.key?(method)
+            return if negated?(node) || safe_navigation_incompatible?(method_call)
+            return if part_of_ignored_node?(node)
+            return if possible_class_hierarchy_check?(lhs, rhs, method)
+
+            add_offense(node, message: message(method, inverse_methods[method])) do |corrector|
+              correct_inverse_method(corrector, node)
+            end
+          end
+        end
+        alias on_csend on_send
+
+        def on_block(node)
+          inverse_block?(node) do |_method_call, method, block|
+            return unless inverse_blocks.key?(method)
+            return if negated?(node) && negated?(node.parent)
+            return if node.each_node(:next).any?
+
+            # Inverse method offenses inside of the block of an inverse method
+            # offense, such as `y.reject { |key, _value| !(key =~ /c\d/) }`,
+            # can cause autocorrection to apply improper corrections.
+            ignore_node(block)
+            add_offense(node, message: message(method, inverse_blocks[method])) do |corrector|
+              correct_inverse_block(corrector, node)
+            end
+          end
+        end
+
+        alias on_numblock on_block
+        alias on_itblock on_block
+
+        private
+
+        def correct_inverse_method(corrector, node)
+          method_call, _lhs, method, _rhs = inverse_candidate?(node)
+          return unless method_call && method
+
+          corrector.remove(not_to_receiver(node, method_call))
+          corrector.replace(method_call.loc.selector, inverse_methods[method].to_s)
+          remove_end_parenthesis(corrector, node, method, method_call)
+        end
+
+        def correct_inverse_block(corrector, node)
+          method_call, method, block = inverse_block?(node)
+
+          corrector.replace(method_call.loc.selector, inverse_blocks[method].to_s)
+          correct_inverse_selector(block, corrector)
+        end
+
+        def correct_inverse_selector(block, corrector)
+          selector_loc = block.loc.selector
+          selector = selector_loc.source
+
+          if NEGATED_EQUALITY_METHODS.include?(selector.to_sym)
+            selector[0] = '='
+            corrector.replace(selector_loc, selector)
+          else
+            if block.loc.dot
+              range = dot_range(block.loc)
+              corrector.remove(range)
+            end
+
+            corrector.remove(selector_loc)
+          end
+        end
+
+        def inverse_methods
+          @inverse_methods ||= cop_config['InverseMethods']
+                               .merge(cop_config['InverseMethods'].invert)
+        end
+
+        def inverse_blocks
+          @inverse_blocks ||= cop_config['InverseBlocks'].merge(cop_config['InverseBlocks'].invert)
+        end
+
+        def negated?(node)
+          node.parent.respond_to?(:method?) && node.parent.method?(:!)
+        end
+
+        def not_to_receiver(node, method_call)
+          node.loc.selector.begin.join(method_call.source_range.begin)
+        end
+
+        def end_parentheses(node, method_call)
+          method_call.source_range.end.join(node.source_range.end)
+        end
+
+        def safe_navigation_incompatible?(node)
+          return false unless node.csend_type?
+
+          SAFE_NAVIGATION_INCOMPATIBLE_METHODS.include?(node.method_name)
+        end
+
+        # When comparing classes, `!(Integer < Numeric)` is not the same as
+        # `Integer > Numeric`.
+        def possible_class_hierarchy_check?(lhs, rhs, method)
+          CLASS_COMPARISON_METHODS.include?(method) &&
+            (camel_case_constant?(lhs) || (rhs.size == 1 && camel_case_constant?(rhs.first)))
+        end
+
+        def camel_case_constant?(node)
+          node.const_type? && CAMEL_CASE.match?(node.source)
+        end
+
+        def dot_range(loc)
+          range_between(loc.dot.begin_pos, loc.expression.end_pos)
+        end
+
+        def remove_end_parenthesis(corrector, node, method, method_call)
+          return unless EQUALITY_METHODS.include?(method) || method_call.parent.begin_type?
+
+          corrector.remove(end_parentheses(node, method_call))
+        end
+
+        def message(method, inverse)
+          format(MSG, method: method, inverse: inverse)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for usages of `unless` which can be replaced by `if` with inverted condition.
+      # Code without `unless` is easier to read, but that is subjective, so this cop
+      # is disabled by default.
+      #
+      # Methods that can be inverted should be defined in `InverseMethods`. Note that
+      # the relationship of inverse methods needs to be defined in both directions.
+      # For example,
+      #
+      # [source,yaml]
+      # ----
+      # InverseMethods:
+      #   :!=: :==
+      #   :even?: :odd?
+      #   :odd?: :even?
+      # ----
+      #
+      # will suggest both `even?` and `odd?` to be inverted, but only `!=` (and not `==`).
+      #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the method
+      #   and its inverse method are both defined on receiver, and also are
+      #   actually inverse of each other.
+      #
+      # @example
+      #   # bad (simple condition)
+      #   foo unless !bar
+      #   foo unless x != y
+      #   foo unless x >= 10
+      #   foo unless x.even?
+      #   foo unless odd?
+      #
+      #   # good
+      #   foo if bar
+      #   foo if x == y
+      #   foo if x < 10
+      #   foo if x.odd?
+      #   foo if even?
+      #
+      #   # bad (complex condition)
+      #   foo unless x != y || x.even?
+      #
+      #   # good
+      #   foo if x == y && x.odd?
+      #
+      #   # good (if)
+      #   foo if !condition
+      #
+      class InvertibleUnlessCondition < Base
+        extend AutoCorrector
+
+        MSG = 'Prefer `%<prefer>s` over `%<current>s`.'
+
+        def on_if(node)
+          return unless node.unless?
+
+          condition = node.condition
+          return unless invertible?(condition)
+
+          message = format(MSG, prefer: "#{node.inverse_keyword} #{preferred_condition(condition)}",
+                                current: "#{node.keyword} #{condition.source}")
+
+          add_offense(node, message: message) do |corrector|
+            corrector.replace(node.loc.keyword, node.inverse_keyword)
+            autocorrect(corrector, condition)
+          end
+        end
+
+        private
+
+        def invertible?(node) # rubocop:disable Metrics/CyclomaticComplexity
+          case node&.type
+          when :begin
+            invertible?(node.children.first)
+          when :send
+            return false if inheritance_check?(node)
+
+            node.method?(:!) || inverse_methods.key?(node.method_name)
+          when :or, :and
+            invertible?(node.lhs) && invertible?(node.rhs)
+          else
+            false
+          end
+        end
+
+        def inheritance_check?(node)
+          argument = node.first_argument
+          node.method?(:<) && argument.const_type? &&
+            argument.short_name.to_s.upcase != argument.short_name.to_s
+        end
+
+        def preferred_condition(node)
+          case node.type
+          when :begin    then "(#{preferred_condition(node.children.first)})"
+          when :send     then preferred_send_condition(node)
+          when :or, :and then preferred_logical_condition(node)
+          end
+        end
+
+        def preferred_send_condition(node) # rubocop:disable Metrics/CyclomaticComplexity
+          receiver_source = node.receiver&.source
+          return receiver_source if node.method?(:!)
+
+          # receiver may be implicit (self)
+          dotted_receiver_source = receiver_source ? "#{receiver_source}." : ''
+
+          inverse_method_name = inverse_methods[node.method_name]
+          return "#{dotted_receiver_source}#{inverse_method_name}" unless node.arguments?
+
+          argument_list = node.arguments.map(&:source).join(', ')
+          if node.operator_method?
+            return "#{receiver_source} #{inverse_method_name} #{argument_list}"
+          end
+
+          if node.parenthesized?
+            return "#{dotted_receiver_source}#{inverse_method_name}(#{argument_list})"
+          end
+
+          "#{dotted_receiver_source}#{inverse_method_name} #{argument_list}"
+        end
+
+        def preferred_logical_condition(node)
+          preferred_lhs = preferred_condition(node.lhs)
+          preferred_rhs = preferred_condition(node.rhs)
+
+          "#{preferred_lhs} #{node.inverse_operator} #{preferred_rhs}"
+        end
+
+        def autocorrect(corrector, node)
+          case node.type
+          when :begin
+            autocorrect(corrector, node.children.first)
+          when :send
+            autocorrect_send_node(corrector, node)
+          when :or, :and
+            corrector.replace(node.loc.operator, node.inverse_operator)
+            autocorrect(corrector, node.lhs)
+            autocorrect(corrector, node.rhs)
+          end
+        end
+
+        def autocorrect_send_node(corrector, node)
+          if node.method?(:!)
+            corrector.remove(node.loc.selector)
+          else
+            corrector.replace(node.loc.selector, inverse_methods[node.method_name])
+          end
+        end
+
+        def inverse_methods
+          @inverse_methods ||= cop_config['InverseMethods']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'resolv'
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for hardcoded IP addresses, which can make code
+      # brittle. IP addresses are likely to need to be changed when code
+      # is deployed to a different server or environment, which may break
+      # a deployment if forgotten. Prefer setting IP addresses in ENV or
+      # other configuration.
+      #
+      # @example
+      #
+      #   # bad
+      #   ip_address = '127.59.241.29'
+      #
+      #   # good
+      #   ip_address = ENV['DEPLOYMENT_IP_ADDRESS']
+      class IpAddresses < Base
+        include StringHelp
+
+        IPV6_MAX_SIZE = 45 # IPv4-mapped IPv6 is the longest
+        MSG = 'Do not hardcode IP addresses.'
+
+        def offense?(node)
+          contents = node.source[1...-1]
+          return false if contents.empty?
+
+          return false if allowed_addresses.include?(contents.downcase)
+
+          # To try to avoid doing two regex checks on every string,
+          # shortcut out if the string does not look like an IP address
+          return false unless potential_ip?(contents)
+
+          ::Resolv::IPv4::Regex.match?(contents) || ::Resolv::IPv6::Regex.match?(contents)
+        end
+
+        # Dummy implementation of method in ConfigurableEnforcedStyle that is
+        # called from StringHelp.
+        def opposite_style_detected; end
+
+        # Dummy implementation of method in ConfigurableEnforcedStyle that is
+        # called from StringHelp.
+        def correct_style_detected; end
+
+        private
+
+        def allowed_addresses
+          allowed_addresses = cop_config['AllowedAddresses']
+          Array(allowed_addresses).map(&:downcase)
+        end
+
+        def potential_ip?(str)
+          # If the string is too long, it can't be an IP
+          return false if too_long?(str)
+
+          # If the string doesn't start with a colon or hexadecimal char,
+          # we know it's not an IP address
+          starts_with_hex_or_colon?(str)
+        end
+
+        def too_long?(str)
+          str.size > IPV6_MAX_SIZE
+        end
+
+        def starts_with_hex_or_colon?(str)
+          first_char = str[0].ord
+          (48..58).cover?(first_char) || (65..70).cover?(first_char) || (97..102).cover?(first_char)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for assignments to a local `it` variable inside a block
+      # where `it` can refer to the first anonymous parameter as of Ruby 3.4.
+      #
+      # Although Ruby allows reassigning `it` in these cases, it could
+      # cause confusion if `it` is used as a block parameter elsewhere.
+      # For consistency, this also applies to numblocks and blocks with
+      # parameters, even though `it` cannot be used in those cases.
+      #
+      # @example
+      #   # bad
+      #   foo { it = 5 }
+      #   foo { |bar| it = bar }
+      #   foo { it = _2 }
+      #
+      #   # good - use a different variable name
+      #   foo { var = 5 }
+      #   foo { |bar| var = bar }
+      #   foo { bar = _2 }
+      class ItAssignment < Base
+        MSG = '`it` is the default block parameter; consider another name.'
+
+        def on_lvasgn(node)
+          return unless node.name == :it
+          return unless node.each_ancestor(:any_block).any?
+
+          add_offense(node.loc.name)
+        end
+      end
+    end
+  end
+end