Class: Module

Inherits:
Object show all
Defined in:
object.c,
object.c

Overview

*********************************************************************

A <code>Module</code> 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 <code>Module#module_function</code>)

In the descriptions that follow, the parameter <i>syml</i> refers
to a symbol, which is either a quoted string or a
<code>Symbol</code> (such as <code>:name</code>).

   module Mod
     include Math
     CONST = 1
     def meth
       #  ...
     end
   end
   Mod.class              #=> Module
   Mod.constants          #=> ["E", "PI", "CONST"]
   Mod.instance_methods   #=> ["meth"]

Direct Known Subclasses

Class

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#new ⇒ Object #new {|mod| ... } ⇒ Object

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"

Overloads:

  • #new {|mod| ... } ⇒ Object

    Yields:

    • (mod) 


1527
1528
1529
 
# File 'object.c', line 1527

static VALUE
rb_mod_initialize(module)
VALUE module;

Class Method Details

.constants ⇒ Array

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:



2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029
 
# File 'eval.c', line 2012

static VALUE
rb_mod_s_constants()
{
    NODE *cbase = ruby_cref;
    void *data = 0;

    while (cbase) {
  if (!NIL_P(cbase->nd_clss)) {
      data = rb_mod_const_at(cbase->nd_clss, data);
  }
  cbase = cbase->nd_next;
    }

    if (!NIL_P(ruby_cbase)) {
  data = rb_mod_const_of(ruby_cbase, data);
    }
    return rb_const_list(data);
}

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

Returns:



1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
 
# File 'eval.c', line 1982

static VALUE
rb_mod_nesting()
{
    NODE *cbase = ruby_cref;
    VALUE ary = rb_ary_new();

    while (cbase && cbase->nd_next) {
  if (!NIL_P(cbase->nd_clss)) rb_ary_push(ary, cbase->nd_clss);
  cbase = cbase->nd_next;
    }
    if (ruby_wrapper && RARRAY(ary)->len == 0) {
  rb_ary_push(ary, ruby_wrapper);
    }
    return ary;
}

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

Returns:

  • (true, false, nil) 


1396
1397
1398
 
# File 'object.c', line 1396

static VALUE
rb_mod_lt(mod, arg)
VALUE mod, arg;

#<=(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”).

Returns:

  • (true, false, nil) 


1351
1352
1353
 
# File 'object.c', line 1351

VALUE
rb_class_inherited_p(mod, arg)
VALUE mod, arg;

#<=>(other_mod) ⇒ -1, ...

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.

Returns:

  • (-1, 0, +1, nil) 


1462
1463
1464
 
# File 'object.c', line 1462

static VALUE
rb_mod_cmp(mod, arg)
VALUE mod, arg;

#==(other) ⇒ Boolean #equal?(other) ⇒ Boolean #eql?(other) ⇒ Boolean

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

<i>obj</i> and <i>anObject</i> 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

Overloads:

  • #==(other) ⇒ Boolean

    Returns:

    • (Boolean)
  • #equal?(other) ⇒ Boolean

    Returns:

    • (Boolean)
  • #eql?(other) ⇒ Boolean

    Returns:

    • (Boolean) 


93
94
95
 
# File 'object.c', line 93

static VALUE
rb_obj_equal(obj1, obj2)
VALUE obj1, obj2;

#===(obj) ⇒ Boolean

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:

  • (Boolean) 


1332
1333
1334
 
# File 'object.c', line 1332

static VALUE
rb_mod_eqq(mod, arg)
VALUE mod, arg;

#>(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”).

Returns:

  • (true, false, nil) 


1443
1444
1445
 
# File 'object.c', line 1443

static VALUE
rb_mod_gt(mod, arg)
VALUE mod, arg;

#>=(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”).

Returns:

  • (true, false, nil) 


1417
1418
1419
 
# File 'object.c', line 1417

static VALUE
rb_mod_ge(mod, arg)
VALUE mod, arg;

#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

Returns:

  • (self) 


2237
2238
2239
 
# File 'eval.c', line 2237

static VALUE
rb_mod_alias_method(mod, newname, oldname)
VALUE mod, newname, oldname;

#ancestors ⇒ Array

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]

Returns:



526
527
528
 
# File 'class.c', line 526

