# class Object

`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`).

### Constants

ARGF

  `ARGF` is a stream designed for use in scripts that process files given as command-line arguments or passed in via `STDIN`.

  See `ARGF` (the class) for more details.

ARGV

  `ARGV` contains the command line arguments used to run ruby.

  A library like `OptionParser` can be used to process command-line arguments.

Bignum

  An obsolete class, use `Integer`

DATA

  `DATA` is a `File` that contains the data section of the executed file. To create a data section use `__END__`:

      $ cat t.rb
      puts DATA.gets
      __END__
      hello world!

      $ ruby t.rb
      hello world!

ENV

  `ENV` is a Hash-like accessor for environment variables.

  See `ENV` (the class) for more details.

FALSE

  An obsolete alias of `false`

Fixnum

  An obsolete class, use `Integer`

NIL

  An obsolete alias of `nil`

ParseError
RUBY_COPYRIGHT

  The copyright string for ruby

RUBY_DESCRIPTION

  The full ruby version string, like `ruby -v` prints

RUBY_ENGINE

  The engine or interpreter this ruby uses.

RUBY_ENGINE_VERSION

  The version of the engine or interpreter this ruby uses.

RUBY_PATCHLEVEL

  The patchlevel for this ruby. If this is a development build of ruby the patchlevel will be -1

RUBY_PLATFORM

  The platform for this ruby

RUBY_RELEASE_DATE

  The date this ruby was released

RUBY_REVISION

  The SVN revision for this ruby.

RUBY_VERSION

  The running version of ruby

STDERR

  Holds the original stderr

STDIN

  Holds the original stdin

STDOUT

  Holds the original stdout

Synchronizer

  A class that provides two-phase lock with a counter. See `Sync_m` for details.

Synchronizer_m

  A module that provides a two-phase lock with a counter.

TOPLEVEL_BINDING

  The `Binding` of the top level scope

TRUE

  An obsolete alias of `true`

ThWait

  This class watches for termination of multiple threads. Basic functionality (wait until specified threads have terminated) can be accessed through the class method `ThreadsWait::all_waits`. Finer control can be gained using instance methods.

  Example:

      ThreadsWait.all_waits(thr1, thr2, ...) do |t|
        STDERR.puts "Thread #{t} has terminated."
      end

      th = ThreadsWait.new(thread1,...)
      th.next_wait # next one to be done

TimeoutError

  Raised by `Timeout.timeout` when the block times out.

### Public Class Methods

yaml_tag(url) click to toggle source

    # File ext/psych/lib/psych/core_ext.rb, line 3
    def self.yaml_tag url
      Psych.add_tag(url, self)
    end

### Public Instance Methods

obj !~ other → true or false click to toggle source

Returns true if two objects do not match (using the =~ method), otherwise false.

    static VALUE
    rb_obj_not_match(VALUE obj1, VALUE obj2)
    {
        VALUE result = rb_funcall(obj1, id_match, 1, obj2);
        return RTEST(result) ? Qfalse : Qtrue;
    }

obj <=> other → 0 or nil click to toggle source

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?`.

    static VALUE
    rb_obj_cmp(VALUE obj1, VALUE obj2)
    {
        if (obj1 == obj2 || rb_equal(obj1, obj2))
            return INT2FIX(0);
        return Qnil;
    }

obj === other → true or false click to toggle source

Case Equality – For class `Object`, effectively the same as calling `#==`, but typically overridden by descendants to provide meaningful semantics in `case` statements.

    VALUE
    rb_equal(VALUE obj1, VALUE obj2)
    {
        VALUE result;

        if (obj1 == obj2) return Qtrue;
        result = rb_equal_opt(obj1, obj2);
        if (result == Qundef) {
            result = rb_funcall(obj1, id_eq, 1, obj2);
        }
        if (RTEST(result)) return Qtrue;
        return Qfalse;
    }

obj =~ other → nil click to toggle source

This method is deprecated.

This is not only unuseful but also troublesome because it may hide a type error.

    static VALUE
    rb_obj_match(VALUE obj1, VALUE obj2)
    {
        rb_warning("deprecated Object#=~ is called on %"PRIsVALUE
                   "; it always returns nil", rb_obj_class(obj1));
        return Qnil;
    }

