class Module - Documentation for Ruby 3.3

# class Module

A `Module` is a collection of methods and constants. The methods in a module may be instance methods or module methods. Instance methods appear as methods in a class when the module is included, module methods do not. Conversely, module methods may be called without creating an encapsulating object, while instance methods may not. (See `Module#module_function`.)

In the descriptions that follow, the parameter sym refers to a symbol, which is either a quoted string or a `Symbol` (such as `:name`).

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

### Public Class Methods

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)
       # => [:ARGF, :ARGV, :ArgumentError, :Array]

    Module.constants.include?(:SEEK_SET)   # => false

    class IO
      Module.constants.include?(:SEEK_SET) # => true
    end

The second form calls the instance method `constants`.

    static VALUE
    rb_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           #=> [M1::M2, M1]
    $a[0].name   #=> "M1::M2"

    static VALUE
    rb_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)   #=> "my string"
    a.meth1          #=> "hello"
    a.meth2          #=> "bye"

Assign the module to a constant (name starting uppercase) if you want to treat it like a regular module.

    static VALUE
    rb_mod_initialize(VALUE module)
    {
        return rb_mod_initialize_exec(module);
    }

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 VALUE
    rb_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);
    }

used_refinements → 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_refinements

produces:

    [#<refinement:Object@B>, #<refinement:Object@A>]

    static VALUE
    rb_mod_s_used_refinements(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_refinements_i, ary);
            }
            cref = CREF_NEXT(cref);
        }

        return ary;
    }

### Public Instance Methods

mod < other → true, false, or nil click to toggle source

