Ruby 2.4.0 リファレンスマニュアル > ライブラリ一覧 > 組み込みライブラリ > Moduleクラス

class Module

クラスの継承リスト: Module < Object < Kernel < BasicObject

要約

モジュールのクラスです。

目次

特異メソッド
constants nesting new
インスタンスメソッド
< <= <=> === > >= ancestors autoload autoload? class_eval module_eval class_variable_defined? class_variables const_defined? const_get const_missing const_set constants freeze include include? included_modules inspect name to_s instance_method instance_methods method_defined? prepend private_class_method private_instance_methods private_method_defined? protected_instance_methods protected_method_defined? public_class_method public_instance_method public_instance_methods public_method_defined? remove_class_variable
privateメソッド
alias_method append_features attr attr_accessor attr_reader attr_writer class_exec module_exec class_variable_get class_variable_set define_method deprecate_constant extend_object extended included method_added method_removed method_undefined module_function prepend_features prepended private private_constant protected public public_constant refine remove_const remove_method singleton_class? undef_method using

特異メソッド

constants -> [Symbol][permalink][rdoc]

このメソッドを呼び出した時点で参照可能な定数名の配列を返します。

class C
  FOO = 1
end
p Module.constants   # => [:RUBY_PLATFORM, :STDIN, ..., :C, ...]
                     # 出力中に :FOO は現われない

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

nesting -> [Class, Module][permalink][rdoc]

このメソッドを呼び出した時点でのクラス/モジュールのネスト情 報を配列に入れて返します。

module Foo
  module Bar
    module Baz
      p Module.nesting   # => [Foo::Bar::Baz, Foo::Bar, Foo]
    end
  end
end
new -> Module[permalink][rdoc]
new {|mod| ... } -> Module

名前の付いていないモジュールを新しく生成して返します。

ブロックが与えられると生成したモジュールをブロックに渡し、 モジュールのコンテキストでブロックを実行します。

mod = Module.new
mod.module_eval {|m| ... }
mod

と同じです。 ブロックの実行は Module#initialize が行います。

ブロックを与えた場合も生成したモジュールを返します。

このメソッドで生成されたモジュールは、 最初に名前が必要になったときに名前が決定します。 モジュールの名前は、 そのモジュールが代入されている定数名のいずれかです。

m = Module.new
p m               # => #<Module 0lx40198a54>
p m.name          # => nil   # まだ名前は未定
Foo = m
# m.name          # ここで m.name を呼べば m の名前は "Foo" に確定する
Bar = m
m.name            # "Foo" か "Bar" のどちらかに決まる

インスタンスメソッド

self < other -> bool | nil[permalink][rdoc]

比較演算子。self が other の子孫である場合、 true を返します。 self が other の先祖か同一のクラス/モジュールである場合、false を返します。

継承関係にないクラス同士の比較では nil を返します。

[PARAM] other:
比較対象のモジュールやクラス
[EXCEPTION] TypeError:
other がクラスやモジュールではない場合に発生します。
module Foo
end
class Bar
  include Foo
end
class Baz < Bar
end
class Qux
end
p Bar < Foo     # => true
p Baz < Bar     # => true
p Baz < Foo     # => true
p Baz < Qux     # => nil
p Baz > Qux     # => nil

p Foo < Object.new # => in `<': compared with non class/module (TypeError)
self <= other -> bool | nil[permalink][rdoc]

比較演算子。self が other の子孫であるか、self と other が 同一クラスである場合、 true を返します。 self が other の先祖である場合、false を返します。

継承関係にないクラス同士の比較では nil を返します。

[PARAM] other:
比較対象のモジュールやクラス
[EXCEPTION] TypeError:
other がクラスやモジュールではない場合に発生します。

[SEE_ALSO] Module#<

self <=> other -> Integer | nil[permalink][rdoc]

self と other の継承関係を比較します。

self と other を比較して、 self が other の子孫であるとき -1、 同一のクラス/モジュールのとき 0、 self が other の先祖であるとき 1 を返します。

継承関係にないクラス同士の比較では nil を返します。

other がクラスやモジュールでなければ nil を返します。

[PARAM] other:
比較対象のクラスやモジュール
module Foo
end
class Bar
  include Foo
end
class Baz < Bar
end
class Qux
end
p Bar <=> Foo     # => -1
p Baz <=> Bar     # => -1
p Baz <=> Foo     # => -1
p Baz <=> Qux     # => nil
p Qux <=> Baz     # => nil

p Baz <=> Object.new  # => nil
self === obj -> bool[permalink][rdoc]

指定された obj が self かそのサブクラスのインスタンスであるとき真を返します。 また、obj が self をインクルードしたクラスかそのサブクラスのインスタンスである場合にも 真を返します。上記のいずれでもない場合に false を返します。

言い替えると obj.kind_of?(self) が true の場合、 true を返します。

このメソッドは主に case 文での比較に用いられます。 case ではクラス、モジュールの所属関係をチェックすることになります。

str = String.new
case str
when String     # String === str を評価する
  p true        # => true
end
[PARAM] obj:
任意のオブジェクト

[SEE_ALSO] Object#kind_of?, Object#instance_of?, 制御構造/case

self > other -> bool | nil[permalink][rdoc]