CSV(*args, &block) click to toggle source

Passes `args` to `CSV::instance`.

    CSV("CSV,data").read
      #=> [["CSV", "data"]]

If a block is given, the instance is passed the block and the return value becomes the return value of the block.

    CSV("CSV,data") { |c|
      c.read.any? { |a| a.include?("data") }
    } #=> true

    CSV("CSV,data") { |c|
      c.read.any? { |a| a.include?("zombies") }
    } #=> false

    # File lib/csv.rb, line 1459
    def CSV(*args, &block)
      CSV.instance(*args, &block)
    end

DelegateClass(superclass) click to toggle source

The primary interface to this library. Use to setup delegation when defining your class.

    class MyClass < DelegateClass(ClassToDelegateTo) # Step 1
      def initialize
        super(obj_of_ClassToDelegateTo)              # Step 2
      end
    end

Here's a sample of use from `Tempfile` which is really a `File` object with a few special rules about storage location and when the `File` should be deleted. That makes for an almost textbook perfect example of how to use delegation.

    class Tempfile < DelegateClass(File)
      # constant and class member data initialization...

      def initialize(basename, tmpdir=Dir::tmpdir)
        # build up file path/name in var tmpname...

        @tmpfile = File.open(tmpname, File::RDWR|File::CREAT|File::EXCL, 0600)

        # ...

        super(@tmpfile)

        # below this point, all methods of File are supported...
      end

      # ...
    end

Calls superclass method

    # File lib/delegate.rb, line 386
    def DelegateClass(superclass)
      klass = Class.new(Delegator)
      methods = superclass.instance_methods
      methods -= ::Delegator.public_api
      methods -= [:to_s, :inspect, :=~, :!~, :===]
      klass.module_eval do
        def __getobj__ # :nodoc:
          unless defined?(@delegate_dc_obj)
            return yield if block_given?
            __raise__ ::ArgumentError, "not delegated"
          end
          @delegate_dc_obj
        end
        def __setobj__(obj)  # :nodoc:
          __raise__ ::ArgumentError, "cannot delegate to self" if self.equal?(obj)
          @delegate_dc_obj = obj
        end
        methods.each do |method|
          define_method(method, Delegator.delegating_block(method))
        end
      end
      klass.define_singleton_method :public_instance_methods do |all=true|
        super(all) - superclass.protected_instance_methods
      end
      klass.define_singleton_method :protected_instance_methods do |all=true|
        super(all) | superclass.protected_instance_methods
      end
      return klass
    end

Digest(name) → digest_subclass click to toggle source

Returns a `Digest` subclass by `name` in a thread-safe manner even when on-demand loading is involved.

    require 'digest'

    Digest("MD5")
    # => Digest::MD5

    Digest(:SHA256)
    # => Digest::SHA256

    Digest(:Foo)
    # => LoadError: library not found for class Digest::Foo -- digest/foo

    # File ext/digest/lib/digest.rb, line 96
    def Digest(name)
      const = name.to_sym
      Digest::REQUIRE_MUTEX.synchronize {
        # Ignore autoload's because it is void when we have #const_missing
        Digest.const_missing(const)
      }
    rescue LoadError
      # Constants do not necessarily rely on digest/*.
      if Digest.const_defined?(const)
        Digest.const_get(const)
      else
        raise
      end
    end

class → class click to toggle source

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

    VALUE
    rb_obj_class(VALUE obj)
    {
        return rb_class_real(CLASS_OF(obj));
    }

clone(freeze: true) → an_object click to toggle source

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.

    static VALUE
    rb_obj_clone2(int argc, VALUE *argv, VALUE obj)
    {
        int kwfreeze = freeze_opt(argc, argv);
        if (!special_object_p(obj))
            return mutable_obj_clone(obj, kwfreeze);
        return immutable_obj_clone(obj, kwfreeze);
    }

dclone() click to toggle source

provides a unified `clone` operation, for `REXML::XPathParser` to use across multiple `Object` types

    # File lib/rexml/xpath_parser.rb, line 11
    def dclone
      clone
    end

define_singleton_method(symbol, method) → symbol click to toggle source
define_singleton_method(symbol) { block } → symbol

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!"

    static VALUE
    rb_obj_define_method(int argc, VALUE *argv, VALUE obj)
    {
        VALUE klass = rb_singleton_class(obj);

        return rb_mod_define_method(argc, argv, klass);
    }

