Ruby 1.8.7 リファレンスマニュアル > ライブラリ一覧 > drbライブラリ > DRb::DRbServerクラス

class DRb::DRbServer + Object

クラスの継承リスト: DRb::DRbServer < Object < Kernel

要約

Class representing a drb server instance.

A DRbServer must be running in the local process before any incoming dRuby calls can be accepted, or any local objects can be passed as dRuby references to remote processes, even if those local objects are never actually called remotely. You do not need to start a DRbServer in the local process if you are only making outgoing dRuby calls passing marshalled parameters.

Unless multiple servers are being used, the local DRbServer is normally started by calling DRb.start_service.

特異メソッド

default_acl(acl)

[TODO]

Set the default value for the :acl option. See new(). The initial default value is nil.

default_argc_limit(argc)

[TODO]

Set the default value for the :argc_limit option. See new(). The initial default value is 256.

default_id_conv(idconv)

[TODO]

Set the default value for the :id_conv option. See #new(). The initial default value is a DRb::DRbIdConv instance.

default_load_limit(sz)

[TODO]

Set the default value for the :load_limit option. See new(). The initial default value is 25 MB.

default_safe_level(level)

[TODO]

new(uri=nil, front=nil, config_or_acl=nil)

[TODO]

Create a new DRbServer instance.

uri is the URI to bind to. This is normally of the form ‘druby://<hostname>:<port>’ where <hostname> is a hostname of the local machine. If nil, then the system’s default hostname will be bound to, on a port selected by the system; these value can be retrieved from the uri attribute. ‘druby:’ specifies the default dRuby transport protocol: another protocol, such as ‘drbunix:’, can be specified instead.

front is the front object for the server, that is, the object to which remote method calls on the server will be passed. If nil, then the server will not accept remote method calls.

If config_or_acl is a hash, it is the configuration to use for this server. The following options are recognised:

idconv

an id-to-object conversion object. This defaults to an instance of the class DRb::DRbIdConv.

verbose

if true, all unsuccessful remote calls on objects in the server will be logged to $stdout. false by default.

tcp_acl

the access control list for this server. See the ACL class from the main dRuby distribution.

load_limit

the maximum message size in bytes accepted by the server. Defaults to 25 MB (26214400).

argc_limit

the maximum number of arguments to a remote method accepted by the server. Defaults to 256.

The default values of these options can be modified on a class-wide basis by the class methods default_argc_limit, default_load_limit, default_acl, default_id_conv, and verbose=

If config_or_acl is not a hash, but is not nil, it is assumed to be the access control list for this server. See the :tcp_acl option for more details.

If no other server is currently set as the primary server, this will become the primary server.

The server will immediately start running in its own thread.

new -> Object

Objectクラスのインスタンスを生成して返します。

some = Object.new
p some #=> #<Object:0x2b696d8>

verbose

verbose=

[TODO]

Get the default value of the :verbose option. See new(). The initial default value is false.

インスタンスメソッド

self == other -> bool

オブジェクトと other が等しければ真を返します。

このメソッドは各クラスの性質に合わせて再定義すべきです。多くの場合、オブジェクトの内容が等しければ真を返すように（同値性を判定するように）再定義されることが期待されています。

デフォルトでは equal? と同じオブジェクトの同一性判定になっています。

[PARAM] other:: 比較するオブジェクトです。

p("foo" == "bar") #=> false
p("foo" == "foo") #=> true

p(4 == 4) #=> true
p(4 == 4.0) #=> true

[SEE_ALSO] Object#equal?,Object#eql?

self === other -> bool

メソッド Object#== の別名です。 case 式で使用されます。このメソッドは case 式での振る舞いを考慮して、各クラスの性質に合わせて再定義すべきです。

一般的に所属性のチェックを実現するため適宜再定義されます。

when 節の式をレシーバーとして === を呼び出すことに注意してください。

また Enumerable#grep でも使用されます。

[PARAM] other:: 比較するオブジェクトです。

age = 12
result =
case age
when 0 .. 2
  "baby"
when 3 .. 6
  "little child"
when 7 .. 12
  "child"
when 13 .. 18
  "youth"
else
  "adult"
end

puts result #=> "child"

def check arg
  case arg
  when /ruby(?!\s*on\s*rails)/i
    "hit! #{arg}"
  when String
    "Instance of String class. But don't hit."
  else
    "unknown"
  end
end

puts check([]) #=> unknown
puts check("mash-up in Ruby on Rails") #=> instance of String class. But not hit...
puts check("<Ruby's world>") #=> hit! <Ruby's world>

[SEE_ALSO] Object#==, Range#===, Module#===, Enumerable#grep

self =~ other -> false

右辺に正規表現オブジェクトを置いた正規表現マッチ obj =~ /RE/ をサポートするためのメソッドです。常に false を返します。

この定義により、=~ が再定義されたオブジェクトでは正常にマッチを行い、それ以外のものは false を返すようになります。

[PARAM] other:: 任意のオブジェクトです。結果に影響しません。

obj = 'regexp'
p(obj =~ /re/) #=> 0

obj = nil
p(obj =~ /re/) #=> false

[SEE_ALSO] String#=~

__id__ -> Integer

object_id -> Integer

id -> Integer

各オブジェクトに対して一意な整数を返します。あるオブジェクトに対してどのような整数が割り当てられるかは不定です。

Rubyでは、(Garbage Collectされていない)アクティブなオブジェクト間で重複しない整数(object_id)が各オブジェクトにひとつずつ割り当てられています。このメソッドはその値を返します。

TrueClass, FalseClass, NilClass, Symbol, Fixnum クラスのインスタンスなど Immutable（変更不可）なオブジェクトの一部は同じ内容ならば必ず同じ object_id になります。

