Programming Ruby

The Pragmatic Programmer's Guide
Previous < Contents ^
Next >
class Module
Parent: Object
Version: 1.6

Index:

constants nesting new <, <=, >, >= <=> === ancestors class_eval class_variables clone const_defined? const_get const_set constants included_modules instance_methods method_defined? module_eval name private_class_method private_instance_methods protected_instance_methods public_class_method public_instance_methods alias_method append_features attr attr_accessor attr_reader attr_writer extend_object include method_added module_function private protected public remove_const remove_method undef_method


Subclasses: Class

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#module_function on page 346.

In the descriptions that follow, the parameter aSymbol 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.type � Module
Mod.constants � ["CONST", "E", "PI"]
Mod.instance_methods � ["meth"]

class methods
constants Module.constants -> anArray

Returns an array of the names of all constants defined in the system. This list includes the names of all modules and classes. 

p Module.constants.sort[1..5]
produces: 
["ARGV", "ArgumentError", "Array", "Bignum", "Binding"]

nesting Module.nesting -> anArray

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"

new Module.new -> aModule

Creates a new anonymous module.

instance methods
<, <=, >, >= mod relop aModule -> true or false

Hierarchy Query---One module is considered greater than another if it is included in (or is a parent class of) the other module. The other operators are defined accordingly. If there is no relationship between the modules, returns false for all operators.

module Mixin
end
module Parent
  include Mixin
end
module Unrelated
end
Parent > Mixin � false
Parent < Mixin � true
Parent <= Parent � true
Parent < Unrelated � false
Parent > Unrelated � false

<=> mod <=> aModule -> -1, 0, +1

Comparison---Returns -1 if mod includes aModule, 0 if mod is the same as aModule, and +1 if mod is included by aModule or if mod has no relationship with aModule.

=== mod === anObject -> true or false

Case Equality---Returns true if anObject is an instance of mod or one of mod's descendents. Of limited use for modules, but can be used in case statements to classify objects by class.

ancestors mod.ancestors -> anArray

Returns a list of modules included in mod (including mod itself).

module Mod
  include Math
  include Comparable
end
Mod.ancestors � [Mod, Comparable, Math]
Math.ancestors � [Math]

class_eval mod.class_eval( aString ) -> anObject
mod.class_eval {| | block } -> anObject

Synonym for Module.module_eval.

class_variables mod.class_variables -> anArray

Returns an array of the names of class variables in mod and the ancestors of mod.

class One
  @@var1 = 1
end
class Two < One
  @@var2 = 2
end
One.class_variables � ["@@var1"]
Two.class_variables � ["@@var2", "@@var1"]

clone mod.clone -> aModule

Creates a new copy of a module.

m = Math.clone � Math
m.constants � ["E", "PI"]
m == Math � false

const_defined? mod.const_defined?( aSymbol ) -> true or false

Returns true if a constant with the given name is defined by mod.

Math.const_defined? "PI" � true

const_get mod.const_get( aSymbol ) -> anObject

Returns the value of the named constant in mod.

Math.const_get :PI � 3.141592654

const_set mod.const_set( aSymbol, anObject ) -> anObject

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.142857143
Math::HIGH_SCHOOL_PI - Math::PI � 0.001264489267

constants mod.constants -> anArray

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).

included_modules mod.included_modules -> anArray

Returns the list of modules included in mod.

module Mixin
end
module Outer
  include Mixin
end
Mixin.included_modules � []
Outer.included_modules � [Mixin]

instance_methods mod.instance_methods( includeSuper=false ) -> anArray

Returns an array containing the names of public instance methods in the receiver. For a module, these are the public methods; for a class, they are the instance (not singleton) methods. With no argument, or with an argument that is false, the instance methods in mod are returned, otherwise the methods in mod and mod's superclasses are returned. 
module A
  def method1()  end
end
class B
  def method2()  end
end
class C < B
  def method3()  end
end

A.instance_methods � ["method1"]
B.instance_methods � ["method2"]
C.instance_methods � ["method3"]
C.instance_methods(true).length � 39

method_defined? mod.method_defined?( aSymbol ) -> true or false

Returns true if the named method is defined by mod (or its included modules and, if mod is a class, its ancestors).

module A
  def method1()  end
end
class B
  def method2()  end
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? "method4" � false

module_eval mod.module_eval( aString ) -> anObject
mod.module_eval {| | block } -> anObject

Evaluates the string or block in the context of mod. This can be used to add methods to a class. module_eval returns the result of evaluating its argument.

class Thing
end
a = %q{def hello() "Hello there!" end}
Thing.module_eval(a) � nil
Thing.new.hello() � "Hello there!"

name mod.name -> aString

Returns the name of the module mod.

private_class_method mod.private_class_method( [ aSymbol ]+ ) -> nil

Makes existing class methods private. Often used to hide the default constructor new. 

class SimpleSingleton  # Not thread safe
  private_class_method :new
  def SimpleSingleton.create(*args, &block)
    @me = new(*args, &block) if ! @me
    @me
  end
end

private_instance_methods
mod.private_instance_methods( includeSuper=false ) -> anArray

