@ai-ecoverse/wasix-ruby 3.4.11-2 → 3.4.11-4

package/lib/ruby/gems/3.4.0/gems/rbs-3.8.0/core/basic_object.rbs

@@ -1,375 +0,0 @@
-# <!-- rdoc-file=object.c -->
-# `BasicObject` is the parent class of all classes in Ruby. In particular,
-# `BasicObject` is the parent class of class Object, which is itself the default
-# parent class of every Ruby class:
-#
-#     class Foo; end
-#     Foo.superclass    # => Object
-#     Object.superclass # => BasicObject
-#
-# `BasicObject` is the only class that has no parent:
-#
-#     BasicObject.superclass # => nil
-#
-# Class `BasicObject` can be used to create an object hierarchy (e.g., class
-# Delegator) that is independent of Ruby's object hierarchy. Such objects:
-#
-# *   Do not have namespace "pollution" from the many methods provided in class
-#     Object and its included module Kernel.
-# *   Do not have definitions of common classes, and so references to such
-#     common classes must be fully qualified (`::String`, not `String`).
-#
-# A variety of strategies can be used to provide useful portions of the Standard
-# Library in subclasses of `BasicObject`:
-#
-# *   The immediate subclass could `include Kernel`, which would define methods
-#     such as `puts`, `exit`, etc.
-# *   A custom Kernel-like module could be created and included.
-# *   Delegation can be used via #method_missing:
-#
-#         class MyObjectSystem < BasicObject
-#           DELEGATE = [:puts, :p]
-#
-#           def method_missing(name, *args, &block)
-#             return super unless DELEGATE.include? name
-#             ::Kernel.send(name, *args, &block)
-#           end
-#
-#           def respond_to_missing?(name, include_private = false)
-#             DELEGATE.include?(name)
-#           end
-#         end
-#
-# ### What's Here
-#
-# These are the methods defined for BasicObject:
-#
-# *   ::new: Returns a new BasicObject instance.
-# *   #!: Returns the boolean negation of `self`: `true` or `false`.
-# *   #!=: Returns whether `self` and the given object are *not* equal.
-# *   #==: Returns whether `self` and the given object are equivalent.
-# *   #__id__: Returns the integer object identifier for `self`.
-# *   #__send__: Calls the method identified by the given symbol.
-# *   #equal?: Returns whether `self` and the given object are the same object.
-# *   #instance_eval: Evaluates the given string or block in the context of
-#     `self`.
-# *   #instance_exec: Executes the given block in the context of `self`, passing
-#     the given arguments.
-# *   #method_missing: Called when `self` is called with a method it does not
-#     define.
-# *   #singleton_method_added: Called when a singleton method is added to
-#     `self`.
-# *   #singleton_method_removed: Called when a singleton method is removed from
-#     `self`.
-# *   #singleton_method_undefined: Called when a singleton method is undefined
-#     in `self`.
-#
-class BasicObject
-  # <!--
-  #   rdoc-file=object.c
-  #   - !obj    -> true or false
-  # -->
-  # Boolean negate.
-  #
-  def !: () -> bool
-
-  # <!--
-  #   rdoc-file=object.c
-  #   - obj != other        -> true or false
-  # -->
-  # Returns true if two objects are not-equal, otherwise false.
-  #
-  def !=: (untyped other) -> bool
-
-  # <!--
-  #   rdoc-file=object.c
-  #   - obj == other        -> true or false
-  #   - obj.equal?(other)   -> true or false
-  #   - obj.eql?(other)     -> true or false
-  # -->
-  # Equality --- At the Object level, #== returns `true` only if `obj` and `other`
-  # are the same object.  Typically, this method is overridden in descendant
-  # classes to provide class-specific meaning.
-  #
-  # Unlike #==, the #equal? method should never be overridden by subclasses as it
-  # is used to determine object identity (that is, `a.equal?(b)` if and only if
-  # `a` is the same object as `b`):
-  #
-  #     obj = "a"
-  #     other = obj.dup
-  #
-  #     obj == other      #=> true
-  #     obj.equal? other  #=> false
-  #     obj.equal? obj    #=> true
-  #
-  # The #eql? method returns `true` if `obj` and `other` refer to the same hash
-  # key.  This is used by Hash to test members for equality.  For any pair of
-  # objects where #eql? returns `true`, the #hash value of both objects must be
-  # equal. So any subclass that overrides #eql? should also override #hash
-  # appropriately.
-  #
-  # For objects of class Object, #eql?  is synonymous with #==.  Subclasses
-  # normally continue this tradition by aliasing #eql? to their overridden #==
-  # method, but there are exceptions. Numeric types, for example, perform type
-  # conversion across #==, but not across #eql?, so:
-  #
-  #     1 == 1.0     #=> true
-  #     1.eql? 1.0   #=> false
-  #
-  def ==: (untyped other) -> bool
-
-  # <!--
-  #   rdoc-file=gc.c
-  #   - obj.__id__       -> integer
-  #   - obj.object_id    -> integer
-  # -->
-  # Returns an integer identifier for `obj`.
-  #
-  # The same number will be returned on all calls to `object_id` for a given
-  # object, and no two active objects will share an id.
-  #
-  # Note: that some objects of builtin classes are reused for optimization. This
-  # is the case for immediate values and frozen string literals.
-  #
-  # BasicObject implements `__id__`, Kernel implements `object_id`.
-  #
-  # Immediate values are not passed by reference but are passed by value: `nil`,
-  # `true`, `false`, Fixnums, Symbols, and some Floats.
-  #
-  #     Object.new.object_id  == Object.new.object_id  # => false
-  #     (21 * 2).object_id    == (21 * 2).object_id    # => true
-  #     "hello".object_id     == "hello".object_id     # => false
-  #     "hi".freeze.object_id == "hi".freeze.object_id # => true
-  #
-  def __id__: () -> Integer
-
-  # <!--
-  #   rdoc-file=vm_eval.c
-  #   - foo.send(symbol [, args...])       -> obj
-  #   - foo.__send__(symbol [, args...])   -> obj
-  #   - foo.send(string [, args...])       -> obj
-  #   - foo.__send__(string [, args...])   -> obj
-  # -->
-  # Invokes the method identified by *symbol*, passing it any arguments specified.
-  # When the method is identified by a string, the string is converted to a
-  # symbol.
-  #
-  # BasicObject implements `__send__`, Kernel implements `send`. `__send__` is
-  # safer than `send` when *obj* has the same method name like `Socket`. See also
-  # `public_send`.
-  #
-  #     class Klass
-  #       def hello(*args)
-  #         "Hello " + args.join(' ')
-  #       end
-  #     end
-  #     k = Klass.new
-  #     k.send :hello, "gentle", "readers"   #=> "Hello gentle readers"
-  #
-  def __send__: (interned name, *untyped, **untyped) ?{ (?) -> untyped } -> untyped
-
-  # <!-- rdoc-file=object.c -->
-  # Equality --- At the Object level, #== returns `true` only if `obj` and `other`
-  # are the same object.  Typically, this method is overridden in descendant
-  # classes to provide class-specific meaning.
-  #
-  # Unlike #==, the #equal? method should never be overridden by subclasses as it
-  # is used to determine object identity (that is, `a.equal?(b)` if and only if
-  # `a` is the same object as `b`):
-  #
-  #     obj = "a"
-  #     other = obj.dup
-  #
-  #     obj == other      #=> true
-  #     obj.equal? other  #=> false
-  #     obj.equal? obj    #=> true
-  #
-  # The #eql? method returns `true` if `obj` and `other` refer to the same hash
-  # key.  This is used by Hash to test members for equality.  For any pair of
-  # objects where #eql? returns `true`, the #hash value of both objects must be
-  # equal. So any subclass that overrides #eql? should also override #hash
-  # appropriately.
-  #
-  # For objects of class Object, #eql?  is synonymous with #==.  Subclasses
-  # normally continue this tradition by aliasing #eql? to their overridden #==
-  # method, but there are exceptions. Numeric types, for example, perform type
-  # conversion across #==, but not across #eql?, so:
-  #
-  #     1 == 1.0     #=> true
-  #     1.eql? 1.0   #=> false
-  #
-  alias equal? ==
-
-  # <!--
-  #   rdoc-file=vm_eval.c
-  #   - obj.instance_eval(string [, filename [, lineno]] )   -> obj
-  #   - obj.instance_eval {|obj| block }                     -> obj
-  # -->
-  # Evaluates a string containing Ruby source code, or the given block, within the
-  # context of the receiver (*obj*). In order to set the context, the variable
-  # `self` is set to *obj* while the code is executing, giving the code access to
-  # *obj*'s instance variables and private methods.
-  #
-  # When `instance_eval` is given a block, *obj* is also passed in as the block's
-  # only argument.
-  #
-  # When `instance_eval` is given a `String`, the optional second and third
-  # parameters supply a filename and starting line number that are used when
-  # reporting compilation errors.
-  #
-  #     class KlassWithSecret
-  #       def initialize
-  #         @secret = 99
-  #       end
-  #       private
-  #       def the_secret
-  #         "Ssssh! The secret is #{@secret}."
-  #       end
-  #     end
-  #     k = KlassWithSecret.new
-  #     k.instance_eval { @secret }          #=> 99
-  #     k.instance_eval { the_secret }       #=> "Ssssh! The secret is 99."
-  #     k.instance_eval {|obj| obj == self } #=> true
-  #
-  def instance_eval: (string code, ?string filename, ?int lineno) -> untyped
-                   | [U] () { (self) [self: self] -> U } -> U
-
-  # <!--
-  #   rdoc-file=vm_eval.c
-  #   - obj.instance_exec(arg...) {|var...| block }                       -> obj
-  # -->
-  # Executes the given block within the context of the receiver (*obj*). In order
-  # to set the context, the variable `self` is set to *obj* while the code is
-  # executing, giving the code access to *obj*'s instance variables.  Arguments
-  # are passed as block parameters.
-  #
-  #     class KlassWithSecret
-  #       def initialize
-  #         @secret = 99
-  #       end
-  #     end
-  #     k = KlassWithSecret.new
-  #     k.instance_exec(5) {|x| @secret+x }   #=> 104
-  #
-  def instance_exec: [U] (*untyped, **untyped) { (?) [self: self] -> U } -> U
-
-  # <!--
-  #   rdoc-file=object.c
-  #   - BasicObject.new
-  # -->
-  # Returns a new BasicObject.
-  #
-  def initialize: () -> void
-
-  private
-
-  # <!--
-  #   rdoc-file=vm_eval.c
-  #   - obj.method_missing(symbol [, *args] )   -> result
-  # -->
-  # Invoked by Ruby when *obj* is sent a message it cannot handle. *symbol* is the
-  # symbol for the method called, and *args* are any arguments that were passed to
-  # it. By default, the interpreter raises an error when this method is called.
-  # However, it is possible to override the method to provide more dynamic
-  # behavior. If it is decided that a particular method should not be handled,
-  # then *super* should be called, so that ancestors can pick up the missing
-  # method. The example below creates a class `Roman`, which responds to methods
-  # with names consisting of roman numerals, returning the corresponding integer
-  # values.
-  #
-  #     class Roman
-  #       def roman_to_int(str)
-  #         # ...
-  #       end
-  #
-  #       def method_missing(symbol, *args)
-  #         str = symbol.id2name
-  #         begin
-  #           roman_to_int(str)
-  #         rescue
-  #           super(symbol, *args)
-  #         end
-  #       end
-  #     end
-  #
-  #     r = Roman.new
-  #     r.iv      #=> 4
-  #     r.xxiii   #=> 23
-  #     r.mm      #=> 2000
-  #     r.foo     #=> NoMethodError
-  #
-  def method_missing: (Symbol, *untyped, **untyped) ?{ (?) -> untyped } -> untyped
-
-  # <!--
-  #   rdoc-file=object.c
-  #   - singleton_method_added(symbol)
-  # -->
-  # Invoked as a callback whenever a singleton method is added to the receiver.
-  #
-  #     module Chatty
-  #       def Chatty.singleton_method_added(id)
-  #         puts "Adding #{id.id2name}"
-  #       end
-  #       def self.one()     end
-  #       def two()          end
-  #       def Chatty.three() end
-  #     end
-  #
-  # *produces:*
-  #
-  #     Adding singleton_method_added
-  #     Adding one
-  #     Adding three
-  #
-  def singleton_method_added: (Symbol name) -> nil
-
-  # <!--
-  #   rdoc-file=object.c
-  #   - singleton_method_removed(symbol)
-  # -->
-  # Invoked as a callback whenever a singleton method is removed from the
-  # receiver.
-  #
-  #     module Chatty
-  #       def Chatty.singleton_method_removed(id)
-  #         puts "Removing #{id.id2name}"
-  #       end
-  #       def self.one()     end
-  #       def two()          end
-  #       def Chatty.three() end
-  #       class << self
-  #         remove_method :three
-  #         remove_method :one
-  #       end
-  #     end
-  #
-  # *produces:*
-  #
-  #     Removing three
-  #     Removing one
-  #
-  def singleton_method_removed: (Symbol name) -> nil
-
-  # <!--
-  #   rdoc-file=object.c
-  #   - singleton_method_undefined(symbol)
-  # -->
-  # Invoked as a callback whenever a singleton method is undefined in the
-  # receiver.
-  #
-  #     module Chatty
-  #       def Chatty.singleton_method_undefined(id)
-  #         puts "Undefining #{id.id2name}"
-  #       end
-  #       def Chatty.one()   end
-  #       class << self
-  #          undef_method(:one)
-  #       end
-  #     end
-  #
-  # *produces:*
-  #
-  #     Undefining one
-  #
-  def singleton_method_undefined: (Symbol name) -> nil
-end