Returns true if mod is a subclass of other. Returns `false` if mod is the same as other or 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 “A < B”.)

    static VALUE
    rb_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”.)

    VALUE
    rb_class_inherited_p(VALUE mod, VALUE arg)
    {
        if (mod == arg) return Qtrue;

        if (RB_TYPE_P(arg, T_CLASS) && RB_TYPE_P(mod, T_CLASS)) {
            // comparison between classes
            size_t mod_depth = RCLASS_SUPERCLASS_DEPTH(mod);
            size_t arg_depth = RCLASS_SUPERCLASS_DEPTH(arg);
            if (arg_depth < mod_depth) {
                // check if mod < arg
                return RCLASS_SUPERCLASSES(mod)[arg_depth] == arg ?
                    Qtrue :
                    Qnil;
            }
            else if (arg_depth > mod_depth) {
                // check if mod > arg
                return RCLASS_SUPERCLASSES(arg)[mod_depth] == mod ?
                    Qfalse :
                    Qnil;
            }
            else {
                // Depths match, and we know they aren't equal: no relation
                return Qnil;
            }
        }
        else {
            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 whether `module` includes `other_module`, they are the same, or if `module` is included by `other_module`.

Returns `nil` if `module` has no relationship with `other_module`, if `other_module` is not a module, or if the two values are incomparable.

    static VALUE
    rb_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, `==` returns `true` only if `obj` and `other` are the same object. Typically, this method is overridden in descendant classes to provide class-specific meaning.

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

    obj = "a"
    other = obj.dup

    obj == other      #=> true
    obj.equal? other  #=> false
    obj.equal? obj    #=> true

The `eql?` method returns `true` if `obj` and `other` refer to the same hash key. This is used by `Hash` to test members for equality. For any pair of objects where `eql?` returns `true`, the `hash` 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     #=> true
    1.eql? 1.0   #=> false

    VALUE
    rb_obj_equal(VALUE obj1, VALUE obj2)
    {
        return RBOOL(obj1 == obj2);
    }

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 VALUE
    rb_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. Returns `false` if mod is the same as other or mod is a descendant 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”.)

    static VALUE
    rb_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 VALUE
    rb_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 #=> :orig_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 VALUE
    rb_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        #=> [Enumerable, Mod, Comparable, Math]
    Math.ancestors       #=> [Math]
    Enumerable.ancestors #=> [Enumerable]

    VALUE
    rb_mod_ancestors(VALUE mod)
    {
        VALUE p, ary = rb_ary_new();
        VALUE refined_class = Qnil;
        if (BUILTIN_TYPE(mod) == T_MODULE && FL_TEST(mod, RMODULE_IS_REFINEMENT)) {
            refined_class = rb_refinement_module_get_refined_class(mod);
        }

        for (p = mod; p; p = RCLASS_SUPER(p)) {
            if (p == refined_class) break;
            if (p != RCLASS_ORIGIN(p)) continue;
            if (BUILTIN_TYPE(p) == T_ICLASS) {
                rb_ary_push(ary, METACLASS_OF(p));
            }
            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.

    VALUE
    rb_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) #=> [:one, :one=, :two, :two=]
    end
    Mod.instance_methods.sort   #=> [:one, :one=, :two, :two=]

    static VALUE
    rb_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 VALUE
    rb_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`. `String` arguments are converted to symbols. Returns an array of defined method names as symbols.

    static VALUE
    rb_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(const, filename) → nil click to toggle source

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

If const in mod is defined as autoload, the file name to be loaded is replaced with filename. If const is defined but not as autoload, does nothing.

    static VALUE
    rb_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 as `autoload` in the namespace of mod or one of its ancestors.

    module A
    end
    A.autoload(:B, "b")
    A.autoload?(:B)            #=> "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)          #=> "const.rb", found in A (ancestor)
    B.autoload?(:CONST, false)   #=> nil, not found in B itself

    static VALUE
    rb_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
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

Alias for: module_eval
class_exec(arg...) {|var...| block } → obj

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!

Alias for: module_exec
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)    #=> true
    Fred.class_variable_defined?(:@@bar)    #=> false

    static VALUE
    rb_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)     #=> 99

    static VALUE
    rb_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)     #=> 101
    Fred.new.foo                             #=> 101

    static VALUE
    rb_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          #=> [:@@var1]
    Two.class_variables          #=> [:@@var2, :@@var1]
    Two.class_variables(false)   #=> [:@@var2]

    VALUE
    rb_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)      #=> true, found in Float itself
    Float.const_defined?("String")      #=> true, found in Object (ancestor)
    BasicObject.const_defined?(:Hash)   #=> false

If mod is a `Module`, additionally `Object` and its ancestors are checked:

    Math.const_defined?(:String)   #=> true, found in Object

In each of the checked classes or modules, if the constant is not present but there is an autoload for it, `true` is returned directly without autoloading:

    module Admin
      autoload :User, 'admin/user'
    end
    Admin.const_defined?(:User)   #=> true

If the constant is not found the callback `const_missing` is not called and the method returns `false`.

If `inherit` is false, the lookup only checks the constants in the receiver:

    IO.const_defined?(:SYNC)          #=> true, found in File::Constants (ancestor)
    IO.const_defined?(:SYNC, false)   #=> false, not found in IO itself

In this case, the same logic for autoloading applies.

If the argument is not a valid constant name a `NameError` is raised with the message “wrong constant name name”:

    Hash.const_defined? 'foobar'   #=> NameError: wrong constant name foobar

    static VALUE
    rb_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 (UNDEF_P(mod)) 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. If `inherit` is set, the lookup will also search the ancestors (and `Object` if mod is a `Module`).

The value of the constant is returned if a definition is found, otherwise a `NameError` is raised.

    Math.const_get(:PI)   #=> 3.14159265358979

This method will recursively look up constant names if a namespaced class name is provided. For example:

    module Foo; class Bar; end end
    Object.const_get 'Foo::Bar'

The `inherit` flag is respected on each lookup. For example:

    module Foo
      class Bar
        VAL = 10
      end

      class Baz < Bar; end
    end

    Object.const_get 'Foo::Baz::VAL'         # => 10
    Object.const_get 'Foo::Baz::VAL', false  # => NameError

If the argument is not a valid constant name a `NameError` will be raised with a warning “wrong constant name”.

    Object.const_get 'foobar' #=> NameError: wrong constant name foobar

    static VALUE
    rb_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 # return the constant name as Symbol
    end

    Foo::UNDEFINED_CONST    #=> :UNDEFINED_CONST: symbol returned

In the next example when a reference is made to an undefined constant, it attempts to load a file whose name is the lowercase version of the constant (thus class `Fred` is assumed to be in file `fred.rb`). If found, it returns the loaded class. It therefore implements an autoload feature similar to `Kernel#autoload` and `Module#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

    VALUE
    rb_mod_const_missing(VALUE klass, VALUE name)
    {
        rb_execution_context_t *ec = GET_EC();
        VALUE ref = ec->private_const_reference;
        rb_vm_pop_cfunc_frame();
        if (ref) {
            ec->private_const_reference = 0;
            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)   #=> 3.14285714285714
    Math::HIGH_SCHOOL_PI - Math::PI              #=> 0.00126448926734968

If `sym` or `str` is not a valid constant name a `NameError` will be raised with a warning “wrong constant name”.

    Object.const_set('foobar', 42) #=> NameError: wrong constant name foobar

    static VALUE
    rb_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).

    # test.rb:
    class A         # line 1
      C1 = 1
      C2 = 2
    end

    module M        # line 6
      C3 = 3
    end

    class B < A     # line 10
      include M
      C4 = 4
    end

    class A # continuation of A definition
      C2 = 8 # constant redefinition; warned yet allowed
    end

    p B.const_source_location('C4')           # => ["test.rb", 12]
    p B.const_source_location('C3')           # => ["test.rb", 7]
    p B.const_source_location('C1')           # => ["test.rb", 2]

    p B.const_source_location('C3', false)    # => nil  -- don't lookup in ancestors

    p A.const_source_location('C2')           # => ["test.rb", 16] -- actual (last) definition place

    p Object.const_source_location('B')       # => ["test.rb", 10] -- top-level constant could be looked through Object
    p Object.const_source_location('A')       # => ["test.rb", 1] -- class reopening is NOT considered new definition

    p B.const_source_location('A')            # => ["test.rb", 1]  -- because Object is in ancestors
    p M.const_source_location('A')            # => ["test.rb", 1]  -- Object is not ancestor, but additionally checked for modules

    p Object.const_source_location('A::C1')   # => ["test.rb", 2]  -- nesting is supported
    p Object.const_source_location('String')  # => []  -- constant is defined in C code

    static VALUE
    rb_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 to `false`.

The implementation makes no guarantees about the order in which the constants are yielded.

    IO.constants.include?(:SYNC)        #=> true
    IO.constants(false).include?(:SYNC) #=> false

Also see `Module#const_defined?`.

    VALUE
    rb_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 an `UnboundMethod` 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 VALUE
    rb_mod_define_method(int argc, VALUE *argv, VALUE mod)
    {
        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;

        if (cref) {
            scope_visi = CREF_SCOPE_VISI(cref);
        }

        return rb_mod_define_method_with_visibility(argc, argv, mod, scope_visi);
    }

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 # previous version of the library used this name

      deprecate_constant :NOT_FOUND
    end

    HTTP::NOT_FOUND
    # warning: constant HTTP::NOT_FOUND is deprecated

    VALUE
    rb_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 VALUE
    rb_mod_freeze(VALUE mod)
    {
        rb_class_name(mod);
        return rb_obj_freeze(mod);
    }

include(module, ...) → self click to toggle source

Invokes `Module.append_features` on each parameter in reverse order.

    static VALUE
    rb_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");

        if (BUILTIN_TYPE(module) == T_MODULE && FL_TEST(module, RMODULE_IS_REFINEMENT)) {
            rb_raise(rb_eTypeError, "Refinement#include has been removed");
        }

        rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
        for (i = 0; i < argc; i++) {
            Check_Type(argv[i], T_MODULE);
            if (FL_TEST(argv[i], RMODULE_IS_REFINEMENT)) {
                rb_raise(rb_eTypeError, "Cannot include refinement");
            }
        }
        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)   #=> true
    C.include?(A)   #=> true
    A.include?(A)   #=> false

    VALUE
    rb_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 (METACLASS_OF(p) == 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   #=> [Sub]
    Outer.included_modules   #=> [Sub, Mixin]

    VALUE
    rb_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 = METACLASS_OF(p);
                if (RB_TYPE_P(m, T_MODULE))
                    rb_ary_push(ary, m);
            }
        }
        return ary;
    }

