Class: Module
Relationships & Source Files | |
Extension / Inclusion / Inheritance Descendants | |
Subclasses:
|
|
Inherits: | Object |
Defined in: | class.c, eval.c, load.c, object.c, proc.c, variable.c, vm_eval.c, vm_method.c |
Overview
A Module
is a collection of methods and constants. The methods in a module may be instance methods or module methods. Instance methods appear as methods in a class when the module is included, module methods do not. Conversely, module methods may be called without creating an encapsulating object, while instance methods may not. (See #module_function.)
In the descriptions that follow, the parameter sym refers to a symbol, which is either a quoted string or a ::Symbol (such as :name
).
module Mod
include Math
CONST = 1
def meth
# ...
end
end
Mod.class #=> Module
Mod.constants #=> [:CONST, :PI, :E]
Mod.instance_methods #=> [:meth]
Class Method Summary
-
.constants ⇒ Array
In the first form, returns an array of the names of all constants accessible from the point of call.
-
.nesting ⇒ Array
Returns the list of
Modules
nested at the point of call. -
.new ⇒ mod
constructor
Creates a new anonymous module.
Instance Attribute Summary
-
#singleton_class? ⇒ Boolean
readonly
Returns
true
if mod is a singleton class orfalse
if it is an ordinary class or module.
Instance Method Summary
-
#<(other) ⇒ true, ...
Returns true if mod is a subclass of other.
-
#<=(other) ⇒ true, ...
Returns true if mod is a subclass of other or is the same as other.
-
#<=>(other_module) ⇒ 1, ...
Comparison—Returns -1, 0, +1 or nil depending on whether
module
includesother_module
, they are the same, or ifmodule
is included byother_module
. -
#==(other) ⇒ Boolean
Alias for Object#eql?.
-
#===(obj) ⇒ Boolean
Case Equality—Returns
true
if obj is an instance of mod or and instance of one of mod's descendants. -
#>(other) ⇒ true, ...
Returns true if mod is an ancestor of other.
-
#>=(other) ⇒ true, ...
Returns true if mod is an ancestor of other, or the two modules are the same.
-
#ancestors ⇒ Array
Returns a list of modules included/prepended in mod (including mod itself).
-
#autoload(module, filename) ⇒ nil
Registers filename to be loaded (using Kernel.require) the first time that module (which may be a ::String or a symbol) is accessed in the namespace of mod.
-
#autoload?(name) ⇒ String?
Returns filename to be loaded if name is registered as #autoload in the namespace of mod.
-
#class_eval(string [, filename [, lineno]]) ⇒ Object
(also: #module_eval)
Evaluates the string or block in the context of mod, except that when a block is given, constant/class variable lookup is not affected.
-
#class_exec(arg...) {|var...| ... } ⇒ Object
(also: #module_exec)
Evaluates the given block in the context of the class/module.
-
#class_variable_defined?(symbol) ⇒ Boolean
Returns
true
if the given class variable is defined in obj. -
#class_variable_get(symbol) ⇒ Object
Returns the value of the given class variable (or throws a ::NameError exception).
-
#class_variable_set(symbol, obj) ⇒ Object
Sets the class variable named by symbol to the given object.
-
#class_variables(inherit = true) ⇒ Array
Returns an array of the names of class variables in mod.
-
#const_defined?(sym, inherit = true) ⇒ Boolean
Says whether mod or its ancestors have a constant with the given name:
-
#const_get(sym, inherit = true) ⇒ Object
Checks for a constant with the given name in mod.
-
#const_missing(sym) ⇒ Object
Invoked when a reference is made to an undefined constant in mod.
-
#const_set(sym, obj) ⇒ Object
Sets the named constant to the given object, returning that object.
-
#constants(inherit = true) ⇒ Array
Returns an array of the names of the constants accessible in mod.
- #deprecate_constant(*args)
-
#freeze ⇒ mod
Prevents further modifications to mod.
-
#include(module, ...) ⇒ self
Invokes #append_features on each parameter in reverse order.
-
#include?(module) ⇒ Boolean
Returns
true
if module is included in mod or one of mod's ancestors. -
#included_modules ⇒ Array
Returns the list of modules included in mod.
-
#inspect ⇒ String
Alias for #to_s.
-
#instance_method(symbol) ⇒ unbound_method
Returns an ::UnboundMethod representing the given instance method in mod.
-
#instance_methods(include_super = true) ⇒ Array
Returns an array containing the names of the public and protected instance methods in the receiver.
-
#method_defined?(symbol) ⇒ Boolean
Returns
true
if the named method is defined by mod (or its included modules and, if mod is a class, its ancestors). -
#module_eval ⇒ Object
Alias for #class_eval.
-
#module_exec(arg...) {|var...| ... } ⇒ Object
Alias for #class_exec.
-
#name ⇒ String
Returns the name of the module mod.
-
#prepend(module, ...) ⇒ self
Invokes #prepend_features on each parameter in reverse order.
-
#private_class_method(symbol, ...) ⇒ mod
Makes existing class methods private.
-
#private_constant(symbol, ...) ⇒ mod
Makes a list of existing constants private.
-
#private_instance_methods(include_super = true) ⇒ Array
Returns a list of the private instance methods defined in mod.
-
#private_method_defined?(symbol) ⇒ Boolean
Returns
true
if the named private method is defined by _ mod_ (or its included modules and, if mod is a class, its ancestors). -
#protected_instance_methods(include_super = true) ⇒ Array
Returns a list of the protected instance methods defined in mod.
-
#protected_method_defined?(symbol) ⇒ Boolean
Returns
true
if the named protected method is defined by mod (or its included modules and, if mod is a class, its ancestors). -
#public_class_method(symbol, ...) ⇒ mod
Makes a list of existing class methods public.
-
#public_constant(symbol, ...) ⇒ mod
Makes a list of existing constants public.
-
#public_instance_method(symbol) ⇒ unbound_method
Similar to instance_method, searches public method only.
-
#public_instance_methods(include_super = true) ⇒ Array
Returns a list of the public instance methods defined in mod.
-
#public_method_defined?(symbol) ⇒ Boolean
Returns
true
if the named public method is defined by mod (or its included modules and, if mod is a class, its ancestors). -
#remove_class_variable(sym) ⇒ Object
Removes the definition of the sym, returning that constant's value.
-
#to_s ⇒ String
(also: #inspect)
Returns a string representing this module or class.
-
#alias_method(new_name, old_name) ⇒ self
private
Makes new_name a new copy of the method old_name.
-
#append_features(mod) ⇒ mod
private
When this module is included in another, Ruby calls
append_features
in this module, passing it the receiving module in mod. - #attr(*args) private
-
#attr_accessor(symbol, ...) ⇒ nil
private
Defines a named attribute for this module, where the name is symbol.
id2name
, creating an instance variable (@name
) and a corresponding access method to read it. -
#attr_reader(symbol, ...) ⇒ nil
private
Creates instance variables and corresponding methods that return the value of each instance variable.
-
#attr_writer(symbol, ...) ⇒ nil
private
Creates an accessor method to allow assignment to the attribute symbol
.id2name
. -
#define_method(symbol, method) ⇒ Symbol
private
Defines an instance method in the receiver.
-
#extend_object(obj) ⇒ Object
private
Extends the specified object by adding this module's constants and methods (which are added as singleton methods).
-
#extended(othermod)
private
The equivalent of #included, but for extended modules.
-
#included(othermod)
private
Callback invoked whenever the receiver is included in another module or class.
-
#method_added(method_name)
private
Invoked as a callback whenever an instance method is added to the receiver.
-
#method_removed(method_name)
private
Invoked as a callback whenever an instance method is removed from the receiver.
- #method_undefined private
-
#module_function(symbol, ...) ⇒ self
private
Creates module functions for the named methods.
-
#prepend_features(mod) ⇒ mod
private
When this module is prepended in another, Ruby calls
prepend_features
in this module, passing it the receiving module in mod. -
#prepended(othermod)
private
The equivalent of #included, but for prepended modules.
-
#private ⇒ self
private
With no arguments, sets the default visibility for subsequently defined methods to private.
-
#protected ⇒ self
private
With no arguments, sets the default visibility for subsequently defined methods to protected.
-
#public ⇒ self
private
With no arguments, sets the default visibility for subsequently defined methods to public.
-
#refine(klass) ⇒ Module
private
Refine klass in the receiver.
-
#remove_const(sym) ⇒ Object
private
Removes the definition of the given constant, returning that constant's previous value.
-
#remove_method(symbol) ⇒ self
private
Removes the method identified by symbol from the current class.
-
#undef_method(symbol) ⇒ self
private
Prevents the current class from responding to calls to the named method.
-
#using(module) ⇒ self
private
Import class refinements from module into the current class or module definition.
Constructor Details
.new ⇒ mod
.new {|mod| ... } ⇒ mod
mod
.new {|mod| ... } ⇒ mod
Creates a new anonymous module. If a block is given, it is passed the module object, and the block is evaluated in the context of this module using #module_eval.
fred = Module.new do
def meth1
"hello"
end
def meth2
"bye"
end
end
a = "my string"
a.extend(fred) #=> "my string"
a.meth1 #=> "hello"
a.meth2 #=> "bye"
Assign the module to a constant (name starting uppercase) if you want to treat it like a regular module.
Class Method Details
In the first form, returns an array of the names of all constants accessible from the point of call. This list includes the names of all modules and classes defined in the global scope.
Module.constants.first(4)
# => [:ARGF, :ARGV, :ArgumentError, :Array]
Module.constants.include?(:SEEK_SET) # => false
class IO
Module.constants.include?(:SEEK_SET) # => true
end
The second form calls the instance method constants
.
.nesting ⇒ Array
Returns the list of Modules
nested at the point of call.
module M1
module M2
$a = Module.nesting
end
end
$a #=> [M1::M2, M1]
$a[0].name #=> "M1::M2"
Instance Attribute Details
#singleton_class? ⇒ Boolean
(readonly)
Returns true
if mod is a singleton class or false
if it is an ordinary class or module.
class C
end
C.singleton_class? #=> false
C.singleton_class.singleton_class? #=> true
Instance Method Details
#<(other) ⇒ true
, ...
Returns true if mod is a subclass of other. Returns nil
if there's no relationship between the two. (Think of the relationship in terms of the class definition: “class A<B” implies “A<B”.)
#<=(other) ⇒ true
, ...
Returns true if mod is a subclass of other or is the same as other. Returns nil
if there's no relationship between the two. (Think of the relationship in terms of the class definition: “class A<B” implies “A<B”.)
#<=>(other_module) ⇒ 1
, ...
Comparison—Returns -1, 0, +1 or nil depending on whether module
includes other_module
, they are the same, or if module
is included by other_module
.
Returns nil
if module
has no relationship with other_module
, if other_module
is not a module, or if the two values are incomparable.
#==(other) ⇒ Boolean
Alias for Object#eql?. Equality — At the ::Object level, ==
returns true
only if obj
and other
are the same object. Typically, this method is overridden in descendant classes to provide class-specific meaning.
Unlike ==
, the equal?
method should never be overridden by subclasses as it is used to determine object identity (that is, a.equal?(b)
if and only if a
is the same object as b
):
obj = "a"
other = obj.dup
obj == other #=> true
obj.equal? other #=> false
obj.equal? obj #=> true
The eql?
method returns true
if obj
and other
refer to the same hash key. This is used by ::Hash to test members for equality. For objects of class ::Object, eql?
is synonymous with ==
. Subclasses normally continue this tradition by aliasing eql?
to their overridden ==
method, but there are exceptions. ::Numeric types, for example, perform type conversion across ==
, but not across eql?
, so:
1 == 1.0 #=> true
1.eql? 1.0 #=> false
#===(obj) ⇒ Boolean
Case Equality—Returns true
if obj is an instance of mod or and instance of one of mod's descendants. Of limited use for modules, but can be used in case
statements to classify objects by class.
#>(other) ⇒ true
, ...
Returns true if mod is an ancestor of other. Returns nil
if there's no relationship between the two. (Think of the relationship in terms of the class definition: “class A<B” implies “B>A”.)
#>=(other) ⇒ true
, ...
Returns true if mod is an ancestor of other, or the two modules are the same. Returns nil
if there's no relationship between the two. (Think of the relationship in terms of the class definition: “class A<B” implies “B>A”.)
#alias_method(new_name, old_name) ⇒ self
(private)
Makes new_name a new copy of the method old_name. This can be used to retain access to methods that are overridden.
module Mod
alias_method :orig_exit, :exit
def exit(code=0)
puts "Exiting with code #{code}"
orig_exit(code)
end
end
include Mod
exit(99)
produces:
Exiting with code 99
#ancestors ⇒ Array
Returns a list of modules included/prepended in mod (including mod itself).
module Mod
include Math
include Comparable
prepend Enumerable
end
Mod.ancestors #=> [Enumerable, Mod, Comparable, Math]
Math.ancestors #=> [Math]
Enumerable.ancestors #=> [Enumerable]
#append_features(mod) ⇒ mod
(private)
When this module is included in another, Ruby calls append_features
in this module, passing it the receiving module in mod. Ruby's default implementation is to add the constants, methods, and module variables of this module to mod if this module has not already been added to mod or one of its ancestors. See also #include.
#attr(*args) (private)
#attr_accessor(symbol, ...) ⇒ nil
(private)
#attr_accessor(string, ...) ⇒ nil
nil
(private)
#attr_accessor(string, ...) ⇒ nil
Defines a named attribute for this module, where the name is symbol.id2name
, creating an instance variable (@name
) and a corresponding access method to read it. Also creates a method called name=
to set the attribute. ::String arguments are converted to symbols.
module Mod
attr_accessor(:one, :two)
end
Mod.instance_methods.sort #=> [:one, :one=, :two, :two=]
#attr_reader(symbol, ...) ⇒ nil
(private)
#attr(symbol, ...) ⇒ nil
#attr_reader(string, ...) ⇒ nil
#attr(string, ...) ⇒ nil
nil
(private)
#attr(symbol, ...) ⇒ nil
#attr_reader(string, ...) ⇒ nil
#attr(string, ...) ⇒ nil
Creates instance variables and corresponding methods that return the value of each instance variable. Equivalent to calling “attr
:name'' on each name in turn. ::String arguments are converted to symbols.
#attr_writer(symbol, ...) ⇒ nil
(private)
#attr_writer(string, ...) ⇒ nil
nil
(private)
#attr_writer(string, ...) ⇒ nil
Creates an accessor method to allow assignment to the attribute symbol.id2name
. ::String arguments are converted to symbols.
#autoload(module, filename) ⇒ nil
Registers filename to be loaded (using Kernel.require) the first time that module (which may be a ::String or a symbol) is accessed in the namespace of mod.
module A
end
A.autoload(:B, "b")
A::B.doit # autoloads "b"
#autoload?(name) ⇒ String?
Also known as: #module_eval
Evaluates the string or block in the context of mod, except that when a block is given, constant/class variable lookup is not affected. This can be used to add methods to a class. #module_eval returns the result of evaluating its argument. The optional filename and lineno parameters set the text for error messages.
class Thing
end
a = %q{def hello() "Hello there!" end}
Thing.module_eval(a)
puts Thing.new.hello()
Thing.module_eval("invalid code", "dummy", 123)
produces:
Hello there!
dummy:123:in `module_eval': undefined local variable
or method `code' for Thing:Class
Also known as: #module_exec
Evaluates the given block in the context of the class/module. The method defined in the block will belong to the receiver. Any arguments passed to the method will be passed to the block. This can be used if the block needs to access instance variables.
class Thing
end
Thing.class_exec{
def hello() "Hello there!" end
}
puts Thing.new.hello()
produces:
Hello there!
#class_variable_defined?(symbol) ⇒ Boolean
#class_variable_defined?(string) ⇒ Boolean
Boolean
#class_variable_defined?(string) ⇒ Boolean
Returns true
if the given class variable is defined in obj. ::String arguments are converted to symbols.
class Fred
@@foo = 99
end
Fred.class_variable_defined?(:@@foo) #=> true
Fred.class_variable_defined?(:@@bar) #=> false
Returns the value of the given class variable (or throws a ::NameError exception). The @@
part of the variable name should be included for regular class variables. ::String arguments are converted to symbols.
class Fred
@@foo = 99
end
Fred.class_variable_get(:@@foo) #=> 99
Sets the class variable named by symbol to the given object. If the class variable name is passed as a string, that string is converted to a symbol.
class Fred
@@foo = 99
def foo
@@foo
end
end
Fred.class_variable_set(:@@foo, 101) #=> 101
Fred.new.foo #=> 101
#class_variables(inherit = true) ⇒ Array
Returns an array of the names of class variables in mod. This includes the names of class variables in any included modules, unless the inherit parameter is set to 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]
#const_defined?(sym, inherit = true) ⇒ Boolean
#const_defined?(str, inherit = true) ⇒ Boolean
Boolean
#const_defined?(str, inherit = true) ⇒ Boolean
Says whether mod or its ancestors have a constant with the given name:
Float.const_defined?(:EPSILON) #=> true, found in Float itself
Float.const_defined?("String") #=> true, found in Object (ancestor)
BasicObject.const_defined?(:Hash) #=> false
If mod is a Module
, additionally ::Object and its ancestors are checked:
Math.const_defined?(:String) #=> true, found in Object
In each of the checked classes or modules, if the constant is not present but there is an autoload for it, true
is returned directly without autoloading:
module Admin
autoload :User, 'admin/user'
end
Admin.const_defined?(:User) #=> true
If the constant is not found the callback #const_missing is not called and the method returns false
.
If inherit
is false, the lookup only checks the constants in the receiver:
IO.const_defined?(:SYNC) #=> true, found in File::Constants (ancestor)
IO.const_defined?(:SYNC, false) #=> false, not found in IO itself
In this case, the same logic for autoloading applies.
If the argument is not a valid constant name a ::NameError is raised with the message “wrong constant name name”:
Hash.const_defined? 'foobar' #=> NameError: wrong constant name foobar
Checks for a constant with the given name in mod. If inherit
is set, the lookup will also search the ancestors (and ::Object if mod is a Module
).
The value of the constant is returned if a definition is found, otherwise a ::NameError is raised.
Math.const_get(:PI) #=> 3.14159265358979
This method will recursively look up constant names if a namespaced class name is provided. For example:
module Foo; class Bar; end end
Object.const_get 'Foo::Bar'
The inherit
flag is respected on each lookup. For example:
module Foo
class Bar
VAL = 10
end
class Baz < Bar; end
end
Object.const_get 'Foo::Baz::VAL' # => 10
Object.const_get 'Foo::Baz::VAL', false # => NameError
If the argument is not a valid constant name a ::NameError will be raised with a warning “wrong constant name”.
Object.const_get 'foobar' #=> NameError: wrong constant name foobar
#const_missing(sym) ⇒ Object
Invoked when a reference is made to an undefined constant in mod. It is passed a symbol for the undefined constant, and returns a value to be used for that constant. The following code is an example of the same:
def Foo.const_missing(name)
name # return the constant name as Symbol
end
Foo::UNDEFINED_CONST #=> :UNDEFINED_CONST: symbol returned
In the next example when a reference is made to an undefined constant, it attempts to load a file whose name is the lowercase version of the constant (thus class Fred
is assumed to be in file fred.rb
). If found, it returns the loaded class. It therefore implements an autoload feature similar to Kernel.autoload and #autoload.
def Object.const_missing(name)
@looked_for ||= {}
str_name = name.to_s
raise "Class not found: #{name}" if @looked_for[str_name]
@looked_for[str_name] = 1
file = str_name.downcase
require file
klass = const_get(name)
return klass if klass
raise "Class not found: #{name}"
end
Sets the named constant to the given object, returning that object. Creates a new constant if no constant with the given name previously existed.
Math.const_set("HIGH_SCHOOL_PI", 22.0/7.0) #=> 3.14285714285714
Math::HIGH_SCHOOL_PI - Math::PI #=> 0.00126448926734968
If sym
or str
is not a valid constant name a ::NameError will be raised with a warning “wrong constant name”.
Object.const_set('foobar', 42) #=> NameError: wrong constant name foobar
#constants(inherit = true) ⇒ Array
Returns an array of the names of the constants accessible in mod. This includes the names of constants in any included modules (example at start of section), unless the inherit parameter is set to false
.
The implementation makes no guarantees about the order in which the constants are yielded.
IO.constants.include?(:SYNC) #=> true
IO.constants(false).include?(:SYNC) #=> false
Also see #const_defined?.
Defines an instance method in the receiver. The method parameter can be a ::Proc, a ::Method or an ::UnboundMethod object. If a block is specified, it is used as the method body. This block is evaluated using instance_eval
, a point that is tricky to demonstrate because define_method
is private. (This is why we resort to the send
hack in this example.)
class A
def fred
puts "In Fred"
end
def create_method(name, &block)
self.class.send(:define_method, name, &block)
end
define_method(:wilma) { puts "Charge it!" }
end
class B < A
define_method(:, instance_method(:fred))
end
a = B.new
a.
a.wilma
a.create_method(:betty) { p self }
a.betty
produces:
In Fred
Charge it!
#<B:0x401b39e8>
#deprecate_constant(*args)
#extend_object(obj) ⇒ Object (private)
Extends the specified object by adding this module's constants and methods (which are added as singleton methods). This is the callback method used by Object#extend.
module Picky
def Picky.extend_object(o)
if String === o
puts "Can't add Picky to a String"
else
puts "Picky added to #{o.class}"
super
end
end
end
(s = Array.new).extend Picky # Call Object.extend
(s = "quick brown fox").extend Picky
produces:
Picky added to Array
Can't add Picky to a String
#extended(othermod) (private)
The equivalent of #included, but for extended modules.
module A
def self.extended(mod)
puts "#{self} extended in #{mod}"
end
end
module Enumerable
extend A
end
# => prints "A extended in Enumerable"
#freeze ⇒ mod
Prevents further modifications to mod.
This method returns self.
#include(module, ...) ⇒ self
Invokes #append_features on each parameter in reverse order.
#include?(module) ⇒ Boolean
Returns true
if module is included in mod or one of mod's ancestors.
module A
end
class B
include A
end
class C < B
end
B.include?(A) #=> true
C.include?(A) #=> true
A.include?(A) #=> false
#included(othermod) (private)
Callback invoked whenever the receiver is included in another module or class. This should be used in preference to #append_features if your code wants to perform some action when a module is included in another.
module A
def A.included(mod)
puts "#{self} included in #{mod}"
end
end
module Enumerable
include A
end
# => prints "A included in Enumerable"
#included_modules ⇒ Array
Returns the list of modules included in mod.
module Mixin
end
module Outer
include Mixin
end
Mixin.included_modules #=> []
Outer.included_modules #=> [Mixin]
Alias for #to_s.
#instance_method(symbol) ⇒ unbound_method
Returns an ::UnboundMethod representing the given instance method in mod.
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')
produces:
Hello there, Dave!
#instance_methods(include_super = true) ⇒ Array
Returns an array containing the names of the public and protected instance methods in the receiver. For a module, these are the public and protected methods; for a class, they are the instance (not singleton) methods. If the optional parameter is false
, the methods of any ancestors are not included.
module A
def method1() end
end
class B
include A
def method2() end
end
class C < B
def method3() end
end
A.instance_methods(false) #=> [:method1]
B.instance_methods(false) #=> [:method2]
B.instance_methods(true).include?(:method1) #=> true
C.instance_methods(false) #=> [:method3]
C.instance_methods.include?(:method2) #=> true
#method_added(method_name) (private)
Invoked as a callback whenever an instance method is added to the receiver.
module Chatty
def self.method_added(method_name)
puts "Adding #{method_name.inspect}"
end
def self.some_class_method() end
def some_instance_method() end
end
produces:
Adding :some_instance_method
#method_defined?(symbol) ⇒ Boolean
#method_defined?(string) ⇒ Boolean
Boolean
#method_defined?(string) ⇒ Boolean
Returns true
if the named method is defined by mod (or its included modules and, if mod is a class, its ancestors). Public and protected methods are matched. ::String arguments are converted to symbols.
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? "method3" #=> true
C.method_defined? "protected_method1" #=> true
C.method_defined? "method4" #=> false
C.method_defined? "private_method2" #=> false
#method_removed(method_name) (private)
Invoked as a callback whenever an instance method is removed from the receiver.
module Chatty
def self.method_removed(method_name)
puts "Removing #{method_name.inspect}"
end
def self.some_class_method() end
def some_instance_method() end
class << self
remove_method :some_class_method
end
remove_method :some_instance_method
end
produces:
Removing :some_instance_method
#method_undefined (private)
Alias for #class_eval.
Alias for #class_exec.
#module_function(symbol, ...) ⇒ self
(private)
#module_function(string, ...) ⇒ self
self
(private)
#module_function(string, ...) ⇒ self
Creates module functions for the named methods. These functions may be called with the module as a receiver, and also become available as instance methods to classes that mix in the module. Module
functions are copies of the original, and so may be changed independently. The instance-method versions are made private. If used with no arguments, subsequently defined methods become module functions. ::String arguments are converted to symbols.
module Mod
def one
"This is one"
end
module_function :one
end
class Cls
include Mod
def call_one
one
end
end
Mod.one #=> "This is one"
c = Cls.new
c.call_one #=> "This is one"
module Mod
def one
"This is the new one"
end
end
Mod.one #=> "This is one"
c.call_one #=> "This is the new one"
#name ⇒ String
Returns the name of the module mod. Returns nil for anonymous modules.
#prepend(module, ...) ⇒ self
Invokes #prepend_features on each parameter in reverse order.
#prepend_features(mod) ⇒ mod
(private)
When this module is prepended in another, Ruby calls prepend_features
in this module, passing it the receiving module in mod. Ruby's default implementation is to overlay the constants, methods, and module variables of this module to mod if this module has not already been added to mod or one of its ancestors. See also #prepend.
#prepended(othermod) (private)
The equivalent of #included, but for prepended modules.
module A
def self.prepended(mod)
puts "#{self} prepended to #{mod}"
end
end
module Enumerable
prepend A
end
# => prints "A prepended to Enumerable"
#private ⇒ self
(private)
#private(symbol, ...) ⇒ self
#private(string, ...) ⇒ self
self
(private)
#private(symbol, ...) ⇒ self
#private(string, ...) ⇒ self
With no arguments, sets the default visibility for subsequently defined methods to private. With arguments, sets the named methods to have private visibility. ::String arguments are converted to symbols.
module Mod
def a() end
def b() end
private
def c() end
private :a
end
Mod.private_instance_methods #=> [:a, :c]
#private_class_method(symbol, ...) ⇒ mod
#private_class_method(string, ...) ⇒ mod
mod
#private_class_method(string, ...) ⇒ mod
#private_constant(symbol, ...) ⇒ mod
Makes a list of existing constants private.
#private_instance_methods(include_super = true) ⇒ Array
Returns a list of the private instance methods defined in mod. If the optional parameter is false
, the methods of any ancestors are not included.
module Mod
def method1() end
private :method1
def method2() end
end
Mod.instance_methods #=> [:method2]
Mod.private_instance_methods #=> [:method1]
#private_method_defined?(symbol) ⇒ Boolean
#private_method_defined?(string) ⇒ Boolean
Boolean
#private_method_defined?(string) ⇒ Boolean
Returns true
if the named private method is defined by _ mod_ (or its included modules and, if mod is a class, its ancestors). ::String arguments are converted to symbols.
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.method_defined? "method2" #=> false
#protected ⇒ self
(private)
#protected(symbol, ...) ⇒ self
#protected(string, ...) ⇒ self
self
(private)
#protected(symbol, ...) ⇒ self
#protected(string, ...) ⇒ self
With no arguments, sets the default visibility for subsequently defined methods to protected. With arguments, sets the named methods to have protected visibility. ::String arguments are converted to symbols.
#protected_instance_methods(include_super = true) ⇒ Array
Returns a list of the protected instance methods defined in mod. If the optional parameter is false
, the methods of any ancestors are not included.
#protected_method_defined?(symbol) ⇒ Boolean
#protected_method_defined?(string) ⇒ Boolean
Boolean
#protected_method_defined?(string) ⇒ Boolean
Returns true
if the named protected method is defined by mod (or its included modules and, if mod is a class, its ancestors). ::String arguments are converted to symbols.
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.method_defined? "method2" #=> true
#public ⇒ self
(private)
#public(symbol, ...) ⇒ self
#public(string, ...) ⇒ self
self
(private)
#public(symbol, ...) ⇒ self
#public(string, ...) ⇒ self
With no arguments, sets the default visibility for subsequently defined methods to public. With arguments, sets the named methods to have public visibility. ::String arguments are converted to symbols.
#public_class_method(symbol, ...) ⇒ mod
#public_class_method(string, ...) ⇒ mod
mod
#public_class_method(string, ...) ⇒ mod
Makes a list of existing class methods public.
::String arguments are converted to symbols.
#public_constant(symbol, ...) ⇒ mod
Makes a list of existing constants public.
#public_instance_method(symbol) ⇒ unbound_method
Similar to instance_method, searches public method only.
#public_instance_methods(include_super = true) ⇒ Array
Returns a list of the public instance methods defined in mod. If the optional parameter is false
, the methods of any ancestors are not included.
#public_method_defined?(symbol) ⇒ Boolean
#public_method_defined?(string) ⇒ Boolean
Boolean
#public_method_defined?(string) ⇒ Boolean
Returns true
if the named public method is defined by mod (or its included modules and, if mod is a class, its ancestors). ::String arguments are converted to symbols.
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? "method2" #=> false
C.method_defined? "method2" #=> true
#refine(klass) ⇒ Module
(private)
Refine klass in the receiver.
Returns an overlaid module.
#remove_class_variable(sym) ⇒ Object
Removes the definition of the sym, returning that constant's value.
class Dummy
@@var = 99
puts @@var
remove_class_variable(:@@var)
p(defined? @@var)
end
produces:
99
nil
#remove_const(sym) ⇒ Object (private)
Removes the definition of the given constant, returning that constant's previous value. If that constant referred to a module, this will not change that module's name and can lead to confusion.
#remove_method(symbol) ⇒ self
(private)
#remove_method(string) ⇒ self
self
(private)
#remove_method(string) ⇒ self
Removes the method identified by symbol from the current class. For an example, see #undef_method. ::String arguments are converted to symbols.
#to_s ⇒ String Also known as: #inspect
Returns a string representing this module or class. For basic classes and modules, this is the name. For singletons, we show information on the thing we're attached to as well.
#undef_method(symbol) ⇒ self
(private)
#undef_method(string) ⇒ self
self
(private)
#undef_method(string) ⇒ self
Prevents the current class from responding to calls to the named method. Contrast this with #remove_method, which deletes the method from the particular class; Ruby will still search superclasses and mixed-in modules for a possible receiver. ::String arguments are converted to symbols.
class Parent
def hello
puts "In parent"
end
end
class Child < Parent
def hello
puts "In child"
end
end
c = Child.new
c.hello
class Child
remove_method :hello # remove from child, still in parent
end
c.hello
class Child
undef_method :hello # prevent any calls to 'hello'
end
c.hello
produces:
In child
In parent
prog.rb:23: undefined method `hello' for #<Child:0x401b3bb4> (NoMethodError)
#using(module) ⇒ self
(private)
Import class refinements from module into the current class or module definition.