これは、Immutable ならば複数の場所から参照されても`破壊的操作'による問題が発生しないので、同じ内容のインスタンスを複数生成しないという内部実装が理由です。

Symbol#to_iで得られる整数と object_id は別物です。

id メソッドの再定義に備えて別名 __id__ が用意されており、ライブラリでは後者の利用が推奨されます。また __id__ を再定義すべきではありません。

id は obsolete なので、object_id か __id__ を使用してください。

p "ruby".object_id #=> 22759500
p "ruby".object_id #=> 22759400

p [].object_id #=> 22759360
p [].object_id #=> 22759340

p :ruby.object_id #=> 103538
p :ruby.object_id #=> 103538

p 11.object_id #=> 23
p 11.object_id #=> 23

p true.object_id #=> 2
p true.object_id #=> 2

[SEE_ALSO] Object#equal?,Symbol

send(name, *args) -> object

send(name, *args) { .... } -> object

__send__(name, *args) -> object

__send__(name, *args) { .... } -> object

オブジェクトのメソッド name を args を引数にして呼び出し、メソッドの実行結果を返します。

ブロック付きで呼ばれたときはブロックもそのまま引き渡します。

send が再定義された場合に備えて別名 __send__ も用意されており、ライブラリではこちらを使うべきです。また __send__ は再定義すべきではありません。

send, __send__ は、メソッドの呼び出し制限にかかわらず任意のメソッドを呼び出せます。クラス／メソッドの定義/呼び出し制限も参照してください。

[PARAM] name:: 文字列かSymbol で指定するメソッド名です。
[PARAM] args:: 呼び出すメソッドに渡す引数です。

p -365.send(:abs) #=> 365
p "ruby".send(:sub,/./,"R") #=> "Ruby"


class Foo
  def foo() "foo" end
  def bar() "bar" end
  def baz() "baz" end
end

# 任意のキーとメソッド(の名前)の関係をハッシュに保持しておく
# レシーバの情報がここにはないことに注意
methods = {1 => :foo,
  2 => :bar,
  3 => :baz}

# キーを使って関連するメソッドを呼び出す
# レシーバは任意(Foo クラスのインスタンスである必要もない)
p Foo.new.send(methods[1])      # => "foo"
p Foo.new.send(methods[2])      # => "bar"
p Foo.new.send(methods[3])      # => "baz"

[SEE_ALSO] Object#method, Kernel.#eval, Proc, Method

_dump(limit) -> String

Marshal.#dump において出力するオブジェクトがメソッド _dump を定義している場合には、そのメソッドの結果が書き出されます。

バージョン1.8.0以降ではObject#marshal_dump, Object#marshal_loadの使用が推奨されます。 Marshal.dump するオブジェクトが _dump と marshal_dump の両方のメソッドを持つ場合は marshal_dump が優先されます。

メソッド _dump は引数として再帰を制限するレベル limit を受け取り、オブジェクトを文字列化したものを返します。

インスタンスがメソッド _dump を持つクラスは必ず同じフォーマットを読み戻すクラスメソッド _load を定義する必要があります。_load はオブジェクトを表現した文字列を受け取り、それをオブジェクトに戻したものを返す必要があります。

[PARAM] limit:: 再帰の制限レベルを表す整数です。
[RETURN]: オブジェクトを文字列化したものを返すように定義すべきです。

class Foo
  def initialize(arg)
    @foo = arg
  end
  def _dump(limit)
    Marshal.dump(@foo, limit)
  end
  def self._load(obj)
    p obj
    Foo.new(Marshal.load(obj))
  end
end
foo = Foo.new(['foo', 'bar'])
p foo                      #=> #<Foo:0xbaf234 @foo=["foo", "bar"]>
dms = Marshal.dump(foo)
p dms                      #=> "\004\bu:\bFoo\023\004\b[\a\"\bfoo\"\bbar"
result = Marshal.load(dms) #=> "\004\b[\a\"\bfoo\"\bbar" # self._load の引数
p result                   #=> #<Foo:0xbaf07c @foo=["foo", "bar"]>

インスタンス変数の情報は普通マーシャルデータに含まれるので、上例のように _dump を定義する必要はありません(ただし _dump を定義するとインスタンス変数の情報は dump されなくなります)。 _dump/_load はより高度な制御を行いたい場合や拡張ライブラリで定義したクラスのインスタンスがインスタンス変数以外に情報を保持する場合に利用します。(例えば、クラス Time は、_dump/_load を定義しています)

[SEE_ALSO] Object#marshal_dump,Object#marshal_load

alive?

[TODO]

Is this server alive?

check_insecure_method(obj, msg_id)

[TODO]

Check that a method is callable via dRuby. obj is the object we want to invoke the method on. msg_id is the method name, as a Symbol. If the method is an insecure method (see insecure_method?) a SecurityError is thrown. If the method is private or undefined, a NameError is thrown.

class -> Class

type -> Class

レシーバのクラスを返します。

p "ruby".class #=> String
p 999999999999999.class #=> Bignum
p ARGV.class #=> Array
p self.class #=> Object
p Class.class #=> Class
p Kernel.class #=> Module

[SEE_ALSO] Class#superclass,Object#kind_of?,Object#instance_of?

clone -> object

dup -> object

オブジェクトの複製を作成して返します。

dup はオブジェクトの内容, taint 情報をコピーし、 clone はそれに加えて freeze, 特異メソッドなどの情報も含めた完全な複製を作成します。

clone や dup は浅い(shallow)コピーであることに注意してください。後述。

[EXCEPTION] TypeError:: TrueClass, FalseClass, NilClass, Symbol, そして Numeric クラスのインスタンスなど一部のオブジェクトを複製しようとすると発生します。

obj = "string"
obj.taint
def obj.fuga
end
obj.freeze

p(obj.equal?(obj))          #=> true
p(obj == obj)               #=> true
p(obj.tainted?)             #=> true
p(obj.frozen?)              #=> true
p(obj.respond_to?(:fuga))   #=> true

obj_c = obj.clone

p(obj.equal?(obj_c))        #=> false
p(obj == obj_c)             #=> true
p(obj_c.tainted?)           #=> true
p(obj_c.frozen?)            #=> true
p(obj_c.respond_to?(:fuga)) #=> true

obj_d = obj.dup

p(obj.equal?(obj_d))        #=> false
p(obj == obj_d)             #=> true
p(obj_d.tainted?)           #=> true
p(obj_d.frozen?)            #=> false
p(obj_d.respond_to?(:fuga)) #=> false

[SEE_ALSO] Object#initialize_copy

深いコピーと浅いコピー

clone や dup はオブジェクト自身を複製するだけで、オブジェクトの指している先(たとえば配列の要素など)までは複製しません。これを浅いコピー(shallow copy)といいます。

深い(deep)コピーが必要な場合には、 Marshalモジュールを利用して

Marshal.load(Marshal.dump(obj))

このように複製を作成する方法があります。ただしMarshal出来ないオブジェクトが含まれている場合には使えません。

obj = ["a","b","c"]

obj_d = obj.dup
obj_d[0] << "PLUS"

p obj   #=> ["aPLUS", "b", "c"]
p obj_d #=> ["aPLUS", "b", "c"]

obj_m = Marshal.load(Marshal.dump(obj))
obj_m[1] << "PLUS"

p obj   #=> ["aPLUS", "b", "c"]
p obj_m #=> ["aPLUS", "bPLUS", "c"]

config

[TODO]

The configuration of this DRbServer

display(out = $stdout) -> nil

オブジェクトを out に出力します。

以下のように定義されています。

class Object
  def display(out = $stdout)
    out.print self.to_s
    nil
  end
end

[PARAM] out:: 出力先のIOオブジェクトです。指定しない場合は標準出力に出力されます。
[RETURN]: nil を返します。

Object.new.display #=> #<Object:0xbb0210>

[SEE_ALSO] $stdout

to_enum(method = :each, *args) -> Enumerable::Enumerator

enum_for(method = :each, *args) -> Enumerable::Enumerator

Enumerable::Enumerator.new(self, method, *args) を返します。

[PARAM] method:: メソッド名の文字列かシンボルです。
[PARAM] args:: 呼び出すメソッドに渡される引数です。
[EXCEPTION] NameError:: 存在しないメソッド名を指定すると発生します。

str = "xyz"

enum = str.enum_for(:each_byte)
p(a = enum.map{|b| '%02x' % b }) #=> ["78", "79", "7a"]

# protects an array from being modified
a = [1, 2, 3]
p(a.to_enum) #=> #<Enumerable::Enumerator:0xbaf7ac>

[SEE_ALSO] Enumerable::Enumerator

eql?(other) -> bool

オブジェクトと other が等しければ真を返します。Hash で二つのキーが等しいかどうかを判定するのに使われます。

このメソッドは各クラスの性質に合わせて再定義すべきです。多くの場合、 == と同様に同値性の判定をするように再定義されていますが、適切にキー判定ができるようにより厳しくなっている場合もあります。

デフォルトでは equal? と同じオブジェクトの同一性判定になっています。

このメソッドを再定義した時には Object#hash メソッドも再定義しなければなりません。

[PARAM] other:: 比較するオブジェクトです。

p("foo".eql?("bar")) #=> false
p("foo".eql?("foo")) #=> true

p(4.eql?(4)) #=> true
p(4.eql?(4.0)) #=> false

[SEE_ALSO] Object#hash,Object#equal?,Object#==

equal?(other) -> bool

other が self 自身の時、真を返します。

二つのオブジェクトが同一のものかどうか調べる時に使用します。このメソッドを再定義してはいけません。

お互いのObject#object_idが一致するかどうかを調べます。

[PARAM] other:: 比較するオブジェクトです。

p("foo".equal?("bar")) #=> false
p("foo".equal?("foo")) #=> false

p(4.equal?(4)) #=> true
p(4.equal?(4.0)) #=> false

p(:foo.equal? :foo) #=> true

[SEE_ALSO] Object#object_id,Object#==,Object#eql?,Symbol

extend(*modules) -> self

引数で指定したモジュールのインスタンスメソッドを self の特異メソッドとして追加します。

Module#include は、クラス(のインスタンス)に機能を追加しますが、extend は、ある特定のオブジェクトだけにモジュールの機能を追加したいときに使用します。

引数に複数のモジュールを指定した場合、最後の引数から逆順に extend を行います。

[PARAM] modules:: モジュールを任意個指定します（クラスは不可）。
[RETURN]: self を返します。

module Foo
  def a
    'ok Foo'
  end
end

module Bar
  def b
    'ok Bar'
  end
end

obj = Object.new
obj.extend Foo, Bar
p obj.a #=> "ok Foo"
p obj.b #=> "ok Bar"

class Klass
  include Foo
  extend Bar
end

p Klass.new.a #=> "ok Foo"
p Klass.b     #=> "ok Bar"

extend の機能は、「特異クラスに対する Module#include」と言い替えることもできます。ただしその場合、フック用のメソッドが Module#extended ではなく Module#included になるという違いがあります。

# obj.extend Foo, Bar とほぼ同じ
class << obj
  include Foo, Bar
end

[SEE_ALSO] Module#extend_object,Module#include,Module#extended

freeze -> self

オブジェクトを凍結（内容の変更を禁止）します。

凍結されたオブジェクトの変更は例外 TypeError を発生させます。いったん凍結されたオブジェクトを元に戻す方法はありません。

凍結されるのはオブジェクトであり、変数ではありません。代入などで変数の指すオブジェクトが変化してしまうことは freeze では防げません。 freeze が防ぐのは、 `破壊的な操作' と呼ばれるもの一般です。変数への参照自体を凍結したい場合は、グローバル変数なら Kernel.#trace_var が使えます。