VALUE
rb_mod_ancestors(mod)
VALUE mod;

#append_features(mod) ⇒ Object (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 Module#include.



7718
7719
7720
 
# File 'eval.c', line 7718

static VALUE
rb_mod_append_features(module, include)
VALUE module, include;

#attr(symbol, writable = false) ⇒ 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. 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

Returns:

  • (nil) 


1734
1735
1736
 
# File 'object.c', line 1734

static VALUE
rb_mod_attr(argc, argv, klass)
int argc;

#attr_accessor(symbol, ...) ⇒ nil (private)

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

Returns:

  • (nil) 


1805
1806
1807
 
# File 'object.c', line 1805

static VALUE
rb_mod_attr_accessor(argc, argv, klass)
int argc;

#attr_reader(symbol, ...) ⇒ nil (private)

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

Returns:

  • (nil) 


1756
1757
1758
 
# File 'object.c', line 1756

static VALUE
rb_mod_attr_reader(argc, argv, klass)
int argc;

#attr_writer(symbol, ...) ⇒ nil (private)

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

Returns:

  • (nil) 


1778
1779
1780
 
# File 'object.c', line 1778

static VALUE
rb_mod_attr_writer(argc, argv, klass)
int argc;

#autoload(name, filename) ⇒ nil

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:

  • (nil) 


8262
8263
8264
 
# File 'eval.c', line 8262

static VALUE
rb_mod_autoload(mod, sym, file)
VALUE mod;

#autoload?(name) ⇒ String?

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"

Returns:



8288
8289
8290
 
# File 'eval.c', line 8288

static VALUE
rb_mod_autoload_p(mod, sym)
VALUE mod, sym;

#class_eval(string[, filename [, lineno]]) ⇒ Object #module_eval { ... } ⇒ Object

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

Overloads:

  • #class_eval(string[, filename [, lineno]]) ⇒ Object

    Returns:

  • #module_eval { ... } ⇒ Object

    Yields:

    Returns:



6912
6913
6914
 
# File 'eval.c', line 6912

VALUE
rb_mod_module_eval(argc, argv, mod)
int argc;

#module_exec(arg...) {|var...| ... } ⇒ Object #class_exec(arg...) {|var...| ... } ⇒ Object

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!

Overloads:

  • #module_exec(arg...) {|var...| ... } ⇒ Object

    Yields:

    • (var...)

    Returns:

  • #class_exec(arg...) {|var...| ... } ⇒ Object

    Yields:

    • (var...)

    Returns:



6941
6942
6943
 
# File 'eval.c', line 6941

VALUE
rb_mod_module_exec(argc, argv, mod)
int argc;

#class_variable_defined?(symbol) ⇒ Boolean

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:

  • (Boolean) 


2174
2175
2176
 
# File 'object.c', line 2174

static VALUE
rb_mod_cvar_defined(obj, iv)
VALUE obj, iv;

#class_variable_get(symbol) ⇒ Object (private)

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

Returns:



2114
2115
2116
 
# File 'object.c', line 2114

static VALUE
rb_mod_cvar_get(obj, iv)
VALUE obj, iv;

#class_variable_set(symbol, obj) ⇒ Object (private)

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

Returns:



2147
2148
2149
 
# File 'object.c', line 2147

static VALUE
rb_mod_cvar_set(obj, iv, val)
VALUE obj, iv, val;

#class_variables ⇒ Array

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:



1897
1898
1899
 
# File 'variable.c', line 1897

VALUE
rb_mod_class_variables(obj)
VALUE obj;

#const_defined?(sym) ⇒ Boolean

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

Math.const_defined? "PI"   #=> true

Returns:

  • (Boolean) 


1875
1876
1877
 
# File 'object.c', line 1875

static VALUE
rb_mod_const_defined(mod, name)
VALUE mod, name;

#const_get(sym) ⇒ Object

Returns the value of the named constant in mod.

Math.const_get(:PI)   #=> 3.14159265358979

Returns:



1828
1829
1830
 
# File 'object.c', line 1828

static VALUE
rb_mod_const_get(mod, name)
VALUE mod, name;

#const_missing(sym) ⇒ Object

Invoked when a reference is made to an undefined constant in