display(port=$>) → nil click to toggle source

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]

    static VALUE
    rb_obj_display(int argc, VALUE *argv, VALUE self)
    {
        VALUE out;

        out = (!rb_check_arity(argc, 0, 1) ? rb_stdout : argv[0]);
        rb_io_write(out, self);

        return Qnil;
    }

dup → an_object click to toggle source

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>

    VALUE
    rb_obj_dup(VALUE obj)
    {
        VALUE dup;

        if (special_object_p(obj)) {
            return obj;
        }
        dup = rb_obj_alloc(rb_obj_class(obj));
        init_copy(dup, obj);
        rb_funcall(dup, id_init_dup, 1, obj);

        return dup;
    }

enum_for(method = :each, *args) → enum click to toggle source
enum_for(method = :each, *args){|*args| block} → enum

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

    static VALUE
    obj_to_enum(int argc, VALUE *argv, VALUE obj)
    {
        VALUE enumerator, meth = sym_each;

        if (argc > 0) {
            --argc;
            meth = *argv++;
        }
        enumerator = rb_enumeratorize_with_size(obj, meth, argc, argv, 0);
        if (rb_block_given_p()) {
            enumerator_ptr(enumerator)->size = rb_block_proc();
        }
        return enumerator;
    }

obj == other → true or false click to toggle source
equal?(other) → true or false
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 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

    MJIT_FUNC_EXPORTED VALUE
    rb_obj_equal(VALUE obj1, VALUE obj2)
    {
        if (obj1 == obj2) return Qtrue;
        return Qfalse;
    }

extend(module, ...) → obj click to toggle source

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"

    static VALUE
    rb_obj_extend(int argc, VALUE *argv, VALUE obj)
    {
        int i;
        ID id_extend_object, id_extended;

        CONST_ID(id_extend_object, "extend_object");
        CONST_ID(id_extended, "extended");

        rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
        for (i = 0; i < argc; i++)
            Check_Type(argv[i], T_MODULE);
        while (argc--) {
            rb_funcall(argv[argc], id_extend_object, 1, obj);
            rb_funcall(argv[argc], id_extended, 1, obj);
        }
        return obj;
    }