比較演算子。 self が other の先祖である場合、true を返します。 self が other の子孫か同一クラスである場合、false を返します。

継承関係にないクラス同士の比較では nil を返します。

[PARAM] other:
比較対象のモジュールやクラス
[EXCEPTION] TypeError:
other がクラスやモジュールではない場合に発生します。

[SEE_ALSO] Module#<

self >= other -> bool | nil[permalink][rdoc]

比較演算子。self が other の先祖か同一クラスである場合、 true を返します。 self が other の子孫である場合、false を返します。

継承関係にないクラス同士の比較では nil を返します。

[PARAM] other:
比較対象のモジュールやクラス
[EXCEPTION] TypeError:
other がクラスやモジュールではない場合に発生します。

[SEE_ALSO] Module#<

ancestors -> [Class, Module][permalink][rdoc]

クラス、モジュールのスーパークラスとインクルードしているモジュール を優先順位順に配列に格納して返します。

module Foo
end
class Bar
  include Foo
end
class Baz < Bar
  p ancestors
  p included_modules
  p superclass
end
# => [Baz, Bar, Foo, Object, Kernel, BasicObject]
# => [Foo, Kernel]
# => Bar

[SEE_ALSO] Module#included_modules

autoload(const_name, feature) -> nil[permalink][rdoc]

定数 const_name を最初に参照した時に feature を Kernel.#require するように設定します。

[PARAM] const_name:
String または Symbol で指定します。 なお、const_name には、"::" 演算子を含めることはできません。 つまり、トップレベルの定数しか指定できません。
[PARAM] feature:
Kernel.#require と同様な方法で autoload する対象を指定する。

[SEE_ALSO] Kernel.#autoload

autoload?(const_name) -> String | nil[permalink][rdoc]

autoload 定数がまだ定義されてない(ロードされていない) ときにそのパス名を返します。 また、ロード済みなら nil を返します。

[PARAM] const_name:
String または Symbol で指定します。

[SEE_ALSO] Kernel.#autoload?

module_eval(expr, fname = "(eval)", lineno = 1) -> object[permalink][rdoc]
module_eval {|mod| ... } -> object
class_eval(expr, fname = "(eval)", lineno = 1) -> object
class_eval {|mod| ... } -> object

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

モジュールのコンテキストで評価するとは、実行中そのモジュールが self になるということです。 つまり、そのモジュールの定義式の中にあるかのように実行されます。

ただし、ローカル変数は module_eval/class_eval の外側のスコープと共有します。

文字列が与えられた場合には、定数とクラス変数のスコープは自身のモジュール定義式内と同じスコープになります。 ブロックが与えられた場合には、定数とクラス変数のスコープはブロックの外側のスコープになります。

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

例:

class C
end
a = 1
C.class_eval %Q{
  def m                   # メソッドを動的に定義できる。
    return :m, #{a}
  end
}

p C.new.m        #=> [:m, 1]

[SEE_ALSO] BasicObject#instance_eval, Module.new, Kernel.#eval

class_variable_defined?(name) -> bool[permalink][rdoc]

name で与えられた名前のクラス変数がモジュールに存在する場合 true を 返します。

[PARAM] name:
SymbolString を指定します。
class Fred
  @@foo = 99
end
Fred.class_variable_defined?(:@@foo)    #=> true
Fred.class_variable_defined?(:@@bar)    #=> false
Fred.class_variable_defined?('@@foo')    #=> true
Fred.class_variable_defined?('@@bar')    #=> false
class_variables(inherit = true) -> [Symbol][permalink][rdoc]

クラス/モジュールに定義されているクラス変数の名前の配列を返します。

[PARAM] inherit:
false を指定しない場合はスーパークラスやインクルードして いるモジュールのクラス変数を含みます。
class One
  @@var1 = 1
end
class Two < One
  @@var2 = 2
end
One.class_variables          # => [:@@var1]
Two.class_variables          # => [:@@var2, :@@var1]
Two.class_variables(false)   # => [:@@var2]

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

const_defined?(name, inherit = true) -> bool[permalink][rdoc]

モジュールに name で指定される名前の定数が定義されている時真 を返します。

スーパークラスや include したモジュールで定義された定数を検索対象 にするかどうかは第二引数で制御することができます。

[PARAM] name:
String, Symbol で指定される定数名。
[PARAM] inherit:
false を指定するとスーパークラスや include したモジュールで 定義された定数は対象にはなりません。
module Kernel
  FOO = 1
end

# Object は include したモジュールの定数に対しても
# true を返す
p Object.const_defined?(:FOO)   # => true

module Bar
  BAR = 1
end
class Object
  include Bar
end
# ユーザ定義のモジュールに対しても同様
p Object.const_defined?(:BAR)   # => true

class Baz
  include Bar
end
# Object 以外でも同様になった
# 第二引数のデフォルト値が true であるため
p Baz.const_defined?(:BAR)      # => true

# 第二引数を false にした場合
p Baz.const_defined?(:BAR, false)   # => false
const_get(name, inherit = true) -> object[permalink][rdoc]

name で指定される名前の定数の値を取り出します。

Module#const_defined? と違って Object を特別扱いすることはありません。

