Class: Namespace

Relationships & Source Files
Namespace Children
Modules: `Loader`, `Refiner`
Classes: `Entry`
Super Chains via Extension / Inclusion / Inheritance
Class Chain: self, `::Module`
Instance Chain: self, `::Module`
Inherits:	Module `::Object` Module Namespace
Defined in:	namespace.c

Class Attribute Summary

.enabled? ⇒ Boolean readonly

`::Module` - Inherited

.constants	In the first form, returns an array of the names of all constants accessible from the point of call.
.gccct_clear_table,
.nesting	Returns the list of `Modules` nested at the point of call.
.new	Creates a new anonymous module.
.used_modules	Returns an array of all modules used in the current scope.
.used_refinements	Returns an array of all modules used in the current scope.

Instance Attribute Summary

`::Module` - Inherited

#singleton_class?

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

Instance Method Summary

#inspect
#load(*args)
#load_path
#require(fname)
#require_relative(fname)

`::Module` - Inherited

#<	Returns true if mod is a subclass of other.
#<=	Returns true if mod is a subclass of other or is the same as other.
#<=>	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`.
#==	Alias for Object#eql?.
#===	Case Equality—Returns `true` if obj is an instance of mod or an instance of one of mod’s descendants.
#>	Returns true if mod is an ancestor of other.
#>=	Returns true if mod is an ancestor of other, or the two modules are the same.
#alias_method	Makes new_name a new copy of the method old_name.
#ancestors	Returns a list of modules included/prepended in mod (including mod itself).
#attr	The first form is equivalent to `#attr_reader`.
#attr_accessor	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.
#attr_reader	Creates instance variables and corresponding methods that return the value of each instance variable.
#attr_writer	Creates an accessor method to allow assignment to the attribute symbol`.id2name`.
#autoload	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.
#autoload?	Returns filename to be loaded if name is registered as `autoload` in the namespace of mod or one of its ancestors.
#class_eval	Evaluates the string or block in the context of mod, except that when a block is given, constant/class variable lookup is not affected.
#class_exec	Evaluates the given block in the context of the class/module.
#class_variable_defined?	Returns `true` if the given class variable is defined in obj.
#class_variable_get	Returns the value of the given class variable (or throws a `::NameError` exception).
#class_variable_set	Sets the class variable named by symbol to the given object.
#class_variables	Returns an array of the names of class variables in mod.
#const_defined?	Says whether mod or its ancestors have a constant with the given name:
#const_get	Checks for a constant with the given name in mod.
#const_missing	Invoked when a reference is made to an undefined constant in mod.
#const_set	Sets the named constant to the given object, returning that object.
#const_source_location	Returns the `::Ruby` source filename and line number containing the definition of the constant specified.
#constants	Returns an array of the names of the constants accessible in mod.
#define_method	Defines an instance method in the receiver.
#deprecate_constant	Makes a list of existing constants deprecated.
#freeze	Prevents further modifications to mod.
#include	Invokes Module#append_features on each parameter in reverse order.
#include?	Returns `true` if module is included or prepended in mod or one of mod’s ancestors.
#included_modules	Returns the list of modules included or prepended in mod or one of mod’s ancestors.
#inspect	Alias for Module#to_s.
#instance_method	Returns an `::UnboundMethod` representing the given instance method in mod.
#instance_methods	Returns an array containing the names of the public and protected instance methods in the receiver.
#method_defined?	Returns `true` if the named method is defined by mod.
#module_eval	Alias for Module#class_eval.
#module_exec	Alias for Module#class_exec.
#name	Returns the name of the module mod.
#prepend	Invokes Module#prepend_features on each parameter in reverse order.
#private_class_method	Makes existing class methods private.
#private_constant	Makes a list of existing constants private.
#private_instance_methods	Returns a list of the private instance methods defined in mod.
#private_method_defined?	Returns `true` if the named private method is defined by mod.
#protected_instance_methods	Returns a list of the protected instance methods defined in mod.
#protected_method_defined?	Returns `true` if the named protected method is defined mod.
#public_class_method	Makes a list of existing class methods public.
#public_constant	Makes a list of existing constants public.
#public_instance_method	Similar to instance_method, searches public method only.
#public_instance_methods	Returns a list of the public instance methods defined in mod.
#public_method_defined?	Returns `true` if the named public method is defined by mod.
#refinements	Returns an array of `::Refinement` defined within the receiver.
#remove_class_variable	Removes the named class variable from the receiver, returning that variable’s value.
#remove_method	Removes the method identified by symbol from the current class.
#set_temporary_name	Sets the temporary name of the module.
#to_s	Returns a string representing this module or class.
#undef_method	Prevents the current class from responding to calls to the named method.
#undefined_instance_methods	Returns a list of the undefined instance methods defined in mod.
#append_features	When this module is included in another, `::Ruby` calls `#append_features` in this module, passing it the receiving module in mod.
#const_added	Invoked as a callback whenever a constant is assigned on the receiver.
#extend_object	Extends the specified object by adding this module’s constants and methods (which are added as singleton methods).
#extended	The equivalent of `included`, but for extended modules.
#included	Callback invoked whenever the receiver is included in another module or class.
#method_added	Invoked as a callback whenever an instance method is added to the receiver.
#method_removed	Invoked as a callback whenever an instance method is removed from the receiver.
#method_undefined	Invoked as a callback whenever an instance method is undefined from the receiver.
#module_function	Creates module functions for the named methods.
#prepend_features	When this module is prepended in another, `::Ruby` calls `#prepend_features` in this module, passing it the receiving module in mod.
#prepended	The equivalent of `included`, but for prepended modules.
#private	With no arguments, sets the default visibility for subsequently defined methods to private.
#protected	With no arguments, sets the default visibility for subsequently defined methods to protected.
#public	With no arguments, sets the default visibility for subsequently defined methods to public.
#refine	Refine mod in the receiver.
#remove_const	Removes the definition of the given constant, returning that constant’s previous value.
#ruby2_keywords	For the given method names, marks the method as passing keywords through a normal argument splat.
#using	Import class refinements from module into the current class or module definition.
#initialize_clone, #initialize_copy,
#with_yjit	Internal helper for built-in initializations to define methods only when YJIT is enabled.

