rubocop 1.57.1 → 1.81.7

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

@@ -1,134 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Naming
-      # Checks that predicate methods names end with a question mark and
-      # do not start with a forbidden prefix.
-      #
-      # A method is determined to be a predicate method if its name starts
-      # with one of the prefixes defined in the `NamePrefix` configuration.
-      # You can change what prefixes are considered by changing this option.
-      # Any method name that starts with one of these prefixes is required by
-      # the cop to end with a `?`. Other methods can be allowed by adding to
-      # the `AllowedMethods` configuration.
-      #
-      # NOTE: The `is_a?` method is allowed by default.
-      #
-      # If `ForbiddenPrefixes` is set, methods that start with the configured
-      # prefixes will not be allowed and will be removed by autocorrection.
-      #
-      # In other words, if `ForbiddenPrefixes` is empty, a method named `is_foo`
-      # will register an offense only due to the lack of question mark (and will be
-      # autocorrected to `is_foo?`). If `ForbiddenPrefixes` contains `is_`,
-      # `is_foo` will register an offense both because the ? is missing and because of
-      # the `is_` prefix, and will be corrected to `foo?`.
-      #
-      # NOTE: `ForbiddenPrefixes` is only applied to prefixes in `NamePrefix`;
-      # a prefix in the former but not the latter will not be considered by
-      # this cop.
-      #
-      # @example
-      #   # bad
-      #   def is_even(value)
-      #   end
-      #
-      #   def is_even?(value)
-      #   end
-      #
-      #   # good
-      #   def even?(value)
-      #   end
-      #
-      #   # bad
-      #   def has_value
-      #   end
-      #
-      #   def has_value?
-      #   end
-      #
-      #   # good
-      #   def value?
-      #   end
-      #
-      # @example AllowedMethods: ['is_a?'] (default)
-      #   # good
-      #   def is_a?(value)
-      #   end
-      #
-      class PredicateName < Base
-        include AllowedMethods
-
-        # @!method dynamic_method_define(node)
-        def_node_matcher :dynamic_method_define, <<~PATTERN
-          (send nil? #method_definition_macros
-            (sym $_)
-            ...)
-        PATTERN
-
-        def on_send(node)
-          dynamic_method_define(node) do |method_name|
-            predicate_prefixes.each do |prefix|
-              next if allowed_method_name?(method_name.to_s, prefix)
-
-              add_offense(
-                node.first_argument.source_range,
-                message: message(method_name, expected_name(method_name.to_s, prefix))
-              )
-            end
-          end
-        end
-
-        def on_def(node)
-          predicate_prefixes.each do |prefix|
-            method_name = node.method_name.to_s
-
-            next if allowed_method_name?(method_name, prefix)
-
-            add_offense(
-              node.loc.name,
-              message: message(method_name, expected_name(method_name, prefix))
-            )
-          end
-        end
-        alias on_defs on_def
-
-        private
-
-        def allowed_method_name?(method_name, prefix)
-          !(method_name.start_with?(prefix) && # cheap check to avoid allocating Regexp
-              method_name.match?(/^#{prefix}[^0-9]/)) ||
-            method_name == expected_name(method_name, prefix) ||
-            method_name.end_with?('=') || # rubocop:todo InternalAffairs/MethodNameEndWith
-            allowed_method?(method_name)
-        end
-
-        def expected_name(method_name, prefix)
-          new_name = if forbidden_prefixes.include?(prefix)
-                       method_name.sub(prefix, '')
-                     else
-                       method_name.dup
-                     end
-          new_name << '?' unless method_name.end_with?('?') # rubocop:todo InternalAffairs/MethodNameEndWith
-          new_name
-        end
-
-        def message(method_name, new_name)
-          "Rename `#{method_name}` to `#{new_name}`."
-        end
-
-        def forbidden_prefixes
-          cop_config['ForbiddenPrefixes']
-        end
-
-        def predicate_prefixes
-          cop_config['NamePrefix']
-        end
-
-        def method_definition_macros(macro_name)
-          cop_config['MethodDefinitionMacros'].include?(macro_name.to_s)
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/cop/utils/regexp_ranges.rb

@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Utils
-      # Helper to abstract complexity of building range pairs
-      # with octal escape reconstruction (needed for regexp_parser < 2.7).
-      class RegexpRanges
-        attr_reader :root
-
-        def initialize(root)
-          @root = root
-          @compound_token = []
-          @pairs = []
-          @populated = false
-        end
-
-        def compound_token
-          populate_all unless @populated
-
-          @compound_token
-        end
-
-        def pairs
-          populate_all unless @populated
-
-          @pairs
-        end
-
-        private
-
-        def populate_all
-          populate(@root)
-
-          # If either bound is a compound the first one is an escape
-          # and that's all we need to work with.
-          # If there are any cops that wanted to operate on the compound
-          # expression we could wrap it with a facade class.
-          @pairs.map! { |pair| pair.map(&:first) }
-
-          @populated = true
-        end
-
-        def populate(expr)
-          expressions = expr.expressions.to_a
-
-          until expressions.empty?
-            current = expressions.shift
-
-            if escaped_octal?(current)
-              @compound_token << current
-              @compound_token.concat(pop_octal_digits(expressions))
-              # If we have all the digits we can discard.
-            end
-
-            next unless current.type == :set
-
-            process_set(expressions, current)
-            @compound_token.clear
-          end
-        end
-
-        def process_set(expressions, current)
-          case current.token
-          when :range
-            @pairs << compose_range(expressions, current)
-          when :character
-            # Child expressions may include the range we are looking for.
-            populate(current)
-          when :intersection
-            # Each child expression could have child expressions that lead to ranges.
-            current.expressions.each do |intersected|
-              populate(intersected)
-            end
-          end
-        end
-
-        def compose_range(expressions, current)
-          range_start, range_end = current.expressions
-          range_start = if @compound_token.size.between?(1, 2) && octal_digit?(range_start.text)
-                          @compound_token.dup << range_start
-                        else
-                          [range_start]
-                        end
-          range_end = [range_end]
-          range_end.concat(pop_octal_digits(expressions)) if escaped_octal?(range_end.first)
-          [range_start, range_end]
-        end
-
-        def escaped_octal?(expr)
-          expr.text =~ /^\\[0-7]$/
-        end
-
-        def octal_digit?(char)
-          ('0'..'7').cover?(char)
-        end
-
-        def pop_octal_digits(expressions)
-          digits = []
-
-          2.times do
-            next unless (next_child = expressions.first)
-            next unless next_child.type == :literal && next_child.text =~ /^[0-7]$/
-
-            digits << expressions.shift
-          end
-
-          digits
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/rspec/host_environment_simulation_helper.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-# RuboCop can be run in contexts where unexpected other libraries are included,
-# which may interfere with its normal behavior. In order to test those
-# situations, it may be necessary to require another library for the duration
-# of one spec
-module HostEnvironmentSimulatorHelper
-  def in_its_own_process_with(*files)
-    if ::Process.respond_to?(:fork)
-      pid = ::Process.fork do
-        # Need to write coverage result under different name
-        if defined?(SimpleCov)
-          SimpleCov.command_name "rspec-fork-#{Process.pid}"
-          SimpleCov.pid = Process.pid
-        end
-
-        files.each { |file| require file }
-        yield
-      end
-      ::Process.wait(pid)
-
-      # assert that the block did not fail
-      expect($CHILD_STATUS).to be_success
-    else
-      warn 'Process.fork is not available.'
-    end
-  end
-end