File Manager
# Object is the default root of all Ruby objects. Object inherits from
# BasicObject which allows creating alternate object hierarchies. Methods on
# Object are available to all classes unless explicitly overridden.
#
# Object mixes in the Kernel module, making the built-in kernel functions
# globally accessible. Although the instance methods of Object are defined by
# the Kernel module, we have chosen to document them here for clarity.
#
# When referencing constants in classes inheriting from Object you do not need
# to use the full namespace. For example, referencing `File` inside `YourClass`
# will find the top-level File class.
#
# In the descriptions of Object's methods, the parameter *symbol* refers to a
# symbol, which is either a quoted string or a Symbol (such as `:name`).
#
class Object < BasicObject
include Kernel
# Returns true if two objects do not match (using the *=~* method), otherwise
# false.
#
def !~: (untyped) -> bool
# Returns 0 if `obj` and `other` are the same object or `obj == other`,
# otherwise nil.
#
# The `<=>` is used by various methods to compare objects, for example
# Enumerable#sort, Enumerable#max etc.
#
# Your implementation of `<=>` should return one of the following values: -1, 0,
# 1 or nil. -1 means self is smaller than other. 0 means self is equal to other.
# 1 means self is bigger than other. Nil means the two values could not be
# compared.
#
# When you define `<=>`, you can include Comparable to gain the methods `<=`,
# `<`, `==`, `>=`, `>` and `between?`.
#
def <=>: (untyped) -> Integer?
# Case Equality -- For class Object, effectively the same as calling `#==`, but
# typically overridden by descendants to provide meaningful semantics in `case`
# statements.
#
def ===: (untyped) -> bool
# This method is deprecated.
#
# This is not only unuseful but also troublesome because it may hide a type
# error.
#
def =~: (untyped) -> bool
# Returns the class of *obj*. This method must always be called with an explicit
# receiver, as `class` is also a reserved word in Ruby.
#
# 1.class #=> Integer
# self.class #=> Object
#
def `class`: () -> untyped
# Produces a shallow copy of *obj*---the instance variables of *obj* are copied,
# but not the objects they reference. `clone` copies the frozen (unless :freeze
# keyword argument is given with a false value) and tainted state of *obj*. See
# also the discussion under `Object#dup`.
#
# class Klass
# attr_accessor :str
# end
# s1 = Klass.new #=> #<Klass:0x401b3a38>
# s1.str = "Hello" #=> "Hello"
# s2 = s1.clone #=> #<Klass:0x401b3998 @str="Hello">
# s2.str[1,4] = "i" #=> "i"
# s1.inspect #=> "#<Klass:0x401b3a38 @str=\"Hi\">"
# s2.inspect #=> "#<Klass:0x401b3998 @str=\"Hi\">"
#
# This method may have class-specific behavior. If so, that behavior will be
# documented under the #`initialize_copy` method of the class.
#
def clone: (?freeze: bool) -> self
# Defines a singleton method in the receiver. The *method* parameter can be a
# `Proc`, a `Method` or an `UnboundMethod` object. If a block is specified, it
# is used as the method body.
#
# class A
# class << self
# def class_name
# to_s
# end
# end
# end
# A.define_singleton_method(:who_am_i) do
# "I am: #{class_name}"
# end
# A.who_am_i # ==> "I am: A"
#
# guy = "Bob"
# guy.define_singleton_method(:hello) { "#{self}: Hello there!" }
# guy.hello #=> "Bob: Hello there!"
#
def define_singleton_method: (Symbol, Method | UnboundMethod) -> Symbol
| (Symbol) { (*untyped) -> untyped } -> Symbol
# Prints *obj* on the given port (default `$>`). Equivalent to:
#
# def display(port=$>)
# port.write self
# nil
# end
#
# For example:
#
# 1.display
# "cat".display
# [ 4, 5, 6 ].display
# puts
#
# *produces:*
#
# 1cat[4, 5, 6]
#
def display: (?_Writeable port) -> void
# Produces a shallow copy of *obj*---the instance variables of *obj* are copied,
# but not the objects they reference. `dup` copies the tainted state of *obj*.
#
# This method may have class-specific behavior. If so, that behavior will be
# documented under the #`initialize_copy` method of the class.
#
# ### on dup vs clone
#
# In general, `clone` and `dup` may have different semantics in descendant
# classes. While `clone` is used to duplicate an object, including its internal
# state, `dup` typically uses the class of the descendant object to create the
# new instance.
#
# When using #dup, any modules that the object has been extended with will not
# be copied.
#
# class Klass
# attr_accessor :str
# end
#
# module Foo
# def foo; 'foo'; end
# end
#
# s1 = Klass.new #=> #<Klass:0x401b3a38>
# s1.extend(Foo) #=> #<Klass:0x401b3a38>
# s1.foo #=> "foo"
#
# s2 = s1.clone #=> #<Klass:0x401b3a38>
# s2.foo #=> "foo"
#
# s3 = s1.dup #=> #<Klass:0x401b3a38>
# s3.foo #=> NoMethodError: undefined method `foo' for #<Klass:0x401b3a38>
#
def dup: () -> self
# Creates a new Enumerator which will enumerate by calling `method` on `obj`,
# passing `args` if any.
#
# If a block is given, it will be used to calculate the size of the enumerator
# without the need to iterate it (see Enumerator#size).
#
# ### Examples
#
# str = "xyz"
#
# enum = str.enum_for(:each_byte)
# enum.each { |b| puts b }
# # => 120
# # => 121
# # => 122
#
# # protect an array from being modified by some_method
# a = [1, 2, 3]
# some_method(a.to_enum)
#
# It is typical to call to_enum when defining methods for a generic Enumerable,
# in case no block is passed.
#
# Here is such an example, with parameter passing and a sizing block:
#
# module Enumerable
# # a generic method to repeat the values of any enumerable
# def repeat(n)
# raise ArgumentError, "#{n} is negative!" if n < 0
# unless block_given?
# return to_enum(__method__, n) do # __method__ is :repeat here
# sz = size # Call size and multiply by n...
# sz * n if sz # but return nil if size itself is nil
# end
# end
# each do |*val|
# n.times { yield *val }
# end
# end
# end
#
# %i[hello world].repeat(2) { |w| puts w }
# # => Prints 'hello', 'hello', 'world', 'world'
# enum = (1..14).repeat(3)
# # => returns an Enumerator when called without a block
# enum.first(4) # => [1, 1, 1, 2]
# enum.size # => 42
#
def enum_for: (Symbol method, *untyped args) ?{ (*untyped args) -> Integer } -> Enumerator[untyped, untyped]
| (*untyped args) ?{ (*untyped args) -> Integer } -> Enumerator[untyped, untyped]
# Creates a new Enumerator which will enumerate by calling `method` on `obj`,
# passing `args` if any.
#
# If a block is given, it will be used to calculate the size of the enumerator
# without the need to iterate it (see Enumerator#size).
#
# ### Examples
#
# str = "xyz"
#
# enum = str.enum_for(:each_byte)
# enum.each { |b| puts b }
# # => 120
# # => 121
# # => 122
#
# # protect an array from being modified by some_method
# a = [1, 2, 3]
# some_method(a.to_enum)
#
# It is typical to call to_enum when defining methods for a generic Enumerable,
# in case no block is passed.
#
# Here is such an example, with parameter passing and a sizing block:
#
# module Enumerable
# # a generic method to repeat the values of any enumerable
# def repeat(n)
# raise ArgumentError, "#{n} is negative!" if n < 0
# unless block_given?
# return to_enum(__method__, n) do # __method__ is :repeat here
# sz = size # Call size and multiply by n...
# sz * n if sz # but return nil if size itself is nil
# end
# end
# each do |*val|
# n.times { yield *val }
# end
# end
# end
#
# %i[hello world].repeat(2) { |w| puts w }
# # => Prints 'hello', 'hello', 'world', 'world'
# enum = (1..14).repeat(3)
# # => returns an Enumerator when called without a block
# enum.first(4) # => [1, 1, 1, 2]
# enum.size # => 42
#
alias to_enum enum_for
# 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 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 eql?: (untyped) -> bool
# Adds to *obj* the instance methods from each module given as a parameter.
#
# module Mod
# def hello
# "Hello from Mod.\n"
# end
# end
#
# class Klass
# def hello
# "Hello from Klass.\n"
# end
# end
#
# k = Klass.new
# k.hello #=> "Hello from Klass.\n"
# k.extend(Mod) #=> #<Klass:0x401b3bc8>
# k.hello #=> "Hello from Mod.\n"
#
def `extend`: (*Module) -> self
# Prevents further modifications to *obj*. A `RuntimeError` will be raised if
# modification is attempted. There is no way to unfreeze a frozen object. See
# also `Object#frozen?`.
#
# This method returns self.
#
# a = [ "a", "b", "c" ]
# a.freeze
# a << "z"
#
# *produces:*
#
# prog.rb:3:in `<<': can't modify frozen Array (FrozenError)
# from prog.rb:3
#
# Objects of the following classes are always frozen: Integer, Float, Symbol.
#
def freeze: () -> self
# Returns the freeze status of *obj*.
#
# a = [ "a", "b", "c" ]
# a.freeze #=> ["a", "b", "c"]
# a.frozen? #=> true
#
def frozen?: () -> bool
def hash: () -> Integer
# Returns a string containing a human-readable representation of *obj*. The
# default `inspect` shows the object's class name, an encoding of the object id,
# and a list of the instance variables and their values (by calling #inspect on
# each of them). User defined classes should override this method to provide a
# better representation of *obj*. When overriding this method, it should return
# a string whose encoding is compatible with the default external encoding.
#
# [ 1, 2, 3..4, 'five' ].inspect #=> "[1, 2, 3..4, \"five\"]"
# Time.new.inspect #=> "2008-03-08 19:43:39 +0900"
#
# class Foo
# end
# Foo.new.inspect #=> "#<Foo:0x0300c868>"
#
# class Bar
# def initialize
# @bar = 1
# end
# end
# Bar.new.inspect #=> "#<Bar:0x0300c868 @bar=1>"
#
def inspect: () -> String
# Returns `true` if *obj* is an instance of the given class. See also
# `Object#kind_of?`.
#
# class A; end
# class B < A; end
# class C < B; end
#
# b = B.new
# b.instance_of? A #=> false
# b.instance_of? B #=> true
# b.instance_of? C #=> false
#
def instance_of?: (Module) -> bool
# Returns `true` if the given instance variable is defined in *obj*. String
# arguments are converted to symbols.
#
# class Fred
# def initialize(p1, p2)
# @a, @b = p1, p2
# end
# end
# fred = Fred.new('cat', 99)
# fred.instance_variable_defined?(:@a) #=> true
# fred.instance_variable_defined?("@b") #=> true
# fred.instance_variable_defined?("@c") #=> false
#
def instance_variable_defined?: (String | Symbol var) -> bool
# Returns the value of the given instance variable, or nil if the instance
# variable is not set. The `@` part of the variable name should be included for
# regular instance variables. Throws a `NameError` exception if the supplied
# symbol is not valid as an instance variable name. String arguments are
# converted to symbols.
#
# class Fred
# def initialize(p1, p2)
# @a, @b = p1, p2
# end
# end
# fred = Fred.new('cat', 99)
# fred.instance_variable_get(:@a) #=> "cat"
# fred.instance_variable_get("@b") #=> 99
#
def instance_variable_get: (String | Symbol var) -> untyped
# Sets the instance variable named by *symbol* to the given object, thereby
# frustrating the efforts of the class's author to attempt to provide proper
# encapsulation. The variable does not have to exist prior to this call. If the
# instance variable name is passed as a string, that string is converted to a
# symbol.
#
# class Fred
# def initialize(p1, p2)
# @a, @b = p1, p2
# end
# end
# fred = Fred.new('cat', 99)
# fred.instance_variable_set(:@a, 'dog') #=> "dog"
# fred.instance_variable_set(:@c, 'cat') #=> "cat"
# fred.inspect #=> "#<Fred:0x401b3da8 @a=\"dog\", @b=99, @c=\"cat\">"
#
def instance_variable_set: [X] (String | Symbol var, X value) -> X
# Returns an array of instance variable names for the receiver. Note that simply
# defining an accessor does not create the corresponding instance variable.
#
# class Fred
# attr_accessor :a1
# def initialize
# @iv = 3
# end
# end
# Fred.new.instance_variables #=> [:@iv]
#
def instance_variables: () -> Array[Symbol]
# Returns `true` if *class* is the class of *obj*, or if *class* is one of the
# superclasses of *obj* or modules included in *obj*.
#
# module M; end
# class A
# include M
# end
# class B < A; end
# class C < B; end
#
# b = B.new
# b.is_a? A #=> true
# b.is_a? B #=> true
# b.is_a? C #=> false
# b.is_a? M #=> true
#
# b.kind_of? A #=> true
# b.kind_of? B #=> true
# b.kind_of? C #=> false
# b.kind_of? M #=> true
#
def is_a?: (Module) -> bool
# Returns `true` if *class* is the class of *obj*, or if *class* is one of the
# superclasses of *obj* or modules included in *obj*.
#
# module M; end
# class A
# include M
# end
# class B < A; end
# class C < B; end
#
# b = B.new
# b.is_a? A #=> true
# b.is_a? B #=> true
# b.is_a? C #=> false
# b.is_a? M #=> true
#
# b.kind_of? A #=> true
# b.kind_of? B #=> true
# b.kind_of? C #=> false
# b.kind_of? M #=> true
#
alias kind_of? is_a?
# Returns the receiver.
#
# string = "my string"
# string.itself.object_id == string.object_id #=> true
#
def `itself`: () -> self
# Looks up the named method as a receiver in *obj*, returning a `Method` object
# (or raising `NameError`). The `Method` object acts as a closure in *obj*'s
# object instance, so instance variables and the value of `self` remain
# available.
#
# class Demo
# def initialize(n)
# @iv = n
# end
# def hello()
# "Hello, @iv = #{@iv}"
# end
# end
#
# k = Demo.new(99)
# m = k.method(:hello)
# m.call #=> "Hello, @iv = 99"
#
# l = Demo.new('Fred')
# m = l.method("hello")
# m.call #=> "Hello, @iv = Fred"
#
# Note that `Method` implements `to_proc` method, which means it can be used
# with iterators.
#
# [ 1, 2, 3 ].each(&method(:puts)) # => prints 3 lines to stdout
#
# out = File.open('test.txt', 'w')
# [ 1, 2, 3 ].each(&out.method(:puts)) # => prints 3 lines to file
#
# require 'date'
# %w[2017-03-01 2017-03-02].collect(&Date.method(:parse))
# #=> [#<Date: 2017-03-01 ((2457814j,0s,0n),+0s,2299161j)>, #<Date: 2017-03-02 ((2457815j,0s,0n),+0s,2299161j)>]
#
def method: (String | Symbol name) -> Method
# Returns a list of the names of public and protected methods of *obj*. This
# will include all the methods accessible in *obj*'s ancestors. If the optional
# parameter is `false`, it returns an array of *obj<i>'s public and protected
# singleton methods, the array will not include methods in modules included in
# <i>obj*.
#
# class Klass
# def klass_method()
# end
# end
# k = Klass.new
# k.methods[0..9] #=> [:klass_method, :nil?, :===,
# # :==~, :!, :eql?
# # :hash, :<=>, :class, :singleton_class]
# k.methods.length #=> 56
#
# k.methods(false) #=> []
# def k.singleton_method; end
# k.methods(false) #=> [:singleton_method]
#
# module M123; def m123; end end
# k.extend M123
# k.methods(false) #=> [:singleton_method]
#
def methods: () -> Array[Symbol]
# Only the object *nil* responds `true` to `nil?`.
#
# Object.new.nil? #=> false
# nil.nil? #=> true
#
def `nil?`: () -> bool
# 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.
#
# 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 object_id: () -> Integer
# Returns the list of private methods accessible to *obj*. If the *all*
# parameter is set to `false`, only those methods in the receiver will be
# listed.
#
def private_methods: () -> Array[Symbol]
# Returns the list of protected methods accessible to *obj*. If the *all*
# parameter is set to `false`, only those methods in the receiver will be
# listed.
#
def protected_methods: () -> Array[Symbol]
# Similar to *method*, searches public method only.
#
def public_method: (name name) -> Method
# Invokes the method identified by *symbol*, passing it any arguments specified.
# Unlike send, public_send calls public methods only. When the method is
# identified by a string, the string is converted to a symbol.
#
# 1.public_send(:puts, "hello") # causes NoMethodError
#
def `public_send`: (name name, *untyped args) ?{ (*untyped) -> untyped } -> untyped
# Removes the named instance variable from *obj*, returning that variable's
# value. String arguments are converted to symbols.
#
# class Dummy
# attr_reader :var
# def initialize
# @var = 99
# end
# def remove
# remove_instance_variable(:@var)
# end
# end
# d = Dummy.new
# d.var #=> 99
# d.remove #=> 99
# d.var #=> nil
#
def remove_instance_variable: (name name) -> untyped
# Returns `true` if *obj* responds to the given method. Private and protected
# methods are included in the search only if the optional second parameter
# evaluates to `true`.
#
# If the method is not implemented, as Process.fork on Windows, File.lchmod on
# GNU/Linux, etc., false is returned.
#
# If the method is not defined, `respond_to_missing?` method is called and the
# result is returned.
#
# When the method name parameter is given as a string, the string is converted
# to a symbol.
#
def respond_to?: (name name, ?boolish include_all) -> bool
# Invokes the method identified by *symbol*, passing it any arguments specified.
# You can use `__send__` if the name `send` clashes with an existing method in
# *obj*. When the method is identified by a string, the string is converted to a
# symbol.
#
# class Klass
# def hello(*args)
# "Hello " + args.join(' ')
# end
# end
# k = Klass.new
# k.send :hello, "gentle", "readers" #=> "Hello gentle readers"
#
def `send`: (name name, *untyped args) ?{ (*untyped) -> untyped } -> untyped
# Returns the singleton class of *obj*. This method creates a new singleton
# class if *obj* does not have one.
#
# If *obj* is `nil`, `true`, or `false`, it returns NilClass, TrueClass, or
# FalseClass, respectively. If *obj* is an Integer, a Float or a Symbol, it
# raises a TypeError.
#
# Object.new.singleton_class #=> #<Class:#<Object:0xb7ce1e24>>
# String.singleton_class #=> #<Class:String>
# nil.singleton_class #=> NilClass
#
def `singleton_class`: () -> Class
# Similar to *method*, searches singleton method only.
#
# class Demo
# def initialize(n)
# @iv = n
# end
# def hello()
# "Hello, @iv = #{@iv}"
# end
# end
#
# k = Demo.new(99)
# def k.hi
# "Hi, @iv = #{@iv}"
# end
# m = k.singleton_method(:hi)
# m.call #=> "Hi, @iv = 99"
# m = k.singleton_method(:hello) #=> NameError
#
def singleton_method: (name name) -> Method
# Returns an array of the names of singleton methods for *obj*. If the optional
# *all* parameter is true, the list will include methods in modules included in
# *obj*. Only public and protected singleton methods are returned.
#
# module Other
# def three() end
# end
#
# class Single
# def Single.four() end
# end
#
# a = Single.new
#
# def a.one()
# end
#
# class << a
# include Other
# def two()
# end
# end
#
# Single.singleton_methods #=> [:four]
# a.singleton_methods(false) #=> [:two, :one]
# a.singleton_methods #=> [:two, :one, :three]
#
def singleton_methods: () -> Array[Symbol]
# Mark the object as tainted.
#
# Objects that are marked as tainted will be restricted from various built-in
# methods. This is to prevent insecure data, such as command-line arguments or
# strings read from Kernel#gets, from inadvertently compromising the user's
# system.
#
# To check whether an object is tainted, use #tainted?.
#
# You should only untaint a tainted object if your code has inspected it and
# determined that it is safe. To do so use #untaint.
#
def taint: () -> self
# Deprecated method that is equivalent to #taint.
#
alias untrust taint
# Returns true if the object is tainted.
#
# See #taint for more information.
#
def tainted?: () -> bool
# Deprecated method that is equivalent to #tainted?.
#
alias untrusted? tainted?
# Yields self to the block, and then returns self. The primary purpose of this
# method is to "tap into" a method chain, in order to perform operations on
# intermediate results within the chain.
#
# (1..10) .tap {|x| puts "original: #{x}" }
# .to_a .tap {|x| puts "array: #{x}" }
# .select {|x| x.even? } .tap {|x| puts "evens: #{x}" }
# .map {|x| x*x } .tap {|x| puts "squares: #{x}" }
#
def tap: () { (self) -> void } -> self
# Yields self to the block and returns the result of the block.
#
# 3.next.then {|x| x**x }.to_s #=> "256"
# "my string".yield_self {|s| s.upcase } #=> "MY STRING"
#
# Good usage for `yield_self` is value piping in method chains:
#
# require 'open-uri'
# require 'json'
#
# construct_url(arguments).
# yield_self {|url| open(url).read }.
# yield_self {|response| JSON.parse(response) }
#
# When called without block, the method returns `Enumerator`, which can be used,
# for example, for conditional circuit-breaking:
#
# # meets condition, no-op
# 1.yield_self.detect(&:odd?) # => 1
# # does not meet condition, drop value
# 2.yield_self.detect(&:odd?) # => nil
#
def `yield_self`: [X] () { (self) -> X } -> X
| () -> Enumerator[self, untyped]
# Returns a string representing *obj*. The default `to_s` prints the object's
# class and an encoding of the object id. As a special case, the top-level
# object that is the initial execution context of Ruby programs returns
# ``main''.
#
def to_s: () -> String
# Removes the tainted mark from the object.
#
# See #taint for more information.
#
def untaint: () -> self
# Deprecated method that is equivalent to #untaint.
#
alias trust untaint
# Yields self to the block and returns the result of the block.
#
# 3.next.then {|x| x**x }.to_s #=> "256"
# "my string".yield_self {|s| s.upcase } #=> "MY STRING"
#
# Good usage for `yield_self` is value piping in method chains:
#
# require 'open-uri'
# require 'json'
#
# construct_url(arguments).
# yield_self {|url| open(url).read }.
# yield_self {|response| JSON.parse(response) }
#
# When called without block, the method returns `Enumerator`, which can be used,
# for example, for conditional circuit-breaking:
#
# # meets condition, no-op
# 1.yield_self.detect(&:odd?) # => 1
# # does not meet condition, drop value
# 2.yield_self.detect(&:odd?) # => nil
#
alias then yield_self
end
interface _Writeable
def write: (untyped) -> void
end
type Object::name = Symbol | String
File Manager Version 1.0, Coded By Lucas
Email: hehe@yahoo.com