package/lib/ruby/gems/3.4.0/gems/rbs-3.8.0/core/binding.rbs

@@ -1,150 +0,0 @@
-# <!-- rdoc-file=proc.c -->
-# Objects of class Binding encapsulate the execution context at some particular
-# place in the code and retain this context for future use. The variables,
-# methods, value of `self`, and possibly an iterator block that can be accessed
-# in this context are all retained. Binding objects can be created using
-# Kernel#binding, and are made available to the callback of
-# Kernel#set_trace_func and instances of TracePoint.
-#
-# These binding objects can be passed as the second argument of the Kernel#eval
-# method, establishing an environment for the evaluation.
-#
-#     class Demo
-#       def initialize(n)
-#         @secret = n
-#       end
-#       def get_binding
-#         binding
-#       end
-#     end
-#
-#     k1 = Demo.new(99)
-#     b1 = k1.get_binding
-#     k2 = Demo.new(-3)
-#     b2 = k2.get_binding
-#
-#     eval("@secret", b1)   #=> 99
-#     eval("@secret", b2)   #=> -3
-#     eval("@secret")       #=> nil
-#
-# Binding objects have no class-specific methods.
-#
-class Binding
-  def clone: () -> self
-
-  def dup: () -> self
-
-  # <!--
-  #   rdoc-file=proc.c
-  #   - binding.eval(string [, filename [,lineno]])  -> obj
-  # -->
-  # Evaluates the Ruby expression(s) in *string*, in the *binding*'s context.  If
-  # the optional *filename* and *lineno* parameters are present, they will be used
-  # when reporting syntax errors.
-  #
-  #     def get_binding(param)
-  #       binding
-  #     end
-  #     b = get_binding("hello")
-  #     b.eval("param")   #=> "hello"
-  #
-  def eval: (string src, ?string filename, ?int lineno) -> untyped
-
-  # <!--
-  #   rdoc-file=proc.c
-  #   - binding.local_variable_defined?(symbol) -> obj
-  # -->
-  # Returns `true` if a local variable `symbol` exists.
-  #
-  #     def foo
-  #       a = 1
-  #       binding.local_variable_defined?(:a) #=> true
-  #       binding.local_variable_defined?(:b) #=> false
-  #     end
-  #
-  # This method is the short version of the following code:
-  #
-  #     binding.eval("defined?(#{symbol}) == 'local-variable'")
-  #
-  def local_variable_defined?: (interned varname) -> bool
-
-  # <!--
-  #   rdoc-file=proc.c
-  #   - binding.local_variable_get(symbol) -> obj
-  # -->
-  # Returns the value of the local variable `symbol`.
-  #
-  #     def foo
-  #       a = 1
-  #       binding.local_variable_get(:a) #=> 1
-  #       binding.local_variable_get(:b) #=> NameError
-  #     end
-  #
-  # This method is the short version of the following code:
-  #
-  #     binding.eval("#{symbol}")
-  #
-  def local_variable_get: (interned varname) -> untyped
-
-  # <!--
-  #   rdoc-file=proc.c
-  #   - binding.local_variable_set(symbol, obj) -> obj
-  # -->
-  # Set local variable named `symbol` as `obj`.
-  #
-  #     def foo
-  #       a = 1
-  #       bind = binding
-  #       bind.local_variable_set(:a, 2) # set existing local variable `a'
-  #       bind.local_variable_set(:b, 3) # create new local variable `b'
-  #                                      # `b' exists only in binding
-  #
-  #       p bind.local_variable_get(:a)  #=> 2
-  #       p bind.local_variable_get(:b)  #=> 3
-  #       p a                            #=> 2
-  #       p b                            #=> NameError
-  #     end
-  #
-  # This method behaves similarly to the following code:
-  #
-  #     binding.eval("#{symbol} = #{obj}")
-  #
-  # if `obj` can be dumped in Ruby code.
-  #
-  def local_variable_set: [U] (interned varname, U obj) -> U
-
-  # <!--
-  #   rdoc-file=proc.c
-  #   - binding.local_variables -> Array
-  # -->
-  # Returns the names of the binding's local variables as symbols.
-  #
-  #     def foo
-  #       a = 1
-  #       2.times do |n|
-  #         binding.local_variables #=> [:a, :n]
-  #       end
-  #     end
-  #
-  # This method is the short version of the following code:
-  #
-  #     binding.eval("local_variables")
-  #
-  def local_variables: () -> Array[Symbol]
-
-  # <!--
-  #   rdoc-file=proc.c
-  #   - binding.receiver    -> object
-  # -->
-  # Returns the bound receiver of the binding object.
-  #
-  def receiver: () -> untyped
-
-  # <!--
-  #   rdoc-file=proc.c
-  #   - binding.source_location  -> [String, Integer]
-  # -->
-  # Returns the Ruby source filename and line number of the binding object.
-  #
-  def source_location: () -> [String, Integer]
-end