class Gem::DependencyList + TSort + Object
クラスの継承リスト: Gem::DependencyList < TSort < Object < Kernel < BasicObject
要約
Gem の依存関係を扱うためのクラスです。
特異メソッド
from_source_index(src_index) -> Gem::DependencyList
-
与えられた Gem::SourceIndex のインスタンスから自身を作成します。
- [PARAM] src_index:
- Gem::SourceIndex を指定します。
[SEE_ALSO] Gem::SourceIndex
new -> Object
-
Objectクラスのインスタンスを生成して返します。
some = Object.new p some #=> #<Object:0x2b696d8>
インスタンスメソッド
self !~ other -> bool
-
自身が other とマッチしない事を判定します。
self#=~(obj) を反転した結果と同じ結果を返します。
- [PARAM] other:
- 判定するオブジェクトを指定します。
[SEE_ALSO] Object#=~
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 -> nil
-
右辺に正規表現オブジェクトを置いた正規表現マッチ obj =~ /RE/ をサポートするためのメソッドです。 常に nil を返します。
この定義により、=~ が再定義されたオブジェクトでは正常にマッチを行い、 それ以外のものは nil を返すようになります。
- [PARAM] other:
- 任意のオブジェクトです。結果に影響しません。
obj = 'regexp' p(obj =~ /re/) #=> 0 obj = nil p(obj =~ /re/) #=> nil
[SEE_ALSO] String#=~
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
add(*gemspecs)
-
与えられた Gem::Specification のインスタンスを自身に追加します。
- [PARAM] gemspecs:
- Gem::Specification のインスタンスを一つ以上指定します。
class -> 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"]
dependency_order -> [Gem::Specification]
-
依存する Gem の数が少ない順にソートされた Gem::Specification のリストを返します。
このことは、インストール済みの Gem を削除するときに便利です。 このメソッドで返された順にインストール済みの Gem 削除すると、 依存関係による多くの問題を回避することができます。
If there are circular dependencies (yuck!), then gems will be returned in order until only the circular dependents and anything they reference are left. Then arbitrary gemspecs will be returned until the circular dependency is broken, after which gems will be returned in dependency order again.
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
each_strongly_connected_component {|nodes| ...} -> nil
-
strongly_connected_components メソッドのイテレータ版です。 obj.each_strongly_connected_component は obj.strongly_connected_components.each に似ていますが、 ブロックの評価中に obj が変更された場合は予期しない結果になる ことがあります。
each_strongly_connected_component は nil を返します。
使用例
require 'tsort' class Hash include TSort alias tsort_each_node each_key def tsort_each_child(node, &block) fetch(node).each(&block) end end non_sort = {1=>[2], 2=>[3, 4], 3=>[2], 4=>[]} non_sort.each_strongly_connected_component{|nodes| p nodes } #出力 #=> [4] #=> [2, 3] #=> [1]
each_strongly_connected_component_from(node) {|nodes| ...} -> ()
-
node から到達可能な強連結成分についてのイテレータです。
返す値は規定されていません。
each_strongly_connected_component_from は tsort_each_node を呼びません。
- [PARAM] node:
- ノードを指定します。
#例 到達可能なノードを表示する require 'tsort' class Hash include TSort alias tsort_each_node each_key def tsort_each_child(node, &block) fetch(node).each(&block) end end non_sort = {1=>[2], 2=>[3, 4], 3=>[2], 4=>[]} non_sort.each_strongly_connected_component{|nodes| p nodes nodes.each {|node| non_sort.each_strongly_connected_component_from(node){|ns| printf("%s -> %s\n", node, ns.join(",")) } } } #出力 #=> [4] #=> 4 -> 4 #=> [2, 3] #=> 2 -> 4 #=> 2 -> 2,3 #=> 3 -> 4 #=> 3 -> 3,2 #=> [1] #=> 1 -> 4 #=> 1 -> 2,3 #=> 1 -> 1
to_enum(method = :each, *args) -> Enumerator
enum_for(method = :each, *args) -> Enumerator
-
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) #=> #<Enumerator: [1, 2, 3]:each>
[SEE_ALSO] 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
find_name(full_name) -> Gem::Specification | nil
-
自身に含まれる与えられた名前を持つ Gem::Specification のインスタンスを返します。
見つからなかった場合は nil を返します。
- [PARAM] full_name:
- バージョンを含むフルネームで Gem の名前を指定します。
[SEE_ALSO] Gem::Specification#full_name
freeze -> self
-
オブジェクトを凍結(内容の変更を禁止)します。
凍結されたオブジェクトの変更は 例外 RuntimeError を発生させます。 いったん凍結されたオブジェクトを元に戻す方法はありません。
凍結されるのはオブジェクトであり、変数ではありません。代入などで変数の指す オブジェクトが変化してしまうことは 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 (RuntimeError)
凍結を解除することはできませんが、Object#dup を使えばほぼ同じ内容の凍結されていない オブジェクトを得ることはできます。
a = [1].freeze p a.frozen? #=> true a[0] = "foo" p a # can't modify frozen array (RuntimeError) 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
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?,BasicObject#__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_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 -> [Symbol]
-
オブジェクトのインスタンス変数名をシンボルの配列として返します。
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 オブジェクトを返します。
me = -365.method(:abs) p me #=> #<Method: Fixnum#abs> p me.call #=> 365
[SEE_ALSO] Module#instance_method,Method,Object#__send__,Kernel.#eval
methods(include_inherited = true) -> [Symbol]
-
そのオブジェクトに対して呼び出せるメソッド名の一覧を返します。 このメソッドは 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) #実行結果 [:protected_singleton, :public_singleton] [:public_singleton, :public_foo] [:private_singleton, :private_foo] [:protected_singleton, :protected_foo] #例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) #実行結果 [:protected_singleton, :public_singleton, :protected_foo, :public_foo, :protected_parent, :public_parent] [:public_singleton, :public_foo, :public_parent] [: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
object_id -> Integer
-
各オブジェクトに対して一意な整数を返します。あるオブジェクトに対し てどのような整数が割り当てられるかは不定です。
Rubyでは、(Garbage Collectされていない)アクティブなオブジェクト間で 重複しない整数(object_id)が各オブジェクトにひとつずつ割り当てられています。この メソッドはその値を返します。
TrueClass, FalseClass, NilClass, Symbol, Fixnum クラス のインスタンスなど Immutable(変更不可)なオブジェクトの一部は同じ内容ならば必ず同じ object_id になります。
これは、Immutable ならば複数の場所から参照されても`破壊的操作'による問題が発生しないので、 同じ内容のインスタンスを複数生成しないという内部実装が理由です。
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
ok? -> bool
-
自身に含まれる全ての Gem::Specification が依存関係を満たしていれば真を返します。 そうでない場合は、偽を返します。
ok_to_remove?(full_name) -> bool
-
与えられた名前を持つ Gem::Specification を自身から削除しても OK な場合は真を返します。 そうでない場合は、偽を返します。
与えられた名前を持つ Gem::Specification を自身から削除すると、 依存関係を壊してしまう場合が、それを削除してはいけない場合です。
- [PARAM] full_name:
- バージョンを含むフルネームで Gem の名前を指定します。
[SEE_ALSO] Gem::Specification#full_name
private_methods(include_inherited = true) -> [Symbol]
-
そのオブジェクトが理解できる private メソッド名の一覧を返します。
- [PARAM] include_inherited:
- 偽となる値を指定すると自身のクラスのスーパークラスで定義されたメソッドを除きます。
[SEE_ALSO] Module#private_instance_methods,Object#methods,Object#singleton_methods
protected_methods(include_inherited = true) -> [Symbol]
-
そのオブジェクトが理解できる protected メソッド名の一覧を返します。
- [PARAM] include_inherited:
- 偽となる値を指定すると自身のクラスのスーパークラスで定義されたメソッドを除きます。
[SEE_ALSO] Module#protected_instance_methods,Object#methods,Object#singleton_methods
public_methods(include_inherited = true) -> [Symbol]
-
そのオブジェクトが理解できる public メソッド名の一覧を返します。
- [PARAM] include_inherited:
- 偽となる値を指定すると自身のクラスのスーパークラスで定義されたメソッドを除きます。
[SEE_ALSO] Module#public_instance_methods,Object#methods,Object#singleton_methods
public_send(name, *args) -> object
-
オブジェクトの public メソッド name を args を引数にして呼び出し、メソッ ドの実行結果を返します。
1.public_send(:+, 2) # => 3
- [PARAM] name:
- 文字列かSymbol で指定するメソッド名です。
- [PARAM] args:
- 呼び出すメソッドに渡す引数です。
- [EXCEPTION] ArgumentError:
- name を指定しなかった場合に発生します。
- [EXCEPTION] NoMethodError:
- protected メソッドや private メソッドに対して実行 した場合に発生します。
1.public_send(:puts, "hello") # => NoMethodError
[SEE_ALSO] Object#send
remove_by_name(full_name) -> Gem::Specification
-
与えられた名前を持つ Gem::Specification を自身から削除します。
このメソッドでは削除後の依存関係をチェックしません。
- [PARAM] full_name:
- バージョンを含むフルネームで Gem の名前を指定します。
[SEE_ALSO] Gem::Specification#full_name, Array#delete_if
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?
respond_to_missing?(symbol, include_private) -> bool
-
自身が symbol で表されるメソッドに対し BasicObject#method_missing で反応するつもりならば真を返します。
Object#respond_to? はメソッドが定義されていない場合、 デフォルトでこのメソッドを呼びだし問合せます。
BasicObject#method_missing を override した場合にこのメソッドも override されるべきです。
false を返します。
- [PARAM] symbol:
- メソッド名シンボル
- [PARAM] include_private:
- private method も含めたい場合に true が渡されます
[SEE_ALSO] Object#respond_to?, BasicObject#method_missing
singleton_class -> Class
-
レシーバの特異クラスを返します。 まだ特異クラスがなければ、新しく作成します。
レシーバが nil か true か false なら、それぞれ NilClass, TrueClass, FalseClass を返します。
- [EXCEPTION] TypeError:
- レシーバが Fixnum か Symbol の場合に発生します。
Object.new.singleton_class #=> #<Class:#<Object:0xb7ce1e24>> String.singleton_class #=> #<Class:String> nil.singleton_class #=> NilClass
[SEE_ALSO] Object#class
singleton_methods(inherited_too = true) -> [Symbol]
-
そのオブジェクトに対して定義されている特異メソッド名 (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) #実行結果 [:protected_self, :public_self] [:protected_self, :public_self] [:protected_class_foo, :public_class_foo] #例2: # あるオブジェクトの特異メソッドの一覧を得る。 # 親クラスのクラスメソッドも含まれるよう true を指定したが、 # Object のクラスメソッドは一覧から排除している。 p obj.singleton_methods(true) p Foo.singleton_methods(true) - Object.singleton_methods(true) #実行結果 [:protected_self, :public_self, :protected_bar, :public_bar] [:protected_class_foo, :public_class_foo, :protected_class_parent, :public_class_parent]
[SEE_ALSO] Object#methods,Object#extend
spec_predecessors -> Hash
-
[TODO] ???
Return a hash of predecessors. <tt>result[spec]</tt> is an Array of gemspecs that have a dependency satisfied by the named spec.
strongly_connected_components -> Array
-
強連結成分の集まりを配列の配列として返します。 この配列は子から親に向かってソートされています。 各要素は強連結成分を表す配列です。
require 'tsort' class Hash include TSort alias tsort_each_node each_key def tsort_each_child(node, &block) fetch(node).each(&block) end end non_sort = {1=>[2], 2=>[3, 4], 3=>[2], 4=>[]} p non_sort.strongly_connected_components #=> [[4], [2, 3], [1]]
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}"}
to_a -> Array
-
オブジェクトを配列に変換した結果を返します。 デフォルトでは定義されていません。
説明のためここに記載してありますが、 このメソッドは実際には Object クラスには定義されていません。 必要に応じてサブクラスで定義すべきものです。
p( {'a'=>1}.to_a ) # [["a", 1]] p ['array'].to_a # ["array"] 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 への暗黙の変換が必要なときに内部で呼ばれます。 デフォルトでは定義されていません。
説明のためここに記載してありますが、 このメソッドは実際には Object クラスには定義されていません。 必要に応じてサブクラスで定義すべきものです。
このメソッドを定義する条件は、
- ハッシュが使われるすべての場面で代置可能であるような、
- ハッシュそのものとみなせるようなもの
という厳しいものになっています。
class Foo def to_hash {'as' => 24} end end it = Foo.new p({:as => 12}.merge(it)) #=> {"as"=>24, :as=>12}
to_int -> Integer
-
オブジェクトの Integer への暗黙の変換が必要なときに内部で呼ばれます。 デフォルトでは定義されていません。
説明のためここに記載してありますが、 このメソッドは実際には Object クラスには定義されていません。 必要に応じてサブクラスで定義すべきものです。
このメソッドを定義する条件は、
- 整数が使われるすべての場面で代置可能であるような、
- 整数そのものとみなせるようなもの
という厳しいものになっています。
class Foo def to_int 666 end end it = Foo.new p(9**9 & it) #=> 8
[SEE_ALSO] Kernel.#Integer
to_io -> IO
-
オブジェクトの IO への暗黙の変換が必要なときに内部で呼ばれます。 デフォルトでは定義されていません。
説明のためここに記載してありますが、 このメソッドは実際には Object クラスには定義されていません。 必要に応じてサブクラスで定義すべきものです。
このメソッドを定義する条件は、
- IOオブジェクトが使われるすべての場面で代置可能であるような、
- IOオブジェクトそのものとみなせるようなもの
という厳しいものになっています。
to_proc -> Proc
-
オブジェクトの Proc への暗黙の変換が必要なときに内部で呼ばれます。 デフォルトでは定義されていません。
説明のためここに記載してありますが、 このメソッドは実際には Object クラスには定義されていません。 必要に応じてサブクラスで定義すべきものです。
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 への暗黙の変換が必要なときに内部で呼ばれます。 デフォルトでは定義されていません。
説明のためここに記載してありますが、 このメソッドは実際には Object クラスには定義されていません。 必要に応じてサブクラスで定義すべきものです。
このメソッドを定義する条件は、
- 正規表現が使われるすべての場面で代置可能であるような、
- 正規表現そのものとみなせるようなもの
という厳しいものになっています。
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 への暗黙の変換が必要なときに内部で呼ばれます。 デフォルトでは定義されていません。
説明のためここに記載してありますが、 このメソッドは実際には Object クラスには定義されていません。 必要に応じてサブクラスで定義すべきものです。
このメソッドを定義する条件は、
- 文字列が使われるすべての場面で代置可能であるような、
- 文字列そのものとみなせるようなもの
という厳しいものになっています。
class Foo def to_str 'Edition' end end it = Foo.new p('Second' + it) #=> "SecondEdition"
[SEE_ALSO] Object#to_s,Kernel.#String
trust -> self
-
[TODO]
オブジェクトの「untrustマーク」を取り除きます。
[SEE_ALSO] Object#untrusted?,Object#untrust
tsort -> Array
-
頂点をトポロジカルソートして得られる配列を返します。 この配列は子から親に向かってソートされています。 すなわち、最初の要素は子を持たず、最後の要素は親を持ちません。
閉路が存在するとき、例外TSort::Cyclicを起こします。
- [EXCEPTION] TSort::Cyclic:
- 閉路が存在するとき、発生します.
使用例
require 'tsort' class Hash include TSort alias tsort_each_node each_key def tsort_each_child(node, &block) fetch(node).each(&block) end end sorted = {1=>[2, 3], 2=>[3], 3=>[], 4=>[]}.tsort p sorted #=> [3, 2, 1, 4]
tsort_each {|node| ...} -> nil
-
tsort メソッドのイテレータ版です。 obj.tsort_each は obj.tsort.each と似ていますが、 ブロックの評価中に obj が変更された場合は予期しない結果になる ことがあります。
tsort_each は nil を返します。 閉路が存在するとき、例外 TSort::Cyclic を起こします。
- [EXCEPTION] TSort::Cyclic:
- 閉路が存在するとき、発生します.
使用例
require 'tsort' class Hash include TSort alias tsort_each_node each_key def tsort_each_child(node, &block) fetch(node).each(&block) end end non_sort = {1=>[2, 3], 2=>[3], 3=>[], 4=>[]} non_sort.tsort_each {|node| non_sort.tsort_each_child(node){|child| printf("%d -> %d\n", node, child) } } # 出力 #=> 2 -> 3 #=> 1 -> 2 #=> 1 -> 3
tsort_each_child(node) {|child| ...} -> ()
-
TSort で拡張されるクラスで定義されていなければならないメソッドです。
tsort_each_child is used to iterate for child nodes of node.
- [PARAM] node:
- ノードを指定します。
- [EXCEPTION] NotImplementedError:
- TSort で拡張されるクラスで定義されていない場合発生します。
tsort_each_node {|node| ...} -> ()
-
TSort で拡張されるクラスで定義されていなければならないメソッドです。
tsort_each_node is used to iterate for all nodes over a graph.
- [EXCEPTION] NotImplementedError:
- TSort で拡張されるクラスで定義されていない場合発生します。
untaint -> self
-
オブジェクトの「汚染マーク」を取り除きます。
汚染マークを取り除くことによる危険性はプログラマが責任を負う必要が あります。
オブジェクトの汚染に関してはセキュリティモデルを参照してください。
- [EXCEPTION] SecurityError:
- セキュリティレベルが3以上の時にこのメソッドを使用すると発生します。
[SEE_ALSO] Object#taint,Object#tainted?
untrust -> self
-
[TODO]
オブジェクトの「untrustマーク」をセットします。
[SEE_ALSO] Object#trust,Object#untrusted?
untrusted? -> bool
-
[TODO]
オブジェクトの「untrustマーク」がセットされている時真を返します。
[SEE_ALSO] Object#trust,Object#untrust
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