[RETURN]: self を返します。

a1 = "foo".freeze
a1 = "bar"
p a1 #=> "bar"

a2 = "foo".freeze
a2.replace("bar")# can't modify frozen string (TypeError)

凍結を解除することはできませんが、Object#dup を使えばほぼ同じ内容の凍結されていないオブジェクトを得ることはできます。

a = [1].freeze
p a.frozen?     #=> true

a[0] = "foo"
p a             # can't modify frozen array (TypeError)

b = a.dup
p b             #=> [1]
p b.frozen?     #=> false

b[0] = "foo"
p b             #=> ["foo"]

[SEE_ALSO] Object#frozen?,Object#dup,Kernel.#trace_var

front

[TODO]

The front object of the DRbServer.

This object receives remote method calls made on the server’s URI alone, with an object id.

frozen? -> bool

オブジェクトが凍結（内容の変更を禁止）されているときに真を返します。

obj = "someone"
p obj.frozen? #=> false
obj.freeze
p obj.frozen? #=> true

[SEE_ALSO] Object#freeze

hash -> Fixnum

オブジェクトのハッシュ値を返します。Hash クラスでオブジェクトを格納するのに用いられています。

メソッド hash は Object#eql? と組み合わせて Hash クラスで利用されます。その際

A.eql?(B) ならば A.hash == B.hash

の関係を必ず満たしていなければいけません。eql? を再定義した時には必ずこちらも合わせて再定義してください。

デフォルトでは、Object#object_id と同じ値を返します。ただし、Fixnum, Symbol, String だけは組込みのハッシュ関数が使用されます(これを変えることはできません)。

hash を再定義する場合は、一様に分布する任意の整数を返すようにします。

[RETURN]: ハッシュ値を返します。Fixnumに収まらない場合は切り捨てられます。

