Class: Module (Ruby 3.0.0) (original) (raw)
constants → array click to toggle source
constants(inherited) → array
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)
Module.constants.include?(:SEEK_SET)
class IO Module.constants.include?(:SEEK_SET) end
The second form calls the instance method constants.
static VALUErb_mod_s_constants(int argc, VALUE *argv, VALUE mod) { const rb_cref_t *cref = rb_vm_cref(); VALUE klass; VALUE cbase = 0; void *data = 0;
if (argc > 0 || mod != rb_cModule) {
return rb_mod_constants(argc, argv, mod);
}
while (cref) {
klass = CREF_CLASS(cref);
if (!CREF_PUSHED_BY_EVAL(cref) &&
!NIL_P(klass)) {
data = rb_mod_const_at(CREF_CLASS(cref), data);
if (!cbase) {
cbase = klass;
}
}
cref = CREF_NEXT(cref);
}
if (cbase) {
data = rb_mod_const_of(cbase, data);
}
return rb_const_list(data);}
nesting → array click to toggle source
Returns the list of Modules nested at the point of call.
module M1
module M2
$a = Module.nesting
end
end
$a
$a[0].name
static VALUErb_mod_nesting(VALUE _) { VALUE ary = rb_ary_new(); const rb_cref_t *cref = rb_vm_cref();
while (cref && CREF_NEXT(cref)) {
VALUE klass = CREF_CLASS(cref);
if (!CREF_PUSHED_BY_EVAL(cref) &&
!NIL_P(klass)) {
rb_ary_push(ary, klass);
}
cref = CREF_NEXT(cref);
}
return ary;}
new → mod click to toggle source
new {|mod| block } → 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 like module_eval.
fred = Module.new do
def meth1
"hello"
end
def meth2
"bye"
end
end
a = "my string"
a.extend(fred)
a.meth1
a.meth2
Assign the module to a constant (name starting uppercase) if you want to treat it like a regular module.
static VALUErb_mod_initialize(VALUE module) { if (rb_block_given_p()) { rb_mod_module_exec(1, &module, module); } return Qnil; }
used_modules → array click to toggle source
Returns an array of all modules used in the current scope. The ordering of modules in the resulting array is not defined.
module A refine Object do end end
module B refine Object do end end
using A using B p Module.used_modules
produces:
[B, A]
static VALUErb_mod_s_used_modules(VALUE _) { const rb_cref_t *cref = rb_vm_cref(); VALUE ary = rb_ary_new();
while (cref) {
if (!NIL_P(CREF_REFINEMENTS(cref))) {
rb_hash_foreach(CREF_REFINEMENTS(cref), used_modules_i, ary);
}
cref = CREF_NEXT(cref);
}
return rb_funcall(ary, rb_intern("uniq"), 0);}
mod < other → true, false, or nil click to toggle source
Returns true if mod is a subclass of other. Returnsnil if there's no relationship between the two. (Think of the relationship in terms of the class definition: “class A < B” implies “A < B”.)
static VALUErb_mod_lt(VALUE mod, VALUE arg) { if (mod == arg) return Qfalse; return rb_class_inherited_p(mod, arg); }
mod <= other → true, false, or nil click to toggle source
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”.)
VALUErb_class_inherited_p(VALUE mod, VALUE arg) { if (mod == arg) return Qtrue; if (!CLASS_OR_MODULE_P(arg) && !RB_TYPE_P(arg, T_ICLASS)) { rb_raise(rb_eTypeError, "compared with non class/module"); } if (class_search_ancestor(mod, RCLASS_ORIGIN(arg))) { return Qtrue; } /* not mod < arg; check if mod > arg */ if (class_search_ancestor(arg, mod)) { return Qfalse; } return Qnil; }
module <=> other_module → -1, 0, +1, or nil click to toggle source
Comparison—Returns -1, 0, +1 or nil depending on whethermodule includes other_module, they are the same, or if module is included by other_module.
Returns nil if module has no relationship withother_module, if other_module is not a module, or if the two values are incomparable.
static VALUErb_mod_cmp(VALUE mod, VALUE arg) { VALUE cmp;
if (mod == arg) return INT2FIX(0);
if (!CLASS_OR_MODULE_P(arg)) {
return Qnil;
}
cmp = rb_class_inherited_p(mod, arg);
if (NIL_P(cmp)) return Qnil;
if (cmp) {
return INT2FIX(-1);
}
return INT2FIX(1);}
obj == other → true or false click to toggle source
equal?(other) → true or false
eql?(other) → true or false
Equality — At the Object level, #== returnstrue 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 ifa is the same object as b):
obj = "a" other = obj.dup
obj == other
obj.equal? other
obj.equal? obj
The eql? method returnstrue if obj and other refer to the same hash key. This is used by Hash to test members for equality. For any pair of objects where eql? returns true, thehash value of both objects must be equal. So any subclass that overrides eql? should also override hash appropriately.
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
1.eql? 1.0
MJIT_FUNC_EXPORTED VALUErb_obj_equal(VALUE obj1, VALUE obj2) { if (obj1 == obj2) return Qtrue; return Qfalse; }
mod === obj → true or false click to toggle source
Case Equality—Returns true if obj is an instance of_mod_ or an instance of one of mod's descendants. Of limited use for modules, but can be used in case statements to classify objects by class.
static VALUErb_mod_eqq(VALUE mod, VALUE arg) { return rb_obj_is_kind_of(arg, mod); }
mod > other → true, false, or nil click to toggle source
Returns true if mod is an ancestor of other. Returnsnil if there's no relationship between the two. (Think of the relationship in terms of the class definition: “class A < B” implies “B > A”.)
static VALUErb_mod_gt(VALUE mod, VALUE arg) { if (mod == arg) return Qfalse; return rb_mod_ge(mod, arg); }
mod >= other → true, false, or nil click to toggle source
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”.)
static VALUErb_mod_ge(VALUE mod, VALUE arg) { if (!CLASS_OR_MODULE_P(arg)) { rb_raise(rb_eTypeError, "compared with non class/module"); }
return rb_class_inherited_p(arg, mod);}
alias_method(new_name, old_name) → symbol click to toggle source
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
static VALUErb_mod_alias_method(VALUE mod, VALUE newname, VALUE oldname) { ID oldid = rb_check_id(&oldname); if (!oldid) { rb_print_undef_str(mod, oldname); } VALUE id = rb_to_id(newname); rb_alias(mod, id, oldid); return ID2SYM(id); }
ancestors → array click to toggle source
Returns a list of modules included/prepended in mod (including_mod_ itself).
module Mod include Math include Comparable prepend Enumerable end
Mod.ancestors
Math.ancestors
Enumerable.ancestors
VALUErb_mod_ancestors(VALUE mod) { VALUE p, ary = rb_ary_new();
for (p = mod; p; p = RCLASS_SUPER(p)) {
if (p != RCLASS_ORIGIN(p)) continue;
if (BUILTIN_TYPE(p) == T_ICLASS) {
rb_ary_push(ary, RBASIC(p)->klass);
}
else {
rb_ary_push(ary, p);
}
}
return ary;}
attr(name, ...) → array click to toggle source
attr(name, true) → array
attr(name, false) → array
The first form is equivalent to attr_reader. The second form is equivalent to attr_accessor(name) but deprecated. The last form is equivalent to attr_reader(name) but deprecated. Returns an array of defined method names as symbols.
VALUErb_mod_attr(int argc, VALUE *argv, VALUE klass) { if (argc == 2 && (argv[1] == Qtrue || argv[1] == Qfalse)) { ID id = id_for_attr(klass, argv[0]); VALUE names = rb_ary_new();
rb_category_warning(RB_WARN_CATEGORY_DEPRECATED, "optional boolean argument is obsoleted");
rb_attr(klass, id, 1, RTEST(argv[1]), TRUE);
rb_ary_push(names, ID2SYM(id));
if (argv[1] == Qtrue) rb_ary_push(names, ID2SYM(rb_id_attrset(id)));
return names;
}
return rb_mod_attr_reader(argc, argv, klass);}
attr_accessor(symbol, ...) → array click to toggle source
attr_accessor(string, ...) → array
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. Returns an array of defined method names as symbols.
module Mod attr_accessor(:one, :two) end Mod.instance_methods.sort
static VALUErb_mod_attr_accessor(int argc, VALUE *argv, VALUE klass) { int i; VALUE names = rb_ary_new2(argc * 2);
for (i=0; i<argc; i++) {
ID id = id_for_attr(klass, argv[i]);
rb_attr(klass, id, TRUE, TRUE, TRUE);
rb_ary_push(names, ID2SYM(id));
rb_ary_push(names, ID2SYM(rb_id_attrset(id)));
}
return names;}
attr_reader(symbol, ...) → array click to toggle source
attr(symbol, ...) → array
attr_reader(string, ...) → array
attr(string, ...) → array
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. Returns an array of defined method names as symbols.
static VALUErb_mod_attr_reader(int argc, VALUE *argv, VALUE klass) { int i; VALUE names = rb_ary_new2(argc);
for (i=0; i<argc; i++) {
ID id = id_for_attr(klass, argv[i]);
rb_attr(klass, id, TRUE, FALSE, TRUE);
rb_ary_push(names, ID2SYM(id));
}
return names;}
attr_writer(symbol, ...) → array click to toggle source
attr_writer(string, ...) → array
Creates an accessor method to allow assignment to the attribute_symbol_.id2name. Stringarguments are converted to symbols. Returns an array of defined method names as symbols.
static VALUErb_mod_attr_writer(int argc, VALUE *argv, VALUE klass) { int i; VALUE names = rb_ary_new2(argc);
for (i=0; i<argc; i++) {
ID id = id_for_attr(klass, argv[i]);
rb_attr(klass, id, FALSE, TRUE, TRUE);
rb_ary_push(names, ID2SYM(rb_id_attrset(id)));
}
return names;}
autoload(module, filename) → nil click to toggle source
Registers filename to be loaded (using Kernel::require) the first time that module (which may be a Stringor a symbol) is accessed in the namespace of mod.
module A end A.autoload(:B, "b") A::B.doit
static VALUErb_mod_autoload(VALUE mod, VALUE sym, VALUE file) { ID id = rb_to_id(sym);
FilePathValue(file);
rb_autoload_str(mod, id, file);
return Qnil;}
autoload?(name, inherit=true) → String or nil click to toggle source
Returns filename to be loaded if name is registered asautoload in the namespace of mod or one of its ancestors.
module A end A.autoload(:B, "b") A.autoload?(:B)
If inherit is false, the lookup only checks the autoloads in the receiver:
class A autoload :CONST, "const.rb" end
class B < A end
B.autoload?(:CONST)
B.autoload?(:CONST, false)
static VALUErb_mod_autoload_p(int argc, VALUE *argv, VALUE mod) { int recur = (rb_check_arity(argc, 1, 2) == 1) ? TRUE : RTEST(argv[1]); VALUE sym = argv[0];
ID id = rb_check_id(&sym);
if (!id) {
return Qnil;
}
return rb_autoload_at_p(mod, id, recur);}
class_eval(string [, filename [, lineno]]) → obj click to toggle source
class_eval {|mod| block } → obj
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
static VALUErb_mod_module_eval_internal(int argc, const VALUE *argv, VALUE mod) { return specific_eval(argc, argv, mod, mod, RB_PASS_CALLED_KEYWORDS); }
class_exec(arg...) {|var...| block } → obj click to toggle source
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!
static VALUErb_mod_module_exec_internal(int argc, const VALUE *argv, VALUE mod) { return yield_under(mod, mod, argc, argv, RB_PASS_CALLED_KEYWORDS); }
class_variable_defined?(symbol) → true or false click to toggle source
class_variable_defined?(string) → true or false
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)
Fred.class_variable_defined?(:@@bar)
static VALUErb_mod_cvar_defined(VALUE obj, VALUE iv) { ID id = id_for_var(obj, iv, class);
if (!id) {
return Qfalse;
}
return rb_cvar_defined(obj, id);}
class_variable_get(symbol) → obj click to toggle source
class_variable_get(string) → obj
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)
static VALUErb_mod_cvar_get(VALUE obj, VALUE iv) { ID id = id_for_var(obj, iv, class);
if (!id) {
rb_name_err_raise("uninitialized class variable %1$s in %2$s",
obj, iv);
}
return rb_cvar_get(obj, id);}
class_variable_set(symbol, obj) → obj click to toggle source
class_variable_set(string, obj) → obj
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)
Fred.new.foo
static VALUErb_mod_cvar_set(VALUE obj, VALUE iv, VALUE val) { ID id = id_for_var(obj, iv, class); if (!id) id = rb_intern_str(iv); rb_cvar_set(obj, id, val); return val; }
class_variables(inherit=true) → array click to toggle source
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
Two.class_variables
Two.class_variables(false)
VALUErb_mod_class_variables(int argc, const VALUE *argv, VALUE mod) { bool inherit = true; st_table *tbl;
if (rb_check_arity(argc, 0, 1)) inherit = RTEST(argv[0]);
if (inherit) {
tbl = mod_cvar_of(mod, 0);
}
else {
tbl = mod_cvar_at(mod, 0);
}
return cvar_list(tbl);}
const_defined?(sym, inherit=true) → true or false click to toggle source
const_defined?(str, inherit=true) → true or false
Says whether mod or its ancestors have a constant with the given name:
Float.const_defined?(:EPSILON)
Float.const_defined?("String")
BasicObject.const_defined?(:Hash)
If mod is a Module, additionally Objectand its ancestors are checked:
Math.const_defined?(:String)
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)
If the constant is not found the callback const_missing isnot called and the method returns false.
If inherit is false, the lookup only checks the constants in the receiver:
IO.const_defined?(:SYNC)
IO.const_defined?(:SYNC, false)
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'
static VALUErb_mod_const_defined(int argc, VALUE *argv, VALUE mod) { VALUE name, recur; rb_encoding *enc; const char *pbeg, *p, *path, *pend; ID id;
rb_check_arity(argc, 1, 2);
name = argv[0];
recur = (argc == 1) ? Qtrue : argv[1];
if (SYMBOL_P(name)) {
if (!rb_is_const_sym(name)) goto wrong_name;
id = rb_check_id(&name);
if (!id) return Qfalse;
return RTEST(recur) ? rb_const_defined(mod, id) : rb_const_defined_at(mod, id);
}
path = StringValuePtr(name);
enc = rb_enc_get(name);
if (!rb_enc_asciicompat(enc)) {
rb_raise(rb_eArgError, "invalid class path encoding (non ASCII)");
}
pbeg = p = path;
pend = path + RSTRING_LEN(name);
if (p >= pend || !*p) {
goto wrong_name;
}
if (p + 2 < pend && p[0] == ':' && p[1] == ':') {
mod = rb_cObject;
p += 2;
pbeg = p;
}
while (p < pend) {
VALUE part;
long len, beglen;
while (p < pend && *p != ':') p++;
if (pbeg == p) goto wrong_name;
id = rb_check_id_cstr(pbeg, len = p-pbeg, enc);
beglen = pbeg-path;
if (p < pend && p[0] == ':') {
if (p + 2 >= pend || p[1] != ':') goto wrong_name;
p += 2;
pbeg = p;
}
if (!id) {
part = rb_str_subseq(name, beglen, len);
OBJ_FREEZE(part);
if (!rb_is_const_name(part)) {
name = part;
goto wrong_name;
}
else {
return Qfalse;
}
}
if (!rb_is_const_id(id)) {
name = ID2SYM(id);
goto wrong_name;
}#if 0 mod = rb_const_search(mod, id, beglen > 0 || !RTEST(recur), RTEST(recur), FALSE); if (mod == Qundef) return Qfalse; #else if (!RTEST(recur)) { if (!rb_const_defined_at(mod, id)) return Qfalse; if (p == pend) return Qtrue; mod = rb_const_get_at(mod, id); } else if (beglen == 0) { if (!rb_const_defined(mod, id)) return Qfalse; if (p == pend) return Qtrue; mod = rb_const_get(mod, id); } else { if (!rb_const_defined_from(mod, id)) return Qfalse; if (p == pend) return Qtrue; mod = rb_const_get_from(mod, id); } #endif
if (p < pend && !RB_TYPE_P(mod, T_MODULE) && !RB_TYPE_P(mod, T_CLASS)) {
rb_raise(rb_eTypeError, "%"PRIsVALUE" does not refer to class/module",
QUOTE(name));
}
}
return Qtrue;wrong_name: rb_name_err_raise(wrong_constant_name, mod, name); UNREACHABLE_RETURN(Qundef); }
const_get(sym, inherit=true) → obj click to toggle source
const_get(str, inherit=true) → obj
Checks for a constant with the given name in mod. Ifinherit is set, the lookup will also search the ancestors (andObject if mod is a Module).
The value of the constant is returned if a definition is found, otherwise aNameError is raised.
Math.const_get(:PI)
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'
Object.const_get 'Foo::Baz::VAL', false
If the argument is not a valid constant name a NameError will be raised with a warning “wrong constant name”.
Object.const_get 'foobar'
static VALUErb_mod_const_get(int argc, VALUE *argv, VALUE mod) { VALUE name, recur; rb_encoding *enc; const char *pbeg, *p, *path, *pend; ID id;
rb_check_arity(argc, 1, 2);
name = argv[0];
recur = (argc == 1) ? Qtrue : argv[1];
if (SYMBOL_P(name)) {
if (!rb_is_const_sym(name)) goto wrong_name;
id = rb_check_id(&name);
if (!id) return rb_const_missing(mod, name);
return RTEST(recur) ? rb_const_get(mod, id) : rb_const_get_at(mod, id);
}
path = StringValuePtr(name);
enc = rb_enc_get(name);
if (!rb_enc_asciicompat(enc)) {
rb_raise(rb_eArgError, "invalid class path encoding (non ASCII)");
}
pbeg = p = path;
pend = path + RSTRING_LEN(name);
if (p >= pend || !*p) {
goto wrong_name;
}
if (p + 2 < pend && p[0] == ':' && p[1] == ':') {
mod = rb_cObject;
p += 2;
pbeg = p;
}
while (p < pend) {
VALUE part;
long len, beglen;
while (p < pend && *p != ':') p++;
if (pbeg == p) goto wrong_name;
id = rb_check_id_cstr(pbeg, len = p-pbeg, enc);
beglen = pbeg-path;
if (p < pend && p[0] == ':') {
if (p + 2 >= pend || p[1] != ':') goto wrong_name;
p += 2;
pbeg = p;
}
if (!RB_TYPE_P(mod, T_MODULE) && !RB_TYPE_P(mod, T_CLASS)) {
rb_raise(rb_eTypeError, "%"PRIsVALUE" does not refer to class/module",
QUOTE(name));
}
if (!id) {
part = rb_str_subseq(name, beglen, len);
OBJ_FREEZE(part);
if (!rb_is_const_name(part)) {
name = part;
goto wrong_name;
}
else if (!rb_method_basic_definition_p(CLASS_OF(mod), id_const_missing)) {
part = rb_str_intern(part);
mod = rb_const_missing(mod, part);
continue;
}
else {
rb_mod_const_missing(mod, part);
}
}
if (!rb_is_const_id(id)) {
name = ID2SYM(id);
goto wrong_name;
}#if 0 mod = rb_const_get_0(mod, id, beglen > 0 || !RTEST(recur), RTEST(recur), FALSE); #else if (!RTEST(recur)) { mod = rb_const_get_at(mod, id); } else if (beglen == 0) { mod = rb_const_get(mod, id); } else { mod = rb_const_get_from(mod, id); } #endif }
return mod;wrong_name: rb_name_err_raise(wrong_constant_name, mod, name); UNREACHABLE_RETURN(Qundef); }
const_missing(sym) → obj click to toggle source
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 end
Foo::UNDEFINED_CONST
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 filefred.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
VALUErb_mod_const_missing(VALUE klass, VALUE name) { VALUE ref = GET_EC()->private_const_reference; rb_vm_pop_cfunc_frame(); if (ref) { rb_name_err_raise("private constant %2$s::%1$s referenced", ref, name); } uninitialized_constant(klass, name);
UNREACHABLE_RETURN(Qnil);}
const_set(sym, obj) → obj click to toggle source
const_set(str, obj) → obj
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)
Math::HIGH_SCHOOL_PI - Math::PI
If sym or str is not a valid constant name aNameError will be raised with a warning “wrong constant name”.
Object.const_set('foobar', 42)
static VALUErb_mod_const_set(VALUE mod, VALUE name, VALUE value) { ID id = id_for_var(mod, name, const); if (!id) id = rb_intern_str(name); rb_const_set(mod, id, value);
return value;}
const_source_location(sym, inherit=true) → [String, Integer] click to toggle source
const_source_location(str, inherit=true) → [String, Integer]
Returns the Ruby source filename and line number containing the definition of the constant specified. If the named constant is not found,nil is returned. If the constant is found, but its source location can not be extracted (constant is defined in C code), empty array is returned.
inherit specifies whether to lookup in mod.ancestors(true by default).
class A
C1 = 1
C2 = 2
end
module M
C3 = 3
end
class B < A
include M
C4 = 4
end
class A C2 = 8 end
p B.const_source_location('C4')
p B.const_source_location('C3')
p B.const_source_location('C1')
p B.const_source_location('C3', false)
p A.const_source_location('C2')
p Object.const_source_location('B')
p Object.const_source_location('A')
p B.const_source_location('A')
p M.const_source_location('A')
p Object.const_source_location('A::C1')
p Object.const_source_location('String')
static VALUErb_mod_const_source_location(int argc, VALUE *argv, VALUE mod) { VALUE name, recur, loc = Qnil; rb_encoding *enc; const char *pbeg, *p, *path, *pend; ID id;
rb_check_arity(argc, 1, 2);
name = argv[0];
recur = (argc == 1) ? Qtrue : argv[1];
if (SYMBOL_P(name)) {
if (!rb_is_const_sym(name)) goto wrong_name;
id = rb_check_id(&name);
if (!id) return Qnil;
return RTEST(recur) ? rb_const_source_location(mod, id) : rb_const_source_location_at(mod, id);
}
path = StringValuePtr(name);
enc = rb_enc_get(name);
if (!rb_enc_asciicompat(enc)) {
rb_raise(rb_eArgError, "invalid class path encoding (non ASCII)");
}
pbeg = p = path;
pend = path + RSTRING_LEN(name);
if (p >= pend || !*p) {
goto wrong_name;
}
if (p + 2 < pend && p[0] == ':' && p[1] == ':') {
mod = rb_cObject;
p += 2;
pbeg = p;
}
while (p < pend) {
VALUE part;
long len, beglen;
while (p < pend && *p != ':') p++;
if (pbeg == p) goto wrong_name;
id = rb_check_id_cstr(pbeg, len = p-pbeg, enc);
beglen = pbeg-path;
if (p < pend && p[0] == ':') {
if (p + 2 >= pend || p[1] != ':') goto wrong_name;
p += 2;
pbeg = p;
}
if (!id) {
part = rb_str_subseq(name, beglen, len);
OBJ_FREEZE(part);
if (!rb_is_const_name(part)) {
name = part;
goto wrong_name;
}
else {
return Qnil;
}
}
if (!rb_is_const_id(id)) {
name = ID2SYM(id);
goto wrong_name;
}
if (p < pend) {
if (RTEST(recur)) {
mod = rb_const_get(mod, id);
}
else {
mod = rb_const_get_at(mod, id);
}
if (!RB_TYPE_P(mod, T_MODULE) && !RB_TYPE_P(mod, T_CLASS)) {
rb_raise(rb_eTypeError, "%"PRIsVALUE" does not refer to class/module",
QUOTE(name));
}
}
else {
if (RTEST(recur)) {
loc = rb_const_source_location(mod, id);
}
else {
loc = rb_const_source_location_at(mod, id);
}
break;
}
recur = Qfalse;
}
return loc;wrong_name: rb_name_err_raise(wrong_constant_name, mod, name); UNREACHABLE_RETURN(Qundef); }
constants(inherit=true) → array click to toggle source
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 tofalse.
The implementation makes no guarantees about the order in which the constants are yielded.
IO.constants.include?(:SYNC)
IO.constants(false).include?(:SYNC)
Also see #const_defined?.
VALUErb_mod_constants(int argc, const VALUE *argv, VALUE mod) { bool inherit = true;
if (rb_check_arity(argc, 0, 1)) inherit = RTEST(argv[0]);
if (inherit) {
return rb_const_list(rb_mod_const_of(mod, 0));
}
else {
return rb_local_constants(mod);
}}
define_method(symbol, method) → symbol click to toggle source
define_method(symbol) { block } → symbol
Defines an instance method in the receiver. The method parameter can be a Proc, a Method or anUnboundMethod object. If a block is specified, it is used as the method body. If a block or the method parameter has parameters, they're used as method parameters. This block is evaluated using instance_eval.
class A def fred puts "In Fred" end def create_method(name, &block) self.class.define_method(name, &block) end define_method(:wilma) { puts "Charge it!" } define_method(:flint) {|name| puts "I'm #{name}!"} end class B < A define_method(:barney, instance_method(:fred)) end a = B.new a.barney a.wilma a.flint('Dino') a.create_method(:betty) { p self } a.betty
produces:
In Fred Charge it! I'm Dino! #<B:0x401b39e8>
static VALUErb_mod_define_method(int argc, VALUE *argv, VALUE mod) { ID id; VALUE body; VALUE name; const rb_cref_t *cref = rb_vm_cref_in_context(mod, mod); const rb_scope_visibility_t default_scope_visi = {METHOD_VISI_PUBLIC, FALSE}; const rb_scope_visibility_t *scope_visi = &default_scope_visi; int is_method = FALSE;
if (cref) {
scope_visi = CREF_SCOPE_VISI(cref);
}
rb_check_arity(argc, 1, 2);
name = argv[0];
id = rb_check_id(&name);
if (argc == 1) {
body = rb_block_lambda();
}
else {
body = argv[1];
if (rb_obj_is_method(body)) {
is_method = TRUE;
}
else if (rb_obj_is_proc(body)) {
is_method = FALSE;
}
else {
rb_raise(rb_eTypeError,
"wrong argument type %s (expected Proc/Method/UnboundMethod)",
rb_obj_classname(body));
}
}
if (!id) id = rb_to_id(name);
if (is_method) {
struct METHOD *method = (struct METHOD *)DATA_PTR(body);
if (method->me->owner != mod && !RB_TYPE_P(method->me->owner, T_MODULE) &&
!RTEST(rb_class_inherited_p(mod, method->me->owner))) {
if (FL_TEST(method->me->owner, FL_SINGLETON)) {
rb_raise(rb_eTypeError,
"can't bind singleton method to a different class");
}
else {
rb_raise(rb_eTypeError,
"bind argument must be a subclass of % "PRIsVALUE,
method->me->owner);
}
}
rb_method_entry_set(mod, id, method->me, scope_visi->method_visi);
if (scope_visi->module_func) {
rb_method_entry_set(rb_singleton_class(mod), id, method->me, METHOD_VISI_PUBLIC);
}
RB_GC_GUARD(body);
}
else {
VALUE procval = rb_proc_dup(body);
if (vm_proc_iseq(procval) != NULL) {
rb_proc_t *proc;
GetProcPtr(procval, proc);
proc->is_lambda = TRUE;
proc->is_from_method = TRUE;
}
rb_add_method(mod, id, VM_METHOD_TYPE_BMETHOD, (void *)procval, scope_visi->method_visi);
if (scope_visi->module_func) {
rb_add_method(rb_singleton_class(mod), id, VM_METHOD_TYPE_BMETHOD, (void *)body, METHOD_VISI_PUBLIC);
}
}
return ID2SYM(id);}
deprecate_constant(symbol, ...) => mod click to toggle source
Makes a list of existing constants deprecated. Attempt to refer to them will produce a warning.
module HTTP NotFound = Exception.new NOT_FOUND = NotFound
deprecate_constant :NOT_FOUND end
HTTP::NOT_FOUND
VALUErb_mod_deprecate_constant(int argc, const VALUE *argv, VALUE obj) { set_const_visibility(obj, argc, argv, CONST_DEPRECATED, CONST_DEPRECATED); return obj; }
freeze → mod click to toggle source
Prevents further modifications to mod.
This method returns self.
static VALUErb_mod_freeze(VALUE mod) { rb_class_name(mod); return rb_obj_freeze(mod); }
include(module, ...) → self click to toggle source
Invokes #append_featureson each parameter in reverse order.
static VALUErb_mod_include(int argc, VALUE *argv, VALUE module) { int i; ID id_append_features, id_included;
CONST_ID(id_append_features, "append_features");
CONST_ID(id_included, "included");
rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
for (i = 0; i < argc; i++)
Check_Type(argv[i], T_MODULE);
while (argc--) {
rb_funcall(argv[argc], id_append_features, 1, module);
rb_funcall(argv[argc], id_included, 1, module);
}
return module;}
include?(module) → true or false click to toggle source
Returns true if module is included or prepended in_mod_ or one of mod's ancestors.
module A
end
class B
include A
end
class C < B
end
B.include?(A)
C.include?(A)
A.include?(A)
VALUErb_mod_include_p(VALUE mod, VALUE mod2) { VALUE p;
Check_Type(mod2, T_MODULE);
for (p = RCLASS_SUPER(mod); p; p = RCLASS_SUPER(p)) {
if (BUILTIN_TYPE(p) == T_ICLASS && !FL_TEST(p, RICLASS_IS_ORIGIN)) {
if (RBASIC(p)->klass == mod2) return Qtrue;
}
}
return Qfalse;}
included_modules → array click to toggle source
Returns the list of modules included or prepended in mod or one of_mod_'s ancestors.
module Sub end
module Mixin prepend Sub end
module Outer include Mixin end
Mixin.included_modules
Outer.included_modules
VALUErb_mod_included_modules(VALUE mod) { VALUE ary = rb_ary_new(); VALUE p; VALUE origin = RCLASS_ORIGIN(mod);
for (p = RCLASS_SUPER(mod); p; p = RCLASS_SUPER(p)) {
if (p != origin && RCLASS_ORIGIN(p) == p && BUILTIN_TYPE(p) == T_ICLASS) {
VALUE m = RBASIC(p)->klass;
if (RB_TYPE_P(m, T_MODULE))
rb_ary_push(ary, m);
}
}
return ary;}
inspect() click to toggle source
instance_method(symbol) → unbound_method click to toggle source
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!
static VALUErb_mod_instance_method(VALUE mod, VALUE vid) { ID id = rb_check_id(&vid); if (!id) { rb_method_name_error(mod, vid); } return mnew(mod, Qundef, id, rb_cUnboundMethod, FALSE); }
instance_methods(include_super=true) → array click to toggle source
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)
B.instance_methods(false)
B.instance_methods(true).include?(:method1)
C.instance_methods(false)
C.instance_methods.include?(:method2)
VALUErb_class_instance_methods(int argc, const VALUE *argv, VALUE mod) { return class_instance_method_list(argc, argv, mod, 0, ins_methods_i); }
method_defined?(symbol, inherit=true) → true or false click to toggle source
method_defined?(string, inherit=true) → true or false
Returns true if the named method is defined by mod. If inherit is set, the lookup will also search mod's 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
C.method_defined? "method1"
C.method_defined? "method2"
C.method_defined? "method2", true
C.method_defined? "method2", false
C.method_defined? "method3"
C.method_defined? "protected_method1"
C.method_defined? "method4"
C.method_defined? "private_method2"
static VALUErb_mod_method_defined(int argc, VALUE *argv, VALUE mod) { rb_method_visibility_t visi = check_definition_visibility(mod, argc, argv); return (visi == METHOD_VISI_PUBLIC || visi == METHOD_VISI_PROTECTED) ? Qtrue : Qfalse; }
module_eval(string [, filename [, lineno]]) → obj click to toggle source
module_eval {|mod| block } → obj
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
static VALUErb_mod_module_eval_internal(int argc, const VALUE *argv, VALUE mod) { return specific_eval(argc, argv, mod, mod, RB_PASS_CALLED_KEYWORDS); }
module_exec(arg...) {|var...| block } → obj click to toggle source
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!
static VALUErb_mod_module_exec_internal(int argc, const VALUE *argv, VALUE mod) { return yield_under(mod, mod, argc, argv, RB_PASS_CALLED_KEYWORDS); }
name → string click to toggle source
Returns the name of the module mod. Returns nil for anonymous modules.
VALUErb_mod_name(VALUE mod) { int permanent; return classname(mod, &permanent); }
prepend(module, ...) → self click to toggle source
Invokes #prepend_features on each parameter in reverse order.
static VALUErb_mod_prepend(int argc, VALUE *argv, VALUE module) { int i; ID id_prepend_features, id_prepended;
CONST_ID(id_prepend_features, "prepend_features");
CONST_ID(id_prepended, "prepended");
rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
for (i = 0; i < argc; i++)
Check_Type(argv[i], T_MODULE);
while (argc--) {
rb_funcall(argv[argc], id_prepend_features, 1, module);
rb_funcall(argv[argc], id_prepended, 1, module);
}
return module;}
private_class_method(symbol, ...) → mod click to toggle source
private_class_method(string, ...) → mod
private_class_method(array) → mod
Makes existing class methods private. Often used to hide the default constructor new.
String arguments are converted to symbols. An Array of Symbols and/or Strings are also accepted.
class SimpleSingleton
private_class_method :new
def SimpleSingleton.create(*args, &block)
@me = new(*args, &block) if ! @me
@me
end
end
static VALUErb_mod_private_method(int argc, VALUE *argv, VALUE obj) { set_method_visibility(rb_singleton_class(obj), argc, argv, METHOD_VISI_PRIVATE); return obj; }
private_constant(symbol, ...) => mod click to toggle source
Makes a list of existing constants private.
VALUErb_mod_private_constant(int argc, const VALUE *argv, VALUE obj) { set_const_visibility(obj, argc, argv, CONST_PRIVATE, CONST_VISIBILITY_MASK); return obj; }
private_instance_methods(include_super=true) → array click to toggle source
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
Mod.private_instance_methods
VALUErb_class_private_instance_methods(int argc, const VALUE *argv, VALUE mod) { return class_instance_method_list(argc, argv, mod, 0, ins_methods_priv_i); }
private_method_defined?(symbol, inherit=true) → true or false click to toggle source
private_method_defined?(string, inherit=true) → true or false
Returns true if the named private method is defined by_mod_. If inherit is set, the lookup will also search_mod_'s 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
C.private_method_defined? "method1"
C.private_method_defined? "method2"
C.private_method_defined? "method2", true
C.private_method_defined? "method2", false
C.method_defined? "method2"
static VALUErb_mod_private_method_defined(int argc, VALUE *argv, VALUE mod) { return check_definition(mod, argc, argv, METHOD_VISI_PRIVATE); }
protected_instance_methods(include_super=true) → array click to toggle source
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.
VALUErb_class_protected_instance_methods(int argc, const VALUE *argv, VALUE mod) { return class_instance_method_list(argc, argv, mod, 0, ins_methods_prot_i); }
protected_method_defined?(symbol, inherit=true) → true or false click to toggle source
protected_method_defined?(string, inherit=true) → true or false
Returns true if the named protected method is defined_mod_. If inherit is set, the lookup will also search_mod_'s 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
C.protected_method_defined? "method1"
C.protected_method_defined? "method2"
C.protected_method_defined? "method2", true
C.protected_method_defined? "method2", false
C.method_defined? "method2"
static VALUErb_mod_protected_method_defined(int argc, VALUE *argv, VALUE mod) { return check_definition(mod, argc, argv, METHOD_VISI_PROTECTED); }
public_class_method(symbol, ...) → mod click to toggle source
public_class_method(string, ...) → mod
public_class_method(array) → mod
Makes a list of existing class methods public.
String arguments are converted to symbols. An Array of Symbols and/or Strings are also accepted.
static VALUErb_mod_public_method(int argc, VALUE *argv, VALUE obj) { set_method_visibility(rb_singleton_class(obj), argc, argv, METHOD_VISI_PUBLIC); return obj; }
public_constant(symbol, ...) => mod click to toggle source
Makes a list of existing constants public.
VALUErb_mod_public_constant(int argc, const VALUE *argv, VALUE obj) { set_const_visibility(obj, argc, argv, CONST_PUBLIC, CONST_VISIBILITY_MASK); return obj; }
public_instance_method(symbol) → unbound_method click to toggle source
Similar to instance_method, searches public method only.
static VALUErb_mod_public_instance_method(VALUE mod, VALUE vid) { ID id = rb_check_id(&vid); if (!id) { rb_method_name_error(mod, vid); } return mnew(mod, Qundef, id, rb_cUnboundMethod, TRUE); }
public_instance_methods(include_super=true) → array click to toggle source
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.
VALUErb_class_public_instance_methods(int argc, const VALUE *argv, VALUE mod) { return class_instance_method_list(argc, argv, mod, 0, ins_methods_pub_i); }
public_method_defined?(symbol, inherit=true) → true or false click to toggle source
public_method_defined?(string, inherit=true) → true or false
Returns true if the named public method is defined by_mod_. If inherit is set, the lookup will also search_mod_'s 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
C.public_method_defined? "method1"
C.public_method_defined? "method1", true
C.public_method_defined? "method1", false
C.public_method_defined? "method2"
C.method_defined? "method2"
static VALUErb_mod_public_method_defined(int argc, VALUE *argv, VALUE mod) { return check_definition(mod, argc, argv, METHOD_VISI_PUBLIC); }
remove_class_variable(sym) → obj click to toggle source
Removes the named class variable from the receiver, returning that variable's value.
class Example @@var = 99 puts remove_class_variable(:@@var) p(defined? @@var) end
produces:
99 nil
VALUErb_mod_remove_cvar(VALUE mod, VALUE name) { const ID id = id_for_var_message(mod, name, class, "wrong class variable name %1$s"); st_data_t val, n = id;
if (!id) {
goto not_defined;
}
rb_check_frozen(mod);
if (RCLASS_IV_TBL(mod) && st_delete(RCLASS_IV_TBL(mod), &n, &val)) {
return (VALUE)val;
}
if (rb_cvar_defined(mod, id)) {
rb_name_err_raise("cannot remove %1$s for %2$s", mod, ID2SYM(id));
}not_defined: rb_name_err_raise("class variable %1$s not defined for %2$s", mod, name); UNREACHABLE_RETURN(Qundef); }
remove_method(symbol) → self click to toggle source
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.
static VALUErb_mod_remove_method(int argc, VALUE *argv, VALUE mod) { int i;
for (i = 0; i < argc; i++) {
VALUE v = argv[i];
ID id = rb_check_id(&v);
if (!id) {
rb_name_err_raise("method `%1$s' not defined in %2$s",
mod, v);
}
remove_method(mod, id);
}
return mod;}
singleton_class? → true or false click to toggle source
Returns true if mod is a singleton class orfalse if it is an ordinary class or module.
class C
end
C.singleton_class?
C.singleton_class.singleton_class?
static VALUErb_mod_singleton_p(VALUE klass) { if (RB_TYPE_P(klass, T_CLASS) && FL_TEST(klass, FL_SINGLETON)) return Qtrue; return Qfalse; }
to_s → string click to toggle source
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.
static VALUErb_mod_to_s(VALUE klass) { ID id_defined_at; VALUE refined_class, defined_at;
if (FL_TEST(klass, FL_SINGLETON)) {
VALUE s = rb_usascii_str_new2("#<Class:");
VALUE v = rb_ivar_get(klass, id__attached__);
if (CLASS_OR_MODULE_P(v)) {
rb_str_append(s, rb_inspect(v));
}
else {
rb_str_append(s, rb_any_to_s(v));
}
rb_str_cat2(s, ">");
return s;
}
refined_class = rb_refinement_module_get_refined_class(klass);
if (!NIL_P(refined_class)) {
VALUE s = rb_usascii_str_new2("#<refinement:");
rb_str_concat(s, rb_inspect(refined_class));
rb_str_cat2(s, "@");
CONST_ID(id_defined_at, "__defined_at__");
defined_at = rb_attr_get(klass, id_defined_at);
rb_str_concat(s, rb_inspect(defined_at));
rb_str_cat2(s, ">");
return s;
}
return rb_class_name(klass);}
undef_method(symbol) → self click to toggle source
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
end
c.hello
class Child
undef_method :hello
end
c.hello
produces:
In child In parent prog.rb:23: undefined method `hello' for #Child:0x401b3bb4 (NoMethodError)
static VALUErb_mod_undef_method(int argc, VALUE *argv, VALUE mod) { int i; for (i = 0; i < argc; i++) { VALUE v = argv[i]; ID id = rb_check_id(&v); if (!id) { rb_method_name_error(mod, v); } rb_undef(mod, id); } return mod; }
append_features(mod) → mod click to toggle source
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.
static VALUErb_mod_append_features(VALUE module, VALUE include) { if (!CLASS_OR_MODULE_P(include)) { Check_Type(include, T_CLASS); } rb_include_module(include, module);
return module;}
extend_object(obj) → obj click to toggle source
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
(s = "quick brown fox").extend Picky
produces:
Picky added to Array Can't add Picky to a String
static VALUErb_mod_extend_object(VALUE mod, VALUE obj) { rb_extend_object(obj, mod); return obj; }
extended(othermod) click to toggle source
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
static VALUErb_obj_dummy1(VALUE _x, VALUE _y) { return rb_obj_dummy(); }
included(othermod) click to toggle source
Callback invoked whenever the receiver is included in another module or class. This should be used in preference toModule.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
static VALUErb_obj_dummy1(VALUE _x, VALUE _y) { return rb_obj_dummy(); }
method_added(method_name) click to toggle source
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
static VALUErb_obj_dummy1(VALUE _x, VALUE _y) { return rb_obj_dummy(); }
method_removed(method_name) click to toggle source
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
static VALUErb_obj_dummy1(VALUE _x, VALUE _y) { return rb_obj_dummy(); }
method_undefined(p1) click to toggle source
static VALUErb_obj_dummy1(VALUE _x, VALUE _y) { return rb_obj_dummy(); }
module_function(symbol, ...) → self click to toggle source
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. Modulefunctions 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
c = Cls.new
c.call_one
module Mod
def one
"This is the new one"
end
end
Mod.one
c.call_one
static VALUErb_mod_modfunc(int argc, VALUE *argv, VALUE module) { int i; ID id; const rb_method_entry_t *me;
if (!RB_TYPE_P(module, T_MODULE)) {
rb_raise(rb_eTypeError, "module_function must be called for modules");
}
if (argc == 0) {
rb_scope_module_func_set();
return module;
}
set_method_visibility(module, argc, argv, METHOD_VISI_PRIVATE);
for (i = 0; i < argc; i++) {
VALUE m = module;
id = rb_to_id(argv[i]);
for (;;) {
me = search_method(m, id, 0);
if (me == 0) {
me = search_method(rb_cObject, id, 0);
}
if (UNDEFINED_METHOD_ENTRY_P(me)) {
rb_print_undef(module, id, METHOD_VISI_UNDEF);
}
if (me->def->type != VM_METHOD_TYPE_ZSUPER) {
break; /* normal case: need not to follow 'super' link */
}
m = RCLASS_SUPER(m);
if (!m)
break;
}
rb_method_entry_set(rb_singleton_class(module), id, me, METHOD_VISI_PUBLIC);
}
return module;}
prepend_features(mod) → mod click to toggle source
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.
static VALUErb_mod_prepend_features(VALUE module, VALUE prepend) { if (!CLASS_OR_MODULE_P(prepend)) { Check_Type(prepend, T_CLASS); } rb_prepend_module(prepend, module);
return module;}
prepended(othermod) click to toggle source
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
static VALUErb_obj_dummy1(VALUE _x, VALUE _y) { return rb_obj_dummy(); }
private → self click to toggle source
private(symbol, ...) → self
private(string, ...) → self
private(array) → 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. An Array of Symbols and/or Strings are also accepted.
module Mod def a() end def b() end private def c() end private :a end Mod.private_instance_methods
Note that to show a private method on RDoc, use :doc:.
static VALUErb_mod_private(int argc, VALUE *argv, VALUE module) { return set_visibility(argc, argv, module, METHOD_VISI_PRIVATE); }
protected → self click to toggle source
protected(symbol, ...) → self
protected(string, ...) → self
protected(array) → 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. An Array of Symbols and/or Strings are also accepted.
If a method has protected visibility, it is callable only whereself of the context is the same as the method. (method definition or instance_eval). This behavior is different from Java's protected method. Usually private should be used.
Note that a protected method is slow because it can't use inline cache.
To show a private method on RDoc, use :doc: instead of this.
static VALUErb_mod_protected(int argc, VALUE *argv, VALUE module) { return set_visibility(argc, argv, module, METHOD_VISI_PROTECTED); }
public → self click to toggle source
public(symbol, ...) → self
public(string, ...) → self
public(array) → 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. An Array of Symbols and/or Strings are also accepted.
static VALUErb_mod_public(int argc, VALUE *argv, VALUE module) { return set_visibility(argc, argv, module, METHOD_VISI_PUBLIC); }
refine(mod) { block } → module click to toggle source
Refine mod in the receiver.
Returns a module, where refined methods are defined.
static VALUErb_mod_refine(VALUE module, VALUE klass) { VALUE refinement; ID id_refinements, id_activated_refinements, id_refined_class, id_defined_at; VALUE refinements, activated_refinements; rb_thread_t *th = GET_THREAD(); VALUE block_handler = rb_vm_frame_block_handler(th->ec->cfp);
if (block_handler == VM_BLOCK_HANDLER_NONE) {
rb_raise(rb_eArgError, "no block given");
}
if (vm_block_handler_type(block_handler) != block_handler_type_iseq) {
rb_raise(rb_eArgError, "can't pass a Proc as a block to Module#refine");
}
ensure_class_or_module(klass);
CONST_ID(id_refinements, "__refinements__");
refinements = rb_attr_get(module, id_refinements);
if (NIL_P(refinements)) {
refinements = hidden_identity_hash_new();
rb_ivar_set(module, id_refinements, refinements);
}
CONST_ID(id_activated_refinements, "__activated_refinements__");
activated_refinements = rb_attr_get(module, id_activated_refinements);
if (NIL_P(activated_refinements)) {
activated_refinements = hidden_identity_hash_new();
rb_ivar_set(module, id_activated_refinements,
activated_refinements);
}
refinement = rb_hash_lookup(refinements, klass);
if (NIL_P(refinement)) {
VALUE superclass = refinement_superclass(klass);
refinement = rb_module_new();
RCLASS_SET_SUPER(refinement, superclass);
FL_SET(refinement, RMODULE_IS_REFINEMENT);
CONST_ID(id_refined_class, "__refined_class__");
rb_ivar_set(refinement, id_refined_class, klass);
CONST_ID(id_defined_at, "__defined_at__");
rb_ivar_set(refinement, id_defined_at, module);
rb_hash_aset(refinements, klass, refinement);
add_activated_refinement(activated_refinements, klass, refinement);
}
rb_yield_refine_block(refinement, activated_refinements);
return refinement;}
remove_const(sym) → obj click to toggle source
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.
VALUErb_mod_remove_const(VALUE mod, VALUE name) { const ID id = id_for_var(mod, name, a, constant);
if (!id) {
undefined_constant(mod, name);
}
return rb_const_remove(mod, id);}
ruby2_keywords(method_name, ...) → self click to toggle source
For the given method names, marks the method as passing keywords through a normal argument splat. This should only be called on methods that accept an argument splat (*args) but not explicit keywords or a keyword splat. It marks the method such that if the method is called with keyword arguments, the final hash argument is marked with a special flag such that if it is the final element of a normal argument splat to another method call, and that method call does not include explicit keywords or a keyword splat, the final element is interpreted as keywords. In other words, keywords will be passed through the method to other methods.
This should only be used for methods that delegate keywords to another method, and only for backwards compatibility with Ruby versions before 2.7.
This method will probably be removed at some point, as it exists only for backwards compatibility. As it does not exist in Ruby versions before 2.7, check that the module responds to this method before calling it. Also, be aware that if this method is removed, the behavior of the method will change so that it does not pass through keywords.
module Mod def foo(meth, *args, &block) send(:"do_#{meth}", *args, &block) end ruby2_keywords(:foo) if respond_to?(:ruby2_keywords, true) end
static VALUErb_mod_ruby2_keywords(int argc, VALUE *argv, VALUE module) { int i; VALUE origin_class = RCLASS_ORIGIN(module);
rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
rb_check_frozen(module);
for (i = 0; i < argc; i++) {
VALUE v = argv[i];
ID name = rb_check_id(&v);
rb_method_entry_t *me;
VALUE defined_class;
if (!name) {
rb_print_undef_str(module, v);
}
me = search_method(origin_class, name, &defined_class);
if (!me && RB_TYPE_P(module, T_MODULE)) {
me = search_method(rb_cObject, name, &defined_class);
}
if (UNDEFINED_METHOD_ENTRY_P(me) ||
UNDEFINED_REFINED_METHOD_P(me->def)) {
rb_print_undef(module, name, METHOD_VISI_UNDEF);
}
if (module == defined_class || origin_class == defined_class) {
switch (me->def->type) {
case VM_METHOD_TYPE_ISEQ:
if (me->def->body.iseq.iseqptr->body->param.flags.has_rest &&
!me->def->body.iseq.iseqptr->body->param.flags.has_kw &&
!me->def->body.iseq.iseqptr->body->param.flags.has_kwrest) {
me->def->body.iseq.iseqptr->body->param.flags.ruby2_keywords = 1;
rb_clear_method_cache(module, name);
}
else {
rb_warn("Skipping set of ruby2_keywords flag for %s (method accepts keywords or method does not accept argument splat)", rb_id2name(name));
}
break;
case VM_METHOD_TYPE_BMETHOD: {
VALUE procval = me->def->body.bmethod.proc;
if (vm_block_handler_type(procval) == block_handler_type_proc) {
procval = vm_proc_to_block_handler(VM_BH_TO_PROC(procval));
}
if (vm_block_handler_type(procval) == block_handler_type_iseq) {
const struct rb_captured_block *captured = VM_BH_TO_ISEQ_BLOCK(procval);
const rb_iseq_t *iseq = rb_iseq_check(captured->code.iseq);
if (iseq->body->param.flags.has_rest &&
!iseq->body->param.flags.has_kw &&
!iseq->body->param.flags.has_kwrest) {
iseq->body->param.flags.ruby2_keywords = 1;
rb_clear_method_cache(module, name);
}
else {
rb_warn("Skipping set of ruby2_keywords flag for %s (method accepts keywords or method does not accept argument splat)", rb_id2name(name));
}
return Qnil;
}
}
/* fallthrough */
default:
rb_warn("Skipping set of ruby2_keywords flag for %s (method not defined in Ruby)", rb_id2name(name));
break;
}
}
else {
rb_warn("Skipping set of ruby2_keywords flag for %s (can only set in method defining module)", rb_id2name(name));
}
}
return Qnil;}
using(module) → self click to toggle source
Import class refinements from module into the current class or module definition.
static VALUEmod_using(VALUE self, VALUE module) { rb_control_frame_t *prev_cfp = previous_frame(GET_EC());
if (prev_frame_func()) {
rb_raise(rb_eRuntimeError,
"Module#using is not permitted in methods");
}
if (prev_cfp && prev_cfp->self != self) {
rb_raise(rb_eRuntimeError, "Module#using is not called on self");
}
if (rb_block_given_p()) {
ignored_block(module, "Module#");
}
rb_using_module(rb_vm_cref_replace_with_duplicated_cref(), module);
return self;}