freeze → obj click to toggle source

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`.

    VALUE
    rb_obj_freeze(VALUE obj)
    {
        if (!OBJ_FROZEN(obj)) {
            OBJ_FREEZE(obj);
            if (SPECIAL_CONST_P(obj)) {
                rb_bug("special consts should be frozen.");
            }
        }
        return obj;
    }

frozen? → true or false click to toggle source

Returns the freeze status of obj.

    a = [ "a", "b", "c" ]
    a.freeze    #=> ["a", "b", "c"]
    a.frozen?   #=> true

    VALUE
    rb_obj_frozen_p(VALUE obj)
    {
        return OBJ_FROZEN(obj) ? Qtrue : Qfalse;
    }

gemfile(install = false, options = {}, &gemfile) click to toggle source

Allows for declaring a Gemfile inline in a ruby script, optionally installing any gems that aren't already installed on the user's system.

@note Every gem that is specified in this 'Gemfile' will be `require`d, as if

    the user had manually called `Bundler.require`. To avoid a requested gem
    being automatically required, add the `:require => false` option to the
    `gem` dependency declaration.

@param install [Boolean] whether gems that aren't already installed on the

    user's system should be installed.
    Defaults to `false`.

@param gemfile [Proc] a block that is evaluated as a `Gemfile`.

@example Using an inline Gemfile

    #!/usr/bin/env ruby

    require 'bundler/inline'

    gemfile do
      source 'https://rubygems.org'
      gem 'json', require: false
      gem 'nap', require: 'rest'
      gem 'cocoapods', '~> 0.34.1'
    end

    puts Pod::VERSION # => "0.34.4"

    # File lib/bundler/inline.rb, line 34
    def gemfile(install = false, options = {}, &gemfile)
      require "bundler"

      opts = options.dup
      ui = opts.delete(:ui) { Bundler::UI::Shell.new }
      raise ArgumentError, "Unknown options: #{opts.keys.join(", ")}" unless opts.empty?

      old_root = Bundler.method(:root)
      def Bundler.root
        Bundler::SharedHelpers.pwd.expand_path
      end
      Bundler::SharedHelpers.set_env "BUNDLE_GEMFILE", "Gemfile"

      Bundler::Plugin.gemfile_install(&gemfile) if Bundler.feature_flag.plugins?
      builder = Bundler::Dsl.new
      builder.instance_eval(&gemfile)

      definition = builder.to_definition(nil, true)
      def definition.lock(*); end
      definition.validate_runtime!

      missing_specs = proc do
        definition.missing_specs?
      end

      Bundler.ui = ui if install
      if install || missing_specs.call
        Bundler.settings.temporary(:inline => true) do
          installer = Bundler::Installer.install(Bundler.root, definition, :system => true)
          installer.post_install_messages.each do |name, message|
            Bundler.ui.info "Post-install message from #{name}:\n#{message}"
          end
        end
      end

      runtime = Bundler::Runtime.new(nil, definition)
      runtime.setup.require
    ensure
      bundler_module = class << Bundler; self; end
      bundler_module.send(:define_method, :root, old_root) if old_root
    end

inspect → string click to toggle source

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>"

    static VALUE
    rb_obj_inspect(VALUE obj)
    {
        if (rb_ivar_count(obj) > 0) {
            VALUE str;
            VALUE c = rb_class_name(CLASS_OF(obj));

            str = rb_sprintf("-<%"PRIsVALUE":%p", c, (void*)obj);
            return rb_exec_recursive(inspect_obj, obj, str);
        }
        else {
            return rb_any_to_s(obj);
        }
    }

instance_of?(class) → true or false click to toggle source

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

    VALUE
    rb_obj_is_instance_of(VALUE obj, VALUE c)
    {
        c = class_or_module_required(c);
        if (rb_obj_class(obj) == c) return Qtrue;
        return Qfalse;
    }

instance_variable_defined?(symbol) → true or false click to toggle source
instance_variable_defined?(string) → true or false

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

    static VALUE
    rb_obj_ivar_defined(VALUE obj, VALUE iv)
    {
        ID id = id_for_var(obj, iv, an, instance);

        if (!id) {
            return Qfalse;
        }
        return rb_ivar_defined(obj, id);
    }

instance_variable_get(symbol) → obj click to toggle source
instance_variable_get(string) → obj

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

    static VALUE
    rb_obj_ivar_get(VALUE obj, VALUE iv)
    {
        ID id = id_for_var(obj, iv, an, instance);

        if (!id) {
            return Qnil;
        }
        return rb_ivar_get(obj, id);
    }

instance_variable_set(symbol, obj) → obj click to toggle source
instance_variable_set(string, obj) → obj

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\">"

    static VALUE
    rb_obj_ivar_set(VALUE obj, VALUE iv, VALUE val)
    {
        ID id = id_for_var(obj, iv, an, instance);
        if (!id) id = rb_intern_str(iv);
        return rb_ivar_set(obj, id, val);
    }

instance_variables → array click to toggle source

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]

    VALUE
    rb_obj_instance_variables(VALUE obj)
    {
        VALUE ary;

        ary = rb_ary_new();
        rb_ivar_foreach(obj, ivar_i, ary);
        return ary;
    }

is_a?(class) → true or false click to toggle source

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

    VALUE
    rb_obj_is_kind_of(VALUE obj, VALUE c)
    {
        VALUE cl = CLASS_OF(obj);

        c = class_or_module_required(c);
        return class_search_ancestor(cl, RCLASS_ORIGIN(c)) ? Qtrue : Qfalse;
    }

itself → obj click to toggle source

Returns the receiver.

    string = "my string"
    string.itself.object_id == string.object_id   #=> true

    static VALUE
    rb_obj_itself(VALUE obj)
    {
        return obj;
    }

kind_of?(class) → true or false click to toggle source

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

    VALUE
    rb_obj_is_kind_of(VALUE obj, VALUE c)
    {
        VALUE cl = CLASS_OF(obj);

        c = class_or_module_required(c);
        return class_search_ancestor(cl, RCLASS_ORIGIN(c)) ? Qtrue : Qfalse;
    }

method(sym) → method click to toggle source

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)>]

    VALUE
    rb_obj_method(VALUE obj, VALUE vid)
    {
        return obj_method(obj, vid, FALSE);
    }

methods(regular=true) → array click to toggle source

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]

    VALUE
    rb_obj_methods(int argc, const VALUE *argv, VALUE obj)
    {
        rb_check_arity(argc, 0, 1);
        if (argc > 0 && !RTEST(argv[0])) {
    	return rb_obj_singleton_methods(argc, argv, obj);
        }
        return class_instance_method_list(argc, argv, CLASS_OF(obj), 1, ins_methods_i);
    }

namespace(name) click to toggle source
Calls superclass method

    # File lib/bundler/vendor/thor/lib/thor/rake_compat.rb, line 60
    def namespace(name)
      if klass = Bundler::Thor::RakeCompat.rake_classes.last # rubocop:disable AssignmentInCondition
        const_name = Bundler::Thor::Util.camel_case(name.to_s).to_sym
        klass.const_set(const_name, Class.new(Bundler::Thor))
        new_klass = klass.const_get(const_name)
        Bundler::Thor::RakeCompat.rake_classes << new_klass
      end

      super
      Bundler::Thor::RakeCompat.rake_classes.pop
    end

Also aliased as: rake_namespace
nil? → true or false click to toggle source

Only the object nil responds `true` to `nil?`.

    Object.new.nil?   #=> false
    nil.nil?          #=> true

    static VALUE
    rb_false(VALUE obj)
    {
        return Qfalse;
    }

__id__ → integer click to toggle source
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.

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

    VALUE
    rb_obj_id(VALUE obj)
    {
        /*
         *                32-bit VALUE space
         *          MSB ------------------------ LSB
         *  false   00000000000000000000000000000000
         *  true    00000000000000000000000000000010
         *  nil     00000000000000000000000000000100
         *  undef   00000000000000000000000000000110
         *  symbol  ssssssssssssssssssssssss00001110
         *  object  oooooooooooooooooooooooooooooo00        = 0 (mod sizeof(RVALUE))
         *  fixnum  fffffffffffffffffffffffffffffff1
         *
         *                    object_id space
         *                                       LSB
         *  false   00000000000000000000000000000000
         *  true    00000000000000000000000000000010
         *  nil     00000000000000000000000000000100
         *  undef   00000000000000000000000000000110
         *  symbol   000SSSSSSSSSSSSSSSSSSSSSSSSSSS0        S...S % A = 4 (S...S = s...s * A + 4)
         *  object   oooooooooooooooooooooooooooooo0        o...o % A = 0
         *  fixnum  fffffffffffffffffffffffffffffff1        bignum if required
         *
         *  where A = sizeof(RVALUE)/4
         *
         *  sizeof(RVALUE) is
         *  20 if 32-bit, double is 4-byte aligned
         *  24 if 32-bit, double is 8-byte aligned
         *  40 if 64-bit
         */
        if (STATIC_SYM_P(obj)) {
            return (SYM2ID(obj) * sizeof(RVALUE) + (4 << 2)) | FIXNUM_FLAG;
        }
        else if (FLONUM_P(obj)) {
    #if SIZEOF_LONG == SIZEOF_VOIDP
            return LONG2NUM((SIGNED_VALUE)obj);
    #else
            return LL2NUM((SIGNED_VALUE)obj);
    #endif
        }
        else if (SPECIAL_CONST_P(obj)) {
            return LONG2NUM((SIGNED_VALUE)obj);
        }
        return nonspecial_obj_id(obj);
    }

private_methods(all=true) → array click to toggle source

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.

    VALUE
    rb_obj_private_methods(int argc, const VALUE *argv, VALUE obj)
    {
        return class_instance_method_list(argc, argv, CLASS_OF(obj), 1, ins_methods_priv_i);
    }

protected_methods(all=true) → array click to toggle source

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.

    VALUE
    rb_obj_protected_methods(int argc, const VALUE *argv, VALUE obj)
    {
        return class_instance_method_list(argc, argv, CLASS_OF(obj), 1, ins_methods_prot_i);
    }

public_method(sym) → method click to toggle source

Similar to method, searches public method only.

    VALUE
    rb_obj_public_method(VALUE obj, VALUE vid)
    {
        return obj_method(obj, vid, TRUE);
    }

public_methods(all=true) → array click to toggle source

Returns the list of public methods accessible to obj. If the all parameter is set to `false`, only those methods in the receiver will be listed.

    VALUE
    rb_obj_public_methods(int argc, const VALUE *argv, VALUE obj)
    {
        return class_instance_method_list(argc, argv, CLASS_OF(obj), 1, ins_methods_pub_i);
    }

public_send(symbol [, args...]) → obj click to toggle source
public_send(string [, args...]) → obj

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

    static VALUE
    rb_f_public_send(int argc, VALUE *argv, VALUE recv)
    {
        return send_internal(argc, argv, recv, CALL_PUBLIC);
    }

rake_namespace(name)
Alias for: namespace
remove_instance_variable(symbol) → obj click to toggle source
remove_instance_variable(string) → obj

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

    VALUE
    rb_obj_remove_instance_variable(VALUE obj, VALUE name)
    {
        VALUE val = Qnil;
        const ID id = id_for_var(obj, name, an, instance);
        st_data_t n, v;
        struct st_table *iv_index_tbl;
        st_data_t index;

        rb_check_frozen(obj);
        if (!id) {
    	goto not_defined;
        }

        switch (BUILTIN_TYPE(obj)) {
          case T_OBJECT:
            iv_index_tbl = ROBJECT_IV_INDEX_TBL(obj);
            if (!iv_index_tbl) break;
            if (!st_lookup(iv_index_tbl, (st_data_t)id, &index)) break;
            if (ROBJECT_NUMIV(obj) <= index) break;
            val = ROBJECT_IVPTR(obj)[index];
            if (val != Qundef) {
                ROBJECT_IVPTR(obj)[index] = Qundef;
                return val;
            }
    	break;
          case T_CLASS:
          case T_MODULE:
    	n = id;
    	if (RCLASS_IV_TBL(obj) && st_delete(RCLASS_IV_TBL(obj), &n, &v)) {
    	    return (VALUE)v;
    	}
    	break;
          default:
    	if (FL_TEST(obj, FL_EXIVAR)) {
    	    if (generic_ivar_remove(obj, id, &val)) {
    		return val;
    	    }
    	}
    	break;
        }

      not_defined:
        rb_name_err_raise("instance variable %1$s not defined",
    		      obj, name);
        UNREACHABLE_RETURN(Qnil);
    }

respond_to?(symbol, include_all=false) → true or false click to toggle source
respond_to?(string, include_all=false) → true or false

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.

    static VALUE
    obj_respond_to(int argc, VALUE *argv, VALUE obj)
    {
        VALUE mid, priv;
        ID id;
        rb_execution_context_t *ec = GET_EC();

        rb_scan_args(argc, argv, "11", &mid, &priv);
        if (!(id = rb_check_id(&mid))) {
            VALUE ret = basic_obj_respond_to_missing(ec, CLASS_OF(obj), obj,
                                                     rb_to_symbol(mid), priv);
            if (ret == Qundef) ret = Qfalse;
            return ret;
        }
        if (basic_obj_respond_to(ec, obj, id, !RTEST(priv)))
            return Qtrue;
        return Qfalse;
    }

respond_to_missing?(symbol, include_all) → true or false click to toggle source
respond_to_missing?(string, include_all) → true or false

DO NOT USE THIS DIRECTLY.

Hook method to return whether the obj can respond to id method or not.

When the method name parameter is given as a string, the string is converted to a symbol.

See `respond_to?`, and the example of `BasicObject`.

    static VALUE
    obj_respond_to_missing(VALUE obj, VALUE mid, VALUE priv)
    {
        return Qfalse;
    }

send(symbol [, args...]) → obj click to toggle source
__send__(symbol [, args...]) → obj
send(string [, args...]) → obj
__send__(string [, args...]) → obj

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"

    VALUE
    rb_f_send(int argc, VALUE *argv, VALUE recv)
    {
        return send_internal(argc, argv, recv, CALL_FCALL);
    }

singleton_class → class click to toggle source

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

    static VALUE
    rb_obj_singleton_class(VALUE obj)
    {
        return rb_singleton_class(obj);
    }

singleton_method(sym) → method click to toggle source

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

    VALUE
    rb_obj_singleton_method(VALUE obj, VALUE vid)
    {
        const rb_method_entry_t *me;
        VALUE klass = rb_singleton_class_get(obj);
        ID id = rb_check_id(&vid);

        if (NIL_P(klass) || NIL_P(klass = RCLASS_ORIGIN(klass))) {
          undef:
            rb_name_err_raise("undefined singleton method `%1$s' for `%2$s'",
                              obj, vid);
        }
        if (!id) {
            if (respond_to_missing_p(klass, obj, vid, FALSE)) {
                id = rb_intern_str(vid);
                return mnew_missing(klass, obj, id, rb_cMethod);
            }
            goto undef;
        }
        me = rb_method_entry_at(klass, id);
        if (UNDEFINED_METHOD_ENTRY_P(me) ||
            UNDEFINED_REFINED_METHOD_P(me->def)) {
            vid = ID2SYM(id);
            goto undef;
        }
        return mnew_from_me(me, klass, klass, obj, id, rb_cMethod, FALSE);
    }