p self.hash #=> 21658870
p 0.hash #=> 1
p 0.0.hash #=> 0
p nil.hash #=> 4

p "ruby".hash #=> -241670986
p "ruby".hash #=> -241670986
p :ruby.hash #=> 103538
p :ruby.hash #=> 103538

[SEE_ALSO] Object#eql?,Object#__id__

inspect -> String

オブジェクトを人間が読める形式に変換した文字列を返します。

組み込み関数 Kernel.#p は、このメソッドの結果を使用してオブジェクトを表示します。

puts Class.new.inspect #=> #<Class:0xbafd88>
puts Time.now.inspect #=> 2007-10-15 21:01:37 +0900

[SEE_ALSO] Kernel.#p

instance_eval(expr, filename = "(eval)", lineno = 1) -> object

instance_eval {|obj| ... } -> object

オブジェクトのコンテキストで文字列 expr またはオブジェクト自身をブロックパラメータとするブロックを評価してその結果を返します。

オブジェクトのコンテキストで評価するとは評価中の self をそのオブジェクトにして実行するということです。また、文字列 expr やブロック中でメソッドを定義すればそのオブジェクトの特異メソッドが定義されます。

ただし、ローカル変数だけは、文字列 expr の評価では instance_eval の外側のスコープと、ブロックの評価ではそのブロックの外側のスコープと、共有します。

メソッド定義の中で instance_eval でメソッドを定義した場合は、囲むメソッドが実行されたときに初めて instance_eval 内のメソッドが定義されます。これはメソッド定義のネストと同じです。クラス／メソッドの定義/メソッド定義のネストを参照してください。

[PARAM] expr:: 評価する文字列です。
[PARAM] filename:: 文字列を指定します。ファイル filename に文字列 expr が書かれているかのように実行されます。スタックトレースの表示などを差し替えることができます。
[PARAM] lineno:: 文字列を指定します。行番号 lineno から文字列 expr が書かれているかのように実行されます。スタックトレースの表示などを差し替えることができます。

例:

class Foo
  def initialize data
    @key = data
  end
private
  def do_fuga
    p 'secret'
  end
end

some = Foo.new 'XXX'
some.instance_eval{p @key} #=> "XXX"
some.instance_eval{do_fuga } #=> "secret" # private メソッドも呼び出せる

some.instance_eval 'raise' # ..:10: (eval):1:  (RuntimeError)
messg = 'unknown'
some.instance_eval 'raise messg','file.rb',999 # file.rb:999: unknown (RuntimeError)

[SEE_ALSO] Module#module_eval, Kernel.#eval

instance_exec(*args) {|*vars| ... } -> object

与えられたブロックをレシーバのコンテキストで実行します。

ブロック実行中は、 self がレシーバのコンテキストになるのでレシーバの持つインスタンス変数にアクセスすることができます。

[PARAM] args:: ブロックパラメータに渡す値です。

class KlassWithSecret
  def initialize
    @secret = 99
  end
end
k = KlassWithSecret.new
# 以下で x には 5 が渡される
k.instance_exec(5) {|x| @secret + x }   #=> 104

[SEE_ALSO] Module#class_exec, Module#module_exec, Object#instance_eval

instance_of?(klass) -> bool

オブジェクトがクラス klass の直接のインスタンスである時真を返します。

obj.instance_of?(c) が成立する時には、常に obj.kind_of?(c) も成立します。

[PARAM] klass:: Classかそのサブクラスのインスタンスです。

class C < Object
end
class S < C
end

obj = S.new
p obj.instance_of?(S)       # true
p obj.instance_of?(C)       # false

[SEE_ALSO] Object#kind_of?,Object#class

instance_variable_defined?(var) -> bool

インスタンス変数 var が定義されていたら真を返します。

[PARAM] var:: インスタンス変数名を文字列か Symbol で指定します。

class Fred
  def initialize(p1, p2)
    @a, @b = p1, p2
  end
end
fred = Fred.new('cat', 99)
p fred.instance_variable_defined?(:@a)    #=> true
p fred.instance_variable_defined?("@b")   #=> true
p fred.instance_variable_defined?("@c")   #=> false

[SEE_ALSO] Object#instance_variable_get,Object#instance_variable_set,Object#instance_variables

instance_variable_get(var) -> object|nil

オブジェクトのインスタンス変数の値を取得して返します。

インスタンス変数が定義されていなければ nil を返します。

[PARAM] var:: インスタンス変数名を文字列か Symbol で指定します。

class Foo
  def initialize
    @foo = 1
  end
end

obj = Foo.new
p obj.instance_variable_get("@foo")     #=> 1
p obj.instance_variable_get(:@foo)      #=> 1
p obj.instance_variable_get(:@bar)      #=> nil

[SEE_ALSO] Object#instance_variable_set,Object#instance_variables,Object#instance_variable_defined?

instance_variable_set(var, value) -> object

オブジェクトのインスタンス変数 var に値 value を設定します。

インスタンス変数が定義されていなければ新たに定義されます。

[PARAM] var:: インスタンス変数名を文字列か Symbol で指定します。
[PARAM] value:: 設定する値です。
[RETURN]: value を返します。

obj = Object.new
p obj.instance_variable_set("@foo", 1)  #=> 1
p obj.instance_variable_set(:@foo, 2)   #=> 2
p obj.instance_variable_get(:@foo)      #=> 2

[SEE_ALSO] Object#instance_variable_get,Object#instance_variables,Object#instance_variable_defined?

instance_variables -> [String]

オブジェクトのインスタンス変数名を文字列の配列として返します。

obj = Object.new
obj.instance_eval { @foo, @bar = nil }
p obj.instance_variables

#=> ["@foo", "@bar"]

[SEE_ALSO] Object#instance_variable_get,Kernel.#local_variables,Kernel.#global_variables,Module.constants,Module#constants,Module#class_variables

is_a?(mod) -> bool

kind_of?(mod) -> bool

オブジェクトが指定されたクラス mod かそのサブクラスのインスタンスであるとき真を返します。

また、オブジェクトがモジュール mod をインクルードしたクラスかそのサブクラスのインスタンスである場合にも真を返します。上記のいずれでもない場合に false を返します。

[PARAM] mod:: クラスやモジュールなど、Moduleかそのサブクラスのインスタンスです。

module M
end
class C < Object
  include M
end
class S < C
end

obj = S.new
p obj.is_a?(S)       # true
p obj.is_a?(C)       # true
p obj.is_a?(Object)  # true
p obj.is_a?(M)       # true
p obj.is_a?(Hash)    # false

