class Module

[edit]

要約

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

目次

特異メソッド
インスタンスメソッド
privateメソッド

特異メソッド

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

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

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][edit]

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

module Foo
  module Bar
    module Baz
      p Module.nesting   # => [Foo::Bar::Baz, Foo::Bar, Foo]
    end
  end
end
new -> Module[permalink][rdoc][edit]
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" のどちらかに決まる
used_modules -> [Module][permalink][rdoc][edit]

現在のスコープで using されているすべてのモジュールを配列で返します。配列内のモジュールの順番は未定義です。

module A
  refine Object do
  end
end

module B
  refine Object do
  end
end

using A
using B
p Module.used_modules
#=> [B, A]

インスタンスメソッド

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

比較演算子。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][edit]

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

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

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

[SEE_ALSO] Module#<

例:

module Foo; end
module Bar
  include Foo
end
module Baz
  prepend Foo
end

Bar.ancestors # => [Bar, Foo]
Foo <= Bar # => false
Bar <= Foo # => true

Baz.ancestors # => [Foo, Baz]
Foo <= Baz # => false
Baz <= Foo # => true

Foo <= Foo # => true
Foo <= Object # => nil
self <=> other -> Integer | nil[permalink][rdoc][edit]

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][edit]

指定された 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][edit]

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

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

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

[SEE_ALSO] Module#<

例:

module Awesome; end
module Included
  include Awesome
end
module Prepended
  prepend Awesome
end

Included.ancestors # => [Included, Awesome]
Awesome > Included # => true
Included > Awesome # => false

Prepended.ancestors # => [Awesome, Prepended]
Awesome > Prepended # => true
Prepended > Awesome # => false

Awesome > Awesome # => false
Awesome > Object # => nil
self >= other -> bool | nil[permalink][rdoc][edit]

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

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

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

[SEE_ALSO] Module#<

例:

module Foo; end
module Bar
  include Foo
end
module Baz
  prepend Foo
end

Bar.ancestors # => [Bar, Foo]
Foo >= Bar # => true
Bar >= Foo # => false

Baz.ancestors # => [Foo, Baz]
Foo >= Baz # => true
Baz >= Foo # => false

Foo >= Foo # => true
Foo >= Object # => nil
alias_method(new, original) -> self[permalink][rdoc][edit]

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

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

  • メソッド名は String または Symbol で指定します
  • グローバル変数の別名をつけることはできません

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

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

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

例:

module Kernel
  alias_method :foo, :puts
end

foo "bar" # bar
ancestors -> [Class, Module][permalink][rdoc][edit]

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

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

attr(*name) -> nil[permalink][rdoc][edit]
attr(name, true) -> nil
attr(name, false) -> nil

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

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

def name
  @name
end

第 2 引数 が true で指定された場合には、属性の書き込み用メソッド name= も同時に定義されます。その定義は次の通りです。

def name=(val)
  @name = val
end

第 2 引数 に true か false を指定する方法は非推奨です。

[PARAM] name:
String または Symbol で指定します。
attr_accessor(*name) -> nil[permalink][rdoc][edit]

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

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

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

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

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

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

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

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

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

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

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

# ------- /tmp/foo.rb ---------
class Foo
  class Bar
  end
end
# ----- end of /tmp/foo.rb ----

class Foo
  autoload :Bar, '/tmp/foo'
end
p Foo::Bar #=> Foo::Bar

以下のようにモジュールを明示的にレシーバとして呼び出すこともできます。


# ------- /tmp/foo.rb ---------
class Foo
  class Bar
  end
end
# ----- end of /tmp/foo.rb ----

class Foo
end
Foo.autoload :Bar, '/tmp/foo'
p Foo::Bar #=> Foo::Bar

以下のように、autoload したライブラリがネストした定数を定義しない場合、NameError が発生します。


# ------- /tmp/bar.rb ---------
class Bar
end
# ----- end of /tmp/bar.rb ----

class Foo
  autoload :Bar, '/tmp/bar.rb'
end
p Foo::Bar
#=> -:4:in `<main>': uninitialized constant Foo::Bar (NameError)

[SEE_ALSO] Kernel.#autoload

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

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

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

[SEE_ALSO] Kernel.#autoload?

例:

autoload :Date, 'date'

autoload?(:Date) # => "date"
Date
autoload?(:Date) # => nil
autoload?(:Foo) # => nil
module_eval(expr, fname = "(eval)", lineno = 1) -> object[permalink][rdoc][edit]
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][edit]

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][edit]

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