Returns a list of the private instance methods defined in mod. If the optional parameter is not false, the methods of any ancestors are included.

module Mod
  def method1()  end
  private :method1
  def method2()  end
end
Mod.instance_methods � ["method2"]
Mod.private_instance_methods � ["method1"]

protected_instance_methods
mod.protected_instance_methods( includeSuper=false ) -> anArray

Returns a list of the protected instance methods defined in mod. If the optional parameter is not false, the methods of any ancestors are included.

public_class_method mod.public_class_method( [ aSymbol ]+ ) -> nil

Makes a list of existing class methods public.

public_instance_methods
mod.public_instance_methods( includeSuper=false ) -> anArray

Returns a list of the public instance methods defined in mod. If the optional parameter is not false, the methods of any ancestors are included.

private methods
alias_method alias_method( newID, oldID ) -> mod

Makes newID a new copy of the method oldID. This can be used to retain access to methods that are overridden. 

module Mod
  alias_method :origExit, :exit
  def exit(code=0)
    print "Exiting with code #{code}\n"
    origExit(code)
  end
end
include Mod
exit(99)
produces: 
Exiting with code 99

append_features append_features( aModule ) -> mod

When this module is included in another, Ruby calls append_features in this module, passing it the receiving module in aModule. Ruby's default implementation is to add the constants, methods, and module variables of this module to aModule if this module has not already been added to aModule or one of its ancestors. See also Module#include on page 345.

attr attr( aSymbol, writable=false ) -> nil
Defines a named attribute for this module, where the name is aSymbol. id2name, creating an instance variable (@name) and a corresponding access method to read it. If the optional writable argument is true, also creates a method called name= to set the attribute. 

module Mod
  attr  :size, true
end
is equivalent to: 

module Mod
  def size
    @size
  end
  def size=(val)
    @size = val
  end
end

attr_accessor attr_accessor( [ aSymbol ]+ ) -> nil

Equivalent to calling ``attr  aSymbol , true'' on each aSymbol in turn.

module Mod
  attr_accessor(:one, :two)
end
Mod.instance_methods.sort � ["one", "one=", "two", "two="]

attr_reader attr_reader( [ aSymbol ]+ ) -> 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.

attr_writer

attr_writer( [ aSymbol ]+ ) -> nil

Creates an accessor method to allow assignment to the attribute aSymbol .id2name.

extend_object extend_object( anObject ) -> anObject

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
      print "Can't add Picky to a String\n"
    else
      print "Picky added to ", o.type, "\n"
      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

include include( [ aModule ]+ ) -> mod

Invokes Module.append_features (documented on page 344) on each parameter in turn.

method_added method_added( aSymbol )

Invoked as a callback whenever a method is added to the receiver. 

module Chatty
  def Chatty.method_added(id)
    print "Adding ", id.id2name, "\n"
  end
  def one()   end
end
module Chatty
  def two()   end
end
produces: 
Adding one
Adding two

module_function module_function( [ aSymbol ]* ) -> mod

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.

module Mod
  def one
    "This is one"
  end
  module_function :one
end
class Cls
  include Mod
  def callOne
    one
  end
end
Mod.one � "This is one"
c = Cls.new
c.callOne � "This is one"
module Mod
  def one
    "This is the new one"
  end
end
Mod.one � "This is one"
c.callOne � "This is the new one"

private private( [ aSymbol ]* ) -> mod

With no arguments, sets the default visibility for subsequently defined methods to private. With arguments, sets the named methods to have private visibility. See Access Control starting on page 233.

module Mod
  def a()  end
  def b()  end
  private
  def c()  end
  private :a
end
Mod.private_instance_methods � ["a", "c"]

protected protected( [ aSymbol ]* ) -> mod

With no arguments, sets the default visibility for subsequently defined methods to protected. With arguments, sets the named methods to have protected visibility. See Access Control starting on page 233.

public public( [ aSymbol ]* ) -> mod

With no arguments, sets the default visibility for subsequently defined methods to public. With arguments, sets the named methods to have public visibility. See Access Control starting on page 233.

remove_const remove_const( aSymbol ) -> anObject

Removes the definition of the given constant, returning that constant's value. Predefined classes and singleton objects (such as true) cannot be removed.

remove_method remove_method( aSymbol ) -> mod
Removes the method identified by aSymbol from the current class. For an example, see Module.undef_method.

undef_method undef_method( aSymbol ) -> mod

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. 

class Parent
  def hello
    print "In parent\n"
  end
end
class Child < Parent
  def hello
    print "In child\n"
  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:0x401b5928> (NameError)

Previous < Contents ^
Next >

Extracted from the book "Programming Ruby - The Pragmatic Programmer's Guide"
Copyright © 2001 by Addison Wesley Longman, Inc. This material may be distributed only subject to the terms and conditions set forth in the Open Publication License, v1.0 or later (the latest version is presently available at http://www.opencontent.org/openpub/)).

Distribution of substantively modified versions of this document is prohibited without the explicit permission of the copyright holder.

Distribution of the work or derivative of the work in any standard (paper) book form is prohibited unless prior permission is obtained from the copyright holder.