File: C:/Ruby27-x64/share/doc/ruby/html/Object.html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>class Object - RDoc Documentation</title>
<script type="text/javascript">
var rdoc_rel_prefix = "./";
var index_rel_prefix = "./";
</script>
<script src="./js/navigation.js" defer></script>
<script src="./js/search.js" defer></script>
<script src="./js/search_index.js" defer></script>
<script src="./js/searcher.js" defer></script>
<script src="./js/darkfish.js" defer></script>
<link href="./css/fonts.css" rel="stylesheet">
<link href="./css/rdoc.css" rel="stylesheet">
<body id="top" role="document" class="class">
<nav role="navigation">
<div id="project-navigation">
<div id="home-section" role="region" title="Quick navigation" class="nav-section">
<h2>
<a href="./index.html" rel="home">Home</a>
</h2>
<div id="table-of-contents-navigation">
<a href="./table_of_contents.html#pages">Pages</a>
<a href="./table_of_contents.html#classes">Classes</a>
<a href="./table_of_contents.html#methods">Methods</a>
</div>
</div>
<div id="search-section" role="search" class="project-section initially-hidden">
<form action="#" method="get" accept-charset="utf-8">
<div id="search-field-wrapper">
<input id="search-field" role="combobox" aria-label="Search"
aria-autocomplete="list" aria-controls="search-results"
type="text" name="search" placeholder="Search" spellcheck="false"
title="Type to search, Up and Down to navigate, Enter to load">
</div>
<ul id="search-results" aria-label="Search Results"
aria-busy="false" aria-expanded="false"
aria-atomic="false" class="initially-hidden"></ul>
</form>
</div>
</div>
<div id="class-metadata">
<div id="parent-class-section" class="nav-section">
<h3>Parent</h3>
<p class="link"><a href="BasicObject.html">BasicObject</a>
</div>
<div id="includes-section" class="nav-section">
<h3>Included Modules</h3>
<ul class="link-list">
<li><a class="include" href="MakeMakefile.html">MakeMakefile</a>
<li><a class="include" href="Kernel.html">Kernel</a>
</ul>
</div>
<!-- Method Quickref -->
<div id="method-list-section" class="nav-section">
<h3>Methods</h3>
<ul class="link-list" role="directory">
<li ><a href="#method-c-yaml_tag">::yaml_tag</a>
<li ><a href="#method-i-21~">#!~</a>
<li ><a href="#method-i-3C-3D-3E">#<=></a>
<li ><a href="#method-i-3D-3D-3D">#===</a>
<li ><a href="#method-i-3D~">#=~</a>
<li ><a href="#method-i-CSV">#CSV</a>
<li class="calls-super" ><a href="#method-i-DelegateClass">#DelegateClass</a>
<li ><a href="#method-i-Digest">#Digest</a>
<li ><a href="#method-i-class">#class</a>
<li ><a href="#method-i-clone">#clone</a>
<li ><a href="#method-i-dclone">#dclone</a>
<li ><a href="#method-i-define_singleton_method">#define_singleton_method</a>
<li ><a href="#method-i-display">#display</a>
<li ><a href="#method-i-dup">#dup</a>
<li ><a href="#method-i-enum_for">#enum_for</a>
<li ><a href="#method-i-eql-3F">#eql?</a>
<li ><a href="#method-i-extend">#extend</a>
<li ><a href="#method-i-freeze">#freeze</a>
<li ><a href="#method-i-frozen-3F">#frozen?</a>
<li ><a href="#method-i-gemfile">#gemfile</a>
<li ><a href="#method-i-hash">#hash</a>
<li ><a href="#method-i-inspect">#inspect</a>
<li ><a href="#method-i-instance_of-3F">#instance_of?</a>
<li ><a href="#method-i-instance_variable_defined-3F">#instance_variable_defined?</a>
<li ><a href="#method-i-instance_variable_get">#instance_variable_get</a>
<li ><a href="#method-i-instance_variable_set">#instance_variable_set</a>
<li ><a href="#method-i-instance_variables">#instance_variables</a>
<li ><a href="#method-i-is_a-3F">#is_a?</a>
<li ><a href="#method-i-itself">#itself</a>
<li ><a href="#method-i-kind_of-3F">#kind_of?</a>
<li ><a href="#method-i-method">#method</a>
<li ><a href="#method-i-methods">#methods</a>
<li class="calls-super" ><a href="#method-i-namespace">#namespace</a>
<li ><a href="#method-i-nil-3F">#nil?</a>
<li ><a href="#method-i-object_id">#object_id</a>
<li ><a href="#method-i-private_methods">#private_methods</a>
<li ><a href="#method-i-protected_methods">#protected_methods</a>
<li ><a href="#method-i-public_method">#public_method</a>
<li ><a href="#method-i-public_methods">#public_methods</a>
<li ><a href="#method-i-public_send">#public_send</a>
<li ><a href="#method-i-rake_namespace">#rake_namespace</a>
<li ><a href="#method-i-remove_instance_variable">#remove_instance_variable</a>
<li ><a href="#method-i-respond_to-3F">#respond_to?</a>
<li ><a href="#method-i-respond_to_missing-3F">#respond_to_missing?</a>
<li ><a href="#method-i-send">#send</a>
<li ><a href="#method-i-singleton_class">#singleton_class</a>
<li ><a href="#method-i-singleton_method">#singleton_method</a>
<li ><a href="#method-i-singleton_methods">#singleton_methods</a>
<li ><a href="#method-i-sysread">#sysread</a>
<li ><a href="#method-i-taint">#taint</a>
<li ><a href="#method-i-tainted-3F">#tainted?</a>
<li ><a href="#method-i-tap">#tap</a>
<li class="calls-super" ><a href="#method-i-task">#task</a>
<li ><a href="#method-i-then">#then</a>
<li ><a href="#method-i-timeout">#timeout</a>
<li ><a href="#method-i-to_enum">#to_enum</a>
<li ><a href="#method-i-to_s">#to_s</a>
<li ><a href="#method-i-to_yaml">#to_yaml</a>
<li ><a href="#method-i-trust">#trust</a>
<li ><a href="#method-i-untaint">#untaint</a>
<li ><a href="#method-i-untrust">#untrust</a>
<li ><a href="#method-i-untrusted-3F">#untrusted?</a>
<li ><a href="#method-i-xmp">#xmp</a>
<li ><a href="#method-i-yield_self">#yield_self</a>
</ul>
</div>
</div>
</nav>
<main role="main" aria-labelledby="class-Object">
<h1 id="class-Object" class="class">
class Object
</h1>
<section class="description">
<p><a href="Object.html"><code>Object</code></a> is the default root of all Ruby objects. <a href="Object.html"><code>Object</code></a> inherits from <a href="BasicObject.html"><code>BasicObject</code></a> which allows creating alternate object hierarchies. Methods on <a href="Object.html"><code>Object</code></a> are available to all classes unless explicitly overridden.</p>
<p><a href="Object.html"><code>Object</code></a> mixes in the <a href="Kernel.html"><code>Kernel</code></a> module, making the built-in kernel functions globally accessible. Although the instance methods of <a href="Object.html"><code>Object</code></a> are defined by the <a href="Kernel.html"><code>Kernel</code></a> module, we have chosen to document them here for clarity.</p>
<p>When referencing constants in classes inheriting from <a href="Object.html"><code>Object</code></a> you do not need to use the full namespace. For example, referencing <code>File</code> inside <code>YourClass</code> will find the top-level <a href="File.html"><code>File</code></a> class.</p>
<p>In the descriptions of Object's methods, the parameter <em>symbol</em> refers to a symbol, which is either a quoted string or a <a href="Symbol.html"><code>Symbol</code></a> (such as <code>:name</code>).</p>
</section>
<section id="5Buntitled-5D" class="documentation-section">
<section class="constants-list">
<header>
<h3>Constants</h3>
</header>
<dl>
<dt id="ARGF">ARGF
<dd><p><a href="ARGF.html"><code>ARGF</code></a> is a stream designed for use in scripts that process files given as command-line arguments or passed in via <a href="Object.html#STDIN"><code>STDIN</code></a>.</p>
<p>See <a href="ARGF.html"><code>ARGF</code></a> (the class) for more details.</p>
<dt id="ARGV">ARGV
<dd><p><a href="Object.html#ARGV"><code>ARGV</code></a> contains the command line arguments used to run ruby.</p>
<p>A library like <a href="OptionParser.html"><code>OptionParser</code></a> can be used to process command-line arguments.</p>
<dt id="AmbiguousTaskError">AmbiguousTaskError
<dd>
<dt id="Bignum">Bignum
<dd><p>An obsolete class, use <a href="Integer.html"><code>Integer</code></a></p>
<dt id="DATA">DATA
<dd><p><a href="Object.html#DATA"><code>DATA</code></a> is a <a href="File.html"><code>File</code></a> that contains the data section of the executed file. To create a data section use <code>__END__</code>:</p>
<pre>$ cat t.rb
puts DATA.gets
__END__
hello world!
$ ruby t.rb
hello world!</pre>
<dt id="ENV">ENV
<dd><p><a href="ENV.html"><code>ENV</code></a> is a Hash-like accessor for environment variables.</p>
<p>See <a href="ENV.html"><code>ENV</code></a> (the class) for more details.</p>
<dt id="FALSE">FALSE
<dd><p>An obsolete alias of <code>false</code></p>
<dt id="Fixnum">Fixnum
<dd><p>An obsolete class, use <a href="Integer.html"><code>Integer</code></a></p>
<dt id="NIL">NIL
<dd><p>An obsolete alias of <code>nil</code></p>
<dt id="ParseError">ParseError
<dd>
<dt id="RUBY_COPYRIGHT">RUBY_COPYRIGHT
<dd><p>The copyright string for ruby</p>
<dt id="RUBY_DESCRIPTION">RUBY_DESCRIPTION
<dd><p>The full ruby version string, like <code>ruby -v</code> prints</p>
<dt id="RUBY_ENGINE">RUBY_ENGINE
<dd><p>The engine or interpreter this ruby uses.</p>
<dt id="RUBY_ENGINE_VERSION">RUBY_ENGINE_VERSION
<dd><p>The version of the engine or interpreter this ruby uses.</p>
<dt id="RUBY_PATCHLEVEL">RUBY_PATCHLEVEL
<dd><p>The patchlevel for this ruby. If this is a development build of ruby the patchlevel will be -1</p>
<dt id="RUBY_PLATFORM">RUBY_PLATFORM
<dd><p>The platform for this ruby</p>
<dt id="RUBY_RELEASE_DATE">RUBY_RELEASE_DATE
<dd><p>The date this ruby was released</p>
<dt id="RUBY_REVISION">RUBY_REVISION
<dd><p>The GIT commit hash for this ruby.</p>
<dt id="RUBY_VERSION">RUBY_VERSION
<dd><p>The running version of ruby</p>
<dt id="Readline">Readline
<dd>
<dt id="STDERR">STDERR
<dd><p>Holds the original stderr</p>
<dt id="STDIN">STDIN
<dd><p>Holds the original stdin</p>
<dt id="STDOUT">STDOUT
<dd><p>Holds the original stdout</p>
<dt id="TOPLEVEL_BINDING">TOPLEVEL_BINDING
<dd><p>The <a href="Binding.html"><code>Binding</code></a> of the top level scope</p>
<dt id="TRUE">TRUE
<dd><p>An obsolete alias of <code>true</code></p>
<dt id="TimeoutError">TimeoutError
<dd><p>Raised by <a href="Timeout.html#method-c-timeout"><code>Timeout.timeout</code></a> when the block times out.</p>
<dt id="UndefinedTaskError">UndefinedTaskError
<dd><p>Raised when a command was not found.</p>
</dl>
</section>
<section id="public-class-5Buntitled-5D-method-details" class="method-section">
<header>
<h3>Public Class Methods</h3>
</header>
<div id="method-c-yaml_tag" class="method-detail ">
<div class="method-heading">
<span class="method-name">yaml_tag</span><span
class="method-args">(url)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="yaml_tag-source">
<pre><span class="ruby-comment"># File ext/psych/lib/psych/core_ext.rb, line 3</span>
<span class="ruby-keyword">def</span> <span class="ruby-keyword">self</span>.<span class="ruby-identifier ruby-title">yaml_tag</span> <span class="ruby-identifier">url</span>
<span class="ruby-constant">Psych</span>.<span class="ruby-identifier">add_tag</span>(<span class="ruby-identifier">url</span>, <span class="ruby-keyword">self</span>)
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
</section>
<section id="public-instance-5Buntitled-5D-method-details" class="method-section">
<header>
<h3>Public Instance Methods</h3>
</header>
<div id="method-i-21~" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
obj !~ other → true or false
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns true if two objects do not match (using the <em>=~</em> method), otherwise false.</p>
<div class="method-source-code" id="21~-source">
<pre>static VALUE
rb_obj_not_match(VALUE obj1, VALUE obj2)
{
VALUE result = rb_funcall(obj1, id_match, 1, obj2);
return RTEST(result) ? Qfalse : Qtrue;
}</pre>
</div>
</div>
</div>
<div id="method-i-3C-3D-3E" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
obj <=> other → 0 or nil
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns 0 if <code>obj</code> and <code>other</code> are the same object or <code>obj == other</code>, otherwise nil.</p>
<p>The #<=> is used by various methods to compare objects, for example <a href="Enumerable.html#method-i-sort"><code>Enumerable#sort</code></a>, <a href="Enumerable.html#method-i-max"><code>Enumerable#max</code></a> etc.</p>
<p>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.</p>
<p>When you define #<=>, you can include <a href="Comparable.html"><code>Comparable</code></a> to gain the methods #<=, #<, #==, #>=, #> and between?.</p>
<div class="method-source-code" id="3C-3D-3E-source">
<pre>static VALUE
rb_obj_cmp(VALUE obj1, VALUE obj2)
{
if (obj1 == obj2 || rb_equal(obj1, obj2))
return INT2FIX(0);
return Qnil;
}</pre>
</div>
</div>
</div>
<div id="method-i-3D-3D-3D" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
obj === other → true or false
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Case Equality – For class <a href="Object.html"><code>Object</code></a>, effectively the same as calling <code>#==</code>, but typically overridden by descendants to provide meaningful semantics in <code>case</code> statements.</p>
<div class="method-source-code" id="3D-3D-3D-source">
<pre>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;
}</pre>
</div>
</div>
</div>
<div id="method-i-3D~" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
obj =~ other → nil
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>This method is deprecated.</p>
<p>This is not only unuseful but also troublesome because it may hide a type error.</p>
<div class="method-source-code" id="3D~-source">
<pre>static VALUE
rb_obj_match(VALUE obj1, VALUE obj2)
{
if (rb_warning_category_enabled_p(RB_WARN_CATEGORY_DEPRECATED)) {
rb_warn("deprecated Object#=~ is called on %"PRIsVALUE
"; it always returns nil", rb_obj_class(obj1));
}
return Qnil;
}</pre>
</div>
</div>
</div>
<div id="method-i-CSV" class="method-detail ">
<div class="method-heading">
<span class="method-name">CSV</span><span
class="method-args">(*args, &block)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Passes <code>args</code> to <a href="CSV.html#method-c-instance"><code>CSV::instance</code></a>.</p>
<pre class="ruby"><span class="ruby-constant">CSV</span>(<span class="ruby-string">"CSV,data"</span>).<span class="ruby-identifier">read</span>
<span class="ruby-comment">#=> [["CSV", "data"]]</span>
</pre>
<p>If a block is given, the instance is passed the block and the return value becomes the return value of the block.</p>
<pre class="ruby"><span class="ruby-constant">CSV</span>(<span class="ruby-string">"CSV,data"</span>) { <span class="ruby-operator">|</span><span class="ruby-identifier">c</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">c</span>.<span class="ruby-identifier">read</span>.<span class="ruby-identifier">any?</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">a</span><span class="ruby-operator">|</span> <span class="ruby-identifier">a</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-string">"data"</span>) }
} <span class="ruby-comment">#=> true</span>
<span class="ruby-constant">CSV</span>(<span class="ruby-string">"CSV,data"</span>) { <span class="ruby-operator">|</span><span class="ruby-identifier">c</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">c</span>.<span class="ruby-identifier">read</span>.<span class="ruby-identifier">any?</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">a</span><span class="ruby-operator">|</span> <span class="ruby-identifier">a</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-string">"zombies"</span>) }
} <span class="ruby-comment">#=> false</span>
</pre>
<div class="method-source-code" id="CSV-source">
<pre><span class="ruby-comment"># File lib/csv.rb, line 1507</span>
<span class="ruby-keyword">def</span> <span class="ruby-constant">CSV</span>(<span class="ruby-operator">*</span><span class="ruby-identifier ruby-title">args</span>, <span class="ruby-operator">&</span><span class="ruby-identifier">block</span>)
<span class="ruby-constant">CSV</span>.<span class="ruby-identifier">instance</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>, <span class="ruby-operator">&</span><span class="ruby-identifier">block</span>)
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-DelegateClass" class="method-detail ">
<div class="method-heading">
<span class="method-name">DelegateClass</span><span
class="method-args">(superclass, &block)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>The primary interface to this library. Use to setup delegation when defining your class.</p>
<pre class="ruby"><span class="ruby-keyword">class</span> <span class="ruby-constant">MyClass</span> <span class="ruby-operator"><</span> <span class="ruby-constant">DelegateClass</span>(<span class="ruby-constant">ClassToDelegateTo</span>) <span class="ruby-comment"># Step 1</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">initialize</span>
<span class="ruby-keyword">super</span>(<span class="ruby-identifier">obj_of_ClassToDelegateTo</span>) <span class="ruby-comment"># Step 2</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
</pre>
<p>or:</p>
<pre class="ruby"><span class="ruby-constant">MyClass</span> = <span class="ruby-constant">DelegateClass</span>(<span class="ruby-constant">ClassToDelegateTo</span>) <span class="ruby-keyword">do</span> <span class="ruby-comment"># Step 1</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">initialize</span>
<span class="ruby-keyword">super</span>(<span class="ruby-identifier">obj_of_ClassToDelegateTo</span>) <span class="ruby-comment"># Step 2</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
</pre>
<p>Here's a sample of use from <a href="Tempfile.html"><code>Tempfile</code></a> which is really a <a href="File.html"><code>File</code></a> object with a few special rules about storage location and when the <a href="File.html"><code>File</code></a> should be deleted. That makes for an almost textbook perfect example of how to use delegation.</p>
<pre class="ruby"><span class="ruby-keyword">class</span> <span class="ruby-constant">Tempfile</span> <span class="ruby-operator"><</span> <span class="ruby-constant">DelegateClass</span>(<span class="ruby-constant">File</span>)
<span class="ruby-comment"># constant and class member data initialization...</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">initialize</span>(<span class="ruby-identifier">basename</span>, <span class="ruby-identifier">tmpdir</span>=<span class="ruby-constant">Dir</span><span class="ruby-operator">::</span><span class="ruby-identifier">tmpdir</span>)
<span class="ruby-comment"># build up file path/name in var tmpname...</span>
<span class="ruby-ivar">@tmpfile</span> = <span class="ruby-constant">File</span>.<span class="ruby-identifier">open</span>(<span class="ruby-identifier">tmpname</span>, <span class="ruby-constant">File</span><span class="ruby-operator">::</span><span class="ruby-constant">RDWR</span><span class="ruby-operator">|</span><span class="ruby-constant">File</span><span class="ruby-operator">::</span><span class="ruby-constant">CREAT</span><span class="ruby-operator">|</span><span class="ruby-constant">File</span><span class="ruby-operator">::</span><span class="ruby-constant">EXCL</span>, <span class="ruby-value">0600</span>)
<span class="ruby-comment"># ...</span>
<span class="ruby-keyword">super</span>(<span class="ruby-ivar">@tmpfile</span>)
<span class="ruby-comment"># below this point, all methods of File are supported...</span>
<span class="ruby-keyword">end</span>
<span class="ruby-comment"># ...</span>
<span class="ruby-keyword">end</span>
</pre>
<div class="method-calls-super">
Calls superclass method
</div>
<div class="method-source-code" id="DelegateClass-source">
<pre><span class="ruby-comment"># File lib/delegate.rb, line 388</span>
<span class="ruby-keyword">def</span> <span class="ruby-constant">DelegateClass</span>(<span class="ruby-identifier ruby-title">superclass</span>, <span class="ruby-operator">&</span><span class="ruby-identifier">block</span>)
<span class="ruby-identifier">klass</span> = <span class="ruby-constant">Class</span>.<span class="ruby-identifier">new</span>(<span class="ruby-constant">Delegator</span>)
<span class="ruby-identifier">ignores</span> = [<span class="ruby-operator">*</span><span class="ruby-operator">::</span><span class="ruby-constant">Delegator</span>.<span class="ruby-identifier">public_api</span>, <span class="ruby-value">:to_s</span>, <span class="ruby-value">:inspect</span>, <span class="ruby-value">:=~</span>, <span class="ruby-value">:!~</span>, <span class="ruby-value">:===</span>]
<span class="ruby-identifier">protected_instance_methods</span> = <span class="ruby-identifier">superclass</span>.<span class="ruby-identifier">protected_instance_methods</span>
<span class="ruby-identifier">protected_instance_methods</span> <span class="ruby-operator">-=</span> <span class="ruby-identifier">ignores</span>
<span class="ruby-identifier">public_instance_methods</span> = <span class="ruby-identifier">superclass</span>.<span class="ruby-identifier">public_instance_methods</span>
<span class="ruby-identifier">public_instance_methods</span> <span class="ruby-operator">-=</span> <span class="ruby-identifier">ignores</span>
<span class="ruby-identifier">klass</span>.<span class="ruby-identifier">module_eval</span> <span class="ruby-keyword">do</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">__getobj__</span> <span class="ruby-comment"># :nodoc:</span>
<span class="ruby-keyword">unless</span> <span class="ruby-keyword">defined?</span>(<span class="ruby-ivar">@delegate_dc_obj</span>)
<span class="ruby-keyword">return</span> <span class="ruby-keyword">yield</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">block_given?</span>
<span class="ruby-identifier">__raise__</span> <span class="ruby-operator">::</span><span class="ruby-constant">ArgumentError</span>, <span class="ruby-string">"not delegated"</span>
<span class="ruby-keyword">end</span>
<span class="ruby-ivar">@delegate_dc_obj</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">__setobj__</span>(<span class="ruby-identifier">obj</span>) <span class="ruby-comment"># :nodoc:</span>
<span class="ruby-identifier">__raise__</span> <span class="ruby-operator">::</span><span class="ruby-constant">ArgumentError</span>, <span class="ruby-string">"cannot delegate to self"</span> <span class="ruby-keyword">if</span> <span class="ruby-keyword">self</span>.<span class="ruby-identifier">equal?</span>(<span class="ruby-identifier">obj</span>)
<span class="ruby-ivar">@delegate_dc_obj</span> = <span class="ruby-identifier">obj</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">protected_instance_methods</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">method</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">define_method</span>(<span class="ruby-identifier">method</span>, <span class="ruby-constant">Delegator</span>.<span class="ruby-identifier">delegating_block</span>(<span class="ruby-identifier">method</span>))
<span class="ruby-identifier">protected</span> <span class="ruby-identifier">method</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">public_instance_methods</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">method</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">define_method</span>(<span class="ruby-identifier">method</span>, <span class="ruby-constant">Delegator</span>.<span class="ruby-identifier">delegating_block</span>(<span class="ruby-identifier">method</span>))
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">klass</span>.<span class="ruby-identifier">define_singleton_method</span> <span class="ruby-value">:public_instance_methods</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">all</span>=<span class="ruby-keyword">true</span><span class="ruby-operator">|</span>
<span class="ruby-keyword">super</span>(<span class="ruby-identifier">all</span>) <span class="ruby-operator">|</span> <span class="ruby-identifier">superclass</span>.<span class="ruby-identifier">public_instance_methods</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">klass</span>.<span class="ruby-identifier">define_singleton_method</span> <span class="ruby-value">:protected_instance_methods</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">all</span>=<span class="ruby-keyword">true</span><span class="ruby-operator">|</span>
<span class="ruby-keyword">super</span>(<span class="ruby-identifier">all</span>) <span class="ruby-operator">|</span> <span class="ruby-identifier">superclass</span>.<span class="ruby-identifier">protected_instance_methods</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">klass</span>.<span class="ruby-identifier">module_eval</span>(<span class="ruby-operator">&</span><span class="ruby-identifier">block</span>) <span class="ruby-keyword">if</span> <span class="ruby-identifier">block</span>
<span class="ruby-keyword">return</span> <span class="ruby-identifier">klass</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-Digest" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
Digest(name) → digest_subclass
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns a <a href="Digest.html"><code>Digest</code></a> subclass by <code>name</code> in a thread-safe manner even when on-demand loading is involved.</p>
<pre class="ruby"><span class="ruby-identifier">require</span> <span class="ruby-string">'digest'</span>
<span class="ruby-constant">Digest</span>(<span class="ruby-string">"MD5"</span>)
<span class="ruby-comment"># => Digest::MD5</span>
<span class="ruby-constant">Digest</span>(<span class="ruby-value">:SHA256</span>)
<span class="ruby-comment"># => Digest::SHA256</span>
<span class="ruby-constant">Digest</span>(<span class="ruby-value">:Foo</span>)
<span class="ruby-comment"># => LoadError: library not found for class Digest::Foo -- digest/foo</span>
</pre>
<div class="method-source-code" id="Digest-source">
<pre><span class="ruby-comment"># File ext/digest/lib/digest.rb, line 96</span>
<span class="ruby-keyword">def</span> <span class="ruby-constant">Digest</span>(<span class="ruby-identifier ruby-title">name</span>)
<span class="ruby-identifier">const</span> = <span class="ruby-identifier">name</span>.<span class="ruby-identifier">to_sym</span>
<span class="ruby-constant">Digest</span><span class="ruby-operator">::</span><span class="ruby-constant">REQUIRE_MUTEX</span>.<span class="ruby-identifier">synchronize</span> {
<span class="ruby-comment"># Ignore autoload's because it is void when we have #const_missing</span>
<span class="ruby-constant">Digest</span>.<span class="ruby-identifier">const_missing</span>(<span class="ruby-identifier">const</span>)
}
<span class="ruby-keyword">rescue</span> <span class="ruby-constant">LoadError</span>
<span class="ruby-comment"># Constants do not necessarily rely on digest/*.</span>
<span class="ruby-keyword">if</span> <span class="ruby-constant">Digest</span>.<span class="ruby-identifier">const_defined?</span>(<span class="ruby-identifier">const</span>)
<span class="ruby-constant">Digest</span>.<span class="ruby-identifier">const_get</span>(<span class="ruby-identifier">const</span>)
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">raise</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-class" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
class → class
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the class of <em>obj</em>. This method must always be called with an explicit receiver, as <a href="Object.html#method-i-class"><code>class</code></a> is also a reserved word in Ruby.</p>
<pre class="ruby"><span class="ruby-value">1</span>.<span class="ruby-identifier">class</span> <span class="ruby-comment">#=> Integer</span>
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">class</span> <span class="ruby-comment">#=> Object</span>
</pre>
<div class="method-source-code" id="class-source">
<pre>VALUE
rb_obj_class(VALUE obj)
{
return rb_class_real(CLASS_OF(obj));
}</pre>
</div>
</div>
</div>
<div id="method-i-clone" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
clone(freeze: true) → an_object
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Produces a shallow copy of <em>obj</em>—the instance variables of <em>obj</em> are copied, but not the objects they reference. <a href="Object.html#method-i-clone"><code>clone</code></a> copies the frozen (unless <code>:freeze</code> keyword argument is given with a false value) state of <em>obj</em>. See also the discussion under <a href="Object.html#method-i-dup"><code>Object#dup</code></a>.</p>
<pre class="ruby"><span class="ruby-keyword">class</span> <span class="ruby-constant">Klass</span>
<span class="ruby-identifier">attr_accessor</span> <span class="ruby-value">:str</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">s1</span> = <span class="ruby-constant">Klass</span>.<span class="ruby-identifier">new</span> <span class="ruby-comment">#=> #<Klass:0x401b3a38></span>
<span class="ruby-identifier">s1</span>.<span class="ruby-identifier">str</span> = <span class="ruby-string">"Hello"</span> <span class="ruby-comment">#=> "Hello"</span>
<span class="ruby-identifier">s2</span> = <span class="ruby-identifier">s1</span>.<span class="ruby-identifier">clone</span> <span class="ruby-comment">#=> #<Klass:0x401b3998 @str="Hello"></span>
<span class="ruby-identifier">s2</span>.<span class="ruby-identifier">str</span>[<span class="ruby-value">1</span>,<span class="ruby-value">4</span>] = <span class="ruby-string">"i"</span> <span class="ruby-comment">#=> "i"</span>
<span class="ruby-identifier">s1</span>.<span class="ruby-identifier">inspect</span> <span class="ruby-comment">#=> "#<Klass:0x401b3a38 @str=\"Hi\">"</span>
<span class="ruby-identifier">s2</span>.<span class="ruby-identifier">inspect</span> <span class="ruby-comment">#=> "#<Klass:0x401b3998 @str=\"Hi\">"</span>
</pre>
<p>This method may have class-specific behavior. If so, that behavior will be documented under the #<code>initialize_copy</code> method of the class.</p>
<div class="method-source-code" id="clone-source">
<pre>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);
}</pre>
</div>
</div>
</div>
<div id="method-i-dclone" class="method-detail ">
<div class="method-heading">
<span class="method-name">dclone</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>provides a unified <code>clone</code> operation, for <a href="REXML/XPathParser.html"><code>REXML::XPathParser</code></a> to use across multiple <a href="Object.html"><code>Object</code></a> types</p>
<div class="method-source-code" id="dclone-source">
<pre><span class="ruby-comment"># File lib/rexml/xpath_parser.rb, line 13</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">dclone</span>
<span class="ruby-identifier">clone</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-define_singleton_method" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
define_singleton_method(symbol, method) → symbol
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-heading">
<span class="method-callseq">
define_singleton_method(symbol) { block } → symbol
</span>
</div>
<div class="method-description">
<p>Defines a singleton method in the receiver. The <em>method</em> parameter can be a <code>Proc</code>, a <code>Method</code> or an <code>UnboundMethod</code> object. If a block is specified, it is used as the method body. If a block or a method has parameters, they're used as method parameters.</p>
<pre class="ruby"><span class="ruby-keyword">class</span> <span class="ruby-constant">A</span>
<span class="ruby-keyword">class</span> <span class="ruby-operator"><<</span> <span class="ruby-keyword">self</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">class_name</span>
<span class="ruby-identifier">to_s</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-constant">A</span>.<span class="ruby-identifier">define_singleton_method</span>(<span class="ruby-value">:who_am_i</span>) <span class="ruby-keyword">do</span>
<span class="ruby-node">"I am: #{class_name}"</span>
<span class="ruby-keyword">end</span>
<span class="ruby-constant">A</span>.<span class="ruby-identifier">who_am_i</span> <span class="ruby-comment"># ==> "I am: A"</span>
<span class="ruby-identifier">guy</span> = <span class="ruby-string">"Bob"</span>
<span class="ruby-identifier">guy</span>.<span class="ruby-identifier">define_singleton_method</span>(<span class="ruby-value">:hello</span>) { <span class="ruby-node">"#{self}: Hello there!"</span> }
<span class="ruby-identifier">guy</span>.<span class="ruby-identifier">hello</span> <span class="ruby-comment">#=> "Bob: Hello there!"</span>
<span class="ruby-identifier">chris</span> = <span class="ruby-string">"Chris"</span>
<span class="ruby-identifier">chris</span>.<span class="ruby-identifier">define_singleton_method</span>(<span class="ruby-value">:greet</span>) {<span class="ruby-operator">|</span><span class="ruby-identifier">greeting</span><span class="ruby-operator">|</span> <span class="ruby-node">"#{greeting}, I'm Chris!"</span> }
<span class="ruby-identifier">chris</span>.<span class="ruby-identifier">greet</span>(<span class="ruby-string">"Hi"</span>) <span class="ruby-comment">#=> "Hi, I'm Chris!"</span>
</pre>
<div class="method-source-code" id="define_singleton_method-source">
<pre>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);
}</pre>
</div>
</div>
</div>
<div id="method-i-display" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
display(port=$>) → nil
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Prints <em>obj</em> on the given port (default <code>$></code>). Equivalent to:</p>
<pre class="ruby"><span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">display</span>(<span class="ruby-identifier">port</span>=<span class="ruby-identifier">$></span>)
<span class="ruby-identifier">port</span>.<span class="ruby-identifier">write</span> <span class="ruby-keyword">self</span>
<span class="ruby-keyword">nil</span>
<span class="ruby-keyword">end</span>
</pre>
<p>For example:</p>
<pre class="ruby"><span class="ruby-value">1</span>.<span class="ruby-identifier">display</span>
<span class="ruby-string">"cat"</span>.<span class="ruby-identifier">display</span>
[ <span class="ruby-value">4</span>, <span class="ruby-value">5</span>, <span class="ruby-value">6</span> ].<span class="ruby-identifier">display</span>
<span class="ruby-identifier">puts</span>
</pre>
<p><em>produces:</em></p>
<pre>1cat[4, 5, 6]</pre>
<div class="method-source-code" id="display-source">
<pre>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;
}</pre>
</div>
</div>
</div>
<div id="method-i-dup" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
dup → an_object
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Produces a shallow copy of <em>obj</em>—the instance variables of <em>obj</em> are copied, but not the objects they reference.</p>
<p>This method may have class-specific behavior. If so, that behavior will be documented under the #<code>initialize_copy</code> method of the class.</p>
<h3 id="method-i-dup-label-on+dup+vs+clone">on dup vs clone<span><a href="#method-i-dup-label-on+dup+vs+clone">¶</a> <a href="#top">↑</a></span></h3>
<p>In general, <a href="Object.html#method-i-clone"><code>clone</code></a> and <a href="Object.html#method-i-dup"><code>dup</code></a> may have different semantics in descendant classes. While <a href="Object.html#method-i-clone"><code>clone</code></a> is used to duplicate an object, including its internal state, <a href="Object.html#method-i-dup"><code>dup</code></a> typically uses the class of the descendant object to create the new instance.</p>
<p>When using <a href="Object.html#method-i-dup"><code>dup</code></a>, any modules that the object has been extended with will not be copied.</p>
<pre class="ruby"><span class="ruby-keyword">class</span> <span class="ruby-constant">Klass</span>
<span class="ruby-identifier">attr_accessor</span> <span class="ruby-value">:str</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">module</span> <span class="ruby-constant">Foo</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">foo</span>; <span class="ruby-string">'foo'</span>; <span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">s1</span> = <span class="ruby-constant">Klass</span>.<span class="ruby-identifier">new</span> <span class="ruby-comment">#=> #<Klass:0x401b3a38></span>
<span class="ruby-identifier">s1</span>.<span class="ruby-identifier">extend</span>(<span class="ruby-constant">Foo</span>) <span class="ruby-comment">#=> #<Klass:0x401b3a38></span>
<span class="ruby-identifier">s1</span>.<span class="ruby-identifier">foo</span> <span class="ruby-comment">#=> "foo"</span>
<span class="ruby-identifier">s2</span> = <span class="ruby-identifier">s1</span>.<span class="ruby-identifier">clone</span> <span class="ruby-comment">#=> #<Klass:0x401b3a38></span>
<span class="ruby-identifier">s2</span>.<span class="ruby-identifier">foo</span> <span class="ruby-comment">#=> "foo"</span>
<span class="ruby-identifier">s3</span> = <span class="ruby-identifier">s1</span>.<span class="ruby-identifier">dup</span> <span class="ruby-comment">#=> #<Klass:0x401b3a38></span>
<span class="ruby-identifier">s3</span>.<span class="ruby-identifier">foo</span> <span class="ruby-comment">#=> NoMethodError: undefined method `foo' for #<Klass:0x401b3a38></span>
</pre>
<div class="method-source-code" id="dup-source">
<pre>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;
}</pre>
</div>
</div>
</div>
<div id="method-i-enum_for" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
enum_for(method = :each, *args) → enum
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-heading">
<span class="method-callseq">
enum_for(method = :each, *args){|*args| block} → enum
</span>
</div>
<div class="method-description">
<p>Creates a new <a href="Enumerator.html"><code>Enumerator</code></a> which will enumerate by calling <code>method</code> on <code>obj</code>, passing <code>args</code> if any. What was <em>yielded</em> by method becomes values of enumerator.</p>
<p>If a block is given, it will be used to calculate the size of the enumerator without the need to iterate it (see <a href="Enumerator.html#method-i-size"><code>Enumerator#size</code></a>).</p>
<h3 id="method-i-enum_for-label-Examples">Examples<span><a href="#method-i-enum_for-label-Examples">¶</a> <a href="#top">↑</a></span></h3>
<pre class="ruby"><span class="ruby-identifier">str</span> = <span class="ruby-string">"xyz"</span>
<span class="ruby-identifier">enum</span> = <span class="ruby-identifier">str</span>.<span class="ruby-identifier">enum_for</span>(<span class="ruby-value">:each_byte</span>)
<span class="ruby-identifier">enum</span>.<span class="ruby-identifier">each</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">b</span><span class="ruby-operator">|</span> <span class="ruby-identifier">puts</span> <span class="ruby-identifier">b</span> }
<span class="ruby-comment"># => 120</span>
<span class="ruby-comment"># => 121</span>
<span class="ruby-comment"># => 122</span>
<span class="ruby-comment"># protect an array from being modified by some_method</span>
<span class="ruby-identifier">a</span> = [<span class="ruby-value">1</span>, <span class="ruby-value">2</span>, <span class="ruby-value">3</span>]
<span class="ruby-identifier">some_method</span>(<span class="ruby-identifier">a</span>.<span class="ruby-identifier">to_enum</span>)
<span class="ruby-comment"># String#split in block form is more memory-effective:</span>
<span class="ruby-identifier">very_large_string</span>.<span class="ruby-identifier">split</span>(<span class="ruby-string">"|"</span>) { <span class="ruby-operator">|</span><span class="ruby-identifier">chunk</span><span class="ruby-operator">|</span> <span class="ruby-keyword">return</span> <span class="ruby-identifier">chunk</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">chunk</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-string">'DATE'</span>) }
<span class="ruby-comment"># This could be rewritten more idiomatically with to_enum:</span>
<span class="ruby-identifier">very_large_string</span>.<span class="ruby-identifier">to_enum</span>(<span class="ruby-value">:split</span>, <span class="ruby-string">"|"</span>).<span class="ruby-identifier">lazy</span>.<span class="ruby-identifier">grep</span>(<span class="ruby-regexp">/DATE/</span>).<span class="ruby-identifier">first</span>
</pre>
<p>It is typical to call <a href="Object.html#method-i-to_enum"><code>to_enum</code></a> when defining methods for a generic <a href="Enumerable.html"><code>Enumerable</code></a>, in case no block is passed.</p>
<p>Here is such an example, with parameter passing and a sizing block:</p>
<pre class="ruby"><span class="ruby-keyword">module</span> <span class="ruby-constant">Enumerable</span>
<span class="ruby-comment"># a generic method to repeat the values of any enumerable</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">repeat</span>(<span class="ruby-identifier">n</span>)
<span class="ruby-identifier">raise</span> <span class="ruby-constant">ArgumentError</span>, <span class="ruby-node">"#{n} is negative!"</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">n</span> <span class="ruby-operator"><</span> <span class="ruby-value">0</span>
<span class="ruby-keyword">unless</span> <span class="ruby-identifier">block_given?</span>
<span class="ruby-keyword">return</span> <span class="ruby-identifier">to_enum</span>(<span class="ruby-identifier">__method__</span>, <span class="ruby-identifier">n</span>) <span class="ruby-keyword">do</span> <span class="ruby-comment"># __method__ is :repeat here</span>
<span class="ruby-identifier">sz</span> = <span class="ruby-identifier">size</span> <span class="ruby-comment"># Call size and multiply by n...</span>
<span class="ruby-identifier">sz</span> <span class="ruby-operator">*</span> <span class="ruby-identifier">n</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">sz</span> <span class="ruby-comment"># but return nil if size itself is nil</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-operator">*</span><span class="ruby-identifier">val</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">n</span>.<span class="ruby-identifier">times</span> { <span class="ruby-keyword">yield</span> <span class="ruby-operator">*</span><span class="ruby-identifier">val</span> }
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-node">%i[hello world]</span>.<span class="ruby-identifier">repeat</span>(<span class="ruby-value">2</span>) { <span class="ruby-operator">|</span><span class="ruby-identifier">w</span><span class="ruby-operator">|</span> <span class="ruby-identifier">puts</span> <span class="ruby-identifier">w</span> }
<span class="ruby-comment"># => Prints 'hello', 'hello', 'world', 'world'</span>
<span class="ruby-identifier">enum</span> = (<span class="ruby-value">1</span><span class="ruby-operator">..</span><span class="ruby-value">14</span>).<span class="ruby-identifier">repeat</span>(<span class="ruby-value">3</span>)
<span class="ruby-comment"># => returns an Enumerator when called without a block</span>
<span class="ruby-identifier">enum</span>.<span class="ruby-identifier">first</span>(<span class="ruby-value">4</span>) <span class="ruby-comment"># => [1, 1, 1, 2]</span>
<span class="ruby-identifier">enum</span>.<span class="ruby-identifier">size</span> <span class="ruby-comment"># => 42</span>
</pre>
<div class="method-source-code" id="enum_for-source">
<pre>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;
}</pre>
</div>
</div>
</div>
<div id="method-i-eql-3F" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
obj == other → true or false
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-heading">
<span class="method-callseq">
equal?(other) → true or false
</span>
</div>
<div class="method-heading">
<span class="method-callseq">
eql?(other) → true or false
</span>
</div>
<div class="method-description">
<p>Equality — At the <a href="Object.html"><code>Object</code></a> level, #== returns <code>true</code> only if <code>obj</code> and <code>other</code> are the same object. Typically, this method is overridden in descendant classes to provide class-specific meaning.</p>
<p>Unlike #==, the <a href="BasicObject.html#method-i-equal-3F"><code>equal?</code></a> method should never be overridden by subclasses as it is used to determine object identity (that is, <code>a.equal?(b)</code> if and only if <code>a</code> is the same object as <code>b</code>):</p>
<pre class="ruby"><span class="ruby-identifier">obj</span> = <span class="ruby-string">"a"</span>
<span class="ruby-identifier">other</span> = <span class="ruby-identifier">obj</span>.<span class="ruby-identifier">dup</span>
<span class="ruby-identifier">obj</span> <span class="ruby-operator">==</span> <span class="ruby-identifier">other</span> <span class="ruby-comment">#=> true</span>
<span class="ruby-identifier">obj</span>.<span class="ruby-identifier">equal?</span> <span class="ruby-identifier">other</span> <span class="ruby-comment">#=> false</span>
<span class="ruby-identifier">obj</span>.<span class="ruby-identifier">equal?</span> <span class="ruby-identifier">obj</span> <span class="ruby-comment">#=> true</span>
</pre>
<p>The <a href="Object.html#method-i-eql-3F"><code>eql?</code></a> method returns <code>true</code> if <code>obj</code> and <code>other</code> refer to the same hash key. This is used by <a href="Hash.html"><code>Hash</code></a> to test members for equality. For any pair of objects where <a href="Object.html#method-i-eql-3F"><code>eql?</code></a> returns <code>true</code>, the <a href="Object.html#method-i-hash"><code>hash</code></a> value of both objects must be equal. So any subclass that overrides <a href="Object.html#method-i-eql-3F"><code>eql?</code></a> should also override <a href="Object.html#method-i-hash"><code>hash</code></a> appropriately.</p>
<p>For objects of class <a href="Object.html"><code>Object</code></a>, <a href="Object.html#method-i-eql-3F"><code>eql?</code></a> is synonymous with #==. Subclasses normally continue this tradition by aliasing <a href="Object.html#method-i-eql-3F"><code>eql?</code></a> to their overridden #== method, but there are exceptions. <a href="Numeric.html"><code>Numeric</code></a> types, for example, perform type conversion across #==, but not across <a href="Object.html#method-i-eql-3F"><code>eql?</code></a>, so:</p>
<pre class="ruby"><span class="ruby-value">1</span> <span class="ruby-operator">==</span> <span class="ruby-value">1.0</span> <span class="ruby-comment">#=> true</span>
<span class="ruby-value">1</span>.<span class="ruby-identifier">eql?</span> <span class="ruby-value">1.0</span> <span class="ruby-comment">#=> false</span>
</pre>
<div class="method-source-code" id="eql-3F-source">
<pre>MJIT_FUNC_EXPORTED VALUE
rb_obj_equal(VALUE obj1, VALUE obj2)
{
if (obj1 == obj2) return Qtrue;
return Qfalse;
}</pre>
</div>
</div>
</div>
<div id="method-i-extend" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
extend(module, ...) → obj
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Adds to <em>obj</em> the instance methods from each module given as a parameter.</p>
<pre class="ruby"><span class="ruby-keyword">module</span> <span class="ruby-constant">Mod</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">hello</span>
<span class="ruby-string">"Hello from Mod.\n"</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">class</span> <span class="ruby-constant">Klass</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">hello</span>
<span class="ruby-string">"Hello from Klass.\n"</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">k</span> = <span class="ruby-constant">Klass</span>.<span class="ruby-identifier">new</span>
<span class="ruby-identifier">k</span>.<span class="ruby-identifier">hello</span> <span class="ruby-comment">#=> "Hello from Klass.\n"</span>
<span class="ruby-identifier">k</span>.<span class="ruby-identifier">extend</span>(<span class="ruby-constant">Mod</span>) <span class="ruby-comment">#=> #<Klass:0x401b3bc8></span>
<span class="ruby-identifier">k</span>.<span class="ruby-identifier">hello</span> <span class="ruby-comment">#=> "Hello from Mod.\n"</span>
</pre>
<div class="method-source-code" id="extend-source">
<pre>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;
}</pre>
</div>
</div>
</div>
<div id="method-i-freeze" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
freeze → obj
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Prevents further modifications to <em>obj</em>. A <a href="RuntimeError.html"><code>RuntimeError</code></a> will be raised if modification is attempted. There is no way to unfreeze a frozen object. See also <a href="Object.html#method-i-frozen-3F"><code>Object#frozen?</code></a>.</p>
<p>This method returns self.</p>
<pre class="ruby"><span class="ruby-identifier">a</span> = [ <span class="ruby-string">"a"</span>, <span class="ruby-string">"b"</span>, <span class="ruby-string">"c"</span> ]
<span class="ruby-identifier">a</span>.<span class="ruby-identifier">freeze</span>
<span class="ruby-identifier">a</span> <span class="ruby-operator"><<</span> <span class="ruby-string">"z"</span>
</pre>
<p><em>produces:</em></p>
<pre>prog.rb:3:in `<<': can't modify frozen Array (FrozenError)
from prog.rb:3</pre>
<p>Objects of the following classes are always frozen: <a href="Integer.html"><code>Integer</code></a>, <a href="Float.html"><code>Float</code></a>, <a href="Symbol.html"><code>Symbol</code></a>.</p>
<div class="method-source-code" id="freeze-source">
<pre>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;
}</pre>
</div>
</div>
</div>
<div id="method-i-frozen-3F" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
frozen? → true or false
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the freeze status of <em>obj</em>.</p>
<pre class="ruby"><span class="ruby-identifier">a</span> = [ <span class="ruby-string">"a"</span>, <span class="ruby-string">"b"</span>, <span class="ruby-string">"c"</span> ]
<span class="ruby-identifier">a</span>.<span class="ruby-identifier">freeze</span> <span class="ruby-comment">#=> ["a", "b", "c"]</span>
<span class="ruby-identifier">a</span>.<span class="ruby-identifier">frozen?</span> <span class="ruby-comment">#=> true</span>
</pre>
<div class="method-source-code" id="frozen-3F-source">
<pre>VALUE
rb_obj_frozen_p(VALUE obj)
{
return OBJ_FROZEN(obj) ? Qtrue : Qfalse;
}</pre>
</div>
</div>
</div>
<div id="method-i-gemfile" class="method-detail ">
<div class="method-heading">
<span class="method-name">gemfile</span><span
class="method-args">(install = false, options = {}, &gemfile)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Allows for declaring a Gemfile inline in a ruby script, optionally installing any gems that aren't already installed on the user's system.</p>
<p>@note Every gem that is specified in this 'Gemfile' will be `require`d, as if</p>
<pre>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.</pre>
<p>@param install [Boolean] whether gems that aren't already installed on the</p>
<pre>user's system should be installed.
Defaults to `false`.</pre>
<p>@param gemfile [Proc] a block that is evaluated as a `Gemfile`.</p>
<p>@example Using an inline Gemfile</p>
<pre class="ruby"><span class="ruby-comment">#!/usr/bin/env ruby</span>
<span class="ruby-identifier">require</span> <span class="ruby-string">'bundler/inline'</span>
<span class="ruby-identifier">gemfile</span> <span class="ruby-keyword">do</span>
<span class="ruby-identifier">source</span> <span class="ruby-string">'https://rubygems.org'</span>
<span class="ruby-identifier">gem</span> <span class="ruby-string">'json'</span>, <span class="ruby-value">require:</span> <span class="ruby-keyword">false</span>
<span class="ruby-identifier">gem</span> <span class="ruby-string">'nap'</span>, <span class="ruby-value">require:</span> <span class="ruby-string">'rest'</span>
<span class="ruby-identifier">gem</span> <span class="ruby-string">'cocoapods'</span>, <span class="ruby-string">'~> 0.34.1'</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">puts</span> <span class="ruby-constant">Pod</span><span class="ruby-operator">::</span><span class="ruby-constant">VERSION</span> <span class="ruby-comment"># => "0.34.4"</span>
</pre>
<div class="method-source-code" id="gemfile-source">
<pre><span class="ruby-comment"># File lib/bundler/inline.rb, line 32</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">gemfile</span>(<span class="ruby-identifier">install</span> = <span class="ruby-keyword">false</span>, <span class="ruby-identifier">options</span> = {}, <span class="ruby-operator">&</span><span class="ruby-identifier">gemfile</span>)
<span class="ruby-identifier">require_relative</span> <span class="ruby-string">"../bundler"</span>
<span class="ruby-identifier">opts</span> = <span class="ruby-identifier">options</span>.<span class="ruby-identifier">dup</span>
<span class="ruby-identifier">ui</span> = <span class="ruby-identifier">opts</span>.<span class="ruby-identifier">delete</span>(<span class="ruby-value">:ui</span>) { <span class="ruby-constant">Bundler</span><span class="ruby-operator">::</span><span class="ruby-constant">UI</span><span class="ruby-operator">::</span><span class="ruby-constant">Shell</span>.<span class="ruby-identifier">new</span> }
<span class="ruby-identifier">ui</span>.<span class="ruby-identifier">level</span> = <span class="ruby-string">"silent"</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">opts</span>.<span class="ruby-identifier">delete</span>(<span class="ruby-value">:quiet</span>)
<span class="ruby-identifier">raise</span> <span class="ruby-constant">ArgumentError</span>, <span class="ruby-node">"Unknown options: #{opts.keys.join(", ")}"</span> <span class="ruby-keyword">unless</span> <span class="ruby-identifier">opts</span>.<span class="ruby-identifier">empty?</span>
<span class="ruby-keyword">begin</span>
<span class="ruby-identifier">old_root</span> = <span class="ruby-constant">Bundler</span>.<span class="ruby-identifier">method</span>(<span class="ruby-value">:root</span>)
<span class="ruby-identifier">bundler_module</span> = <span class="ruby-keyword">class</span> <span class="ruby-operator"><<</span> <span class="ruby-constant">Bundler</span>; <span class="ruby-keyword">self</span>; <span class="ruby-keyword">end</span>
<span class="ruby-identifier">bundler_module</span>.<span class="ruby-identifier">send</span>(<span class="ruby-value">:remove_method</span>, <span class="ruby-value">:root</span>)
<span class="ruby-keyword">def</span> <span class="ruby-constant">Bundler</span>.<span class="ruby-identifier ruby-title">root</span>
<span class="ruby-constant">Bundler</span><span class="ruby-operator">::</span><span class="ruby-constant">SharedHelpers</span>.<span class="ruby-identifier">pwd</span>.<span class="ruby-identifier">expand_path</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">old_gemfile</span> = <span class="ruby-constant">ENV</span>[<span class="ruby-string">"BUNDLE_GEMFILE"</span>]
<span class="ruby-constant">Bundler</span><span class="ruby-operator">::</span><span class="ruby-constant">SharedHelpers</span>.<span class="ruby-identifier">set_env</span> <span class="ruby-string">"BUNDLE_GEMFILE"</span>, <span class="ruby-string">"Gemfile"</span>
<span class="ruby-constant">Bundler</span><span class="ruby-operator">::</span><span class="ruby-constant">Plugin</span>.<span class="ruby-identifier">gemfile_install</span>(<span class="ruby-operator">&</span><span class="ruby-identifier">gemfile</span>) <span class="ruby-keyword">if</span> <span class="ruby-constant">Bundler</span>.<span class="ruby-identifier">feature_flag</span>.<span class="ruby-identifier">plugins?</span>
<span class="ruby-identifier">builder</span> = <span class="ruby-constant">Bundler</span><span class="ruby-operator">::</span><span class="ruby-constant">Dsl</span>.<span class="ruby-identifier">new</span>
<span class="ruby-identifier">builder</span>.<span class="ruby-identifier">instance_eval</span>(<span class="ruby-operator">&</span><span class="ruby-identifier">gemfile</span>)
<span class="ruby-constant">Bundler</span>.<span class="ruby-identifier">settings</span>.<span class="ruby-identifier">temporary</span>(<span class="ruby-value">:frozen</span> <span class="ruby-operator">=></span> <span class="ruby-keyword">false</span>) <span class="ruby-keyword">do</span>
<span class="ruby-identifier">definition</span> = <span class="ruby-identifier">builder</span>.<span class="ruby-identifier">to_definition</span>(<span class="ruby-keyword">nil</span>, <span class="ruby-keyword">true</span>)
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">definition</span>.<span class="ruby-identifier">lock</span>(<span class="ruby-operator">*</span>); <span class="ruby-keyword">end</span>
<span class="ruby-identifier">definition</span>.<span class="ruby-identifier">validate_runtime!</span>
<span class="ruby-constant">Bundler</span>.<span class="ruby-identifier">ui</span> = <span class="ruby-identifier">install</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">ui</span> <span class="ruby-operator">:</span> <span class="ruby-constant">Bundler</span><span class="ruby-operator">::</span><span class="ruby-constant">UI</span><span class="ruby-operator">::</span><span class="ruby-constant">Silent</span>.<span class="ruby-identifier">new</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">install</span> <span class="ruby-operator">||</span> <span class="ruby-identifier">definition</span>.<span class="ruby-identifier">missing_specs?</span>
<span class="ruby-constant">Bundler</span>.<span class="ruby-identifier">settings</span>.<span class="ruby-identifier">temporary</span>(<span class="ruby-value">:inline</span> <span class="ruby-operator">=></span> <span class="ruby-keyword">true</span>, <span class="ruby-value">:disable_platform_warnings</span> <span class="ruby-operator">=></span> <span class="ruby-keyword">true</span>) <span class="ruby-keyword">do</span>
<span class="ruby-identifier">installer</span> = <span class="ruby-constant">Bundler</span><span class="ruby-operator">::</span><span class="ruby-constant">Installer</span>.<span class="ruby-identifier">install</span>(<span class="ruby-constant">Bundler</span>.<span class="ruby-identifier">root</span>, <span class="ruby-identifier">definition</span>, <span class="ruby-value">:system</span> <span class="ruby-operator">=></span> <span class="ruby-keyword">true</span>)
<span class="ruby-identifier">installer</span>.<span class="ruby-identifier">post_install_messages</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">name</span>, <span class="ruby-identifier">message</span><span class="ruby-operator">|</span>
<span class="ruby-constant">Bundler</span>.<span class="ruby-identifier">ui</span>.<span class="ruby-identifier">info</span> <span class="ruby-node">"Post-install message from #{name}:\n#{message}"</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">runtime</span> = <span class="ruby-constant">Bundler</span><span class="ruby-operator">::</span><span class="ruby-constant">Runtime</span>.<span class="ruby-identifier">new</span>(<span class="ruby-keyword">nil</span>, <span class="ruby-identifier">definition</span>)
<span class="ruby-identifier">runtime</span>.<span class="ruby-identifier">setup</span>.<span class="ruby-identifier">require</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">ensure</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">bundler_module</span>
<span class="ruby-identifier">bundler_module</span>.<span class="ruby-identifier">send</span>(<span class="ruby-value">:remove_method</span>, <span class="ruby-value">:root</span>)
<span class="ruby-identifier">bundler_module</span>.<span class="ruby-identifier">send</span>(<span class="ruby-value">:define_method</span>, <span class="ruby-value">:root</span>, <span class="ruby-identifier">old_root</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">old_gemfile</span>
<span class="ruby-constant">ENV</span>[<span class="ruby-string">"BUNDLE_GEMFILE"</span>] = <span class="ruby-identifier">old_gemfile</span>
<span class="ruby-keyword">else</span>
<span class="ruby-constant">ENV</span>[<span class="ruby-string">"BUNDLE_GEMFILE"</span>] = <span class="ruby-string">""</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-hash" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
hash → integer
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Generates an <a href="Integer.html"><code>Integer</code></a> hash value for this object. This function must have the property that <code>a.eql?(b)</code> implies <code>a.hash == b.hash</code>.</p>
<p>The hash value is used along with <a href="Object.html#method-i-eql-3F"><code>eql?</code></a> by the <a href="Hash.html"><code>Hash</code></a> class to determine if two objects reference the same hash key. Any hash value that exceeds the capacity of an <a href="Integer.html"><code>Integer</code></a> will be truncated before being used.</p>
<p>The hash value for an object may not be identical across invocations or implementations of Ruby. If you need a stable identifier across Ruby invocations and implementations you will need to generate one with a custom method.</p>
<div class="method-source-code" id="hash-source">
<pre>VALUE
rb_obj_hash(VALUE obj)
{
long hnum = any_hash(obj, objid_hash);
return ST2FIX(hnum);
}</pre>
</div>
</div>
</div>
<div id="method-i-inspect" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
inspect → string
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns a string containing a human-readable representation of <em>obj</em>. The default <a href="Object.html#method-i-inspect"><code>inspect</code></a> shows the object's class name, an encoding of the object id, and a list of the instance variables and their values (by calling <a href="Object.html#method-i-inspect"><code>inspect</code></a> on each of them). User defined classes should override this method to provide a better representation of <em>obj</em>. When overriding this method, it should return a string whose encoding is compatible with the default external encoding.</p>
<pre class="ruby">[ <span class="ruby-value">1</span>, <span class="ruby-value">2</span>, <span class="ruby-value">3</span><span class="ruby-operator">..</span><span class="ruby-value">4</span>, <span class="ruby-string">'five'</span> ].<span class="ruby-identifier">inspect</span> <span class="ruby-comment">#=> "[1, 2, 3..4, \"five\"]"</span>
<span class="ruby-constant">Time</span>.<span class="ruby-identifier">new</span>.<span class="ruby-identifier">inspect</span> <span class="ruby-comment">#=> "2008-03-08 19:43:39 +0900"</span>
<span class="ruby-keyword">class</span> <span class="ruby-constant">Foo</span>
<span class="ruby-keyword">end</span>
<span class="ruby-constant">Foo</span>.<span class="ruby-identifier">new</span>.<span class="ruby-identifier">inspect</span> <span class="ruby-comment">#=> "#<Foo:0x0300c868>"</span>
<span class="ruby-keyword">class</span> <span class="ruby-constant">Bar</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">initialize</span>
<span class="ruby-ivar">@bar</span> = <span class="ruby-value">1</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-constant">Bar</span>.<span class="ruby-identifier">new</span>.<span class="ruby-identifier">inspect</span> <span class="ruby-comment">#=> "#<Bar:0x0300c868 @bar=1>"</span>
</pre>
<div class="method-source-code" id="inspect-source">
<pre>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);
}
}</pre>
</div>
</div>
</div>
<div id="method-i-instance_of-3F" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
instance_of?(class) → true or false
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns <code>true</code> if <em>obj</em> is an instance of the given class. See also <a href="Object.html#method-i-kind_of-3F"><code>Object#kind_of?</code></a>.</p>
<pre class="ruby"><span class="ruby-keyword">class</span> <span class="ruby-constant">A</span>; <span class="ruby-keyword">end</span>
<span class="ruby-keyword">class</span> <span class="ruby-constant">B</span> <span class="ruby-operator"><</span> <span class="ruby-constant">A</span>; <span class="ruby-keyword">end</span>
<span class="ruby-keyword">class</span> <span class="ruby-constant">C</span> <span class="ruby-operator"><</span> <span class="ruby-constant">B</span>; <span class="ruby-keyword">end</span>
<span class="ruby-identifier">b</span> = <span class="ruby-constant">B</span>.<span class="ruby-identifier">new</span>
<span class="ruby-identifier">b</span>.<span class="ruby-identifier">instance_of?</span> <span class="ruby-constant">A</span> <span class="ruby-comment">#=> false</span>
<span class="ruby-identifier">b</span>.<span class="ruby-identifier">instance_of?</span> <span class="ruby-constant">B</span> <span class="ruby-comment">#=> true</span>
<span class="ruby-identifier">b</span>.<span class="ruby-identifier">instance_of?</span> <span class="ruby-constant">C</span> <span class="ruby-comment">#=> false</span>
</pre>
<div class="method-source-code" id="instance_of-3F-source">
<pre>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;
}</pre>
</div>
</div>
</div>
<div id="method-i-instance_variable_defined-3F" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
instance_variable_defined?(symbol) → true or false
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-heading">
<span class="method-callseq">
instance_variable_defined?(string) → true or false
</span>
</div>
<div class="method-description">
<p>Returns <code>true</code> if the given instance variable is defined in <em>obj</em>. <a href="String.html"><code>String</code></a> arguments are converted to symbols.</p>
<pre class="ruby"><span class="ruby-keyword">class</span> <span class="ruby-constant">Fred</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">initialize</span>(<span class="ruby-identifier">p1</span>, <span class="ruby-identifier">p2</span>)
<span class="ruby-ivar">@a</span>, <span class="ruby-ivar">@b</span> = <span class="ruby-identifier">p1</span>, <span class="ruby-identifier">p2</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">fred</span> = <span class="ruby-constant">Fred</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">'cat'</span>, <span class="ruby-value">99</span>)
<span class="ruby-identifier">fred</span>.<span class="ruby-identifier">instance_variable_defined?</span>(<span class="ruby-value">:@a</span>) <span class="ruby-comment">#=> true</span>
<span class="ruby-identifier">fred</span>.<span class="ruby-identifier">instance_variable_defined?</span>(<span class="ruby-string">"@b"</span>) <span class="ruby-comment">#=> true</span>
<span class="ruby-identifier">fred</span>.<span class="ruby-identifier">instance_variable_defined?</span>(<span class="ruby-string">"@c"</span>) <span class="ruby-comment">#=> false</span>
</pre>
<div class="method-source-code" id="instance_variable_defined-3F-source">
<pre>static VALUE
rb_obj_ivar_defined(VALUE obj, VALUE iv)
{
ID id = id_for_var(obj, iv, instance);
if (!id) {
return Qfalse;
}
return rb_ivar_defined(obj, id);
}</pre>
</div>
</div>
</div>
<div id="method-i-instance_variable_get" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
instance_variable_get(symbol) → obj
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-heading">
<span class="method-callseq">
instance_variable_get(string) → obj
</span>
</div>
<div class="method-description">
<p>Returns the value of the given instance variable, or nil if the instance variable is not set. The <code>@</code> part of the variable name should be included for regular instance variables. Throws a <a href="NameError.html"><code>NameError</code></a> exception if the supplied symbol is not valid as an instance variable name. <a href="String.html"><code>String</code></a> arguments are converted to symbols.</p>
<pre class="ruby"><span class="ruby-keyword">class</span> <span class="ruby-constant">Fred</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">initialize</span>(<span class="ruby-identifier">p1</span>, <span class="ruby-identifier">p2</span>)
<span class="ruby-ivar">@a</span>, <span class="ruby-ivar">@b</span> = <span class="ruby-identifier">p1</span>, <span class="ruby-identifier">p2</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">fred</span> = <span class="ruby-constant">Fred</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">'cat'</span>, <span class="ruby-value">99</span>)
<span class="ruby-identifier">fred</span>.<span class="ruby-identifier">instance_variable_get</span>(<span class="ruby-value">:@a</span>) <span class="ruby-comment">#=> "cat"</span>
<span class="ruby-identifier">fred</span>.<span class="ruby-identifier">instance_variable_get</span>(<span class="ruby-string">"@b"</span>) <span class="ruby-comment">#=> 99</span>
</pre>
<div class="method-source-code" id="instance_variable_get-source">
<pre>static VALUE
rb_obj_ivar_get(VALUE obj, VALUE iv)
{
ID id = id_for_var(obj, iv, instance);
if (!id) {
return Qnil;
}
return rb_ivar_get(obj, id);
}</pre>
</div>
</div>
</div>
<div id="method-i-instance_variable_set" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
instance_variable_set(symbol, obj) → obj
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-heading">
<span class="method-callseq">
instance_variable_set(string, obj) → obj
</span>
</div>
<div class="method-description">
<p>Sets the instance variable named by <em>symbol</em> 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.</p>
<pre class="ruby"><span class="ruby-keyword">class</span> <span class="ruby-constant">Fred</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">initialize</span>(<span class="ruby-identifier">p1</span>, <span class="ruby-identifier">p2</span>)
<span class="ruby-ivar">@a</span>, <span class="ruby-ivar">@b</span> = <span class="ruby-identifier">p1</span>, <span class="ruby-identifier">p2</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">fred</span> = <span class="ruby-constant">Fred</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">'cat'</span>, <span class="ruby-value">99</span>)
<span class="ruby-identifier">fred</span>.<span class="ruby-identifier">instance_variable_set</span>(<span class="ruby-value">:@a</span>, <span class="ruby-string">'dog'</span>) <span class="ruby-comment">#=> "dog"</span>
<span class="ruby-identifier">fred</span>.<span class="ruby-identifier">instance_variable_set</span>(<span class="ruby-value">:@c</span>, <span class="ruby-string">'cat'</span>) <span class="ruby-comment">#=> "cat"</span>
<span class="ruby-identifier">fred</span>.<span class="ruby-identifier">inspect</span> <span class="ruby-comment">#=> "#<Fred:0x401b3da8 @a=\"dog\", @b=99, @c=\"cat\">"</span>
</pre>
<div class="method-source-code" id="instance_variable_set-source">
<pre>static VALUE
rb_obj_ivar_set(VALUE obj, VALUE iv, VALUE val)
{
ID id = id_for_var(obj, iv, instance);
if (!id) id = rb_intern_str(iv);
return rb_ivar_set(obj, id, val);
}</pre>
</div>
</div>
</div>
<div id="method-i-instance_variables" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
instance_variables → array
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns an array of instance variable names for the receiver. Note that simply defining an accessor does not create the corresponding instance variable.</p>
<pre class="ruby"><span class="ruby-keyword">class</span> <span class="ruby-constant">Fred</span>
<span class="ruby-identifier">attr_accessor</span> <span class="ruby-value">:a1</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">initialize</span>
<span class="ruby-ivar">@iv</span> = <span class="ruby-value">3</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-constant">Fred</span>.<span class="ruby-identifier">new</span>.<span class="ruby-identifier">instance_variables</span> <span class="ruby-comment">#=> [:@iv]</span>
</pre>
<div class="method-source-code" id="instance_variables-source">
<pre>VALUE
rb_obj_instance_variables(VALUE obj)
{
VALUE ary;
ary = rb_ary_new();
rb_ivar_foreach(obj, ivar_i, ary);
return ary;
}</pre>
</div>
</div>
</div>
<div id="method-i-is_a-3F" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
is_a?(class) → true or false
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns <code>true</code> if <em>class</em> is the class of <em>obj</em>, or if <em>class</em> is one of the superclasses of <em>obj</em> or modules included in <em>obj</em>.</p>
<pre class="ruby"><span class="ruby-keyword">module</span> <span class="ruby-constant">M</span>; <span class="ruby-keyword">end</span>
<span class="ruby-keyword">class</span> <span class="ruby-constant">A</span>
<span class="ruby-identifier">include</span> <span class="ruby-constant">M</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">class</span> <span class="ruby-constant">B</span> <span class="ruby-operator"><</span> <span class="ruby-constant">A</span>; <span class="ruby-keyword">end</span>
<span class="ruby-keyword">class</span> <span class="ruby-constant">C</span> <span class="ruby-operator"><</span> <span class="ruby-constant">B</span>; <span class="ruby-keyword">end</span>
<span class="ruby-identifier">b</span> = <span class="ruby-constant">B</span>.<span class="ruby-identifier">new</span>
<span class="ruby-identifier">b</span>.<span class="ruby-identifier">is_a?</span> <span class="ruby-constant">A</span> <span class="ruby-comment">#=> true</span>
<span class="ruby-identifier">b</span>.<span class="ruby-identifier">is_a?</span> <span class="ruby-constant">B</span> <span class="ruby-comment">#=> true</span>
<span class="ruby-identifier">b</span>.<span class="ruby-identifier">is_a?</span> <span class="ruby-constant">C</span> <span class="ruby-comment">#=> false</span>
<span class="ruby-identifier">b</span>.<span class="ruby-identifier">is_a?</span> <span class="ruby-constant">M</span> <span class="ruby-comment">#=> true</span>
<span class="ruby-identifier">b</span>.<span class="ruby-identifier">kind_of?</span> <span class="ruby-constant">A</span> <span class="ruby-comment">#=> true</span>
<span class="ruby-identifier">b</span>.<span class="ruby-identifier">kind_of?</span> <span class="ruby-constant">B</span> <span class="ruby-comment">#=> true</span>
<span class="ruby-identifier">b</span>.<span class="ruby-identifier">kind_of?</span> <span class="ruby-constant">C</span> <span class="ruby-comment">#=> false</span>
<span class="ruby-identifier">b</span>.<span class="ruby-identifier">kind_of?</span> <span class="ruby-constant">M</span> <span class="ruby-comment">#=> true</span>
</pre>
<div class="method-source-code" id="is_a-3F-source">
<pre>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;
}</pre>
</div>
</div>
</div>
<div id="method-i-itself" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
itself → obj
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the receiver.</p>
<pre class="ruby"><span class="ruby-identifier">string</span> = <span class="ruby-string">"my string"</span>
<span class="ruby-identifier">string</span>.<span class="ruby-identifier">itself</span>.<span class="ruby-identifier">object_id</span> <span class="ruby-operator">==</span> <span class="ruby-identifier">string</span>.<span class="ruby-identifier">object_id</span> <span class="ruby-comment">#=> true</span>
</pre>
<div class="method-source-code" id="itself-source">
<pre>static VALUE
rb_obj_itself(VALUE obj)
{
return obj;
}</pre>
</div>
</div>
</div>
<div id="method-i-kind_of-3F" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
kind_of?(class) → true or false
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns <code>true</code> if <em>class</em> is the class of <em>obj</em>, or if <em>class</em> is one of the superclasses of <em>obj</em> or modules included in <em>obj</em>.</p>
<pre class="ruby"><span class="ruby-keyword">module</span> <span class="ruby-constant">M</span>; <span class="ruby-keyword">end</span>
<span class="ruby-keyword">class</span> <span class="ruby-constant">A</span>
<span class="ruby-identifier">include</span> <span class="ruby-constant">M</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">class</span> <span class="ruby-constant">B</span> <span class="ruby-operator"><</span> <span class="ruby-constant">A</span>; <span class="ruby-keyword">end</span>
<span class="ruby-keyword">class</span> <span class="ruby-constant">C</span> <span class="ruby-operator"><</span> <span class="ruby-constant">B</span>; <span class="ruby-keyword">end</span>
<span class="ruby-identifier">b</span> = <span class="ruby-constant">B</span>.<span class="ruby-identifier">new</span>
<span class="ruby-identifier">b</span>.<span class="ruby-identifier">is_a?</span> <span class="ruby-constant">A</span> <span class="ruby-comment">#=> true</span>
<span class="ruby-identifier">b</span>.<span class="ruby-identifier">is_a?</span> <span class="ruby-constant">B</span> <span class="ruby-comment">#=> true</span>
<span class="ruby-identifier">b</span>.<span class="ruby-identifier">is_a?</span> <span class="ruby-constant">C</span> <span class="ruby-comment">#=> false</span>
<span class="ruby-identifier">b</span>.<span class="ruby-identifier">is_a?</span> <span class="ruby-constant">M</span> <span class="ruby-comment">#=> true</span>
<span class="ruby-identifier">b</span>.<span class="ruby-identifier">kind_of?</span> <span class="ruby-constant">A</span> <span class="ruby-comment">#=> true</span>
<span class="ruby-identifier">b</span>.<span class="ruby-identifier">kind_of?</span> <span class="ruby-constant">B</span> <span class="ruby-comment">#=> true</span>
<span class="ruby-identifier">b</span>.<span class="ruby-identifier">kind_of?</span> <span class="ruby-constant">C</span> <span class="ruby-comment">#=> false</span>
<span class="ruby-identifier">b</span>.<span class="ruby-identifier">kind_of?</span> <span class="ruby-constant">M</span> <span class="ruby-comment">#=> true</span>
</pre>
<div class="method-source-code" id="kind_of-3F-source">
<pre>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;
}</pre>
</div>
</div>
</div>
<div id="method-i-method" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
method(sym) → method
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Looks up the named method as a receiver in <em>obj</em>, returning a <a href="Method.html"><code>Method</code></a> object (or raising <a href="NameError.html"><code>NameError</code></a>). The <a href="Method.html"><code>Method</code></a> object acts as a closure in <em>obj</em>'s object instance, so instance variables and the value of <code>self</code> remain available.</p>
<pre class="ruby"><span class="ruby-keyword">class</span> <span class="ruby-constant">Demo</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">initialize</span>(<span class="ruby-identifier">n</span>)
<span class="ruby-ivar">@iv</span> = <span class="ruby-identifier">n</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">hello</span>()
<span class="ruby-node">"Hello, @iv = #{@iv}"</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">k</span> = <span class="ruby-constant">Demo</span>.<span class="ruby-identifier">new</span>(<span class="ruby-value">99</span>)
<span class="ruby-identifier">m</span> = <span class="ruby-identifier">k</span>.<span class="ruby-identifier">method</span>(<span class="ruby-value">:hello</span>)
<span class="ruby-identifier">m</span>.<span class="ruby-identifier">call</span> <span class="ruby-comment">#=> "Hello, @iv = 99"</span>
<span class="ruby-identifier">l</span> = <span class="ruby-constant">Demo</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">'Fred'</span>)
<span class="ruby-identifier">m</span> = <span class="ruby-identifier">l</span>.<span class="ruby-identifier">method</span>(<span class="ruby-string">"hello"</span>)
<span class="ruby-identifier">m</span>.<span class="ruby-identifier">call</span> <span class="ruby-comment">#=> "Hello, @iv = Fred"</span>
</pre>
<p>Note that <a href="Method.html"><code>Method</code></a> implements <code>to_proc</code> method, which means it can be used with iterators.</p>
<pre class="ruby">[ <span class="ruby-value">1</span>, <span class="ruby-value">2</span>, <span class="ruby-value">3</span> ].<span class="ruby-identifier">each</span>(<span class="ruby-operator">&</span><span class="ruby-identifier">method</span>(<span class="ruby-value">:puts</span>)) <span class="ruby-comment"># => prints 3 lines to stdout</span>
<span class="ruby-identifier">out</span> = <span class="ruby-constant">File</span>.<span class="ruby-identifier">open</span>(<span class="ruby-string">'test.txt'</span>, <span class="ruby-string">'w'</span>)
[ <span class="ruby-value">1</span>, <span class="ruby-value">2</span>, <span class="ruby-value">3</span> ].<span class="ruby-identifier">each</span>(<span class="ruby-operator">&</span><span class="ruby-identifier">out</span>.<span class="ruby-identifier">method</span>(<span class="ruby-value">:puts</span>)) <span class="ruby-comment"># => prints 3 lines to file</span>
<span class="ruby-identifier">require</span> <span class="ruby-string">'date'</span>
<span class="ruby-node">%w[2017-03-01 2017-03-02]</span>.<span class="ruby-identifier">collect</span>(<span class="ruby-operator">&</span><span class="ruby-constant">Date</span>.<span class="ruby-identifier">method</span>(<span class="ruby-value">:parse</span>))
<span class="ruby-comment">#=> [#<Date: 2017-03-01 ((2457814j,0s,0n),+0s,2299161j)>, #<Date: 2017-03-02 ((2457815j,0s,0n),+0s,2299161j)>]</span>
</pre>
<div class="method-source-code" id="method-source">
<pre>VALUE
rb_obj_method(VALUE obj, VALUE vid)
{
return obj_method(obj, vid, FALSE);
}</pre>
</div>
</div>
</div>
<div id="method-i-methods" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
methods(regular=true) → array
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns a list of the names of public and protected methods of <em>obj</em>. This will include all the methods accessible in <em>obj</em>'s ancestors. If the optional parameter is <code>false</code>, it returns an array of <em>obj</em>'s public and protected singleton methods, the array will not include methods in modules included in <em>obj</em>.</p>
<pre class="ruby"><span class="ruby-keyword">class</span> <span class="ruby-constant">Klass</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">klass_method</span>()
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">k</span> = <span class="ruby-constant">Klass</span>.<span class="ruby-identifier">new</span>
<span class="ruby-identifier">k</span>.<span class="ruby-identifier">methods</span>[<span class="ruby-value">0</span><span class="ruby-operator">..</span><span class="ruby-value">9</span>] <span class="ruby-comment">#=> [:klass_method, :nil?, :===,</span>
<span class="ruby-comment"># :==~, :!, :eql?</span>
<span class="ruby-comment"># :hash, :<=>, :class, :singleton_class]</span>
<span class="ruby-identifier">k</span>.<span class="ruby-identifier">methods</span>.<span class="ruby-identifier">length</span> <span class="ruby-comment">#=> 56</span>
<span class="ruby-identifier">k</span>.<span class="ruby-identifier">methods</span>(<span class="ruby-keyword">false</span>) <span class="ruby-comment">#=> []</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">k</span>.<span class="ruby-identifier">singleton_method</span>; <span class="ruby-keyword">end</span>
<span class="ruby-identifier">k</span>.<span class="ruby-identifier">methods</span>(<span class="ruby-keyword">false</span>) <span class="ruby-comment">#=> [:singleton_method]</span>
<span class="ruby-keyword">module</span> <span class="ruby-constant">M123</span>; <span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">m123</span>; <span class="ruby-keyword">end</span> <span class="ruby-keyword">end</span>
<span class="ruby-identifier">k</span>.<span class="ruby-identifier">extend</span> <span class="ruby-constant">M123</span>
<span class="ruby-identifier">k</span>.<span class="ruby-identifier">methods</span>(<span class="ruby-keyword">false</span>) <span class="ruby-comment">#=> [:singleton_method]</span>
</pre>
<div class="method-source-code" id="methods-source">
<pre>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);
}</pre>
</div>
</div>
</div>
<div id="method-i-namespace" class="method-detail ">
<div class="method-heading">
<span class="method-name">namespace</span><span
class="method-args">(name)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-calls-super">
Calls superclass method
</div>
<div class="method-source-code" id="namespace-source">
<pre><span class="ruby-comment"># File lib/bundler/vendor/thor/lib/thor/rake_compat.rb, line 61</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">namespace</span>(<span class="ruby-identifier">name</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">klass</span> = <span class="ruby-constant">Bundler</span><span class="ruby-operator">::</span><span class="ruby-constant">Thor</span><span class="ruby-operator">::</span><span class="ruby-constant">RakeCompat</span>.<span class="ruby-identifier">rake_classes</span>.<span class="ruby-identifier">last</span> <span class="ruby-comment"># rubocop:disable AssignmentInCondition</span>
<span class="ruby-identifier">const_name</span> = <span class="ruby-constant">Bundler</span><span class="ruby-operator">::</span><span class="ruby-constant">Thor</span><span class="ruby-operator">::</span><span class="ruby-constant">Util</span>.<span class="ruby-identifier">camel_case</span>(<span class="ruby-identifier">name</span>.<span class="ruby-identifier">to_s</span>).<span class="ruby-identifier">to_sym</span>
<span class="ruby-identifier">klass</span>.<span class="ruby-identifier">const_set</span>(<span class="ruby-identifier">const_name</span>, <span class="ruby-constant">Class</span>.<span class="ruby-identifier">new</span>(<span class="ruby-constant">Bundler</span><span class="ruby-operator">::</span><span class="ruby-constant">Thor</span>))
<span class="ruby-identifier">new_klass</span> = <span class="ruby-identifier">klass</span>.<span class="ruby-identifier">const_get</span>(<span class="ruby-identifier">const_name</span>)
<span class="ruby-constant">Bundler</span><span class="ruby-operator">::</span><span class="ruby-constant">Thor</span><span class="ruby-operator">::</span><span class="ruby-constant">RakeCompat</span>.<span class="ruby-identifier">rake_classes</span> <span class="ruby-operator"><<</span> <span class="ruby-identifier">new_klass</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">super</span>
<span class="ruby-constant">Bundler</span><span class="ruby-operator">::</span><span class="ruby-constant">Thor</span><span class="ruby-operator">::</span><span class="ruby-constant">RakeCompat</span>.<span class="ruby-identifier">rake_classes</span>.<span class="ruby-identifier">pop</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
<div class="aliases">
Also aliased as: <a href="Object.html#method-i-rake_namespace">rake_namespace</a>
</div>
</div>
<div id="method-i-nil-3F" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
nil? → true or false
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Only the object <em>nil</em> responds <code>true</code> to <code>nil?</code>.</p>
<pre class="ruby"><span class="ruby-constant">Object</span>.<span class="ruby-identifier">new</span>.<span class="ruby-identifier">nil?</span> <span class="ruby-comment">#=> false</span>
<span class="ruby-keyword">nil</span>.<span class="ruby-identifier">nil?</span> <span class="ruby-comment">#=> true</span>
</pre>
<div class="method-source-code" id="nil-3F-source">
<pre>MJIT_FUNC_EXPORTED VALUE
rb_false(VALUE obj)
{
return Qfalse;
}</pre>
</div>
</div>
</div>
<div id="method-i-object_id" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
__id__ → integer
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-heading">
<span class="method-callseq">
object_id → integer
</span>
</div>
<div class="method-description">
<p>Returns an integer identifier for <code>obj</code>.</p>
<p>The same number will be returned on all calls to <code>object_id</code> for a given object, and no two active objects will share an id.</p>
<p>Note: that some objects of builtin classes are reused for optimization. This is the case for immediate values and frozen string literals.</p>
<p><a href="BasicObject.html"><code>BasicObject</code></a> implements +__id__+, <a href="Kernel.html"><code>Kernel</code></a> implements <code>object_id</code>.</p>
<p>Immediate values are not passed by reference but are passed by value: <code>nil</code>, <code>true</code>, <code>false</code>, Fixnums, Symbols, and some Floats.</p>
<pre class="ruby"><span class="ruby-constant">Object</span>.<span class="ruby-identifier">new</span>.<span class="ruby-identifier">object_id</span> <span class="ruby-operator">==</span> <span class="ruby-constant">Object</span>.<span class="ruby-identifier">new</span>.<span class="ruby-identifier">object_id</span> <span class="ruby-comment"># => false</span>
(<span class="ruby-value">21</span> <span class="ruby-operator">*</span> <span class="ruby-value">2</span>).<span class="ruby-identifier">object_id</span> <span class="ruby-operator">==</span> (<span class="ruby-value">21</span> <span class="ruby-operator">*</span> <span class="ruby-value">2</span>).<span class="ruby-identifier">object_id</span> <span class="ruby-comment"># => true</span>
<span class="ruby-string">"hello"</span>.<span class="ruby-identifier">object_id</span> <span class="ruby-operator">==</span> <span class="ruby-string">"hello"</span>.<span class="ruby-identifier">object_id</span> <span class="ruby-comment"># => false</span>
<span class="ruby-string">"hi"</span>.<span class="ruby-identifier">freeze</span>.<span class="ruby-identifier">object_id</span> <span class="ruby-operator">==</span> <span class="ruby-string">"hi"</span>.<span class="ruby-identifier">freeze</span>.<span class="ruby-identifier">object_id</span> <span class="ruby-comment"># => true</span>
</pre>
<div class="method-source-code" id="object_id-source">
<pre>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
*/
return rb_find_object_id(obj, cached_object_id);
}</pre>
</div>
</div>
</div>
<div id="method-i-private_methods" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
private_methods(all=true) → array
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the list of private methods accessible to <em>obj</em>. If the <em>all</em> parameter is set to <code>false</code>, only those methods in the receiver will be listed.</p>
<div class="method-source-code" id="private_methods-source">
<pre>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);
}</pre>
</div>
</div>
</div>
<div id="method-i-protected_methods" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
protected_methods(all=true) → array
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the list of protected methods accessible to <em>obj</em>. If the <em>all</em> parameter is set to <code>false</code>, only those methods in the receiver will be listed.</p>
<div class="method-source-code" id="protected_methods-source">
<pre>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);
}</pre>
</div>
</div>
</div>
<div id="method-i-public_method" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
public_method(sym) → method
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Similar to <em>method</em>, searches public method only.</p>
<div class="method-source-code" id="public_method-source">
<pre>VALUE
rb_obj_public_method(VALUE obj, VALUE vid)
{
return obj_method(obj, vid, TRUE);
}</pre>
</div>
</div>
</div>
<div id="method-i-public_methods" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
public_methods(all=true) → array
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the list of public methods accessible to <em>obj</em>. If the <em>all</em> parameter is set to <code>false</code>, only those methods in the receiver will be listed.</p>
<div class="method-source-code" id="public_methods-source">
<pre>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);
}</pre>
</div>
</div>
</div>
<div id="method-i-public_send" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
public_send(symbol [, args...]) → obj
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-heading">
<span class="method-callseq">
public_send(string [, args...]) → obj
</span>
</div>
<div class="method-description">
<p>Invokes the method identified by <em>symbol</em>, passing it any arguments specified. Unlike send, <a href="Object.html#method-i-public_send"><code>public_send</code></a> calls public methods only. When the method is identified by a string, the string is converted to a symbol.</p>
<pre class="ruby"><span class="ruby-value">1</span>.<span class="ruby-identifier">public_send</span>(<span class="ruby-value">:puts</span>, <span class="ruby-string">"hello"</span>) <span class="ruby-comment"># causes NoMethodError</span>
</pre>
<div class="method-source-code" id="public_send-source">
<pre>static VALUE
rb_f_public_send(int argc, VALUE *argv, VALUE recv)
{
return send_internal_kw(argc, argv, recv, CALL_PUBLIC);
}</pre>
</div>
</div>
</div>
<div id="method-i-rake_namespace" class="method-detail method-alias">
<div class="method-heading">
<span class="method-name">rake_namespace</span><span
class="method-args">(name)</span>
</div>
<div class="method-description">
</div>
<div class="aliases">
Alias for: <a href="Object.html#method-i-namespace">namespace</a>
</div>
</div>
<div id="method-i-remove_instance_variable" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
remove_instance_variable(symbol) → obj
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-heading">
<span class="method-callseq">
remove_instance_variable(string) → obj
</span>
</div>
<div class="method-description">
<p>Removes the named instance variable from <em>obj</em>, returning that variable's value. <a href="String.html"><code>String</code></a> arguments are converted to symbols.</p>
<pre class="ruby"><span class="ruby-keyword">class</span> <span class="ruby-constant">Dummy</span>
<span class="ruby-identifier">attr_reader</span> <span class="ruby-value">:var</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">initialize</span>
<span class="ruby-ivar">@var</span> = <span class="ruby-value">99</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">remove</span>
<span class="ruby-identifier">remove_instance_variable</span>(<span class="ruby-value">:@var</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">d</span> = <span class="ruby-constant">Dummy</span>.<span class="ruby-identifier">new</span>
<span class="ruby-identifier">d</span>.<span class="ruby-identifier">var</span> <span class="ruby-comment">#=> 99</span>
<span class="ruby-identifier">d</span>.<span class="ruby-identifier">remove</span> <span class="ruby-comment">#=> 99</span>
<span class="ruby-identifier">d</span>.<span class="ruby-identifier">var</span> <span class="ruby-comment">#=> nil</span>
</pre>
<div class="method-source-code" id="remove_instance_variable-source">
<pre>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);
}</pre>
</div>
</div>
</div>
<div id="method-i-respond_to-3F" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
respond_to?(symbol, include_all=false) → true or false
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-heading">
<span class="method-callseq">
respond_to?(string, include_all=false) → true or false
</span>
</div>
<div class="method-description">
<p>Returns <code>true</code> if <em>obj</em> responds to the given method. Private and protected methods are included in the search only if the optional second parameter evaluates to <code>true</code>.</p>
<p>If the method is not implemented, as <a href="Process.html#method-c-fork"><code>Process.fork</code></a> on Windows, <a href="File.html#method-c-lchmod"><code>File.lchmod</code></a> on GNU/Linux, etc., false is returned.</p>
<p>If the method is not defined, <code>respond_to_missing?</code> method is called and the result is returned.</p>
<p>When the method name parameter is given as a string, the string is converted to a symbol.</p>
<div class="method-source-code" id="respond_to-3F-source">
<pre>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;
}</pre>
</div>
</div>
</div>
<div id="method-i-respond_to_missing-3F" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
respond_to_missing?(symbol, include_all) → true or false
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-heading">
<span class="method-callseq">
respond_to_missing?(string, include_all) → true or false
</span>
</div>
<div class="method-description">
<p>DO NOT USE THIS DIRECTLY.</p>
<p>Hook method to return whether the <em>obj</em> can respond to <em>id</em> method or not.</p>
<p>When the method name parameter is given as a string, the string is converted to a symbol.</p>
<p>See <a href="Object.html#method-i-respond_to-3F"><code>respond_to?</code></a>, and the example of <a href="BasicObject.html"><code>BasicObject</code></a>.</p>
<div class="method-source-code" id="respond_to_missing-3F-source">
<pre>static VALUE
obj_respond_to_missing(VALUE obj, VALUE mid, VALUE priv)
{
return Qfalse;
}</pre>
</div>
</div>
</div>
<div id="method-i-send" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
send(symbol [, args...]) → obj
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-heading">
<span class="method-callseq">
__send__(symbol [, args...]) → obj
</span>
</div>
<div class="method-heading">
<span class="method-callseq">
send(string [, args...]) → obj
</span>
</div>
<div class="method-heading">
<span class="method-callseq">
__send__(string [, args...]) → obj
</span>
</div>
<div class="method-description">
<p>Invokes the method identified by <em>symbol</em>, passing it any arguments specified. You can use <code>__send__</code> if the name <code>send</code> clashes with an existing method in <em>obj</em>. When the method is identified by a string, the string is converted to a symbol.</p>
<p><a href="BasicObject.html"><code>BasicObject</code></a> implements +__send__+, <a href="Kernel.html"><code>Kernel</code></a> implements <code>send</code>.</p>
<pre class="ruby"><span class="ruby-keyword">class</span> <span class="ruby-constant">Klass</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">hello</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
<span class="ruby-string">"Hello "</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">args</span>.<span class="ruby-identifier">join</span>(<span class="ruby-string">' '</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">k</span> = <span class="ruby-constant">Klass</span>.<span class="ruby-identifier">new</span>
<span class="ruby-identifier">k</span>.<span class="ruby-identifier">send</span> <span class="ruby-value">:hello</span>, <span class="ruby-string">"gentle"</span>, <span class="ruby-string">"readers"</span> <span class="ruby-comment">#=> "Hello gentle readers"</span>
</pre>
<div class="method-source-code" id="send-source">
<pre>VALUE
rb_f_send(int argc, VALUE *argv, VALUE recv)
{
return send_internal_kw(argc, argv, recv, CALL_FCALL);
}</pre>
</div>
</div>
</div>
<div id="method-i-singleton_class" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
singleton_class → class
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the singleton class of <em>obj</em>. This method creates a new singleton class if <em>obj</em> does not have one.</p>
<p>If <em>obj</em> is <code>nil</code>, <code>true</code>, or <code>false</code>, it returns <a href="NilClass.html"><code>NilClass</code></a>, <a href="TrueClass.html"><code>TrueClass</code></a>, or <a href="FalseClass.html"><code>FalseClass</code></a>, respectively. If <em>obj</em> is an <a href="Integer.html"><code>Integer</code></a>, a <a href="Float.html"><code>Float</code></a> or a <a href="Symbol.html"><code>Symbol</code></a>, it raises a <a href="TypeError.html"><code>TypeError</code></a>.</p>
<pre class="ruby"><span class="ruby-constant">Object</span>.<span class="ruby-identifier">new</span>.<span class="ruby-identifier">singleton_class</span> <span class="ruby-comment">#=> #<Class:#<Object:0xb7ce1e24>></span>
<span class="ruby-constant">String</span>.<span class="ruby-identifier">singleton_class</span> <span class="ruby-comment">#=> #<Class:String></span>
<span class="ruby-keyword">nil</span>.<span class="ruby-identifier">singleton_class</span> <span class="ruby-comment">#=> NilClass</span>
</pre>
<div class="method-source-code" id="singleton_class-source">
<pre>static VALUE
rb_obj_singleton_class(VALUE obj)
{
return rb_singleton_class(obj);
}</pre>
</div>
</div>
</div>
<div id="method-i-singleton_method" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
singleton_method(sym) → method
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Similar to <em>method</em>, searches singleton method only.</p>
<pre class="ruby"><span class="ruby-keyword">class</span> <span class="ruby-constant">Demo</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">initialize</span>(<span class="ruby-identifier">n</span>)
<span class="ruby-ivar">@iv</span> = <span class="ruby-identifier">n</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">hello</span>()
<span class="ruby-node">"Hello, @iv = #{@iv}"</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">k</span> = <span class="ruby-constant">Demo</span>.<span class="ruby-identifier">new</span>(<span class="ruby-value">99</span>)
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">k</span>.<span class="ruby-identifier">hi</span>
<span class="ruby-node">"Hi, @iv = #{@iv}"</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">m</span> = <span class="ruby-identifier">k</span>.<span class="ruby-identifier">singleton_method</span>(<span class="ruby-value">:hi</span>)
<span class="ruby-identifier">m</span>.<span class="ruby-identifier">call</span> <span class="ruby-comment">#=> "Hi, @iv = 99"</span>
<span class="ruby-identifier">m</span> = <span class="ruby-identifier">k</span>.<span class="ruby-identifier">singleton_method</span>(<span class="ruby-value">:hello</span>) <span class="ruby-comment">#=> NameError</span>
</pre>
<div class="method-source-code" id="singleton_method-source">
<pre>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) {
VALUE m = mnew_missing_by_name(klass, obj, &vid, FALSE, rb_cMethod);
if (m) return m;
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);
}</pre>
</div>
</div>
</div>
<div id="method-i-singleton_methods" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
singleton_methods(all=true) → array
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns an array of the names of singleton methods for <em>obj</em>. If the optional <em>all</em> parameter is true, the list will include methods in modules included in <em>obj</em>. Only public and protected singleton methods are returned.</p>
<pre class="ruby"><span class="ruby-keyword">module</span> <span class="ruby-constant">Other</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">three</span>() <span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">class</span> <span class="ruby-constant">Single</span>
<span class="ruby-keyword">def</span> <span class="ruby-constant">Single</span>.<span class="ruby-identifier ruby-title">four</span>() <span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">a</span> = <span class="ruby-constant">Single</span>.<span class="ruby-identifier">new</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">a</span>.<span class="ruby-identifier">one</span>()
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">class</span> <span class="ruby-operator"><<</span> <span class="ruby-identifier">a</span>
<span class="ruby-identifier">include</span> <span class="ruby-constant">Other</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">two</span>()
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-constant">Single</span>.<span class="ruby-identifier">singleton_methods</span> <span class="ruby-comment">#=> [:four]</span>
<span class="ruby-identifier">a</span>.<span class="ruby-identifier">singleton_methods</span>(<span class="ruby-keyword">false</span>) <span class="ruby-comment">#=> [:two, :one]</span>
<span class="ruby-identifier">a</span>.<span class="ruby-identifier">singleton_methods</span> <span class="ruby-comment">#=> [:two, :one, :three]</span>
</pre>
<div class="method-source-code" id="singleton_methods-source">
<pre>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]);
if (RB_TYPE_P(obj, T_CLASS) && FL_TEST(obj, FL_SINGLETON)) {
rb_singleton_class(obj);
}
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_new2(me_arg.list->num_entries);
st_foreach(me_arg.list, ins_methods_i, ary);
st_free_table(me_arg.list);
return ary;
}</pre>
</div>
</div>
</div>
<div id="method-i-sysread" class="method-detail ">
<div class="method-heading">
<span class="method-name">sysread</span><span
class="method-args">(io, size)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>cgi_runner.rb – <a href="CGI.html"><code>CGI</code></a> launcher.</p>
<p>Author: IPR – Internet Programming with Ruby – writers Copyright © 2000 TAKAHASHI Masayoshi, GOTOU YUUZOU Copyright © 2002 Internet Programming with Ruby writers. All rights reserved.</p>
<p>$IPR: cgi_runner.rb,v 1.9 2002/09/25 11:33:15 gotoyuzo Exp $</p>
<div class="method-source-code" id="sysread-source">
<pre><span class="ruby-comment"># File lib/webrick/httpservlet/cgi_runner.rb, line 12</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">sysread</span>(<span class="ruby-identifier">io</span>, <span class="ruby-identifier">size</span>)
<span class="ruby-identifier">buf</span> = <span class="ruby-string">""</span>
<span class="ruby-keyword">while</span> <span class="ruby-identifier">size</span> <span class="ruby-operator">></span> <span class="ruby-value">0</span>
<span class="ruby-identifier">tmp</span> = <span class="ruby-identifier">io</span>.<span class="ruby-identifier">sysread</span>(<span class="ruby-identifier">size</span>)
<span class="ruby-identifier">buf</span> <span class="ruby-operator"><<</span> <span class="ruby-identifier">tmp</span>
<span class="ruby-identifier">size</span> <span class="ruby-operator">-=</span> <span class="ruby-identifier">tmp</span>.<span class="ruby-identifier">bytesize</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">return</span> <span class="ruby-identifier">buf</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-taint" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
taint → obj
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns object. This method is deprecated and will be removed in Ruby 3.2.</p>
<div class="method-source-code" id="taint-source">
<pre>VALUE
rb_obj_taint(VALUE obj)
{
rb_warning("Object#taint is deprecated and will be removed in Ruby 3.2.");
return obj;
}</pre>
</div>
</div>
</div>
<div id="method-i-tainted-3F" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
tainted? → false
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns false. This method is deprecated and will be removed in Ruby 3.2.</p>
<div class="method-source-code" id="tainted-3F-source">
<pre>VALUE
rb_obj_tainted(VALUE obj)
{
rb_warning("Object#tainted? is deprecated and will be removed in Ruby 3.2.");
return Qfalse;
}</pre>
</div>
</div>
</div>
<div id="method-i-tap" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
tap {|x| block } → obj
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>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.</p>
<pre class="ruby">(<span class="ruby-value">1</span><span class="ruby-operator">..</span><span class="ruby-value">10</span>) .<span class="ruby-identifier">tap</span> {<span class="ruby-operator">|</span><span class="ruby-identifier">x</span><span class="ruby-operator">|</span> <span class="ruby-identifier">puts</span> <span class="ruby-node">"original: #{x}"</span> }
.<span class="ruby-identifier">to_a</span> .<span class="ruby-identifier">tap</span> {<span class="ruby-operator">|</span><span class="ruby-identifier">x</span><span class="ruby-operator">|</span> <span class="ruby-identifier">puts</span> <span class="ruby-node">"array: #{x}"</span> }
.<span class="ruby-identifier">select</span> {<span class="ruby-operator">|</span><span class="ruby-identifier">x</span><span class="ruby-operator">|</span> <span class="ruby-identifier">x</span>.<span class="ruby-identifier">even?</span> } .<span class="ruby-identifier">tap</span> {<span class="ruby-operator">|</span><span class="ruby-identifier">x</span><span class="ruby-operator">|</span> <span class="ruby-identifier">puts</span> <span class="ruby-node">"evens: #{x}"</span> }
.<span class="ruby-identifier">map</span> {<span class="ruby-operator">|</span><span class="ruby-identifier">x</span><span class="ruby-operator">|</span> <span class="ruby-identifier">x</span><span class="ruby-operator">*</span><span class="ruby-identifier">x</span> } .<span class="ruby-identifier">tap</span> {<span class="ruby-operator">|</span><span class="ruby-identifier">x</span><span class="ruby-operator">|</span> <span class="ruby-identifier">puts</span> <span class="ruby-node">"squares: #{x}"</span> }
</pre>
<div class="method-source-code" id="tap-source">
<pre>VALUE
rb_obj_tap(VALUE obj)
{
rb_yield(obj);
return obj;
}</pre>
</div>
</div>
</div>
<div id="method-i-task" class="method-detail ">
<div class="method-heading">
<span class="method-name">task</span><span
class="method-args">(*)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-calls-super">
Calls superclass method
</div>
<div class="method-source-code" id="task-source">
<pre><span class="ruby-comment"># File lib/bundler/vendor/thor/lib/thor/rake_compat.rb, line 41</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">task</span>(<span class="ruby-operator">*</span>)
<span class="ruby-identifier">task</span> = <span class="ruby-keyword">super</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">klass</span> = <span class="ruby-constant">Bundler</span><span class="ruby-operator">::</span><span class="ruby-constant">Thor</span><span class="ruby-operator">::</span><span class="ruby-constant">RakeCompat</span>.<span class="ruby-identifier">rake_classes</span>.<span class="ruby-identifier">last</span> <span class="ruby-comment"># rubocop:disable AssignmentInCondition</span>
<span class="ruby-identifier">non_namespaced_name</span> = <span class="ruby-identifier">task</span>.<span class="ruby-identifier">name</span>.<span class="ruby-identifier">split</span>(<span class="ruby-string">":"</span>).<span class="ruby-identifier">last</span>
<span class="ruby-identifier">description</span> = <span class="ruby-identifier">non_namespaced_name</span>
<span class="ruby-identifier">description</span> <span class="ruby-operator"><<</span> <span class="ruby-identifier">task</span>.<span class="ruby-identifier">arg_names</span>.<span class="ruby-identifier">map</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">n</span><span class="ruby-operator">|</span> <span class="ruby-identifier">n</span>.<span class="ruby-identifier">to_s</span>.<span class="ruby-identifier">upcase</span> }.<span class="ruby-identifier">join</span>(<span class="ruby-string">" "</span>)
<span class="ruby-identifier">description</span>.<span class="ruby-identifier">strip!</span>
<span class="ruby-identifier">klass</span>.<span class="ruby-identifier">desc</span> <span class="ruby-identifier">description</span>, <span class="ruby-constant">Rake</span>.<span class="ruby-identifier">application</span>.<span class="ruby-identifier">last_description</span> <span class="ruby-operator">||</span> <span class="ruby-identifier">non_namespaced_name</span>
<span class="ruby-constant">Rake</span>.<span class="ruby-identifier">application</span>.<span class="ruby-identifier">last_description</span> = <span class="ruby-keyword">nil</span>
<span class="ruby-identifier">klass</span>.<span class="ruby-identifier">send</span> <span class="ruby-value">:define_method</span>, <span class="ruby-identifier">non_namespaced_name</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-operator">*</span><span class="ruby-identifier">args</span><span class="ruby-operator">|</span>
<span class="ruby-constant">Rake</span><span class="ruby-operator">::</span><span class="ruby-constant">Task</span>[<span class="ruby-identifier">task</span>.<span class="ruby-identifier">name</span>.<span class="ruby-identifier">to_sym</span>].<span class="ruby-identifier">invoke</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">task</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-then" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
then {|x| block } → an_object
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Yields self to the block and returns the result of the block.</p>
<pre class="ruby"><span class="ruby-value">3</span>.<span class="ruby-identifier">next</span>.<span class="ruby-identifier">then</span> {<span class="ruby-operator">|</span><span class="ruby-identifier">x</span><span class="ruby-operator">|</span> <span class="ruby-identifier">x</span><span class="ruby-operator">**</span><span class="ruby-identifier">x</span> }.<span class="ruby-identifier">to_s</span> <span class="ruby-comment">#=> "256"</span>
<span class="ruby-string">"my string"</span>.<span class="ruby-identifier">yield_self</span> {<span class="ruby-operator">|</span><span class="ruby-identifier">s</span><span class="ruby-operator">|</span> <span class="ruby-identifier">s</span>.<span class="ruby-identifier">upcase</span> } <span class="ruby-comment">#=> "MY STRING"</span>
</pre>
<p>Good usage for <code>then</code> is value piping in method chains:</p>
<pre class="ruby"><span class="ruby-identifier">require</span> <span class="ruby-string">'open-uri'</span>
<span class="ruby-identifier">require</span> <span class="ruby-string">'json'</span>
<span class="ruby-identifier">construct_url</span>(<span class="ruby-identifier">arguments</span>).
<span class="ruby-identifier">then</span> {<span class="ruby-operator">|</span><span class="ruby-identifier">url</span><span class="ruby-operator">|</span> <span class="ruby-identifier">open</span>(<span class="ruby-identifier">url</span>).<span class="ruby-identifier">read</span> }.
<span class="ruby-identifier">then</span> {<span class="ruby-operator">|</span><span class="ruby-identifier">response</span><span class="ruby-operator">|</span> <span class="ruby-constant">JSON</span>.<span class="ruby-identifier">parse</span>(<span class="ruby-identifier">response</span>) }
</pre>
<p>When called without block, the method returns <code>Enumerator</code>, which can be used, for example, for conditional circuit-breaking:</p>
<pre class="ruby"><span class="ruby-comment"># meets condition, no-op</span>
<span class="ruby-value">1</span>.<span class="ruby-identifier">then</span>.<span class="ruby-identifier">detect</span>(<span class="ruby-operator">&</span><span class="ruby-value">:odd?</span>) <span class="ruby-comment"># => 1</span>
<span class="ruby-comment"># does not meet condition, drop value</span>
<span class="ruby-value">2</span>.<span class="ruby-identifier">then</span>.<span class="ruby-identifier">detect</span>(<span class="ruby-operator">&</span><span class="ruby-value">:odd?</span>) <span class="ruby-comment"># => nil</span>
</pre>
<div class="method-source-code" id="then-source">
<pre>static VALUE
rb_obj_yield_self(VALUE obj)
{
RETURN_SIZED_ENUMERATOR(obj, 0, 0, rb_obj_size);
return rb_yield_values2(1, &obj);
}</pre>
</div>
</div>
</div>
<div id="method-i-timeout" class="method-detail ">
<div class="method-heading">
<span class="method-name">timeout</span><span
class="method-args">(*args, &block)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="timeout-source">
<pre><span class="ruby-comment"># File lib/timeout.rb, line 122</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">timeout</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>, <span class="ruby-operator">&</span><span class="ruby-identifier">block</span>)
<span class="ruby-identifier">warn</span> <span class="ruby-node">"Object##{__method__} is deprecated, use Timeout.timeout instead."</span>, <span class="ruby-value">uplevel:</span> <span class="ruby-value">1</span>
<span class="ruby-constant">Timeout</span>.<span class="ruby-identifier">timeout</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>, <span class="ruby-operator">&</span><span class="ruby-identifier">block</span>)
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-to_enum" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
to_enum(method = :each, *args) → enum
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-heading">
<span class="method-callseq">
to_enum(method = :each, *args) {|*args| block} → enum
</span>
</div>
<div class="method-description">
<p>Creates a new <a href="Enumerator.html"><code>Enumerator</code></a> which will enumerate by calling <code>method</code> on <code>obj</code>, passing <code>args</code> if any. What was <em>yielded</em> by method becomes values of enumerator.</p>
<p>If a block is given, it will be used to calculate the size of the enumerator without the need to iterate it (see <a href="Enumerator.html#method-i-size"><code>Enumerator#size</code></a>).</p>
<h3 id="method-i-to_enum-label-Examples">Examples<span><a href="#method-i-to_enum-label-Examples">¶</a> <a href="#top">↑</a></span></h3>
<pre class="ruby"><span class="ruby-identifier">str</span> = <span class="ruby-string">"xyz"</span>
<span class="ruby-identifier">enum</span> = <span class="ruby-identifier">str</span>.<span class="ruby-identifier">enum_for</span>(<span class="ruby-value">:each_byte</span>)
<span class="ruby-identifier">enum</span>.<span class="ruby-identifier">each</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">b</span><span class="ruby-operator">|</span> <span class="ruby-identifier">puts</span> <span class="ruby-identifier">b</span> }
<span class="ruby-comment"># => 120</span>
<span class="ruby-comment"># => 121</span>
<span class="ruby-comment"># => 122</span>
<span class="ruby-comment"># protect an array from being modified by some_method</span>
<span class="ruby-identifier">a</span> = [<span class="ruby-value">1</span>, <span class="ruby-value">2</span>, <span class="ruby-value">3</span>]
<span class="ruby-identifier">some_method</span>(<span class="ruby-identifier">a</span>.<span class="ruby-identifier">to_enum</span>)
<span class="ruby-comment"># String#split in block form is more memory-effective:</span>
<span class="ruby-identifier">very_large_string</span>.<span class="ruby-identifier">split</span>(<span class="ruby-string">"|"</span>) { <span class="ruby-operator">|</span><span class="ruby-identifier">chunk</span><span class="ruby-operator">|</span> <span class="ruby-keyword">return</span> <span class="ruby-identifier">chunk</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">chunk</span>.<span class="ruby-identifier">include?</span>(<span class="ruby-string">'DATE'</span>) }
<span class="ruby-comment"># This could be rewritten more idiomatically with to_enum:</span>
<span class="ruby-identifier">very_large_string</span>.<span class="ruby-identifier">to_enum</span>(<span class="ruby-value">:split</span>, <span class="ruby-string">"|"</span>).<span class="ruby-identifier">lazy</span>.<span class="ruby-identifier">grep</span>(<span class="ruby-regexp">/DATE/</span>).<span class="ruby-identifier">first</span>
</pre>
<p>It is typical to call <a href="Object.html#method-i-to_enum"><code>to_enum</code></a> when defining methods for a generic <a href="Enumerable.html"><code>Enumerable</code></a>, in case no block is passed.</p>
<p>Here is such an example, with parameter passing and a sizing block:</p>
<pre class="ruby"><span class="ruby-keyword">module</span> <span class="ruby-constant">Enumerable</span>
<span class="ruby-comment"># a generic method to repeat the values of any enumerable</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">repeat</span>(<span class="ruby-identifier">n</span>)
<span class="ruby-identifier">raise</span> <span class="ruby-constant">ArgumentError</span>, <span class="ruby-node">"#{n} is negative!"</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">n</span> <span class="ruby-operator"><</span> <span class="ruby-value">0</span>
<span class="ruby-keyword">unless</span> <span class="ruby-identifier">block_given?</span>
<span class="ruby-keyword">return</span> <span class="ruby-identifier">to_enum</span>(<span class="ruby-identifier">__method__</span>, <span class="ruby-identifier">n</span>) <span class="ruby-keyword">do</span> <span class="ruby-comment"># __method__ is :repeat here</span>
<span class="ruby-identifier">sz</span> = <span class="ruby-identifier">size</span> <span class="ruby-comment"># Call size and multiply by n...</span>
<span class="ruby-identifier">sz</span> <span class="ruby-operator">*</span> <span class="ruby-identifier">n</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">sz</span> <span class="ruby-comment"># but return nil if size itself is nil</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-operator">*</span><span class="ruby-identifier">val</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">n</span>.<span class="ruby-identifier">times</span> { <span class="ruby-keyword">yield</span> <span class="ruby-operator">*</span><span class="ruby-identifier">val</span> }
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-node">%i[hello world]</span>.<span class="ruby-identifier">repeat</span>(<span class="ruby-value">2</span>) { <span class="ruby-operator">|</span><span class="ruby-identifier">w</span><span class="ruby-operator">|</span> <span class="ruby-identifier">puts</span> <span class="ruby-identifier">w</span> }
<span class="ruby-comment"># => Prints 'hello', 'hello', 'world', 'world'</span>
<span class="ruby-identifier">enum</span> = (<span class="ruby-value">1</span><span class="ruby-operator">..</span><span class="ruby-value">14</span>).<span class="ruby-identifier">repeat</span>(<span class="ruby-value">3</span>)
<span class="ruby-comment"># => returns an Enumerator when called without a block</span>
<span class="ruby-identifier">enum</span>.<span class="ruby-identifier">first</span>(<span class="ruby-value">4</span>) <span class="ruby-comment"># => [1, 1, 1, 2]</span>
<span class="ruby-identifier">enum</span>.<span class="ruby-identifier">size</span> <span class="ruby-comment"># => 42</span>
</pre>
<div class="method-source-code" id="to_enum-source">
<pre>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;
}</pre>
</div>
</div>
</div>
<div id="method-i-to_s" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
to_s → string
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns a string representing <em>obj</em>. The default <a href="Object.html#method-i-to_s"><code>to_s</code></a> 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''.</p>
<div class="method-source-code" id="to_s-source">
<pre>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);
return str;
}</pre>
</div>
</div>
</div>
<div id="method-i-to_yaml" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
to_yaml(options = {})
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Convert an object to YAML. See <a href="Psych.html#method-c-dump"><code>Psych.dump</code></a> for more information on the available <code>options</code>.</p>
<div class="method-source-code" id="to_yaml-source">
<pre><span class="ruby-comment"># File ext/psych/lib/psych/core_ext.rb, line 12</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">to_yaml</span> <span class="ruby-identifier">options</span> = {}
<span class="ruby-constant">Psych</span>.<span class="ruby-identifier">dump</span> <span class="ruby-keyword">self</span>, <span class="ruby-identifier">options</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-trust" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
trust → obj
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns object. This method is deprecated and will be removed in Ruby 3.2.</p>
<div class="method-source-code" id="trust-source">
<pre>VALUE
rb_obj_trust(VALUE obj)
{
rb_warning("Object#trust is deprecated and will be removed in Ruby 3.2.");
return obj;
}</pre>
</div>
</div>
</div>
<div id="method-i-untaint" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
untaint → obj
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns object. This method is deprecated and will be removed in Ruby 3.2.</p>
<div class="method-source-code" id="untaint-source">
<pre>VALUE
rb_obj_untaint(VALUE obj)
{
rb_warning("Object#untaint is deprecated and will be removed in Ruby 3.2.");
return obj;
}</pre>
</div>
</div>
</div>
<div id="method-i-untrust" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
untrust → obj
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns object. This method is deprecated and will be removed in Ruby 3.2.</p>
<div class="method-source-code" id="untrust-source">
<pre>VALUE
rb_obj_untrust(VALUE obj)
{
rb_warning("Object#untrust is deprecated and will be removed in Ruby 3.2.");
return obj;
}</pre>
</div>
</div>
</div>
<div id="method-i-untrusted-3F" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
untrusted? → false
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns false. This method is deprecated and will be removed in Ruby 3.2.</p>
<div class="method-source-code" id="untrusted-3F-source">
<pre>VALUE
rb_obj_untrusted(VALUE obj)
{
rb_warning("Object#untrusted? is deprecated and will be removed in Ruby 3.2.");
return Qfalse;
}</pre>
</div>
</div>
</div>
<div id="method-i-xmp" class="method-detail ">
<div class="method-heading">
<span class="method-name">xmp</span><span
class="method-args">(exps, bind = nil)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>A convenience method that's only available when the you require the IRB::XMP standard library.</p>
<p>Creates a new <a href="XMP.html"><code>XMP</code></a> object, using the given expressions as the <code>exps</code> parameter, and optional binding as <code>bind</code> or uses the top-level binding. Then evaluates the given expressions using the <code>:XMP</code> prompt mode.</p>
<p>For example:</p>
<pre class="ruby"><span class="ruby-identifier">require</span> <span class="ruby-string">'irb/xmp'</span>
<span class="ruby-identifier">ctx</span> = <span class="ruby-identifier">binding</span>
<span class="ruby-identifier">xmp</span> <span class="ruby-string">'foo = "bar"'</span>, <span class="ruby-identifier">ctx</span>
<span class="ruby-comment">#=> foo = "bar"</span>
<span class="ruby-comment">#==>"bar"</span>
<span class="ruby-identifier">ctx</span>.<span class="ruby-identifier">eval</span> <span class="ruby-string">'foo'</span>
<span class="ruby-comment">#=> "bar"</span>
</pre>
<p>See <a href="XMP.html#method-c-new"><code>XMP.new</code></a> for more information.</p>
<div class="method-source-code" id="xmp-source">
<pre><span class="ruby-comment"># File lib/irb/xmp.rb, line 165</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">xmp</span>(<span class="ruby-identifier">exps</span>, <span class="ruby-identifier">bind</span> = <span class="ruby-keyword">nil</span>)
<span class="ruby-identifier">bind</span> = <span class="ruby-constant">IRB</span><span class="ruby-operator">::</span><span class="ruby-constant">Frame</span>.<span class="ruby-identifier">top</span>(<span class="ruby-value">1</span>) <span class="ruby-keyword">unless</span> <span class="ruby-identifier">bind</span>
<span class="ruby-identifier">xmp</span> = <span class="ruby-constant">XMP</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">bind</span>)
<span class="ruby-identifier">xmp</span>.<span class="ruby-identifier">puts</span> <span class="ruby-identifier">exps</span>
<span class="ruby-identifier">xmp</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-yield_self" class="method-detail ">
<div class="method-heading">
<span class="method-callseq">
yield_self {|x| block } → an_object
</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Yields self to the block and returns the result of the block.</p>
<pre class="ruby"><span class="ruby-value">3</span>.<span class="ruby-identifier">next</span>.<span class="ruby-identifier">then</span> {<span class="ruby-operator">|</span><span class="ruby-identifier">x</span><span class="ruby-operator">|</span> <span class="ruby-identifier">x</span><span class="ruby-operator">**</span><span class="ruby-identifier">x</span> }.<span class="ruby-identifier">to_s</span> <span class="ruby-comment">#=> "256"</span>
<span class="ruby-string">"my string"</span>.<span class="ruby-identifier">yield_self</span> {<span class="ruby-operator">|</span><span class="ruby-identifier">s</span><span class="ruby-operator">|</span> <span class="ruby-identifier">s</span>.<span class="ruby-identifier">upcase</span> } <span class="ruby-comment">#=> "MY STRING"</span>
</pre>
<p>Good usage for <code>then</code> is value piping in method chains:</p>
<pre class="ruby"><span class="ruby-identifier">require</span> <span class="ruby-string">'open-uri'</span>
<span class="ruby-identifier">require</span> <span class="ruby-string">'json'</span>
<span class="ruby-identifier">construct_url</span>(<span class="ruby-identifier">arguments</span>).
<span class="ruby-identifier">then</span> {<span class="ruby-operator">|</span><span class="ruby-identifier">url</span><span class="ruby-operator">|</span> <span class="ruby-identifier">open</span>(<span class="ruby-identifier">url</span>).<span class="ruby-identifier">read</span> }.
<span class="ruby-identifier">then</span> {<span class="ruby-operator">|</span><span class="ruby-identifier">response</span><span class="ruby-operator">|</span> <span class="ruby-constant">JSON</span>.<span class="ruby-identifier">parse</span>(<span class="ruby-identifier">response</span>) }
</pre>
<p>When called without block, the method returns <code>Enumerator</code>, which can be used, for example, for conditional circuit-breaking:</p>
<pre class="ruby"><span class="ruby-comment"># meets condition, no-op</span>
<span class="ruby-value">1</span>.<span class="ruby-identifier">then</span>.<span class="ruby-identifier">detect</span>(<span class="ruby-operator">&</span><span class="ruby-value">:odd?</span>) <span class="ruby-comment"># => 1</span>
<span class="ruby-comment"># does not meet condition, drop value</span>
<span class="ruby-value">2</span>.<span class="ruby-identifier">then</span>.<span class="ruby-identifier">detect</span>(<span class="ruby-operator">&</span><span class="ruby-value">:odd?</span>) <span class="ruby-comment"># => nil</span>
</pre>
<div class="method-source-code" id="yield_self-source">
<pre>static VALUE
rb_obj_yield_self(VALUE obj)
{
RETURN_SIZED_ENUMERATOR(obj, 0, 0, rb_obj_size);
return rb_yield_values2(1, &obj);
}</pre>
</div>
</div>
</div>
</section>
</section>
</main>
<footer id="validator-badges" role="contentinfo">
<p><a href="https://validator.w3.org/check/referer">Validate</a>
<p>Generated by <a href="https://ruby.github.io/rdoc/">RDoc</a> 6.2.1.1.
<p>Based on <a href="http://deveiate.org/projects/Darkfish-RDoc/">Darkfish</a> by <a href="http://deveiate.org">Michael Granger</a>.
</footer>