Constructor Details

.new

[ GitHub ]

# File 'namespace.c', line 529


static VALUE
namespace_initialize(VALUE namespace)
{
    rb_namespace_t *ns;
    rb_classext_t *object_classext;
    VALUE entry;
    ID id_namespace_entry;
    CONST_ID(id_namespace_entry, "__namespace_entry__");

    if (!rb_namespace_available()) {
        rb_raise(rb_eRuntimeError, "Namespace is disabled. Set RUBY_NAMESPACE=1 environment variable to use Namespace.");
    }

    entry = rb_class_new_instance_pass_kw(0, NULL, rb_cNamespaceEntry);
    ns = get_namespace_struct_internal(entry);

    ns->ns_object = namespace;
    ns->ns_id = namespace_generate_id();
    ns->load_path = rb_ary_dup(GET_VM()->load_path);
    ns->is_user = true;
    rb_define_singleton_method(ns->load_path, "resolve_feature_path", rb_resolve_feature_path, 1);

    // Set the Namespace object unique/consistent from any namespaces to have just single
    // constant table from any view of every (including main) namespace.
    // If a code in the namespace adds a constant, the constant will be visible even from root/main.
    RCLASS_SET_PRIME_CLASSEXT_WRITABLE(namespace, true);

    // fallback to ivptr for ivars from shapes to manipulate the constant table
    rb_evict_ivars_to_hash(namespace);

    // Get a clean constant table of Object even by writable one
    // because ns was just created, so it has not touched any constants yet.
    object_classext = RCLASS_EXT_WRITABLE_IN_NS(rb_cObject, ns);
    RCLASS_SET_CONST_TBL(namespace, RCLASSEXT_CONST_TBL(object_classext), true);

    rb_ivar_set(namespace, id_namespace_entry, entry);

    setup_pushing_loading_namespace(ns);

    return namespace;
}

Class Attribute Details

.enabled? ⇒ `Boolean` (readonly)

[ GitHub ]

# File 'namespace.c', line 571


static VALUE
rb_namespace_s_getenabled(VALUE namespace)
{
    return RBOOL(rb_namespace_available());
}

Class Method Details

.current

[ GitHub ]

# File 'namespace.c', line 577


static VALUE
rb_namespace_current(VALUE klass)
{
    const rb_namespace_t *ns = rb_current_namespace();
    if (NAMESPACE_USER_P(ns)) {
        return ns->ns_object;
    }
    if (NAMESPACE_BUILTIN_P(ns)) {
        return Qnil;
    }
    return Qfalse;
}