inspect
Alias for: to_s
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 VALUE
    rb_mod_instance_method(VALUE mod, VALUE vid)
    {
        ID id = rb_check_id(&vid);
        if (!id) {
            rb_method_name_error(mod, vid);
        }
        return mnew_unbound(mod, 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)                   #=> [:method1]
    B.instance_methods(false)                   #=> [:method2]
    B.instance_methods(true).include?(:method1) #=> true
    C.instance_methods(false)                   #=> [:method3]
    C.instance_methods.include?(:method2)       #=> true

Note that method visibility changes in the current class, as well as aliases, are considered as methods of the current class by this method:

    class C < B
      alias method4 method2
      protected :method2
    end
    C.instance_methods(false).sort               #=> [:method2, :method3, :method4]

    VALUE
    rb_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              #=> true
    C.method_defined? "method1"             #=> true
    C.method_defined? "method2"             #=> true
    C.method_defined? "method2", true       #=> true
    C.method_defined? "method2", false      #=> false
    C.method_defined? "method3"             #=> true
    C.method_defined? "protected_method1"   #=> true
    C.method_defined? "method4"             #=> false
    C.method_defined? "private_method2"     #=> false

    static VALUE
    rb_mod_method_defined(int argc, VALUE *argv, VALUE mod)
    {
        rb_method_visibility_t visi = check_definition_visibility(mod, argc, argv);
        return RBOOL(visi == METHOD_VISI_PUBLIC || visi == METHOD_VISI_PROTECTED);
    }

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 VALUE
    rb_mod_module_eval_internal(int argc, const VALUE *argv, VALUE mod)
    {
        return specific_eval(argc, argv, mod, FALSE, RB_PASS_CALLED_KEYWORDS);
    }

Also aliased as: class_eval
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 VALUE
    rb_mod_module_exec_internal(int argc, const VALUE *argv, VALUE mod)
    {
        return yield_under(mod, FALSE, argc, argv, RB_PASS_CALLED_KEYWORDS);
    }

Also aliased as: class_exec
name → string click to toggle source

Returns the name of the module mod. Returns nil for anonymous modules.

    VALUE
    rb_mod_name(VALUE mod)
    {
        bool permanent;
        return classname(mod, &permanent);
    }

prepend(module, ...) → self click to toggle source

Invokes `Module.prepend_features` on each parameter in reverse order.

    static VALUE
    rb_mod_prepend(int argc, VALUE *argv, VALUE module)
    {
        int i;
        ID id_prepend_features, id_prepended;

        if (BUILTIN_TYPE(module) == T_MODULE && FL_TEST(module, RMODULE_IS_REFINEMENT)) {
            rb_raise(rb_eTypeError, "Refinement#prepend has been removed");
        }

        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);
            if (FL_TEST(argv[i], RMODULE_IS_REFINEMENT)) {
                rb_raise(rb_eTypeError, "Cannot prepend refinement");
            }
        }
        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 is also accepted.

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

    static VALUE
    rb_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.

    VALUE
    rb_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           #=> [:method2]
    Mod.private_instance_methods   #=> [:method1]

    VALUE
    rb_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                   #=> true
    C.private_method_defined? "method1"          #=> false
    C.private_method_defined? "method2"          #=> true
    C.private_method_defined? "method2", true    #=> true
    C.private_method_defined? "method2", false   #=> false
    C.method_defined? "method2"                  #=> false

    static VALUE
    rb_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.

    VALUE
    rb_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                    #=> true
    C.protected_method_defined? "method1"         #=> false
    C.protected_method_defined? "method2"         #=> true
    C.protected_method_defined? "method2", true   #=> true
    C.protected_method_defined? "method2", false  #=> false
    C.method_defined? "method2"                   #=> true

    static VALUE
    rb_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 is also accepted.

    static VALUE
    rb_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.

    VALUE
    rb_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 VALUE
    rb_mod_public_instance_method(VALUE mod, VALUE vid)
    {
        ID id = rb_check_id(&vid);
        if (!id) {
            rb_method_name_error(mod, vid);
        }
        return mnew_unbound(mod, 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.

    VALUE
    rb_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                 #=> true
    C.public_method_defined? "method1"         #=> true
    C.public_method_defined? "method1", true   #=> true
    C.public_method_defined? "method1", false  #=> true
    C.public_method_defined? "method2"         #=> false
    C.method_defined? "method2"                #=> true

    static VALUE
    rb_mod_public_method_defined(int argc, VALUE *argv, VALUE mod)
    {
        return check_definition(mod, argc, argv, METHOD_VISI_PUBLIC);
    }

refinements → array click to toggle source

Returns an array of modules defined within the receiver.

    module A
      refine Integer do
      end

      refine String do
      end
    end

    p A.refinements

produces:

    [#<refinement:Integer@A>, #<refinement:String@A>]

    static VALUE
    mod_refinements(VALUE self)
    {
        ID id_refinements;
        VALUE refinements;

        CONST_ID(id_refinements, "__refinements__");
        refinements = rb_attr_get(self, id_refinements);
        if (NIL_P(refinements)) {
            return rb_ary_new();
        }
        return rb_hash_values(refinements);
    }

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

    VALUE
    rb_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;

        if (!id) {
            goto not_defined;
        }
        rb_check_frozen(mod);
        val = rb_ivar_delete(mod, id, Qundef);
        if (!UNDEF_P(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 `Module#undef_method`. `String` arguments are converted to symbols.

    static VALUE
    rb_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;
    }

set_temporary_name(string) → self click to toggle source
set_temporary_name(nil) → self

Sets the temporary name of the module. This name is reflected in introspection of the module and the values that are related to it, such as instances, constants, and methods.

The name should be `nil` or non-empty string that is not a valid constant name (to avoid confusing between permanent and temporary names).

The method can be useful to distinguish dynamically generated classes and modules without assigning them to constants.

If the module is given a permanent name by assigning it to a constant, the temporary name is discarded. A temporary name can’t be assigned to modules that have a permanent name.

If the given name is `nil`, the module becomes anonymous again.

Example:

    m = Module.new # => #<Module:0x0000000102c68f38>
    m.name #=> nil

    m.set_temporary_name("fake_name") # => fake_name
    m.name #=> "fake_name"

    m.set_temporary_name(nil) # => #<Module:0x0000000102c68f38>
    m.name #=> nil

    c = Class.new
    c.set_temporary_name("MyClass(with description)")

    c.new # => #<MyClass(with description):0x0....>

    c::M = m
    c::M.name #=> "MyClass(with description)::M"

    # Assigning to a constant replaces the name with a permanent one
    C = c

    C.name #=> "C"
    C::M.name #=> "C::M"
    c.new # => #<C:0x0....>

    VALUE
    rb_mod_set_temporary_name(VALUE mod, VALUE name)
    {
        // We don't allow setting the name if the classpath is already permanent:
        if (RCLASS_EXT(mod)->permanent_classpath) {
            rb_raise(rb_eRuntimeError, "can't change permanent name");
        }

        if (NIL_P(name)) {
            // Set the temporary classpath to NULL (anonymous):
            RB_VM_LOCK_ENTER();
            set_sub_temporary_name(mod, 0);
            RB_VM_LOCK_LEAVE();
        }
        else {
            // Ensure the name is a string:
            StringValue(name);

            if (RSTRING_LEN(name) == 0) {
                rb_raise(rb_eArgError, "empty class/module name");
            }

            if (is_constant_path(name)) {
                rb_raise(rb_eArgError, "the temporary name must not be a constant path to avoid confusion");
            }

            name = rb_str_new_frozen(name);

            // Set the temporary classpath to the given name:
            RB_VM_LOCK_ENTER();
            set_sub_temporary_name(mod, name);
            RB_VM_LOCK_LEAVE();
        }

        return mod;
    }

singleton_class? → true or false click to toggle source

Returns `true` if mod is a singleton class or `false` if it is an ordinary class or module.

    class C
    end
    C.singleton_class?                  #=> false
    C.singleton_class.singleton_class?  #=> true

    static VALUE
    rb_mod_singleton_p(VALUE klass)
    {
        return RBOOL(RB_TYPE_P(klass, T_CLASS) && FL_TEST(klass, FL_SINGLETON));
    }

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.

    VALUE
    rb_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 = RCLASS_ATTACHED_OBJECT(klass);

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

Also aliased as: inspect
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  # 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)

    static VALUE
    rb_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;
    }

undefined_instance_methods → array click to toggle source

Returns a list of the undefined instance methods defined in mod. The undefined methods of any ancestors are not included.

    VALUE
    rb_class_undefined_instance_methods(VALUE mod)
    {
        VALUE include_super = Qfalse;
        return class_instance_method_list(1, &include_super, mod, 0, ins_methods_undef_i);
    }

### Private Instance Methods

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

    static VALUE
    rb_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;
    }

const_added(const_name) click to toggle source

Invoked as a callback whenever a constant is assigned on the receiver

    module Chatty
      def self.const_added(const_name)
        super
        puts "Added #{const_name.inspect}"
      end
      FOO = 1
    end

produces:

    Added :FOO

    #define rb_obj_mod_const_added rb_obj_dummy1

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  # Call Object.extend
    (s = "quick brown fox").extend Picky

produces:

    Picky added to Array
    Can't add Picky to a String

    static VALUE
    rb_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
     # => prints "A extended in Enumerable"

    #define rb_obj_mod_extended rb_obj_dummy1

included(othermod) click to toggle source

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
     # => prints "A included in Enumerable"

    #define rb_obj_mod_included rb_obj_dummy1

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

    #define rb_obj_mod_method_added rb_obj_dummy1

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

    #define rb_obj_mod_method_removed rb_obj_dummy1

method_undefined(method_name) click to toggle source

Invoked as a callback whenever an instance method is undefined from the receiver.

    module Chatty
      def self.method_undefined(method_name)
        puts "Undefining #{method_name.inspect}"
      end
      def self.some_class_method() end
      def some_instance_method() end
      class << self
        undef_method :some_class_method
      end
      undef_method :some_instance_method
    end

produces:

    Undefining :some_instance_method

    #define rb_obj_mod_method_undefined rb_obj_dummy1

module_function → nil click to toggle source
module_function(method_name) → method_name
module_function(method_name, method_name, ...) → array

Creates module functions for the named methods. These functions may be called with the module as a receiver, and also become available as instance methods to classes that mix in the module. `Module` functions are copies of the original, and so may be changed independently. The instance-method versions are made private. If used with no arguments, subsequently defined methods become module functions. `String` arguments are converted to symbols. If a single argument is passed, it is returned. If no argument is passed, nil is returned. If multiple arguments are passed, the arguments are returned as an array.

    module Mod
      def one
        "This is one"
      end
      module_function :one
    end
    class Cls
      include Mod
      def call_one
        one
      end
    end
    Mod.one     #=> "This is one"
    c = Cls.new
    c.call_one  #=> "This is one"
    module Mod
      def one
        "This is the new one"
      end
    end
    Mod.one     #=> "This is one"
    c.call_one  #=> "This is the new one"

    static VALUE
    rb_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 Qnil;
        }

        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);
        }
        if (argc == 1) {
            return argv[0];
        }
        return rb_ary_new_from_values(argc, argv);
    }

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 `Module#prepend`.

    static VALUE
    rb_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
     # => prints "A prepended to Enumerable"

    #define rb_obj_mod_prepended rb_obj_dummy1

