class RuboCop::Cop::Lint::DeprecatedClassMethods

Addrinfo.tcp(host, port).getnameinfo
Addrinfo.getaddrinfo(nodename, service)
ENV.to_h # ‘ENV.dup` cannot dup `ENV`, use `ENV.to_h` to get a copy of `ENV` as a hash.
ENV.to_h
ENV # `ENV.freeze` cannot prohibit changes to environment variables.
attr_reader :name
attr_accessor :name
block_given?
Dir.exist?(some_path)
File.exist?(some_path)
# good
Socket.gethostbyaddr(host)
Socket.gethostbyname(host)
ENV.dup # Calling `Env.dup` raises `TypeError` since Ruby 3.1.
ENV.clone
ENV.freeze # Calling `Env.freeze` raises `TypeError` since Ruby 2.7.
attr :name, false
attr :name, true
iterator?
Dir.exists?(some_path)
File.exists?(some_path)
# bad
@example
Checks for uses of the deprecated class method usages.

def dir_env_file_const?(node) 

def dir_env_file_const?(node)
  DIR_ENV_FILE_CONSTANTS.include?(node&.short_name)
end

def offense_range(node) 

def offense_range(node)
  if socket_const?(node.receiver) || dir_env_file_const?(node.receiver)
    node.source_range.begin.join(node.loc.selector.end)
  elsif node.method?(:attr)
    node
  else
    node.loc.selector
  end
end

def on_send(node) 

def on_send(node)
  return unless deprecated_class_method?(node)
  offense_range = offense_range(node)
  prefer = preferred_method(node)
  message = format(MSG, current: offense_range.source, prefer: prefer)
  add_offense(offense_range, message: message) do |corrector|
    next if socket_const?(node.receiver)
    if node.method?(:freeze)
      corrector.replace(node, 'ENV')
    else
      corrector.replace(offense_range, prefer)
    end
  end
end

def preferred_method(node) 

def preferred_method(node)
  if node.method?(:attr)
    boolean_argument = node.arguments[1].source
    preferred_attr_method = boolean_argument == 'true' ? 'attr_accessor' : 'attr_reader'
    "#{preferred_attr_method} #{node.first_argument.source}"
  elsif dir_env_file_const?(node.receiver)
    prefer = PREFERRED_METHODS[node.method_name]
    prefer ? "#{node.receiver.source}.#{prefer}" : 'ENV'
  else
    PREFERRED_METHODS[node.method_name]
  end
end

def socket_const?(node) 

def socket_const?(node)
  node&.short_name == :Socket
end