[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][edit]

モジュールに 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][edit]

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][edit]

定義されていない定数を参照したときに 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][edit]

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

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

[PARAM] name:
Symbol,String で定数の名前を指定します。
[PARAM] value:
セットしたい値を指定します。

例:

module Foo; end

# Symbolを指定した場合
Foo.const_set(:FOO, 123)
Foo::FOO # => 123

# Stringを指定した場合
Foo.const_set('BAR', 'abc')
Foo::BAR # => "abc"

# 既に定義されている定数の名前を指定した場合
Foo.const_set('BAR', '123')
# warning: already initialized constant Foo::BAR
# warning: previous definition of BAR was here
# => "123"

# 不適切な定数名を指定した場合
Foo.const_set('foo', 1) # => NameError: wrong constant name foo
const_source_location(sym, inherit=true) -> [String, Integer][permalink][rdoc][edit]
const_source_location(str, inherit=true) -> [String, Integer]

Returns the Ruby source filename and line number containing the definition of the constant specified. If the named constant is not found, `nil` is returned. If the constant is found, but its source location can not be extracted (constant is defined in C code), empty array is returned.

*inherit* specifies whether to lookup in `mod.ancestors` (`true` by default).


# test.rb:
class A         # line 1
  C1 = 1
  C2 = 2
end

module M        # line 6
  C3 = 3
end

class B < A     # line 10
  include M
  C4 = 4
end

class A # continuation of A definition
  C2 = 8 # constant redefinition; warned yet allowed
end

p B.const_source_location('C4')           # => ["test.rb", 12]
p B.const_source_location('C3')           # => ["test.rb", 7]
p B.const_source_location('C1')           # => ["test.rb", 2]

p B.const_source_location('C3', false)    # => nil  -- don't lookup in ancestors

p A.const_source_location('C2')           # => ["test.rb", 16] -- actual (last) definition place

p Object.const_source_location('B')       # => ["test.rb", 10] -- top-level constant could be looked through Object
p Object.const_source_location('A')       # => ["test.rb", 1] -- class reopening is NOT considered new definition

p B.const_source_location('A')            # => ["test.rb", 1]  -- because Object is in ancestors
p M.const_source_location('A')            # => ["test.rb", 1]  -- Object is not ancestor, but additionally checked for modules

p Object.const_source_location('A::C1')   # => ["test.rb", 2]  -- nesting is supported
p Object.const_source_location('String')  # => []  -- constant is defined in C code
constants(inherit = true) -> [Symbol][permalink][rdoc][edit]

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

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
define_method(name, method) -> Symbol[permalink][rdoc][edit]
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
freeze -> self[permalink][rdoc][edit]

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

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

[SEE_ALSO] Object#freeze

例:

module Foo; end
Foo.freeze

module Foo
  def foo; end
end # => FrozenError: can't modify frozen module
include(*mod) -> self[permalink][rdoc][edit]

モジュール 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][edit]

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][edit]

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

module Mixin
end

module Outer
  include Mixin
end

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

[SEE_ALSO] Module#ancestors

name -> String | nil[permalink][rdoc][edit]
to_s -> String
inspect -> String

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

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

[RETURN]
名前のないモジュール / クラスに対しては、name は nil を、それ以外はオブジェクト ID の文字列を返します。
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
p Module.new.to_s   #=> "#<Module:0x00007f90b09112c8>"
p Class.new.to_s    #=> "#<Class:0x00007fa5c40b41b0>"
instance_method(name) -> UnboundMethod[permalink][rdoc][edit]

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

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

[SEE_ALSO] Module#public_instance_method, Object#method

例:

class Interpreter
  def do_a() print "there, "; end
  def do_d() print "Hello ";  end
  def do_e() print "!\n";     end
  def do_v() print "Dave";    end
  Dispatcher = {
    "a" => instance_method(:do_a),
    "d" => instance_method(:do_d),
    "e" => instance_method(:do_e),
    "v" => instance_method(:do_v)
  }
  def interpret(string)
    string.each_char {|b| Dispatcher[b].bind(self).call }
  end
end

interpreter = Interpreter.new
interpreter.interpret('dave')
# => Hello there, Dave!
instance_methods(inherited_too = true) -> [Symbol][permalink][rdoc][edit]