private → nil click to toggle source
private(method_name) → method_name
private(method_name, method_name, ...) → array
private(array) → array

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 is also accepted. If a single argument is passed, it is returned. If no argument is passed, nil is returned. If multiple arguments are passed, the arguments are returned as an array.

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

Note that to show a private method on `RDoc`, use `:doc:`.

    static VALUE
    rb_mod_private(int argc, VALUE *argv, VALUE module)
    {
        return set_visibility(argc, argv, module, METHOD_VISI_PRIVATE);
    }

protected → nil click to toggle source
protected(method_name) → method_name
protected(method_name, method_name, ...) → array
protected(array) → array

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 is also accepted. If a single argument is passed, it is returned. If no argument is passed, nil is returned. If multiple arguments are passed, the arguments are returned as an array.

If a method has protected visibility, it is callable only where `self` 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 VALUE
    rb_mod_protected(int argc, VALUE *argv, VALUE module)
    {
        return set_visibility(argc, argv, module, METHOD_VISI_PROTECTED);
    }

public → nil click to toggle source
public(method_name) → method_name
public(method_name, method_name, ...) → array
public(array) → array

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 is also accepted. If a single argument is passed, it is returned. If no argument is passed, nil is returned. If multiple arguments are passed, the arguments are returned as an array.

    static VALUE
    rb_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 VALUE
    rb_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_refinement_new();
            RCLASS_SET_SUPER(refinement, superclass);
            RUBY_ASSERT(BUILTIN_TYPE(refinement) == T_MODULE);
            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.

    VALUE
    rb_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, ...) → nil 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 3.0. See www.ruby-lang.org/en/news/2019/12/12/separation-of-positional-and-keyword-arguments-in-ruby-3-0/ for details on why `ruby2_keywords` exists and when and how to use it.

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:

    module Mod
      def foo(meth, *args, &block)
        send(:"do_#{meth}", *args, &block)
      end
      ruby2_keywords(:foo) if respond_to?(:ruby2_keywords, true)
    end