<i>mod</i>. 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 <code>Fred</code> is
assumed to be in file <code>fred.rb</code>). 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

Returns:



1269
1270
1271
 
# File 'variable.c', line 1269

VALUE
rb_mod_const_missing(klass, name)
VALUE klass, name;

#const_set(sym, obj) ⇒ Object

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:



1852
1853
1854
 
# File 'object.c', line 1852

static VALUE
rb_mod_const_set(mod, name, value)
VALUE mod, name, value;

#constants ⇒ 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).

Returns:



1590
1591
1592
 
# File 'variable.c', line 1590

VALUE
rb_mod_constants(mod)
VALUE mod;

#define_method ⇒ Object (private)

#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

Returns:



7803
7804
7805
 
# File 'eval.c', line 7803

static VALUE
rb_mod_extend_object(mod, obj)
VALUE mod, obj;

#extended ⇒ Object (private)

Not documented



658
659
660
661
662
 
# File 'object.c', line 658

static VALUE
rb_obj_dummy()
{
    return Qnil;
}

#freeze ⇒ Object

Prevents further modifications to mod.



1314
1315
1316
 
# File 'object.c', line 1314

static VALUE
rb_mod_freeze(mod)
VALUE mod;

#include ⇒ self (private)

Invokes Module.append_features on each parameter in turn.

Returns:

  • (self) 


7742
7743
7744
 
# File 'eval.c', line 7742

static VALUE
rb_mod_include(argc, argv, module)
int argc;

#include? ⇒ 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

Returns:

  • (Boolean) 


494
495
496
 
# File 'class.c', line 494

VALUE
rb_mod_include_p(mod, mod2)
VALUE mod;

#included ⇒ Object (private)

Not documented



658
659
660
661
662
 
# File 'object.c', line 658

static VALUE
rb_obj_dummy()
{
    return Qnil;
}

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

Returns:



460
461
462
 
# File 'class.c', line 460

VALUE
rb_mod_included_modules(mod)
VALUE mod;

#initialize_copy ⇒ Object

:nodoc:



83
84
85
 
# File 'class.c', line 83

VALUE
rb_mod_init_copy(clone, orig)
VALUE clone, orig;

#instance_method(symbol) ⇒ Object

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!



9448
9449
9450
 
# File 'eval.c', line 9448

static VALUE
rb_mod_method(mod, vid)
VALUE mod;

#instance_methods(include_super = true) ⇒ Array

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:



686
687
688
 
# File 'class.c', line 686

VALUE
rb_class_instance_methods(argc, argv, mod)
int argc;

#method_added ⇒ Object (private)

Not documented



658
659
660
661
662
 
# File 'object.c', line 658

static VALUE
rb_obj_dummy()
{
    return Qnil;
}

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

Returns:

  • (Boolean) 


4300
4301
4302
 
# File 'eval.c', line 4300

static VALUE
rb_mod_method_defined(mod, mid)
VALUE mod, mid;

#method_removed ⇒ Object (private)

Not documented



658
659
660
661
662
 
# File 'object.c', line 658

static VALUE
rb_obj_dummy()
{
    return Qnil;
}

#method_undefined ⇒ Object (private)

Not documented



658
659
660
661
662
 
# File 'object.c', line 658

static VALUE
rb_obj_dummy()
{
    return Qnil;
}

#class_eval(string[, filename [, lineno]]) ⇒ Object #module_eval { ... } ⇒ Object

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

Overloads:

  • #class_eval(string[, filename [, lineno]]) ⇒ Object

    Returns:

  • #module_eval { ... } ⇒ Object

    Yields:

    Returns:



6912
6913
6914
 
# File 'eval.c', line 6912

VALUE
rb_mod_module_eval(argc, argv, mod)
int argc;

#module_exec(arg...) {|var...| ... } ⇒ Object #class_exec(arg...) {|var...| ... } ⇒ Object

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!

Overloads:

  • #module_exec(arg...) {|var...| ... } ⇒ Object

    Yields:

    • (var...)

    Returns:

  • #class_exec(arg...) {|var...| ... } ⇒ Object

    Yields:

    • (var...)

    Returns:



6941
6942
6943
 
# File 'eval.c', line 6941

VALUE
rb_mod_module_exec(argc, argv, mod)
int argc;