[SEE_ALSO] Object#instance_of?,Module#===,Object#class

marshal_dump -> object

Marshal.#dump を制御するメソッドです。

Marshal.dump(some) において、出力するオブジェクト some がメソッド marshal_dump を持つ場合には、その返り値がダンプされたものが Marshal.dump(some) の返り値となります。

marshal_dump/marshal_load の仕組みは Ruby 1.8.0 から導入されました。これから書くプログラムでは _dump/_load ではなく marshal_dump/marshal_load を使うべきです。

[RETURN]: 任意のオブジェクトで marshal_load の引数に利用できます。

class Foo
  def initialize(arg)
    @foo = arg
  end
  def marshal_dump
    @foo
  end
  def marshal_load(obj)
    p obj
    @foo = obj
  end
end
foo = Foo.new(['foo', 'bar'])
p foo                      #=> #<Foo:0xbaf3b0 @foo=["foo", "bar"]>
dms = Marshal.dump(foo)
p dms                      #=> "\004\bU:\bFoo[\a\"\bfoo\"\bbar"
result = Marshal.load(dms) #=> ["foo", "bar"] # marshal_load の引数
p result                   #=> #<Foo:0xbaf2ac @foo=["foo", "bar"]>

インスタンス変数の情報は普通マーシャルデータに含まれるので、上例のように marshal_dump を定義する必要はありません (ただし marshal_dump を定義するとインスタンス変数の情報はダンプされなくなるので、marshal_dump/marshal_load で扱う必要があります)。 marshal_dump/marshal_load はより高度な制御を行いたい場合や拡張ライブラリで定義したクラスのインスタンスがインスタンス変数以外に情報を保持する場合に利用します。

特に、marshal_dump/marshal_load を定義したオブジェクトは特異メソッドが定義されていてもマーシャルできるようになります (特異メソッドの情報が自動的に dump されるようになるわけではなく、 marshal_dump/marshal_load によりそれを実現する余地があるということです)。

[SEE_ALSO] Object#marshal_load, Marshal

marshal_load(obj) -> object

Marshal.#load を制御するメソッドです。

some のダンプ結果（Marshal.dump(some)）をロードする（Marshal.load(Marshal.dump(some))）には some がメソッド marshal_load を持っていなければなりません。このとき、marshal_dump の返り値が marshal_load の引数に利用されます。 marshal_load 時の self は、生成されたばかり（Class#allocate されたばかり）の状態です。

marshal_dump/marshal_load の仕組みは Ruby 1.8.0 から導入されました。これから書くプログラムでは _dump/_load ではなく marshal_dump/marshal_load を使うべきです。

[PARAM] obj:: marshal_dump の返り値のコピーです。
[RETURN]: 返り値は無視されます。

[SEE_ALSO] Object#marshal_dump, Marshal

method(name) -> Method

オブジェクトのメソッド name をオブジェクト化した Method オブジェクトを返します。

[PARAM] name:: メソッド名をSymbol またはStringで指定します。
[EXCEPTION] NameError:: 定義されていないメソッド名を引数として与えると発生します。

me = -365.method(:abs)
p me #=> #<Method: Fixnum#abs>
p me.call #=> 365

[SEE_ALSO] Module#instance_method,Method,Object#__send__,Kernel.#eval

method_missing(name, *args) -> object

呼びだされたメソッドが定義されていなかった時、Rubyインタプリタがこのメソッドを呼び出します。

呼び出しに失敗したメソッドの名前 (Symbol) が name にその時の引数が第二引数以降に渡されます。

デフォルトではこのメソッドは例外 NameError を発生させます。

[PARAM] name:: 未定義メソッドの名前（シンボル）です。
[PARAM] args:: 未定義メソッドに渡された引数です。
[RETURN]: ユーザー定義の method_missing メソッドの返り値が未定義メソッドの返り値であるかのように見えます。

class Foo
  def initialize(data)
    @data = data
  end
  def method_missing(name, lang)
    if name.to_s =~ /\Afind_(\d+)_in\z/
      if @data[lang]
        p @data[lang][$1.to_i]
      else
        raise "#{lang} unknown"
      end
    else
      super
    end
  end
end

dic = Foo.new({:English => %w(zero one two), :Esperanto => %w(nulo unu du)})
dic.find_2_in :Esperanto #=> "du"

methods(include_inherited = true) -> [String]

そのオブジェクトに対して呼び出せるメソッド名の一覧を返します。このメソッドは public メソッドおよび protected メソッドの名前を返します。

ただし特別に、引数が偽の時は Object#singleton_methods(false) と同じになっています。

[PARAM] include_inherited:: 引数が偽の時は Object#singleton_methods(false) と同じになります。

#例1:

class Parent
  private;   def private_parent()   end
  protected; def protected_parent() end
  public;    def public_parent()    end
end

class Foo < Parent
  private;   def private_foo()   end
  protected; def protected_foo() end
  public;    def public_foo()    end
end

obj = Foo.new
class <<obj
    private;   def private_singleton()   end
    protected; def protected_singleton() end
    public;    def public_singleton()    end
end

# あるオブジェクトの応答できるメソッドの一覧を得る。
p obj.methods(false)
p obj.public_methods(false)
p obj.private_methods(false)
p obj.protected_methods(false)

#実行結果

["public_singleton", "protected_singleton"]
["public_foo", "public_singleton"]
["private_foo", "private_singleton"]
["protected_foo", "protected_singleton"]

#例2:

# あるオブジェクトの応答できるメソッドの一覧を得る。
# 自身のクラスの親クラスのインスタンスメソッドも含めるために true を指定して
# いるが、Object のインスタンスメソッドは一覧から排除している。
p obj.methods(true)           - Object.instance_methods(true)
p obj.public_methods(true)    - Object.public_instance_methods(true)
p obj.private_methods(true)   - Object.private_instance_methods(true)
p obj.protected_methods(true) - Object.protected_instance_methods(true)

#実行結果

["public_foo", "public_parent", "protected_singleton", "public_singleton", "protected_foo", "protected_parent"]
["public_foo", "public_parent", "public_singleton"]
["private_singleton", "private_foo", "private_parent"]
["protected_singleton", "protected_foo", "protected_parent"]

[SEE_ALSO] Module#instance_methods,Object#singleton_methods

nil? -> bool

レシーバが nil であれば真を返します。

p false.nil? #=> false
p nil.nil? #=> true