However, be aware that if the `ruby2_keywords` method is removed, the behavior of the `foo` method using the above approach will change so that the method does not pass through keywords.

    static VALUE
    rb_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 (ISEQ_BODY(me->def->body.iseq.iseqptr)->param.flags.has_rest &&
                            !ISEQ_BODY(me->def->body.iseq.iseqptr)->param.flags.has_post &&
                            !ISEQ_BODY(me->def->body.iseq.iseqptr)->param.flags.has_kw &&
                            !ISEQ_BODY(me->def->body.iseq.iseqptr)->param.flags.has_kwrest) {
                        ISEQ_BODY(me->def->body.iseq.iseqptr)->param.flags.ruby2_keywords = 1;
                        rb_clear_method_cache(module, name);
                    }
                    else {
                        rb_warn("Skipping set of ruby2_keywords flag for %"PRIsVALUE" (method accepts keywords or post arguments or method does not accept argument splat)", QUOTE_ID(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(iseq)->param.flags.has_rest &&
                                !ISEQ_BODY(iseq)->param.flags.has_post &&
                                !ISEQ_BODY(iseq)->param.flags.has_kw &&
                                !ISEQ_BODY(iseq)->param.flags.has_kwrest) {
                            ISEQ_BODY(iseq)->param.flags.ruby2_keywords = 1;
                            rb_clear_method_cache(module, name);
                        }
                        else {
                            rb_warn("Skipping set of ruby2_keywords flag for %"PRIsVALUE" (method accepts keywords or post arguments or method does not accept argument splat)", QUOTE_ID(name));
                        }
                        break;
                    }
                  }
                  /* fallthrough */
                  default:
                    rb_warn("Skipping set of ruby2_keywords flag for %"PRIsVALUE" (method not defined in Ruby)", QUOTE_ID(name));
                    break;
                }
            }
            else {
                rb_warn("Skipping set of ruby2_keywords flag for %"PRIsVALUE" (can only set in method defining module)", QUOTE_ID(name));
            }
        }
        return Qnil;
    }

using(module) → self click to toggle source

Import class refinements from module into the current class or module definition.

    static VALUE
    mod_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;
    }