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
-
.enabled? ⇒ Boolean
readonly
Returns
true
if namespace is enabled.
Class Method Summary
-
.current ⇒ Namespace, ...
Returns the current namespace.
-
.is_builtin?(klass) ⇒ Boolean
Returns
true
ifklass
is only in a user namespace. -
.new ⇒ Namespace
constructor
Returns a new
Namespace
object.
::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 |
.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 |
Instance Method Summary
- #eval(str)
- #inspect
- #load(*args)
-
#load_path ⇒ Array
Returns namespace local 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 |
#== | Alias for Object#eql?. |
#=== | Case Equality—Returns |
#> | 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_accessor | Defines a named attribute for this module, where the name is symbol. |
#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 |
#autoload | Registers filename to be loaded (using Kernel.require) the first time that const (which may be a |
#autoload? | Returns filename to be loaded if name is registered as |
#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 |
#class_variable_get | Returns the value of the given class variable (or throws a |
#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 |
#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 |
#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 |
#instance_methods | Returns an array containing the names of the public and protected instance methods in the receiver. |
#method_defined? | Returns |
#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 |
#protected_instance_methods | Returns a list of the protected instance methods defined in mod. |
#protected_method_defined? | Returns |
#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 |
#refinements | Returns an array of |
#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, |
#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 | 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, |
#prepended | The equivalent of |
#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
.new ⇒ Namespace
Returns a new Namespace
object.
# 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.
# File 'namespace.c', line 465
static VALUE rb_namespace_s_getenabled(VALUE namespace) { return RBOOL(rb_namespace_available()); }
Class Method Details
.current ⇒ Namespace
, ...
Returns the current namespace. Returns nil
if it is the built-in namespace. Returns false
if namespace is not enabled.
# 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.
# 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_path ⇒ Array
Returns namespace local load path.
# 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); }