Class Module < Object

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

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"

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"

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

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

Comparison—Returns -1 if mod includes other_mod, 0 if mod is the same as other_mod, and +1 if mod is included by other_mod or if mod has no relationship with other_mod. Returns nil if other_mod is not a module.

Equality—At the Object level, == returns true only if obj and other are the same object. Typically, this method is overridden in descendent classes to provide class-specific meaning.

Unlike ==, the equal? method should never be overridden by subclasses: it is used to determine object identity (that is, a.equal?(b) iff a is the same object as b).

The eql? method returns true if obj and anObject have the same value. Used by Hash to test members for equality. For objects of class Object, eql? is synonymous with ==. Subclasses normally continue this tradition, 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

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.

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

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

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]

Registers filename to be loaded (using Kernel::require) the first time that name (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"

Returns filename to be loaded if name is registered as autoload in the namespace of mod.

   module A
   end
   A.autoload(:B, "b")
   A.autoload?(:B)            # => "b"

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

Evaluates the given block in the context of the class/module. The method defined in the block will belong to the receiver.

   class Thing
   end
   Thing.class_exec{
     def hello() "Hello there!" end
   }
   puts Thing.new.hello()

produces:

   Hello there!

Returns true if the given class variable is defined in obj.

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

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

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

   Math.const_defined? "PI"   #=> true

Returns the value of the named constant in mod.

   Math.const_get(:PI)   #=> 3.14159265358979

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 a (very bad) example: if 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 value of the loaded class. It therefore implements a perverse kind of autoload facility.

  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

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

Prevents further modifications to mod.

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

Returns the list of modules included in mod.

   module Mixin
   end

   module Outer
     include Mixin
   end

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

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_byte {|b| Dispatcher[b].bind(self).call }
     end
   end

   interpreter = Interpreter.new
   interpreter.interpret('dave')

produces:

   Hello there, Dave!

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(false)         #=> ["method2"]
   C.instance_methods(false)         #=> ["method3"]
   C.instance_methods(true).length   #=> 43

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.

   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

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

Evaluates the given block in the context of the class/module. The method defined in the block will belong to the receiver.

   class Thing
   end
   Thing.class_exec{
     def hello() "Hello there!" end
   }
   puts Thing.new.hello()

produces:

   Hello there!

Returns the name of the module mod.

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

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

Returns true if the named private 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
     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

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.

Returns true if the named protected 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
     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

Makes a list of existing class methods public.

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.

Returns true if the named public 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
     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

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

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

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 Module#include.

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

Equivalent to calling ``attrsymbol, true’’ on each symbol in turn.

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

Creates instance variables and corresponding methods that return the value of each instance variable. Equivalent to calling ``attr:name’’ on each name in turn.

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

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

   class Fred
     @@foo = 99
   end

   def Fred.foo
     class_variable_get(:@@foo)     #=> 99
   end

Sets the class variable names by symbol to object.

   class Fred
     @@foo = 99
     def foo
       @@foo
     end
   end

   def Fred.foo
     class_variable_set(:@@foo, 101)      #=> 101
   end
   Fred.foo
   Fred.new.foo                             #=> 101

Defines an instance method in the receiver. The method parameter can be a Proc or Method 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(:barney, instance_method(:fred))
   end
   a = B.new
   a.barney
   a.wilma
   a.create_method(:betty) { p self }
   a.betty

produces:

   In Fred
   Charge it!
   #<B:0x401b39e8>

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

Not documented

Invokes Module.append_features on each parameter in turn.

Callback invoked whenever the receiver is included in another module or class. This should be used in preference to Module.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

Not documented

Not documented

Not documented

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"

With no arguments, sets the default visibility for subsequently defined methods to private. With arguments, sets the named methods to have private visibility.

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

With no arguments, sets the default visibility for subsequently defined methods to protected. With arguments, sets the named methods to have protected visibility.

With no arguments, sets the default visibility for subsequently defined methods to public. With arguments, sets the named methods to have public visibility.

Removes the definition of the sym, returning that constant’s value.

   class Dummy
     @@var = 99
     puts @@var
     remove_class_variable(:@@var)
     puts(defined? @@var)
   end

produces:

   99
   nil

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

Removes the method identified by symbol from the current class. For an example, see Module.undef_method.

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