123456789_123456789_123456789_123456789_123456789_

Class: Namespace

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

Overview

Namespace is designed to provide separated spaces in a ::Ruby process, to isolate applications and libraries. See {namespace.md }.

Class Attribute Summary

Class Method Summary

::Module - Inherited

.constants

In the first form, returns an array of the names of all constants accessible from the point of call.

.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

::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
#module_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

Sets the visibility of a section or of a list of method names as 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_jit

Internal helper for built-in initializations to define methods only when JIT is enabled.

Constructor Details

.newNamespace

Returns a new Namespace object.

[ GitHub ]

  
# File 'namespace.c', line 420

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

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

Returns true if namespace is enabled.

[ GitHub ]

  
# File 'namespace.c', line 465

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

Class Method Details

.currentNamespace, ...

Returns the current namespace. Returns nil if it is the built-in namespace. Returns false if namespace is not enabled.

[ GitHub ]

  
# File 'namespace.c', line 479

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

.is_builtin?(klass) ⇒ Boolean

Returns true if klass is only in a user namespace.

[ GitHub ]

  
# File 'namespace.c', line 498

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

#eval(str)

[ GitHub ]

  
# File 'namespace.c', line 900

static VALUE
rb_namespace_eval(VALUE namespace, VALUE str)
{
    rb_thread_t *th = GET_THREAD();

    StringValue(str);

    namespace_push(th, namespace);
    return rb_ensure(rb_namespace_eval_string, str, namespace_pop, (VALUE)th);
}

#inspect

[ GitHub ]

  
# File 'namespace.c', line 941

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 847

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_pathArray

Returns namespace local load path.

[ GitHub ]

  
# File 'namespace.c', line 512

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

#require(fname)

[ GitHub ]

  
# File 'namespace.c', line 866

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 880

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