.current_details

[ GitHub ]

# File 'namespace.c', line 283


VALUE
rb_current_namespace_details(VALUE opt)
{
    const rb_callable_method_entry_t *cme;
    VALUE str, part, nsobj;
    char buf[2048];
    const char *path;
    int calling = 1;
    long i;
    rb_execution_context_t *ec = GET_EC();
    rb_control_frame_t *cfp = ec->cfp;
    rb_thread_t *th = rb_ec_thread_ptr(ec);
    const rb_namespace_t *ns = rb_current_namespace();
    rb_vm_t *vm = GET_VM();
    VALUE require_stack = vm->require_stack;

    str = rb_namespace_inspect(ns ? ns->ns_object : Qfalse);
    if (NIL_P(opt)) return str;

    rb_str_cat_cstr(str, "\n");

    part = rb_namespace_inspect(th->ns ? th->ns->ns_object : Qfalse);
    snprintf(buf, 2048, "main:%s, th->ns:%s, th->nss:%ld, rstack:%ld\n",
             main_namespace ? "t" : "f",
             RSTRING_PTR(part),
             th->namespaces ? RARRAY_LEN(th->namespaces) : 0,
             require_stack ? RARRAY_LEN(require_stack) : 0);
    RB_GC_GUARD(part);
    rb_str_cat_cstr(str, buf);

    if (th->namespaces && RARRAY_LEN(th->namespaces) > 0) {
        for (i=0; i<RARRAY_LEN(th->namespaces); i++) {
            nsobj = RARRAY_AREF(th->namespaces, i);
            part = rb_namespace_inspect(nsobj);
            snprintf(buf, 2048, "  th->nss[%ld] %s\n", i, RSTRING_PTR(part));
            RB_GC_GUARD(part);
            rb_str_cat_cstr(str, buf);
        }
    }


    rb_str_cat_cstr(str, "calls:\n");

    while (calling && cfp) {
        const rb_namespace_t *proc_ns;
        VALUE bh;
        if (VM_FRAME_NS_SWITCH_P(cfp)) {
            bh = rb_vm_frame_block_handler(cfp);
            if (bh && vm_block_handler_type(bh) == block_handler_type_proc) {
                proc_ns = block_proc_namespace(VM_BH_TO_PROC(bh));
                if (NAMESPACE_USER_P(ns)) {
                    part = rb_namespace_inspect(proc_ns->ns_object);
                    snprintf(buf, 2048, " cfp->ns:%s", RSTRING_PTR(part));
                    RB_GC_GUARD(part);
                    calling = 0;
                    break;
                }
            }
        }
        cme = rb_vm_frame_method_entry(cfp);
        if (cme && cme->def) {
            if (cme->def->type == VM_METHOD_TYPE_ISEQ)
                path = RSTRING_PTR(pathobj_path(cme->def->body.iseq.iseqptr->body->location.pathobj));
            else
                path = "(cfunc)";
            ns = cme->def->ns;
            if (ns) {
                part = rb_namespace_inspect(ns->ns_object);
                if (!namespace_ignore_builtin_primitive_methods_p(ns, cme->def)) {
                    snprintf(buf, 2048, " cfp cme->def id:%s, ns:%s, exprim:t, path:%s\n",
                             rb_id2name(cme->def->original_id),
                             RSTRING_PTR(part),
                             path);
                    RB_GC_GUARD(part);
                    rb_str_cat_cstr(str, buf);
                    calling = 0;
                    break;
                }
                else {
                    snprintf(buf, 2048, " cfp cme->def id:%s, ns:%s, exprim:f, path:%s\n",
                             rb_id2name(cme->def->original_id),
                             RSTRING_PTR(part),
                             path);
                    RB_GC_GUARD(part);
                    rb_str_cat_cstr(str, buf);
                }
            }
            else {
                snprintf(buf, 2048, " cfp cme->def id:%s, ns:null, path:%s\n",
                         rb_id2name(cme->def->original_id),
                         path);
                rb_str_cat_cstr(str, buf);
            }
            cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
        }
        else {
            calling = 0;
        }
    }
    rb_str_cat_cstr(str, ".\n");
    return str;
}

