class Module (Ruby 4.0 リファレンスマニュアル)

要約

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

特異メソッド

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 Company
  module Department
    module Team
      p Module.nesting   # => [Company::Department::Team, Company::Department, Company]
    end
  end
end

new -> Module[permalink][rdoc][edit]

new {|mod| ... } -> Module

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

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

例

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

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

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

このメソッドで生成された直後のモジュールは無名で、最初にいずれかの定数に代入された時点で名前が確定します (Module#name を参照)。

例

m = Module.new
p m               # => #<Module 0lx40198a54>
p m.name          # => nil   # まだ名前は未定
Utils = m
p m.name          # => "Utils"   # 最初に代入された定数名で確定する
Helpers = m
p m.name          # => "Utils"   # 一度確定した名前は変わらない

used_modules -> [Module]Ruby 2.4.0 から[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 Flyable
end
class Bird
  include Flyable
end
class Eagle < Bird
end
class Fish
end
p Bird < Flyable        # => true
p Eagle < Bird          # => true
p Eagle < Flyable       # => true
p Eagle < Fish          # => nil
p Eagle > Fish          # => nil
Flyable < 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 Awesome; end
module Included
  include Awesome
end
module Prepended
  prepend Awesome
end

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

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

p Awesome <= Awesome # => true
p Awesome <= Object # => nil

self <=> other -> -1 | 0 | 1 | nil[permalink][rdoc][edit]

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

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

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

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

[PARAM] other:: 比較対象のクラスやモジュール

例

module Flyable
end
class Bird
  include Flyable
end
class Eagle < Bird
end
class Fish
end
p Bird <=> Flyable      # => -1
p Eagle <=> Bird        # => -1
p Eagle <=> Flyable     # => -1
p Eagle <=> Fish        # => nil
p Fish <=> Eagle        # => nil

p Eagle <=> 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

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

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

p Awesome > Awesome # => false
p 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 Awesome; end
module Included
  include Awesome
end
module Prepended
  prepend Awesome
end

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

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

p Awesome >= Awesome # => true
p Awesome >= Object # => nil

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

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

例

module Kernel
  p alias_method :hoge, :puts # => :hoge
  p alias_method "foo", :puts # => :foo
end

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

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

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

[PARAM] new:: 新しいメソッド名。String または Symbol で指定します。
[PARAM] original:: 元のメソッド名。String または Symbol で指定します。
[RETURN]: 作成したエイリアスのメソッド名を表す Symbol を返します。

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

例

module Kernel
  alias_method :foo, :puts
end

foo "bar" # bar

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

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

例

module Drivable
end
class Vehicle
  include Drivable
end
class Car < Vehicle
  p ancestors
  p included_modules
  p superclass
end
# => [Car, Vehicle, Drivable, Object, Kernel, BasicObject]
# => [Drivable, Kernel]
# => Vehicle

[SEE_ALSO] Module#included_modules

attr(*name) -> [Symbol][permalink][rdoc][edit]

attr(name, true) -> [Symbol]

attr(name, false) -> [Symbol]

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

例

class User
  p attr :name # => [:name]
  # 複数の名前を渡すこともできる
  p attr :id, :age # => [:id, :age]
end

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

例

def name
  @name
end

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

例

def name=(val)
  @name = val
end

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

[PARAM] name:: String または Symbol で指定します。
[RETURN]: 定義されたメソッド名を Symbol の配列で返します。

attr_accessor(*name) -> [Symbol][permalink][rdoc][edit]

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

例

class User
  p attr_accessor :name # => [:name, :name=]
  # 複数の名前を渡すこともできる
  p attr_accessor :id, :age # => [:id, :id=, :age, :age=]
end

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

例

def name
  @name
end
def name=(val)
  @name = val
end

[PARAM] name:: String または Symbol を 1 つ以上指定します。
[RETURN]: 定義されたメソッド名を Symbol の配列で返します。

attr_reader(*name) -> [Symbol][permalink][rdoc][edit]

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

例

class User
  p attr_reader :name # => [:name]
  # 複数の名前を渡すこともできる
  p attr_reader :id, :age # => [:id, :age]
end

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

例

def name
  @name
end

[PARAM] name:: String または Symbol を 1 つ以上指定します。
[RETURN]: 定義されたメソッド名を Symbol の配列で返します。

attr_writer(*name) -> [Symbol][permalink][rdoc][edit]

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

例

class User
  p attr_writer :name # => [:name=]
  # 複数の名前を渡すこともできる
  p attr_writer :id, :age # => [:id=, :age=]
end

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

例

def name=(val)
  @name = val
end

[PARAM] name:: String または Symbol を 1 つ以上指定します。
[RETURN]: 定義されたメソッド名を Symbol の配列で返します。

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

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

const_name が autoload 設定されていて、まだ定義されてない(ロードされていない)ときは、 autoload する対象を置き換えます。 const_name が(autoloadではなく)既に定義されているときは何もしません。

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

例

# ------- /tmp/zoo.rb ---------
class Zoo
  class Animal
  end
end
# ----- end of /tmp/zoo.rb ----

class Zoo
  autoload :Animal, '/tmp/zoo'
end
p Zoo::Animal # => Zoo::Animal

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

例

# ------- /tmp/zoo.rb ---------
class Zoo
  class Animal
  end
end
# ----- end of /tmp/zoo.rb ----

class Zoo
end
Zoo.autoload :Animal, '/tmp/zoo'
p Zoo::Animal # => Zoo::Animal

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

例

# ------- /tmp/animal.rb ---------
class Animal
end
# ----- end of /tmp/animal.rb ----

class Zoo
  autoload :Animal, '/tmp/animal.rb'
end
Zoo::Animal
# => -:4:in '<main>': uninitialized constant Zoo::Animal (NameError)

[SEE_ALSO] Kernel?.autoload

autoload?(const_name, inherit = true) -> String | nil[permalink][rdoc][edit]

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

[PARAM] const_name:: String または Symbol で指定します。
[PARAM] inherit:: false にすると、スーパークラスや include したモジュールで定義された autoload を検索対象にしません。

[SEE_ALSO] Kernel?.autoload?

例

autoload :Date, 'date'

p autoload?(:Date) # => "date"
Date
p autoload?(:Date) # => nil
p autoload?(:Foo) # => nil

例: inherit引数

class Parent
  autoload :Logger, "logger"
end

class Child < Parent
end

p Child.autoload?(:Logger)        # => "logger"
p Child.autoload?(:Logger, false) # => 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]

定数のスコープが異なる例

class C
end

# ブロックが渡された場合は、ブロックの外側のスコープになる。
# つまり、この場合はトップレベルに定数 X を定義する。
C.class_eval { X = 1 }

# 文字列が渡された場合は、モジュール定義式内と同じスコープになる。つまり、この場合は
# class C
#   X = 2
# end
# と書いたのと同じ意味になる。
C.class_eval 'X = 2'

p X    #=> 1
p C::X #=> 2

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

module_exec(*args) {|*vars| ... } -> object[permalink][rdoc][edit]

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

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

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

[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_defined?(name) -> bool[permalink][rdoc][edit]

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

[PARAM] name:: Symbol か String を指定します。

例

class Fred
  @@foo = 99
end
p Fred.class_variable_defined?(:@@foo)  #=> true
p Fred.class_variable_defined?(:@@bar)  #=> false
p Fred.class_variable_defined?('@@foo')  #=> true
p Fred.class_variable_defined?('@@bar')  #=> false

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

class_variables(inherit = true) -> [Symbol][permalink][rdoc][edit]

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

[PARAM] inherit:: false を指定しない場合はスーパークラスやインクルードしているモジュールのクラス変数を含みます。

例

class One
  @@var1 = 1
end
class Two < One
  @@var2 = 2
end
p One.class_variables        # => [:@@var1]
p Two.class_variables        # => [:@@var2, :@@var1]
p 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
  ANSWER = 42
end

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

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

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

# 第二引数を false にした場合
p Robot.const_defined?(:HELLO, false)   # => false

const_get(name, inherit = true) -> object[permalink][rdoc][edit]

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

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

[PARAM] name:: 定数名。String か Symbol で指定します。完全修飾名を指定しなかった場合はモジュールに定義されている name で指定される名前の定数の値を取り出します。
[PARAM] inherit:: false を指定するとスーパークラスや include したモジュールで定義された定数は対象にはなりません。
[EXCEPTION] NameError:: 定数が定義されていないときに発生します。

例

module Loggable
  LEVEL = 1
end
class Object
  include Loggable
end
# Object では include されたモジュールに定義された定数を見付ける
p Object.const_get(:LEVEL)            # => 1

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

const_missing(name)[permalink][rdoc][edit]

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

[PARAM] name:: 参照した定数名の Symbol
[EXCEPTION] NameError:: このメソッドを呼び出した場合、デフォルトで発生する例外

例

class Application
  def Application.const_missing(id)
    warn "undefined constant #{id.inspect}"
  end

  Timezone
end
Application::Timezone

# => undefined constant :Timezone
#    undefined constant :Timezone

const_set(name, value) -> object[permalink][rdoc][edit]

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

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

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

例

module Config; end

# Symbolを指定した場合
Config.const_set(:VERSION, 123)
p Config::VERSION # => 123

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

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

# 不適切な定数名を指定した場合
Config.const_set('name', 1) # ~> NameError: wrong constant name name

const_source_location(name, inherited = true) -> [String, Integer]Ruby 2.7.0 から[permalink][rdoc][edit]

name で指定した定数の定義を含むソースコードのファイル名と行番号を配列で返します。

[PARAM] name:: Symbol,String で定数の名前を指定します。
[PARAM] inherited:: true を指定するとスーパークラスや include したモジュールで定義された定数が対象にはなります。false を指定した場合対象にはなりません。
[RETURN]: ソースコードのファイル名と行番号を配列で返します。指定した定数が見つからない場合は nil を返します。定数は見つかったがソースファイルが見つからなかった場合は空の配列を返します。

例

# 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 # 継続して A を定義する
  C2 = 8 # 定数を再定義する
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  -- include したモジュールは検索しない

p A.const_source_location('C2')           # => ["test.rb", 16] -- 最後に定義された位置を返す

p Object.const_source_location('B')       # => ["test.rb", 10] -- Object はトップレベルの定数を検索する
p Object.const_source_location('A')       # => ["test.rb", 1] -- クラスが再定義された場合は最初の定義位置を返す

p B.const_source_location('A')            # => ["test.rb", 1]  -- Object を継承している為
p M.const_source_location('A')            # => ["test.rb", 1]  -- Object は継承していないが追加で modules をチェックする

p Object.const_source_location('A::C1')   # => ["test.rb", 2]  -- ネストの指定もサポートしている
p Object.const_source_location('String')  # => []  -- 定数は C のコードで定義されている

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 Circle
  PI = 3.14
end
class Shape
  SIDES = 4

  # Shape は SIDES を含む
  p constants                         # => [:SIDES]
  # 出力に PI は含まれない
  p Module.constants - $clist         # => [:SIDES, :Circle, :Shape]
  class Square
    # Square は定数を含まない
    p constants                       # => []

    # ネストしたクラスでは、外側のクラスで定義した定数は
    # 参照可能なので、SIDES は、Module.constants には含まれる
    # (クラス Square も Shape の定数なので同様)
    p Module.constants - $clist       # => [:Square, :SIDES, :Circle, :Shape]
  end
end

define_method(name, method) -> Symbol[permalink][rdoc][edit]

define_method(name) { ... } -> Symbol

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

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

[PARAM] name:: メソッド名を String または Symbol を指定します。
[PARAM] method:: Proc、Method あるいは UnboundMethod のいずれかのインスタンスを指定します。
[RETURN]: メソッド名を表す Symbol を返します。
[EXCEPTION] TypeError:: method に同じクラス、サブクラス、モジュール以外のメソッドを指定した場合に発生します。

例

class Foo
  def foo() p :foo end
  define_method(:bar, instance_method(:foo))
end
p Foo.new.bar  # => :foo

deprecate_constant(*name) -> selfRuby 2.3.0 から[permalink][rdoc][edit]

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

Ruby 2.7.2 から Warning[:deprecated] のデフォルト値が false に変更になったため、デフォルトでは警告が表示されません。

コマンドラインオプション(詳細はRubyの起動/コマンドラインオプション参照)で、「-w」か「-W2」などを指定するか、実行中に「Warning[:deprecated] = true」で変更すると表示されるようになります。

「$VERBOSE = true」は「Warning[:deprecated]」に影響しないため、表示されるかどうかは変わりません。

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

例

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

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

Object.deprecate_constant(:BAR)
# NameError: constant Object::BAR not defined

freeze -> self[permalink][rdoc][edit]

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

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

[SEE_ALSO] Object#freeze

例

module Settings; end
Settings.freeze

module Settings
  def foo; end
end # ~> FrozenError: can't modify frozen module: Settings

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

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

[SEE_ALSO] Module#ancestors

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

to_s -> String

inspect -> String

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

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

Module.new や Class.new で生成した直後の無名のモジュール / クラスは、最初にいずれかの定数に代入された時点で名前が確定します。一度確定した名前は、その定数を remove_const で取り除いたり、そのモジュール / クラスを別の定数へ代入し直したりしても変わりません。返り値の文字列は freeze されています。

[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>"

# 名前は最初に代入された定数で確定し、以後は変わらない
c = Class.new
p c.name         #=> nil
Foo = c
p c.name         #=> "Foo"
Bar = c
p c.name         #=> "Foo"
p c.name.frozen? #=> true

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, Module#public_instance_methods, Module#private_instance_methods, Module#protected_instance_methods

例1

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

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

class Kitten < Cat
end

実行結果

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

例2

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

# あるクラスのインスタンスメソッドの一覧を得る。
# 親のクラスのインスタンスメソッドも含めるため true を指定して
# いるが、Object のインスタンスメソッドは一覧から排除している。
p Dog.instance_methods(true)           - Object.instance_methods(true)
p Dog.public_instance_methods(true)    - Object.public_instance_methods(true)
p Dog.private_instance_methods(true)   - Object.private_instance_methods(true)
p Dog.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:: Symbol か String を指定します。
[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

p A.method_defined? :method1            #=> true
p C.method_defined? "method1"           #=> true
p C.method_defined? "method2"           #=> true
p C.method_defined? "method2", true     #=> true
p C.method_defined? "method2", false    #=> false
p C.method_defined? "method3"           #=> true
p C.method_defined? "protected_method1" #=> true
p C.method_defined? "method4"           #=> false
p C.method_defined? "private_method2"   #=> false

prepend(*modules) -> selfRuby 1.9.3 から[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]

private_class_method(names) -> self

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

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

例

module Gadget
  def self.foo; end
end

p Gadget.singleton_class.private_method_defined?(:foo) # => false
p Gadget.private_class_method(:foo) # => Gadget
p Gadget.singleton_class.private_method_defined?(:foo) # => true

private_constant(*name) -> selfRuby 1.9.3 から[permalink][rdoc][edit]

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

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

[SEE_ALSO] Module#public_constant

例

module Api
  VERSION = '1.0'
  class Client; end
  SECRET = 'token'
  class Internal; end

  private_constant :SECRET
  private_constant :Internal
end

p Api::VERSION  # => "1.0"
p Api::Client   # => Api::Client
Api::SECRET     # ~> NameError: private constant Api::SECRET referenced
Api::Internal   # ~> NameError: private constant Api::Internal referenced

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

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

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

[SEE_ALSO] Object#private_methods, Module#instance_methods, Module#public_instance_methods, Module#protected_instance_methods

例

module Taggable
  def foo; end
  private def bar; end
end

module Sortable
  include Taggable

  def baz; end
  private def qux; end
end

p Sortable.private_instance_methods # => [:qux, :bar]
p Sortable.private_instance_methods(false) # => [:qux]

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

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

[PARAM] name:: Symbol か String を指定します。
[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

p A.method_defined? :method1                 #=> true
p C.private_method_defined? "method1"        #=> false
p C.private_method_defined? "method2"        #=> true
p C.private_method_defined? "method2", true  #=> true
p C.private_method_defined? "method2", false #=> false
p 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, Module#public_instance_methods, Module#private_instance_methods

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

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

[PARAM] name:: Symbol か String を指定します。
[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

p A.method_defined? :method1                  #=> true
p C.protected_method_defined? "method1"       #=> false
p C.protected_method_defined? "method2"       #=> true
p C.protected_method_defined? "method2", true #=> true
p C.protected_method_defined? "method2", false  #=> false
p C.method_defined? "method2"                 #=> true

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

public_class_method(names) -> self

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

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

例

class Factory
  def self.foo
    "foo"
  end

  private_class_method :foo
end

Factory.foo # NoMethodError: private method 'foo' called for class Factory

p Factory.public_class_method(:foo) # => Factory
p Factory.foo # => "foo"

public_constant(*name) -> selfRuby 1.9.3 から[permalink][rdoc][edit]

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

[PARAM] name:: 0 個以上の String か Symbol を指定します。
[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

p SampleModule::SampleInnerClass # => SampleModule::SampleInnerClass

[SEE_ALSO] Module#private_constant

public_instance_method(name) -> UnboundMethodRuby 1.9.3 から[permalink][rdoc][edit]

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

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

例

p 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, Module#private_instance_methods, Module#protected_instance_methods

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

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

[PARAM] name:: Symbol か String を指定します。
[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

p A.method_defined? :method1               #=> true
p C.public_method_defined? "method1"       #=> true
p C.public_method_defined? "method1", true #=> true
p C.public_method_defined? "method1", false  #=> true
p C.public_method_defined? "method2"       #=> false
p C.method_defined? "method2"              #=> true

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

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

[PARAM] name:: String または Symbol を指定します。
[RETURN]: 引数で指定されたクラス変数に設定されていた値を返します。
[EXCEPTION] NameError:: 引数で指定されたクラス変数がそのモジュールやクラスに定義されていない場合に発生します。

例

class Counter
  @@count = 1
  p remove_class_variable(:@@count) # => 1
  @@count     # => uninitialized class variable @@count in Counter (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 個以上の String か Symbol を指定します。
[EXCEPTION] NameError:: 指定したメソッドが定義されていない場合に発生します。

例

class C
  def foo
  end

  remove_method :foo
  remove_method :no_such_method   # ~> NameError
end

[SEE_ALSO] Module#undef_method

singleton_class? -> boolRuby 2.1.0 から[permalink][rdoc][edit]

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

例

class C
end
p C.singleton_class?                # => false
p C.singleton_class.singleton_class?  # => true

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

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

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

「未定義にする」とは

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

例

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

p B.new.ok # => B

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

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

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

例

module M1
  def foo
  end
  def self.moo
    undef foo
  end
end
p M1.instance_methods false #=> ["foo"]
M1.moo
p M1.instance_methods false #=> []
module M2
  def foo
  end
  def self.moo
    undef_method :foo
  end
end
p M2.instance_methods false #=> ["foo"]
M2.moo
p 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

const_added(name) -> ()Ruby 3.2 から[permalink][rdoc][edit]

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

module Chatty
  def self.const_added(const_name)
    super
    puts "Added #{const_name.inspect}"
  end
  FOO = 1
end
# => Added :FOO

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 Debuggable
  def self.extended(obj)
    p "#{obj} extend #{self}"
  end
end

Object.new.extend Debuggable

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

[SEE_ALSO] Module#extend_object

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

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

[PARAM] class_or_module:: Module#include を実行したオブジェクト

例

module Trackable
  def self.included(mod)
    p "#{mod} include #{self}"
  end
end
class Report
  include Trackable
end
# => "Report include Trackable"

[SEE_ALSO] Module#append_features

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

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

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

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

例

class Watcher
  def Watcher.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 Watcher
  def Watcher.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() -> nil[permalink][rdoc][edit]

module_function(name) -> String | Symbol

module_function(*name) -> Array

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

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

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

単一の引数が与えられた時には与えられた引数をそのまま返します。複数の引数が与えられた時には配列にまとめて返します。引数なしの時は nil を返します。

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

注意

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

例

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

p M.foo # => "foo"
M.bar   # => undefined method 'bar' for module M (NoMethodError)

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

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

例

module M
  def foo
    p "foo"
  end

  alias bar foo
  module_function :foo, :bar
end

p M.foo # => "foo"
p M.bar # => "foo"

prepend_features(mod) -> selfRuby 2.0.0 から[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

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

[SEE_ALSO] Module#prepend, Module#prepended

prepended(class_or_module) -> ()Ruby 2.0.0 から[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() -> nil[permalink][rdoc][edit]

private(name) -> String | Symbol

private(*name) -> Array

private(names) -> Array

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

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

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

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

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

例

class Account
  def foo1() 1 end      # デフォルトでは public
  private               # 可視性を private に変更
  def foo2() 2 end      # foo2 は private メソッド
end

account = Account.new
p account.foo1          # => 1
account.foo2            # => private method 'foo2' called for an instance of Account (NoMethodError)

protected() -> nil[permalink][rdoc][edit]

protected(name) -> String | Symbol

protected(*name) -> Array

protected(names) -> Array

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

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

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

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

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

[SEE_ALSO] Module#protected_method_defined?

public() -> nil[permalink][rdoc][edit]

public(name) -> String | Symbol

public(*name) -> Array

public(names) -> Array

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

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

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

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

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

例

def foo() 1 end
p foo             # => 1
# the toplevel default is private
# (Ruby 2.7 以降、レシーバが self そのものの呼び出しは private でも可能なため
#  self.foo はエラーにならない。別のオブジェクトをレシーバにすると呼び出せない)
Object.new.foo    # => private method 'foo' called for an instance of Object (NoMethodError)

def bar() 2 end
public :bar       # visibility changed (all access allowed)
p bar             # => 2
p Object.new.bar  # => 2

refine(klass) { ... } -> ModuleRuby 2.0.0 から[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
p x.foo # => "C#foo"

using M

x = C.new
p 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 Registry
  VALUE = 1
  p remove_const(:VALUE)    # => 1
  VALUE       # => uninitialized constant Registry::VALUE (NameError)
end

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

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

[SEE_ALSO] Module#remove_class_variable, Object#remove_instance_variable

ruby2_keywords(method_name, ...) -> nilRuby 2.7.0 から[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

using(module) -> selfRuby 2.1.0 から[permalink][rdoc][edit]

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

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

https://docs.ruby-lang.org/en/master/syntax/refinements_rdoc.html#label-Scope

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

[SEE_ALSO] Module#refine, main.using

追加されるメソッド

rake_extension(method) { ... } -> ()Ruby 1.9.3 から[permalink][rdoc][edit] [added by rake]

与えられたブロック内で既に存在するメソッドを再定義しようとした場合に警告を表示します。この場合、ブロックは評価されません。

[PARAM] method:: ブロック内で再定義する予定のメソッド名を指定します。

例

class String
  rake_extension("xyz") do
    def xyz
      # ...
    end
  end
end

要約

目次

特異メソッド

インスタンスメソッド

「未定義にする」とは

privateメソッド

注意

追加されるメソッド