[SEE_ALSO] NilClass

private_methods(include_inherited = true) -> [String]

そのオブジェクトが理解できる private メソッド名の一覧を返します。

[PARAM] include_inherited:: 偽となる値を指定すると自身のクラスのスーパークラスで定義されたメソッドを除きます。

[SEE_ALSO] Module#private_instance_methods,Object#methods,Object#singleton_methods

protected_methods(include_inherited = true) -> [String]

そのオブジェクトが理解できる protected メソッド名の一覧を返します。

[PARAM] include_inherited:: 偽となる値を指定すると自身のクラスのスーパークラスで定義されたメソッドを除きます。

[SEE_ALSO] Module#protected_instance_methods,Object#methods,Object#singleton_methods

public_methods(include_inherited = true) -> [String]

そのオブジェクトが理解できる public メソッド名の一覧を返します。

[PARAM] include_inherited:: 偽となる値を指定すると自身のクラスのスーパークラスで定義されたメソッドを除きます。

[SEE_ALSO] Module#public_instance_methods,Object#methods,Object#singleton_methods

respond_to?(name, include_private = false) -> bool

オブジェクトがメソッド name を持つとき真を返します。

オブジェクトがメソッド name を持つというのは、オブジェクトがメソッド name に応答することができることをいいます。

[PARAM] name:: Symbol または文字列で指定するメソッド名です。
[PARAM] include_private:: private メソッドを確認の対象に含めるかを true か false で指定します。省略した場合は false(含めない) を指定した事になります。

class F
  def hello
    "Bonjour"
  end
end

class D
private
  def hello
    "Guten Tag"
  end
end
list = [F.new,D.new]

list.each{|it| puts it.hello if it.respond_to?(:hello)}
#=> Bonjour

list.each{|it| it.instance_eval("puts hello if it.respond_to?(:hello, true)")}
#=> Bonjour
#   Guten Tag

[SEE_ALSO] Module#method_defined?

safe_level

[TODO]

singleton_methods(inherited_too = true) -> [String]

そのオブジェクトに対して定義されている特異メソッド名 (public あるいは protected メソッド) の一覧を返します。

クラスメソッド(Classのインスタンスの特異メソッド)に関しては引数が真のとき、スーパークラスのクラスメソッドも対象になります。

singleton_methods(false) は、Object#methods(false) と同じです。

[PARAM] inherited_too:: 引数が真のとき、スーパークラスのクラスメソッドも対象になります。これが意味を持つのは self がクラスオブジェクトであるときだけです。

#例1:

Parent = Class.new

class <<Parent
  private;   def private_class_parent() end
  protected; def protected_class_parent() end
  public;    def public_class_parent() end
end

Foo = Class.new(Parent)

class <<Foo
  private;   def private_class_foo() end
  protected; def protected_class_foo() end
  public;    def public_class_foo() end
end

module Bar
  private;   def private_bar()   end
  protected; def protected_bar() end
  public;    def public_bar()    end
end

obj = Foo.new
class <<obj
  include Bar
  private;   def private_self()   end
  protected; def protected_self() end
  public;    def public_self()    end
end

# あるオブジェクトの特異メソッドの一覧を得る。
p obj.singleton_methods(false)
p obj.methods(false)
p Foo.singleton_methods(false)

#実行結果

["public_self", "protected_self"]
["public_self", "protected_self"]
["public_class_foo", "protected_class_foo"]


#例2:

# あるオブジェクトの特異メソッドの一覧を得る。
# 親クラスのクラスメソッドも含まれるよう true を指定したが、
# Object のクラスメソッドは一覧から排除している。

p obj.singleton_methods(true)
p Foo.singleton_methods(true) - Object.singleton_methods(true)

#実行結果

["public_bar", "public_self", "protected_bar", "protected_self"]
["public_class_foo", "public_class_parent", "protected_class_foo", "protected_class_parent"]

[SEE_ALSO] Object#methods,Object#extend

stop_service()

[TODO]

Stop this server.

taint -> self

オブジェクトの「汚染マーク」をセットします。

環境変数（ENVで得られる文字列）など一部のオブジェクトは最初から汚染されています。オブジェクトの汚染に関してはセキュリティモデルを参照してください。

$SAFE = 1

some = "puts '@&%&(#!'"
p some.tainted? #=> false
eval(some) #=> @&%&(#!

some.taint
p some.tainted? #=> true
eval(some) # Insecure operation - eval (SecurityError)

some.untaint
p some.tainted? #=> false
eval(some) #=> @&%&(#!

p ENV['OS'].tainted? #=> true

[SEE_ALSO] Object#tainted?,Object#untaint,Object#freeze

tainted? -> bool

オブジェクトの「汚染マーク」がセットされている時真を返します。

オブジェクトの汚染に関してはセキュリティモデルを参照してください。

p String.new.tainted? #=> false
p ENV['OS'].tainted? #=> true

[SEE_ALSO] Object#taint,Object#untaint

tap {|x| ... } -> self

self を引数としてブロックを評価し、self を返します。

メソッドチェインの途中で直ちに操作結果を表示するためにメソッドチェインに "入り込む" ことが、このメソッドの主目的です。

(1..10)                    .tap {|x| puts "original: #{x.inspect}"}.
   to_a                    .tap {|x| puts "array: #{x.inspect}"}.
   select {|x| x % 2 == 0} .tap {|x| puts "evens: #{x.inspect}"}.
   map { |x| x * x }       .tap {|x| puts "squares: #{x.inspect}"}

thread

[TODO]

The main thread of this DRbServer.

This is the thread that listens for and accepts connections from clients, not that handles each client’s request-response session.

to_a -> Array

オブジェクトを配列に変換した結果を返します。

配列に変換できない(to_ary を持たない)オブジェクトは、自身のみを含む長さ 1 の配列に変換されます。このメソッドは、将来 Object のメソッドからは取り除かれます。なので to_a を使用する場合、

すべてのオブジェクトに to_a が定義されているという期待はしない。
ユーザー定義のクラスには必要に応じて自分で定義する

などということが必要です。

p( {'a'=>1}.to_a )  # [["a", 1]]
p ['array'].to_a    # ["array"]
p 1.to_a            # [1]       (warning: default `to_a' will be obsolete)
p nil.to_a          # []

[SEE_ALSO] Object#to_ary,Kernel.#Array

to_ary -> Array

オブジェクトの Array への暗黙の変換が必要なときに内部で呼ばれます。デフォルトでは定義されていません。