[PARAM] name:
定数名。StringSymbol で指定します。 完全修飾名を指定しなかった場合はモジュールに定義されている name で指定される名前の定数の値を取り出します。
[PARAM] inherit:
false を指定するとスーパークラスや include したモジュールで 定義された定数は対象にはなりません。
[EXCEPTION] NameError:
定数が定義されていないときに発生します。
module Bar
  BAR = 1
end
class Object
  include Bar
end
# Object では include されたモジュールに定義された定数を見付ける
p Object.const_get(:BAR)   # => 1

class Baz
  include Bar
end
# Object以外でも同様
p Baz.const_get(:BAR)      # => 1
# 定義されていない定数
p Baz.const_get(:NOT_DEFINED) #=> raise NameError
# 第二引数に false を指定すると自分自身に定義された定数から探す
p Baz.const_get(:BAR, false) #=> raise NameError
# 完全修飾名を指定すると include や自分自身へ定義されていない場合でも参照できる
p Class.const_get("Bar::BAR") # => 1
const_missing(name)[permalink][rdoc]

定義されていない定数を参照したときに Ruby インタプリタが このメソッドを呼びます。

[PARAM] name:
参照した定数名の Symbol
[EXCEPTION] NameError:
このメソッドを呼び出した場合、デフォルトで発生する例外
class Foo
  def Foo.const_missing(id)
    warn "undefined constant #{id.inspect}"
  end

  Bar
end
Foo::Bar

# => undefined constant :Bar
     undefined constant :Bar
const_set(name, value) -> object[permalink][rdoc]

モジュールに name で指定された名前の定数を value とい う値として定義し、value を返します。

そのモジュールにおいてすでにその名前の定数が定義されている場合、警 告メッセージが出力されます。

[PARAM] name:
Symbol,String で定数の名前を指定します。
[PARAM] value:
セットしたい値を指定します。
constants(inherit = true) -> [Symbol][permalink][rdoc]

そのモジュール(またはクラス)で定義されている定数名の配列を返します。

inherit に真を指定すると スーパークラスやインクルードしているモジュールの定数も含みます。 Object のサブクラスの場合、Objectやそのスーパークラスで定義されている 定数は含まれません。 Object.constants とすると Object クラスで定義された 定数の配列が得られます。

得られる定数の順序は保証されません。

[PARAM] inherit:
true を指定するとスーパークラスや include したモジュールで 定義された定数が対象にはなります。false を指定した場合 対象にはなりません。

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

Module.constants と Module#constants の違い

 # 出力の簡略化のため起動時の定数一覧を取得して後で差し引く
 $clist = Module.constants

 class Foo
   FOO = 1
 end
 class Bar
   BAR = 1

   # Bar は BAR を含む
   p constants                         # => [:BAR]
   # 出力に FOO は含まれない
   p Module.constants - $clist         # => [:BAR, :Bar, :Foo]
   class Baz
     # Baz は定数を含まない
     p constants                       # => []

     # ネストしたクラスでは、外側のクラスで定義した定数は
     # 参照可能なので、BAR は、Module.constants には含まれる
     # (クラス Baz も Bar の定数なので同様)
     p Module.constants - $clist       # => [:BAR, :Baz, :Foo, :Bar]
   end
 end
freeze -> self[permalink][rdoc]

モジュールを凍結(内容の変更を禁止)します。

凍結したモジュールにメソッドの追加など何らかの変更を加えようとした場合 に RuntimeError が発生します。

[SEE_ALSO] Object#freeze

include(*mod) -> self[permalink][rdoc]

モジュール mod をインクルードします。

[PARAM] mod:
Module のインスタンス( Enumerable など)を指定します。
[EXCEPTION] ArgumentError:
継承関係が循環してしまうような include を行った場合に発生します。
module M
end
module M2
  include M
end
module M
  include M2
end

実行結果:

-:3:in `append_features': cyclic include detected (ArgumentError)
        from -:3:in `include'
        from -:3

インクルードとは、指定されたモジュールの定義 (メソッド、定数) を引き継ぐことです。 インクルードは多重継承の代わりに用いられており、 mix-in とも呼びます。

class C
  include FileTest
  include Math
end

p C.ancestors

# => [C, Math, FileTest, Object, Kernel]