#module_function(symbol, ...) ⇒ self (private)

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"

Returns:

  • (self) 


7662
7663
7664
 
# File 'eval.c', line 7662

static VALUE
rb_mod_modfunc(argc, argv, module)
int argc;

#name ⇒ String

Returns the name of the module mod.

Returns:



176
177
178
 
# File 'variable.c', line 176

VALUE
rb_mod_name(mod)
VALUE mod;

#private ⇒ self (private) #private(symbol, ...) ⇒ self (private)

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

Overloads:

  • #private ⇒ self

    Returns:

    • (self)
  • #private(symbol, ...) ⇒ self

    Returns:

    • (self) 


7541
7542
7543
 
# File 'eval.c', line 7541

static VALUE
rb_mod_private(argc, argv, module)
int argc;

#private_class_method(symbol, ...) ⇒ Object

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



7590
7591
7592
 
# File 'eval.c', line 7590

static VALUE
rb_mod_private_method(argc, argv, obj)
int argc;

#private_instance_methods(include_super = true) ⇒ Array

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:



730
731
732
 
# File 'class.c', line 730

VALUE
rb_class_private_instance_methods(argc, argv, mod)
int argc;

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

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:

  • (Boolean) 


4375
4376
4377
 
# File 'eval.c', line 4375

static VALUE
rb_mod_private_method_defined(mod, mid)
VALUE mod, mid;

#protected ⇒ self (private) #protected(symbol, ...) ⇒ self (private)

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

Overloads:

  • #protected ⇒ self

    Returns:

    • (self)
  • #protected(symbol, ...) ⇒ self

    Returns:

    • (self) 


7506
7507
7508
 
# File 'eval.c', line 7506

static VALUE
rb_mod_protected(argc, argv, module)
int argc;

#protected_instance_methods(include_super = true) ⇒ Array

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:



704
705
706
 
# File 'class.c', line 704

VALUE
rb_class_protected_instance_methods(argc, argv, mod)
int argc;

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

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

Returns:

  • (Boolean) 


4415
4416
4417
 
# File 'eval.c', line 4415

static VALUE
rb_mod_protected_method_defined(mod, mid)
VALUE mod, mid;

#public ⇒ self (private) #public(symbol, ...) ⇒ self (private)

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

Overloads:

  • #public ⇒ self

    Returns:

    • (self)
  • #public(symbol, ...) ⇒ self

    Returns:

    • (self) 


7480
7481
7482
 
# File 'eval.c', line 7480

static VALUE
rb_mod_public(argc, argv, module)
int argc;

#public_class_method(symbol, ...) ⇒ Object

Makes a list of existing class methods public.



7564
7565
7566
 
# File 'eval.c', line 7564

static VALUE
rb_mod_public_method(argc, argv, obj)
int argc;

#public_instance_methods(include_super = true) ⇒ Array

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:



748
749
750
 
# File 'class.c', line 748

VALUE
rb_class_public_instance_methods(argc, argv, mod)
int argc;

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

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

Returns:

  • (Boolean) 


4335
4336
4337
 
# File 'eval.c', line 4335

static VALUE
rb_mod_public_method_defined(mod, mid)
VALUE mod, mid;

#remove_class_variable(sym) ⇒ Object (private)

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

Returns:



1933
1934
1935
 
# File 'variable.c', line 1933

VALUE
rb_mod_remove_cvar(mod, name)
VALUE mod, name;

#remove_const(sym) ⇒ Object (private)

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

Returns:



1483
1484
1485
 
# File 'variable.c', line 1483

VALUE
rb_mod_remove_const(mod, name)
VALUE mod, name;

#remove_method(symbol) ⇒ self (private)

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

Returns:

  • (self) 


607
608
609
 
# File 'eval.c', line 607

static VALUE
rb_mod_remove_method(argc, argv, mod)
int argc;

#to_s ⇒ String

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.

Returns:



1282
1283
1284
 
# File 'object.c', line 1282

static VALUE
rb_mod_to_s(klass)
VALUE klass;

#undef_method(symbol) ⇒ self (private)

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)

Returns:

  • (self) 


2145
2146
2147
 
# File 'eval.c', line 2145

static VALUE
rb_mod_undef_method(argc, argv, mod)
int argc;