.is_builtin?(klass) ⇒ `Boolean`

[ GitHub ]

# File 'namespace.c', line 590


static VALUE
rb_namespace_s_is_builtin_p(VALUE namespace, VALUE klass)
{
    if (RCLASS_PRIME_CLASSEXT_READABLE_P(klass) && !RCLASS_PRIME_CLASSEXT_WRITABLE_P(klass))
        return Qtrue;
    return Qfalse;
}

Instance Method Details

#inspect

[ GitHub ]

# File 'namespace.c', line 1010


static VALUE
rb_namespace_inspect(VALUE obj)
{
    rb_namespace_t *ns;
    VALUE r;
    if (obj == Qfalse) {
        r = rb_str_new_cstr("#<Namespace:root>");
        return r;
    }
    ns = rb_get_namespace_t(obj);
    r = rb_str_new_cstr("#<Namespace:");
    rb_str_concat(r, rb_funcall(LONG2NUM(ns->ns_id), rb_intern("to_s"), 0));
    if (NAMESPACE_BUILTIN_P(ns)) {
        rb_str_cat_cstr(r, ",builtin");
    }
    if (NAMESPACE_USER_P(ns)) {
        rb_str_cat_cstr(r, ",user");
    }
    if (NAMESPACE_MAIN_P(ns)) {
        rb_str_cat_cstr(r, ",main");
    }
    else if (NAMESPACE_OPTIONAL_P(ns)) {
        rb_str_cat_cstr(r, ",optional");
    }
    rb_str_cat_cstr(r, ">");
    return r;
}

#load(*args)

[ GitHub ]

# File 'namespace.c', line 933


static VALUE
rb_namespace_load(int argc, VALUE *argv, VALUE namespace)
{
    VALUE fname, wrap;
    rb_thread_t *th = GET_THREAD();
    rb_namespace_t *ns = rb_get_namespace_t(namespace);

    rb_scan_args(argc, argv, "11", &fname, &wrap);

    VALUE args = rb_ary_new_from_args(2, fname, wrap);
    namespace_push(th, namespace);
    rb_namespace_push_loading_namespace(ns);
    struct namespace_pop2_arg arg = {
        .th = th,
        .ns = ns
    };
    return rb_ensure(rb_load_entrypoint, args, namespace_both_pop, (VALUE)&arg);
}

#load_path

[ GitHub ]

# File 'namespace.c', line 598


static VALUE
rb_namespace_load_path(VALUE namespace)
{
    return rb_get_namespace_t(namespace)->load_path;
}

#require(fname)

[ GitHub ]

# File 'namespace.c', line 952


static VALUE
rb_namespace_require(VALUE namespace, VALUE fname)
{
    rb_thread_t *th = GET_THREAD();
    rb_namespace_t *ns = rb_get_namespace_t(namespace);
    namespace_push(th, namespace);
    rb_namespace_push_loading_namespace(ns);
    struct namespace_pop2_arg arg = {
        .th = th,
        .ns = ns
    };
    return rb_ensure(rb_require_string, fname, namespace_both_pop, (VALUE)&arg);
}

#require_relative(fname)

[ GitHub ]

# File 'namespace.c', line 966


static VALUE
rb_namespace_require_relative(VALUE namespace, VALUE fname)
{
    rb_thread_t *th = GET_THREAD();
    rb_namespace_t *ns = rb_get_namespace_t(namespace);
    namespace_push(th, namespace);
    rb_namespace_push_loading_namespace(ns);
    struct namespace_pop2_arg arg = {
        .th = th,
        .ns = ns
    };
    return rb_ensure(rb_require_relative_entrypoint, fname, namespace_both_pop, (VALUE)&arg);
}

Class: Namespace

Class Attribute Summary

Class Method Summary

::Module - Inherited

Instance Attribute Summary

::Module - Inherited

Instance Method Summary

::Module - Inherited

Constructor Details

.new

Class Attribute Details

.enabled? ⇒ Boolean (readonly)

Class Method Details

.current

.current_details

.is_builtin?(klass) ⇒ Boolean

Instance Method Details

#inspect

#load(*args)

#load_path

#require(fname)

#require_relative(fname)

`::Module` - Inherited

`::Module` - Inherited

`::Module` - Inherited

.enabled? ⇒ `Boolean` (readonly)

.is_builtin?(klass) ⇒ `Boolean`