そのモジュールで定義されている 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, inherit=true) -> bool[permalink][rdoc][edit]

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

[PARAM] name:
SymbolString を指定します。
[PARAM] inherit:
真を指定するとスーパークラスや include したモジュールで定義されたメソッドも対象になります。

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



module A
  def method1()  end
  def protected_method1()  end
  protected :protected_method1
end
class B
  def method2()  end
  def private_method2()  end
  private :private_method2
end
class C < B
  include A
  def method3()  end
end

A.method_defined? :method1              #=> true
C.method_defined? "method1"             #=> true
C.method_defined? "method2"             #=> true
C.method_defined? "method2", true       #=> true
C.method_defined? "method2", false      #=> false
C.method_defined? "method3"             #=> true
C.method_defined? "protected_method1"   #=> true
C.method_defined? "method4"             #=> false
C.method_defined? "private_method2"     #=> false
prepend(*modules) -> self[permalink][rdoc][edit]

指定したモジュールを 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, Module#prepended

# 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][edit]

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

[PARAM] name:
0 個以上の StringSymbol を指定します。

例:

module Foo
  def self.foo; end
end

Foo.singleton_class.private_method_defined?(:foo) # => false
Foo.private_class_method(:foo) # => Foo
Foo.singleton_class.private_method_defined?(:foo) # => true
private_instance_methods(inherited_too = true) -> [Symbol][permalink][rdoc][edit]

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

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

[SEE_ALSO] Object#private_methods, Module#instance_methods

例:

module Foo
  def foo; end
  private def bar; end
end

module Bar
  include Foo

  def baz; end
  private def qux; end
end

Bar.private_instance_methods # => [:qux, :bar]
Bar.private_instance_methods(false) # => [:qux]
private_method_defined?(name, inherit=true) -> bool[permalink][rdoc][edit]

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

[PARAM] name:
SymbolString を指定します。
[PARAM] inherit:
真を指定するとスーパークラスや include したモジュールで定義されたメソッドも対象になります。

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



module A
  def method1()  end
end
class B
  private
  def method2()  end
end
class C < B
  include A
  def method3()  end
end

A.method_defined? :method1                   #=> true
C.private_method_defined? "method1"          #=> false
C.private_method_defined? "method2"          #=> true
C.private_method_defined? "method2", true    #=> true
C.private_method_defined? "method2", false   #=> false
C.method_defined? "method2"                  #=> false
protected_instance_methods(inherited_too = true) -> [Symbol][permalink][rdoc][edit]

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

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

[SEE_ALSO] Object#protected_methods, Module#instance_methods

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

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

[PARAM] name:
SymbolString を指定します。
[PARAM] inherit:
真を指定するとスーパークラスや include したモジュールで定義されたメソッドも対象になります。

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



module A
  def method1()  end
end
class B
  protected
  def method2()  end
end
class C < B
  include A
  def method3()  end
end

A.method_defined? :method1                    #=> true
C.protected_method_defined? "method1"         #=> false
C.protected_method_defined? "method2"         #=> true
C.protected_method_defined? "method2", true   #=> true
C.protected_method_defined? "method2", false  #=> false
C.method_defined? "method2"                   #=> true
public_class_method(*name) -> self[permalink][rdoc][edit]

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

[PARAM] name:
0 個以上の StringSymbol を指定します。

例:

class Foo
  def self.foo
    "foo"
  end

  private_class_method :foo
end

Foo.foo # NoMethodError: private method `foo' called for Foo:Class

Foo.public_class_method(:foo) # => Foo
Foo.foo # => "foo"
public_instance_method(name) -> UnboundMethod[permalink][rdoc][edit]

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][edit]

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

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

[SEE_ALSO] Object#public_methods, Module#instance_methods

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

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

[PARAM] name:
SymbolString を指定します。
[PARAM] inherit:
真を指定するとスーパークラスや include したモジュールで定義されたメソッドも対象になります。

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



module A
  def method1()  end
end
class B
  protected
  def method2()  end
end
class C < B
  include A
  def method3()  end
end

A.method_defined? :method1                 #=> true
C.public_method_defined? "method1"         #=> true
C.public_method_defined? "method1", true   #=> true
C.public_method_defined? "method1", false  #=> true
C.public_method_defined? "method2"         #=> false
C.method_defined? "method2"                #=> true
remove_class_variable(name) -> object[permalink][rdoc][edit]

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