説明のためここに記載してありますが、このメソッドは実際には Object クラスには定義されていません。必要に応じてサブクラスで定義すべきものです。

このメソッドを定義する条件は、

配列が使われるすべての場面で代置可能であるような、
配列そのものとみなせるようなもの

という厳しいものになっています。

class Foo
 def to_ary
   [3,4]
 end
end

it = Foo.new
p([1,2] + it) #=> [1, 2, 3, 4]

[SEE_ALSO] Object#to_a,Kernel.#Array

to_hash -> Hash

オブジェクトの Hash への暗黙の変換が必要なときに内部で呼ばれます。デフォルトでは定義されていません。

このメソッドを定義する条件は、

ハッシュが使われるすべての場面で代置可能であるような、
ハッシュそのものとみなせるようなもの

という厳しいものになっています。

class Foo
 def to_hash
   {'as' => 24}
 end
end

it = Foo.new
p({:as => 12}.merge(it)) #=> {"as"=>24, :as=>12}

to_id(obj)

[TODO]

Convert a local object to a dRuby reference.

to_int -> Integer

オブジェクトの Integer への暗黙の変換が必要なときに内部で呼ばれます。デフォルトでは定義されていません。

このメソッドを定義する条件は、

整数が使われるすべての場面で代置可能であるような、
整数そのものとみなせるようなもの

という厳しいものになっています。

class Foo
 def to_int
   666
 end
end

it = Foo.new
p(9**9 & it) #=> 8

[SEE_ALSO] Kernel.#Integer

to_io -> IO

オブジェクトの IO への暗黙の変換が必要なときに内部で呼ばれます。デフォルトでは定義されていません。

このメソッドを定義する条件は、

IOオブジェクトが使われるすべての場面で代置可能であるような、
IOオブジェクトそのものとみなせるようなもの

という厳しいものになっています。

to_obj(ref)

[TODO]

Convert a dRuby reference to the local object it refers to.

to_proc -> Proc

オブジェクトの Proc への暗黙の変換が必要なときに内部で呼ばれます。デフォルトでは定義されていません。

def doing
  yield
end

class Foo
 def to_proc
   Proc.new{p 'ok'}
 end
end

it = Foo.new
doing(&it) #=> "ok"

to_regexp -> Regexp

オブジェクトの Regexp への暗黙の変換が必要なときに内部で呼ばれます。デフォルトでは定義されていません。

このメソッドを定義する条件は、

正規表現が使われるすべての場面で代置可能であるような、
正規表現そのものとみなせるようなもの

という厳しいものになっています。

class Foo
 def to_regexp
   /[\d]+/
 end
end

it = Foo.new
p Regexp.union(/^at/, it) #=> /(?-mix:^at)|(?-mix:[\d]+)/

to_s -> String

オブジェクトの文字列表現を返します。

Kernel.#print や Kernel.#sprintf は文字列以外のオブジェクトが引数に渡された場合このメソッドを使って文字列に変換します。

class Foo
  def initialize num
    @num = num
  end
end
it = Foo.new(40)

puts it #=> #<Foo:0x2b69110>

class Foo
 def to_s
   "Class:Foo Number:#{@num}"
 end
end

puts it #=> Class:Foo Number:40

[SEE_ALSO] Object#to_str,Kernel.#String

to_str -> String

オブジェクトの String への暗黙の変換が必要なときに内部で呼ばれます。デフォルトでは定義されていません。

このメソッドを定義する条件は、

文字列が使われるすべての場面で代置可能であるような、
文字列そのものとみなせるようなもの

という厳しいものになっています。

class Foo
 def to_str
   'Edition'
 end
end

it = Foo.new
p('Second' + it) #=> "SecondEdition"

[SEE_ALSO] Object#to_s,Kernel.#String

untaint -> self

オブジェクトの「汚染マーク」を取り除きます。

汚染マークを取り除くことによる危険性はプログラマが責任を負う必要があります。

オブジェクトの汚染に関してはセキュリティモデルを参照してください。

[EXCEPTION] SecurityError:: セキュリティレベルが3以上の時にこのメソッドを使用すると発生します。

[SEE_ALSO] Object#taint,Object#tainted?

uri

[TODO]

The URI of this DRbServer.

verbose

verbose=

[TODO]

Get whether the server is in verbose mode. In verbose mode, failed calls are logged to stdout.

privateメソッド

initialize(*args, &block) -> object

ユーザ定義クラスのオブジェクト初期化メソッド。

このメソッドは Class#new から新しく生成されたオブジェクトの初期化のために呼び出されます。他の言語のコンストラクタに相当します。デフォルトの動作ではなにもしません。

initialize には Class#new に与えられた引数がそのまま渡されます。

サブクラスではこのメソッドを必要に応じて再定義されることが期待されています。

initialize という名前のメソッドは自動的に private に設定されます。

[PARAM] args:: 初期化時の引数です。
[PARAM] block:: 初期化時のブロック引数です。必須ではありません。

class Foo
  def initialize name
    puts "initialize Foo"
    @name = name
  end
end

class Bar < Foo
  def initialize name, pass
    puts "initialize Bar"
    super name
    @pass = pass
  end
end

it = Bar.new('myname','0500')
p it
#=> initialize Bar
#   initialize Foo
#   #<Bar:0x2b68f08 @name="myname", @pass="0500">

[SEE_ALSO] Class#new

initialize_copy(obj) -> object

(拡張ライブラリによる) ユーザ定義クラスのオブジェクトコピーの初期化メソッド。

このメソッドは self を obj の内容で置き換えます。ただし、self のインスタンス変数や特異メソッドは変化しません。 Object#clone, Object#dupの内部で使われています。

initialize_copy は、Ruby インタプリタが知り得ない情報をコピーするために使用(定義)されます。例えば C 言語でクラスを実装する場合、情報をインスタンス変数に保持させない場合がありますが、そういった内部情報を initialize_copy でコピーするよう定義しておくことで、dup や clone を再定義する必要がなくなります。

デフォルトの Object#initialize_copy は、 freeze チェックおよび型のチェックを行い self を返すだけのメソッドです。

initialize_copy という名前のメソッドは自動的に private に設定されます。

[EXCEPTION] TypeError:: レシーバが freeze されているか、obj のクラスがレシーバのクラスと異なる場合に発生します。

[SEE_ALSO] Object#clone,Object#dup

以下に例として、dup や clone がこのメソッドをどのように利用しているかを示します。