モジュールの機能追加は、クラスの継承関係の間にそのモジュールが挿入 されることで実現されています。従って、メソッドの探索などは スーパークラスよりもインクルードされたモジュールのほうが 先に行われます (上の例の Module#ancestors の結果がメソッド探索の順序です)。

同じモジュールを二回以上 include すると二回目以降は無視されます。

module M
end
class C1
  include M
end
class C2 < C1
  include M   # この include は無視される
end

p C2.ancestors  # => [C2, C1, M, Object, Kernel]

引数に複数のモジュールを指定した場合、 最後の引数から順にインクルードします。

include?(mod) -> bool[permalink][rdoc]

self かその親クラス / 親モジュールがモジュール mod を インクルードしていれば true を返します。

[PARAM] mod:
Module を指定します。
module M
end
class C1
  include M
end
class C2 < C1
end

p C1.include?(M)   # => true
p C2.include?(M)   # => true
included_modules -> [Module][permalink][rdoc]

self にインクルードされているモジュールの配列を返します。

module Mixin
end

module Outer
  include Mixin
end

Mixin.included_modules   #=> []
Outer.included_modules   #=> [Mixin]

[SEE_ALSO] Module#ancestors

name -> String[permalink][rdoc]
to_s -> String
inspect -> String

モジュールやクラスの名前を文字列で返します。

このメソッドが返す「モジュール / クラスの名前」とは、 より正確には「クラスパス」を指します。 クラスパスとは、ネストしているモジュールすべてを 「::」を使って表示した名前のことです。 クラスパスの例としては「CGI::Session」「Net::HTTP」が挙げられます。

[RETURN]
名前のないモジュール / クラスに対しては nil を返します。
module A
  module B
  end

  p B.name  #=> "A::B"

  class C
  end
end

p A.name    #=> "A"
p A::B.name #=> "A::B"
p A::C.name #=> "A::C"

# 名前のないモジュール / クラス
p Module.new.name   #=> nil
p Class.new.name    #=> nil
instance_method(name) -> UnboundMethod[permalink][rdoc]

self のインスタンスメソッド name をオブジェクト化した UnboundMethod を返します。

[PARAM] name:
メソッド名を Symbol または String で指定します。
[EXCEPTION] NameError:
self に存在しないメソッドを指定した場合に発生します。

[SEE_ALSO] Module#public_instance_method, Object#method

instance_methods(inherited_too = true) -> [Symbol][permalink][rdoc]

そのモジュールで定義されている public および protected メソッド名 の一覧を配列で返します。

[PARAM] inherited_too:
false を指定するとそのモジュールで定義されているメソッドのみ返します。

[SEE_ALSO] Object#methods

例1:

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

# あるクラスのインスタンスメソッドの一覧を得る
p Foo.instance_methods(false)
p Foo.public_instance_methods(false)
p Foo.private_instance_methods(false)
p Foo.protected_instance_methods(false)

class Bar < Foo
end

実行結果

[:protected_foo, :public_foo]
[:public_foo]
[:private_foo]
[:protected_foo]

例2:

class Bar
  private;   def private_foo()   end
  protected; def protected_foo() end
  public;    def public_foo()    end
end

# あるクラスのインスタンスメソッドの一覧を得る。
# 親のクラスのインスタンスメソッドも含めるため true を指定して
# いるが、Object のインスタンスメソッドは一覧から排除している。
p Bar.instance_methods(true)           - Object.instance_methods(true)
p Bar.public_instance_methods(true)    - Object.public_instance_methods(true)
p Bar.private_instance_methods(true)   - Object.private_instance_methods(true)
p Bar.protected_instance_methods(true) - Object.protected_instance_methods(true)

実行結果

[:protected_foo, :public_foo]
[:public_foo]
[:private_foo]
[:protected_foo]
method_defined?(name) -> bool[permalink][rdoc]

モジュールにインスタンスメソッド name が定義されているとき true を返します。

[PARAM] name:
SymbolString を指定します。

[SEE_ALSO] Module#public_method_defined?, Module#private_method_defined?, Module#protected_method_defined?

prepend(*modules) -> self[permalink][rdoc]

指定したモジュールを self の継承チェインの先頭に「追加する」ことで self の定数、メソッド、モジュール変数を「上書き」します。

継承チェイン上で、self のモジュール/クラスよりも「手前」に 追加されるため、結果として self で定義されたメソッドは override されます。

modules で指定したモジュールは後ろから順に処理されるため、 modules の先頭が最も優先されます。

また、継承によってこの「上書き」を処理するため、prependの引数として 渡したモジュールのインスタンスメソッドでsuperを呼ぶことで self のモジュール/クラスのメソッドを呼び出すことができます。

実際の処理は modules の各要素の prepend_features を後ろから順に呼びだすだけです。 Module#prepend_features が継承チェインの改変を実行し、結果として上のような 処理が実現されます。そのため、prepend_features を override することで prepend の処理を追加/変更できます。

[PARAM] modules:
prepend する Module を指定します

[SEE_ALSO] Module#prepend_features

# super と prepend の組み合わせの例
module X
  def foo
    puts "X1" # (1x)
    super # (2x)
    puts "X2" # (3x)
  end
end

class A
  prepend X

  def foo
    puts "A" #(1a)
  end
end

A.new.foo
# (1x) (2x)(ここの super で A#foo を呼びだす) (1a) (3x) の順に実行される
# >> X1
# >> A
# >> X2

# 2つのモジュールを X, Y を prepend X, Y という順で指定したもの
module Y
  def foo
    puts "Y1" #(1y)
    super #(2y)
    puts "Y2" #(3y)
  end
end

class B
  prepend X, Y
  def foo
    puts "B" # (1b)
  end
end

B.new.foo
# (1x) (2x) (1y) (2y) (1b) (3y) (3x) の順に実行される
# X#foo のほうが Y#foo より継承チェインの手前側にあり、そちらが優先される
# >> X1
# >> Y1
# >> B
# >> Y2
# >> X2
# prepend Y, X とすると Y1 X1 B X2 Y2 の順で表示される
private_class_method(*name) -> self[permalink][rdoc]

name で指定したクラスメソッド (クラスの特異メソッド) の 可視性を private に変更します。

[PARAM] name:
0 個以上の StringSymbol を指定します。
private_instance_methods(inherited_too = true) -> [Symbol][permalink][rdoc]

そのモジュールで定義されている private メソッド名 の一覧を配列で返します。

[PARAM] inherited_too:
false を指定するとそのモジュールで定義されているメソッドのみ返します。

[SEE_ALSO] Object#private_methods, Module#instance_methods

private_method_defined?(name) -> bool[permalink][rdoc]

インスタンスメソッド name がモジュールに定義されており、 しかもその可視性が private であるときに true を返します。 そうでなければ false を返します。

[PARAM] name:
SymbolString を指定します。

[SEE_ALSO] Module#method_defined?

protected_instance_methods(inherited_too = true) -> [Symbol][permalink][rdoc]

そのモジュールで定義されている protected メソッド名 の一覧を配列で返します。

[PARAM] inherited_too:
false を指定するとそのモジュールで定義されているメソッドのみ返します。

[SEE_ALSO] Object#protected_methods, Module#instance_methods

protected_method_defined?(name) -> bool[permalink][rdoc]

インスタンスメソッド name がモジュールに定義されており、 しかもその可視性が protected であるときに true を返します。 そうでなければ false を返します。

[PARAM] name:
SymbolString を指定します。

[SEE_ALSO] Module#method_defined?

public_class_method(*name) -> self[permalink][rdoc]

name で指定したクラスメソッド (クラスの特異メソッド) の 可視性を public に変更します。

[PARAM] name:
0 個以上の StringSymbol を指定します。
public_instance_method(name) -> UnboundMethod[permalink][rdoc]

self の public インスタンスメソッド name をオブジェクト化した UnboundMethod を返します。

[PARAM] name:
メソッド名を Symbol または String で指定します。
[EXCEPTION] NameError:
定義されていないメソッド名や、 protected メソッド名、 private メソッド名を引数として与えると発生します。
Kernel.public_instance_method(:object_id) #=> #<UnboundMethod: Kernel#object_id>
Kernel.public_instance_method(:p)         #   method `p' for module `Kernel' is private (NameError)

[SEE_ALSO] Module#instance_method,Object#public_method

public_instance_methods(inherited_too = true) -> [Symbol][permalink][rdoc]

そのモジュールで定義されている public メソッド名 の一覧を配列で返します。

[PARAM] inherited_too:
false を指定するとそのモジュールで定義されているメソッドのみ返します。

[SEE_ALSO] Object#public_methods, Module#instance_methods

public_method_defined?(name) -> bool[permalink][rdoc]

インスタンスメソッド name がモジュールに定義されており、 しかもその可視性が public であるときに true を返します。 そうでなければ false を返します。

[PARAM] name:
SymbolString を指定します。

[SEE_ALSO] Module#method_defined?

remove_class_variable(name) -> object[permalink][rdoc]

引数で指定したクラス変数を取り除き、そのクラス変数に設定さ れていた値を返します。

[PARAM] name:
String または Symbol を指定します。
[RETURN]
引数で指定されたクラス変数に設定されていた値を返します。
[EXCEPTION] NameError:
引数で指定されたクラス変数がそのモジュールやクラスに定義されていない場合に発生します。
class Foo
  @@foo = 1
  remove_class_variable(:@@foo)   # => 1
  p @@foo   # => uninitialized class variable @@foo in Foo (NameError)
end

[SEE_ALSO] Module#remove_const, Object#remove_instance_variable

privateメソッド

alias_method(new, original) -> self[permalink][rdoc]

メソッドの別名を定義します。

alias との違いは以下の通りです。

また、クラスメソッドに対して使用することはできません。

[PARAM] new:
新しいメソッド名。String または Symbol で指定します。
[PARAM] original:
元のメソッド名。String または Symbol で指定します。

[SEE_ALSO] クラス/メソッドの定義/alias

append_features(module_or_class) -> self[permalink][rdoc]

モジュール(あるいはクラス)に self の機能を追加します。

このメソッドは Module#include の実体であり、 include を Ruby で書くと以下のように定義できます。

def include(*modules)
  modules.reverse_each do |mod|
    # append_features や included はプライベートメソッドなので
    # 直接 mod.append_features(self) などとは書けない
    mod.__send__(:append_features, self)
    mod.__send__(:included, self)
  end
end

[SEE_ALSO] Module#included

attr(name, assignable = false) -> nil[permalink][rdoc]

インスタンス変数読み取りのためのインスタンスメソッド name を定義します。

このメソッドで定義されるアクセスメソッドの定義は次の通りです。

def name
  @name
end

省略可能な第 2 引数 assignable が指定されその値が真である 場合には、属性の書き込み用メソッド name= も同時に定義されます。 その定義は次の通りです。

def name=(val)
  @name = val
end
[PARAM] name:
String または Symbol で指定します。
[PARAM] assignable:
true を指定するとインスタンス変数書き込み用のインスタンスメソッドも定義します。
attr_accessor(*name) -> nil[permalink][rdoc]

インスタンス変数 name に対する読み取りメソッドと書き込みメソッドの両方を 定義します。

このメソッドで定義されるメソッドの定義は以下の通りです。

def name
  @name
end
def name=(val)
  @name = val
end
[PARAM] name:
String または Symbol を 1 つ以上指定します。
attr_reader(*name) -> nil[permalink][rdoc]

インスタンス変数 name の読み取りメソッドを定義します。

このメソッドで定義されるメソッドの定義は以下の通りです。

def name
  @name
end
[PARAM] name:
String または Symbol を 1 つ以上指定します。
attr_writer(*name) -> nil[permalink][rdoc]

インスタンス変数 name への書き込みメソッド (name=) を定義します。

このメソッドで定義されるメソッドの定義は以下の通りです。

def name=(val)
  @name = val
end
[PARAM] name:
String または Symbol を 1 つ以上指定します。
module_exec(*args) {|*vars| ... } -> object[permalink][rdoc]
class_exec(*args) {|*vars| ... } -> object

与えられたブロックを指定された args を引数としてモジュールのコンテキストで評価します。

モジュールのコンテキストで評価するとは、実行中そのモジュールが self になるということです。 つまり、そのモジュールの定義式の中にあるかのように実行されます。

ローカル変数、定数とクラス変数のスコープはブロックの外側のスコープになります。

[PARAM] args:
ブロックに渡す引数を指定します。
class Thing
end
c = 1

Thing.class_exec{
  def hello()
    "Hello there!"
  end

  define_method(:foo) do   # ローカル変数がブロックの外側を参照している
    c
  end
}

t = Thing.new
p t.hello()            #=> "Hello there!"
p t.foo()              #=> 1

[SEE_ALSO] Module#module_eval, Module#class_eval

class_variable_get(name) -> object[permalink][rdoc]

クラス/モジュールに定義されているクラス変数 name の値を返します。

[PARAM] name:
String または Symbol を指定します。
[EXCEPTION] NameError:
クラス変数 name が定義されていない場合、発生します。
class Fred
  @@foo = 99
end

def Fred.foo
  class_variable_get(:@@foo)
end

p Fred.foo #=> 99
class_variable_set(name, val) -> object[permalink][rdoc]

クラス/モジュールにクラス変数 name を定義して、その値として val をセットします。val を返します。

[PARAM] name:
String または Symbol を指定します。
class Fred
  @@foo = 99
  def foo
    @@foo
  end
end

def Fred.foo(val)
  class_variable_set(:@@foo, val)
end

p Fred.foo(101)   # => 101
p Fred.new.foo    # => 101
define_method(name, method) -> Symbol[permalink][rdoc]
define_method(name) { ... } -> Symbol

インスタンスメソッド name を定義します。

ブロックを与えた場合、定義したメソッドの実行時にブロックが レシーバクラスのインスタンスの上で BasicObject#instance_eval されます。

[PARAM] name:
メソッド名を String または Symbol を指定します。
[PARAM] method:
ProcMethod あるいは UnboundMethod の いずれかのインスタンスを指定します。
[RETURN]
メソッド名を表す Symbol を返します。
[EXCEPTION] TypeError:
method に同じクラス、サブクラス、モジュール以外のメソッ ドを指定した場合に発生します。
class Foo
  def foo() p :foo end
  define_method(:bar, instance_method(:foo))
end
Foo.new.bar    # => :foo
deprecate_constant(*name) -> self[permalink][rdoc]

name で指定した定数を deprecate に設定します。 deprecate に設定した定数を参照すると警告メッセージが表示されます。

[PARAM] name:
0 個以上の StringSymbol を指定します。
[EXCEPTION] NameError:
存在しない定数を指定した場合に発生します。
[RETURN]
self を返します。
extend_object(obj) -> object[permalink][rdoc]

Object#extend の実体です。オブジェクトにモジュールの機能を追加します。

Object#extend は、Ruby で書くと以下のように定義できます。

def extend(*modules)
  modules.reverse_each do |mod|
    # extend_object や extended はプライベートメソッドなので
    # 直接 mod.extend_object(self) などとは書けない
    mod.__send__(:extend_object, self)
    mod.__send__(:extended, self)
  end
end

extend_object のデフォルトの実装では、self に定義されて いるインスタンスメソッドを obj の特異メソッドとして追加します。

[PARAM] obj:
self の機能を追加するオブジェクトを指定します。
[RETURN]
obj で指定されたオブジェクトを返します。

[SEE_ALSO] Module#extended

extended(obj) -> ()[permalink][rdoc]

self が他のオブジェクト に Object#extend されたときに 呼ばれます。引数には extend を行ったオブジェクトが渡されます。

[PARAM] obj:
Object#extend を行ったオブジェクト
module Foo
  def self.extended(obj)
    p "#{obj} extend #{self}"
  end
end

Object.new.extend Foo

# => "#<Object:0x401cbc3c> extend Foo"

[SEE_ALSO] Module#extend_object

included(class_or_module) -> ()[permalink][rdoc]

self が Module#include されたときに対象のクラスまたはモジュー ルを引数にしてインタプリタがこのメソッドを呼び出します。

[PARAM] class_or_module:
Module#include を実行したオブジェクト
module Foo
  def self.included(mod)
    p "#{mod} include #{self}"
  end
end
class Bar
  include Foo
end
# => "Bar include Foo"

[SEE_ALSO] Module#append_features

method_added(name) -> ()[permalink][rdoc]

メソッド name が追加された時にインタプリタがこのメソッドを呼び出します。

特異メソッドの追加に対するフックには BasicObject#singleton_method_added を使います。

[PARAM] name:
追加されたメソッドの名前が Symbol で渡されます。
class Foo
  def Foo.method_added(name)
    puts "method \"#{name}\" was added"
  end

  def foo
  end
  define_method :bar, instance_method(:foo)
end

=> method "foo" was added
   method "bar" was added
method_removed(name) -> ()[permalink][rdoc]

メソッドが Module#remove_method により削除 された時にインタプリタがこのメソッドを呼び出します。

特異メソッドの削除に対するフックには BasicObject#singleton_method_removed を使います。

[PARAM] name:
削除されたメソッド名が Symbol で渡されます。
class Foo
  def Foo.method_removed(name)
    puts "method \"#{name}\" was removed"
  end

  def foo
  end
  remove_method :foo
end

=> method "foo" was removed
method_undefined(name) -> ()[permalink][rdoc]

このモジュールのインスタンスメソッド name が Module#undef_method によって削除されるか、 undef 文により未定義にされると、インタプリタがこのメソッドを呼び出します。

特異メソッドの削除をフックするには BasicObject#singleton_method_undefined を使います。

[PARAM] name:
削除/未定義にされたメソッド名が Symbol で渡されます。
class C
  def C.method_undefined(name)
    puts "method C\##{name} was undefined"
  end

  def foo
  end
  def bar
  end

  undef_method :foo
  undef bar
end

実行結果:

method C#foo was undefined
method C#bar was undefined
module_function(*name) -> self[permalink][rdoc]

メソッドをモジュール関数にします。

引数が与えられた時には、 引数で指定されたメソッドをモジュール関数にします。 引数なしのときは今後このモジュール定義文内で 新しく定義されるメソッドをすべてモジュール関数にします。

モジュール関数とは、プライベートメソッドであると同時に モジュールの特異メソッドでもあるようなメソッドです。 例えば Math モジュールのメソッドはすべてモジュール関数です。

self を返します。

[PARAM] name:
String または Symbol を 0 個以上指定します。

注意

module_function はメソッドに「モジュール関数」という属性をつけるメ ソッドではなく、プライベートメソッドとモジュールの特異メソッドの 2 つを同時に定義するメソッドです。 そのため、以下のように書いてもモジュール関数の別名は定義できません。

module M
  def foo
    p "foo"
  end
  module_function :foo
  alias bar foo
end

M.foo   # => "foo"
M.bar   # => undefined method `bar' for Foo:Module (NoMethodError)

このコードでは、モジュール関数 foo と プライベートインスタンスメソッド bar を定義してしまいます。

正しくモジュール関数に別名を付けるには、 以下のように、先に別名を定義してから それぞれをモジュール関数にしなければいけません。

module M
  def foo
    p "foo"
  end

  alias bar foo
  module_function :foo, :bar
end

M.foo   # => "foo"
M.bar   # => "foo"
prepend_features(mod) -> self[permalink][rdoc]

Module#prepend から呼び出されるメソッドで、 prepend の処理の実体です。このメソッド自体は mod で指定した モジュール/クラスの継承チェインの先頭に self を追加します。

このメソッドを上書きすることで、prepend の処理を変更したり 追加したりすることができます。

[PARAM] mod:
prepend を呼び出したモジュール
[RETURN]
mod が返されます
prepended(class_or_module) -> ()[permalink][rdoc]

self が Module#prepend されたときに対象のクラスまたはモジュールを 引数にしてインタプリタがこのメソッドを呼び出します。

[PARAM] class_or_module:
Module#prepend を実行したオブジェクト
module A
  def self.prepended(mod)
    puts "#{self} prepended to #{mod}"
  end
end
module Enumerable
  prepend A
end
# => "A prepended to Enumerable"

[SEE_ALSO] Module#included, Module#prepend

private(*name) -> self[permalink][rdoc]

メソッドを private に設定します。

引数なしのときは今後このクラスまたはモジュール定義内で新規に定義さ れるメソッドを関数形式でだけ呼び出せるように(private)設定します。

引数が与えられた時には引数によって指定されたメソッドを private に 設定します。

[PARAM] name:
String または Symbol を 0 個以上指定します。
[EXCEPTION] NameError:
存在しないメソッド名を指定した場合に発生します。
class Foo
  def foo1() 1 end      # デフォルトでは public
  private               # 可視性を private に変更
  def foo2() 2 end      # foo2 は private メソッド
end

foo = Foo.new
p foo.foo1          # => 1
p foo.foo2          # => private method `foo2' called for #<Foo:0x401b7628> (NoMethodError)
private_constant(*name) -> self[permalink][rdoc]

name で指定した定数の可視性を private に変更します。

[PARAM] name:
0 個以上の StringSymbol を指定します。
[EXCEPTION] NameError:
存在しない定数を指定した場合に発生します。
[RETURN]
self を返します。

[SEE_ALSO] Module#public_constant, Object#untrusted?

protected(*name) -> self[permalink][rdoc]

メソッドを protected に設定します。

引数なしのときは今後このクラスまたはモジュール定義内で新規に定義さ れるメソッドを protected に設定します。

引数が与えられた時には引数によって指定されたメソッドを protected に設定します。

[PARAM] name:
String または Symbol を 0 個以上指定します。
[EXCEPTION] NameError:
存在しないメソッド名を指定した場合に発生します。
public(*name) -> self[permalink][rdoc]

メソッドを public に設定します。

引数なしのときは今後このクラスまたはモジュール定義内で新規に定義さ れるメソッドをどんな形式でも呼び出せるように(public)設定します。

引数が与えられた時には引数によって指定されたメソッドを public に設 定します。

[PARAM] name:
String または Symbol を 0 個以上指定します。
[EXCEPTION] NameError:
存在しないメソッド名を指定した場合に発生します。
def foo() 1 end
p foo             # => 1
# the toplevel default is private
p self.foo        # => private method `foo' called for #<Object:0x401c83b0> (NoMethodError)

def bar() 2 end
public :bar       # visibility changed (all access allowed)
p bar             # => 2
p self.bar        # => 2
public_constant(*name) -> self[permalink][rdoc]

name で指定した定数の可視性を public に変更します。

[PARAM] name:
0 個以上の StringSymbol を指定します。
[EXCEPTION] NameError:
存在しない定数を指定した場合に発生します。
[RETURN]
self を返します。

[SEE_ALSO] Module#private_constant, Object#untrusted?

refine(klass) { ... } -> Module[permalink][rdoc]

引数 klass で指定したクラスだけに対して、ブロックで指定した機能を提供で きるモジュールを定義します。定義した機能は Module#refine を使用せずに直 接 klass に対して変更を行う場合と異なり、限られた範囲のみ有効にできます。 そのため、既存の機能を局所的に修正したい場合などに用いる事ができます。

refinements 機能の詳細については以下を参照してください。

定義した機能は main.using, Module#using を実行した場合のみ 有効になります。

[PARAM] klass:
拡張する対象のクラスを指定します。
[RETURN]
ブロックで指定した機能を持つ無名のモジュールを返します。
class C
  def foo
    puts "C#foo"
  end
end

module M
  refine C do
    def foo
      puts "C#foo in M"
    end
  end
end

x = C.new
x.foo # => "C#foo"

using M

x = C.new
x.foo # => "C#foo in M"

[SEE_ALSO] main.using

remove_const(name) -> object[permalink][rdoc]

name で指定した定数を取り除き、その定数に設定されていた値を 返します。

[PARAM] name:
String または Symbol を指定します。
[RETURN]
引数で指定された定数に設定されていた値を返します。
[EXCEPTION] NameError:
引数で指定された定数がそのモジュールやクラスに定義されていない場合に発生します。
class Foo
  FOO = 1
  p remove_const(:FOO)    # => 1
  p FOO     # => uninitialized constant FOO at Foo (NameError)
end

組み込みクラス/モジュールを設定している定数や Kernel.#autoload を指定した(まだロードしてない)定数を含めて削除する事ができます。

取り除かれた定数は参照できなくなりますが、消える訳ではないので注意して 使用してください。

[SEE_ALSO] Module#remove_class_variable, Object#remove_instance_variable

remove_method(*name) -> self[permalink][rdoc]

インスタンスメソッド name をモジュールから削除します。

Ruby 1.8.0 以降は複数のメソッド名を指定して一度に削除できます。

[PARAM] name:
0 個以上の StringSymbol を指定します。
[EXCEPTION] NameError:
指定したメソッドが定義されていない場合に発生します。
class C
  def foo
  end

  remove_method :foo
  remove_method :no_such_method   # 例外 NameError が発生
end

[SEE_ALSO] Module#undef_method

singleton_class? -> bool[permalink][rdoc]

self が特異クラスの場合に true を返します。そうでなければ false を返し ます。

class C
end
C.singleton_class?                  # => false
C.singleton_class.singleton_class?  # => true
undef_method(*name) -> self[permalink][rdoc]

このモジュールのインスタンスメソッド name を未定義にします。

[PARAM] name:
0 個以上の StringSymbol を指定します。
[EXCEPTION] NameError:
指定したインスタンスメソッドが定義されていない場合に発生します。

「未定義にする」とは

このモジュールのインスタンスに対して name という メソッドを呼び出すことを禁止するということです。 スーパークラスの定義が継承されるかどうかという点において、 「未定義」は「メソッドの削除」とは区別されます。 以下のコード例を参照してください。

class A
  def ok
    puts 'A'
  end
end
class B < A
  def ok
    puts 'B'
  end
end

B.new.ok   # => B

# undef_method の場合はスーパークラスに同名のメソッドがあっても
# その呼び出しはエラーになる
class B
  undef_method :ok
end
B.new.ok   # => NameError

# remove_method の場合はスーパークラスに同名のメソッドがあると
# それが呼ばれる
class B
  remove_method :ok
end
B.new.ok   # => A

また、undef 文と undef_method の違いは、 メソッド名を String または Symbol で与えられることです。

module M1
  def foo
  end
  def self.moo
    undef foo
  end
end
M1.instance_methods false #=> ["foo"]
M1.moo
M1.instance_methods false #=> []
module M2
  def foo
  end
  def self.moo
    undef_method :foo
  end
end
M2.instance_methods false #=> ["foo"]
M2.moo
M2.instance_methods false #=> []
using(module) -> self[permalink][rdoc]

引数で指定したモジュールで定義された拡張を現在のクラス、モジュールで有 効にします。

有効にした拡張の有効範囲については以下を参照してください。

[PARAM] module:
有効にするモジュールを指定します。

[SEE_ALSO] Module#refine, main.using