[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

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

インスタンスメソッド 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

undef_method(*name) -> self[permalink][rdoc][edit]

このモジュールのインスタンスメソッド 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 #=> []

privateメソッド

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

モジュール(あるいはクラス)に 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

module_exec(*args) {|*vars| ... } -> object[permalink][rdoc][edit]
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][edit]

クラス/モジュールに定義されているクラス変数 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][edit]

クラス/モジュールにクラス変数 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
deprecate_constant(*name) -> self[permalink][rdoc][edit]

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

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

例:

FOO = 123
Object.deprecate_constant(:FOO) # => Object

FOO
# warning: constant ::FOO is deprecated
# => 123

Object.deprecate_constant(:BAR)
# NameError: constant Object::BAR not defined
extend_object(obj) -> object[permalink][rdoc][edit]

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][edit]

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][edit]

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][edit]

メソッド 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][edit]

メソッドが 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][edit]

このモジュールのインスタンスメソッド 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][edit]

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

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

モジュール関数とは、プライベートメソッドであると同時にモジュールの特異メソッドでもあるようなメソッドです。例えば 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][edit]

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

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

[PARAM] mod:
prepend を呼び出したモジュール
[RETURN]
mod が返されます


class Recorder
  RECORDS = []
end

module X
  def self.prepend_features(mod)
    Recorder::RECORDS << mod
  end
end

class A
  prepend X
end

class B
  include X
end

class C
  prepend X
end

Recorder::RECORDS # => [A, C]

[SEE_ALSO] Module#prepend, Module#prepended

prepended(class_or_module) -> ()[permalink][rdoc][edit]

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, Module#prepend_features

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

メソッドを 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][edit]

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

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

[SEE_ALSO] Module#public_constant, Object#untrusted?

例:

module Foo
  BAR = 'bar'
  class Baz; end
  QUX = 'qux'
  class Quux; end

  private_constant :QUX
  private_constant :Quux
end

Foo::BAR  # => "bar"
Foo::Baz  # => Foo::Baz
Foo::QUX  # => NameError: private constant Foo::QUX referenced
Foo::Quux # => NameError: private constant Foo::Quux referenced
protected(*name) -> self[permalink][rdoc][edit]

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

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

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

可視性については クラス/メソッドの定義/呼び出し制限 を参照して下さい。

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

[SEE_ALSO] Module#protected_method_defined?

public(*name) -> self[permalink][rdoc][edit]

メソッドを 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][edit]

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

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


module SampleModule
  class SampleInnerClass
  end

  # => 非公開クラスであることを明示するために private にする
  private_constant :SampleInnerClass
end

begin
  SampleModule::SampleInnerClass
rescue => e
  e # => #<NameError: private constant SampleModule::SampleInnerClass referenced>
end

module SampleModule
  # => 非公開クラスであることは承知で利用するために public にする
  public_constant :SampleInnerClass
end

SampleModule::SampleInnerClass # => SampleModule::SampleInnerClass

[SEE_ALSO] Module#private_constant, Object#untrusted?

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

引数 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][edit]

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

ruby2_keywords(method_name, ...) -> self[permalink][rdoc][edit]

For the given method names, marks the method as passing keywords through a normal argument splat. This should only be called on methods that accept an argument splat (`*args`) but not explicit keywords or a keyword splat. It marks the method such that if the method is called with keyword arguments, the final hash argument is marked with a special flag such that if it is the final element of a normal argument splat to another method call, and that method call does not include explicit keywords or a keyword splat, the final element is interpreted as keywords. In other words, keywords will be passed through the method to other methods.

This should only be used for methods that delegate keywords to another method, and only for backwards compatibility with Ruby versions before 2.7.

This method will probably be removed at some point, as it exists only for backwards compatibility. As it does not exist in Ruby versions before 2.7, check that the module responds to this method before calling it. Also, be aware that if this method is removed, the behavior of the method will change so that it does not pass through keywords.


module Mod
  def foo(meth, *args, &block)
    send(:"do_#{meth}", *args, &block)
  end
  ruby2_keywords(:foo) if respond_to?(:ruby2_keywords, true)
end
singleton_class? -> bool[permalink][rdoc][edit]

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

class C
end
C.singleton_class?                  # => false
C.singleton_class.singleton_class?  # => true
using(module) -> self[permalink][rdoc][edit]

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

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

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

[SEE_ALSO] Module#refine, main.using