obj.dup は、新たに生成したオブジェクトに対して initialize_copy を呼び

obj2 = obj.class.allocate
obj2.initialize_copy(obj)

obj2 に対してさらに obj の汚染状態、インスタンス変数、ファイナライザをコピーすることで複製を作ります。 obj.clone は、さらに特異メソッドのコピーも行います。

obj = Object.new
class <<obj
  attr_accessor :foo
  def bar
    :bar
  end
end

def check(obj)
  puts "instance variables: #{obj.inspect}"
  puts "tainted?: #{obj.tainted?}"
  print "singleton methods: "
  begin
    p obj.bar
  rescue NameError
    p $!
  end
end

obj.foo = 1
obj.taint

check Object.new.send(:initialize_copy, obj)
        #=> instance variables: #<Object:0x4019c9d4>
        #   tainted?: false
        #   singleton methods: #<NoMethodError: ...>
check obj.dup
        #=> instance variables: #<Object:0x4019c9c0 @foo=1>
        #   tainted?: true
        #   singleton methods: #<NoMethodError: ...>
check obj.clone
        #=> instance variables: #<Object:0x4019c880 @foo=1>
        #   tainted?: true
        #   singleton methods: :bar

remove_instance_variable(name) -> object

オブジェクトからインスタンス変数 name を取り除き、そのインスタンス変数に設定されていた値を返します。

[PARAM] name:: 削除するインスタンス変数の名前をシンボルか文字列で指定します。
[EXCEPTION] NameError:: オブジェクトがインスタンス変数 name を持たない場合に発生します。

class Foo
  def foo
    @foo = 1
    p remove_instance_variable(:@foo) #=> 1
    p remove_instance_variable(:@foo) # instance variable @foo not defined (NameError)
  end
end
Foo.new.foo

[SEE_ALSO] Module#remove_class_variable,Module#remove_const

singleton_method_added(name) -> object

特異メソッドが追加された時にインタプリタから呼び出されます。

通常のメソッドの追加に対するフックには Module#method_addedを使います。

[PARAM] name:: 追加されたメソッド名が Symbol で渡されます。

class Foo
  def singleton_method_added(name)
    puts "singleton method \"#{name}\" was added"
  end
end

obj = Foo.new
def obj.foo
end

#=> singleton method "foo" was added

[SEE_ALSO] Module#method_added,Object#singleton_method_removed,Object#singleton_method_undefined

singleton_method_removed(name) -> object

特異メソッドが Module#remove_method により削除された時にインタプリタから呼び出されます。

通常のメソッドの削除に対するフックには Module#method_removedを使います。

[PARAM] name:: 削除されたメソッド名が Symbol で渡されます。

class Foo
  def singleton_method_removed(name)
    puts "singleton method \"#{name}\" was removed"
  end
end

obj = Foo.new
def obj.foo
end

class << obj
  remove_method :foo
end

#=> singleton method "foo" was removed

[SEE_ALSO] Module#method_removed,Object#singleton_method_added,Object#singleton_method_undefined

singleton_method_undefined(name) -> object

特異メソッドが Module#undef_method または undef により未定義にされた時にインタプリタから呼び出されます。

通常のメソッドの未定義に対するフックには Module#method_undefined を使います。

[PARAM] name:: 未定義にされたメソッド名が Symbol で渡されます。

class Foo
  def singleton_method_undefined(name)
    puts "singleton method \"#{name}\" was undefined"
  end
end

obj = Foo.new
def obj.foo
end
def obj.bar
end

class << obj
  undef_method :foo
end
obj.instance_eval {undef bar}

#=> singleton method "foo" was undefined
#   singleton method "bar" was undefined

[SEE_ALSO] Module#method_undefined,Object#singleton_method_added,Object#singleton_method_removed , クラス／メソッドの定義/undef

定数

INSECURE_METHOD

[TODO]

List of insecure methods. These methods are not callable via dRuby.

class DRb::DRbServer

Ruby 1.8.7 リファレンスマニュアル
- はじめに
- コマンド
- Rubyの起動
- 環境変数
- Ruby言語仕様
- 組み込みライブラリ
- 標準添付ライブラリ
  - CUI
    - curses
    - expect
    - io/console
    - pty
    - readline
    - shell
  - 文字コード
    - iconv
    - kconv
    - nkf
  - コマンドライン
    - getoptlong
    - optparse
  - データベース
    - dbm
    - gdbm
    - pstore
    - sdbm
  - 日付・時間
    - date
    - time
  - デザインパターン
  - 開発
    - benchmark
    - coverage
    - debug
    - irb
    - minitest/mock
    - minitest/spec
    - minitest/unit
    - mkmf
    - pp
    - profile
    - profiler
    - rake
    - rbconfig
    - test/unit
    - tracer
  - ファイル
    - fileutils
    - find
    - pathname
    - tempfile
    - tmpdir
    - un
  - ファイルフォーマット
    - csv
    - json
    - psych
    - rdoc
    - rexml
    - rss
    - syck
    - yaml
    - zlib
  - GC
    - weakref
  - GUI
    - tk
  - 入出力
    - fcntl
    - io/nonblock
    - io/wait
    - open3
    - scanf
  - 数学
    - bigdecimal
    - cmath
    - complex
    - mathn
    - matrix
    - prime
    - rational
    - set
    - tsort
  - ネットワーク
    - cgi
    - drb
    - gserver
    - ipaddr
    - net/ftp
    - net/http
    - net/https
    - net/imap
    - net/pop
    - net/protocol
    - net/smtp
    - net/telnet
    - open-uri
    - openssl
    - resolv
    - resolv-replace
    - socket
    - uri
    - webrick
    - xmlrpc
  - テキスト
    - digest
    - erb
    - ripper
    - shellwords
    - stringio
    - strscan
  - スレッド
    - monitor
    - mutex_m
    - sync
    - thread
    - thwait
    - timeout
  - Unix
    - etc
    - syslog
  - Windows
  - その他
    - abbrev
    - base64
    - continuation
    - dl
    - e2mmap
    - English
    - fiber
    - logger
    - objspace
    - ostruct
    - prettyprint
    - racc/parser
    - rinda/rinda
    - rinda/tuplespace
    - rubygems
    - securerandom
    - ubygems
- pack テンプレート文字列
- sprintf フォーマット
- Ruby用語集
- Rubyで使われる記号の意味
- 疑似BNFによるRubyの文法
- バージョン情報 / このリファレンスについて