singleton_methods(all=true) → array click to toggle source

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]

    VALUE
    rb_obj_singleton_methods(int argc, const VALUE *argv, VALUE obj)
    {
        VALUE ary, klass, origin;
        struct method_entry_arg me_arg;
        struct rb_id_table *mtbl;
        int recur = TRUE;

        if (rb_check_arity(argc, 0, 1)) recur = RTEST(argv[0]);
        klass = CLASS_OF(obj);
        origin = RCLASS_ORIGIN(klass);
        me_arg.list = st_init_numtable();
        me_arg.recur = recur;
        if (klass && FL_TEST(klass, FL_SINGLETON)) {
    	if ((mtbl = RCLASS_M_TBL(origin)) != 0) rb_id_table_foreach(mtbl, method_entry_i, &me_arg);
    	klass = RCLASS_SUPER(klass);
        }
        if (recur) {
    	while (klass && (FL_TEST(klass, FL_SINGLETON) || RB_TYPE_P(klass, T_ICLASS))) {
    	    if (klass != origin && (mtbl = RCLASS_M_TBL(klass)) != 0) rb_id_table_foreach(mtbl, method_entry_i, &me_arg);
    	    klass = RCLASS_SUPER(klass);
    	}
        }
        ary = rb_ary_new();
        st_foreach(me_arg.list, ins_methods_i, ary);
        st_free_table(me_arg.list);

        return ary;
    }

sysread(io, size) click to toggle source

cgi_runner.rb – `CGI` launcher.

Author: IPR – Internet Programming with Ruby – writers Copyright © 2000 TAKAHASHI Masayoshi, GOTOU YUUZOU Copyright © 2002 Internet Programming with Ruby writers. All rights reserved.

$IPR: cgi_runner.rb,v 1.9 2002/09/25 11:33:15 gotoyuzo Exp $

    # File lib/webrick/httpservlet/cgi_runner.rb, line 12
    def sysread(io, size)
      buf = ""
      while size > 0
        tmp = io.sysread(size)
        buf << tmp
        size -= tmp.bytesize
      end
      return buf
    end

taint → obj click to toggle source

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`.

    VALUE
    rb_obj_taint(VALUE obj)
    {
        if (!OBJ_TAINTED(obj) && OBJ_TAINTABLE(obj)) {
            rb_check_frozen(obj);
            OBJ_TAINT(obj);
        }
        return obj;
    }

tainted? → true or false click to toggle source

Returns true if the object is tainted.

See `taint` for more information.

    VALUE
    rb_obj_tainted(VALUE obj)
    {
        if (OBJ_TAINTED(obj))
            return Qtrue;
        return Qfalse;
    }

tap {|x| block } → obj click to toggle source

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}" }

    VALUE
    rb_obj_tap(VALUE obj)
    {
        rb_yield(obj);
        return obj;
    }

task(*) click to toggle source
Calls superclass method

    # File lib/bundler/vendor/thor/lib/thor/rake_compat.rb, line 40
    def task(*)
      task = super

      if klass = Bundler::Thor::RakeCompat.rake_classes.last # rubocop:disable AssignmentInCondition
        non_namespaced_name = task.name.split(":").last

        description = non_namespaced_name
        description << task.arg_names.map { |n| n.to_s.upcase }.join(" ")
        description.strip!

        klass.desc description, Rake.application.last_description || non_namespaced_name
        Rake.application.last_description = nil
        klass.send :define_method, non_namespaced_name do |*args|
          Rake::Task[task.name.to_sym].invoke(*args)
        end
      end

      task
    end

then {|x| block } → an_object click to toggle source

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

    static VALUE
    rb_obj_yield_self(VALUE obj)
    {
        RETURN_SIZED_ENUMERATOR(obj, 0, 0, rb_obj_size);
        return rb_yield_values2(1, &obj);
    }

timeout(*args, &block) click to toggle source

    # File lib/timeout.rb, line 120
    def timeout(*args, &block)
      warn "Object##{__method__} is deprecated, use Timeout.timeout instead.", uplevel: 1
      Timeout.timeout(*args, &block)
    end

to_enum(method = :each, *args) → enum click to toggle source
to_enum(method = :each, *args) {|*args| block} → enum

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

    static VALUE
    obj_to_enum(int argc, VALUE *argv, VALUE obj)
    {
        VALUE enumerator, meth = sym_each;

        if (argc > 0) {
            --argc;
            meth = *argv++;
        }
        enumerator = rb_enumeratorize_with_size(obj, meth, argc, argv, 0);
        if (rb_block_given_p()) {
            enumerator_ptr(enumerator)->size = rb_block_proc();
        }
        return enumerator;
    }

to_s → string click to toggle source

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''.

    VALUE
    rb_any_to_s(VALUE obj)
    {
        VALUE str;
        VALUE cname = rb_class_name(CLASS_OF(obj));

        str = rb_sprintf("#<%"PRIsVALUE":%p>", cname, (void*)obj);
        OBJ_INFECT(str, obj);

        return str;
    }

to_yaml(options = {}) click to toggle source

Convert an object to YAML. See `Psych.dump` for more information on the available `options`.

    # File ext/psych/lib/psych/core_ext.rb, line 12
    def to_yaml options = {}
      Psych.dump self, options
    end

trust → obj click to toggle source

Deprecated method that is equivalent to `untaint`.

    VALUE
    rb_obj_trust(VALUE obj)
    {
        rb_warning("trust is deprecated and its behavior is same as untaint");
        return rb_obj_untaint(obj);
    }

untaint → obj click to toggle source

Removes the tainted mark from the object.

See `taint` for more information.

    VALUE
    rb_obj_untaint(VALUE obj)
    {
        if (OBJ_TAINTED(obj)) {
            rb_check_frozen(obj);
            FL_UNSET(obj, FL_TAINT);
        }
        return obj;
    }

untrust → obj click to toggle source

Deprecated method that is equivalent to `taint`.

    VALUE
    rb_obj_untrust(VALUE obj)
    {
        rb_warning("untrust is deprecated and its behavior is same as taint");
        return rb_obj_taint(obj);
    }

untrusted? → true or false click to toggle source

Deprecated method that is equivalent to `tainted?`.

    VALUE
    rb_obj_untrusted(VALUE obj)
    {
        rb_warning("untrusted? is deprecated and its behavior is same as tainted?");
        return rb_obj_tainted(obj);
    }

xmp(exps, bind = nil) click to toggle source

A convenience method that's only available when the you require the IRB::XMP standard library.

Creates a new `XMP` object, using the given expressions as the `exps` parameter, and optional binding as `bind` or uses the top-level binding. Then evaluates the given expressions using the `:XMP` prompt mode.

For example:

    require 'irb/xmp'
    ctx = binding
    xmp 'foo = "bar"', ctx
    #=> foo = "bar"
      #==>"bar"
    ctx.eval 'foo'
    #=> "bar"

See `XMP.new` for more information.

    # File lib/irb/xmp.rb, line 165
    def xmp(exps, bind = nil)
      bind = IRB::Frame.top(1) unless bind
      xmp = XMP.new(bind)
      xmp.puts exps
      xmp
    end

yield_self {|x| block } → an_object click to toggle source

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

    static VALUE
    rb_obj_yield_self(VALUE obj)
    {
        RETURN_SIZED_ENUMERATOR(obj, 0, 0, rb_obj_size);
        return rb_yield_values2(1, &obj);
    }