Class: Ruby::Box

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

Overview

Box is designed to provide separated spaces in a Ruby process, to isolate applications and libraries. See {file:box.html }.

Class Attribute Summary

Namespace.enabled? ⇒ Boolean readonly

Returns true if Box is enabled.

Class Method Summary

Namespace.current ⇒ Box, ...

Returns the current box.
Namespace.new ⇒ Box constructor

Returns a new Box object.
.main Internal use only
.root Internal use only

`::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

#main? ⇒ Boolean readonly Internal use only
#root? ⇒ Boolean readonly Internal use only

`::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

#eval(str)
#inspect
#load(*args)

And it requires calling dlclose before deleting it.
#load_path ⇒ Array

Returns box 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 `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	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,
#with_jit	Internal helper for built-in initializations to define methods only when JIT is enabled.

Constructor Details

Namespace.new ⇒ `Box`

Returns a new Box object.

[ GitHub ]

# File 'box.c', line 322


static VALUE
box_initialize(VALUE box_value)
{
    rb_box_t *box;
    rb_classext_t *object_classext;
    VALUE entry;
    ID id_box_entry;
    CONST_ID(id_box_entry, "__box_entry__");

    if (!rb_box_available()) {
        rb_raise(rb_eRuntimeError, "Ruby Box is disabled. Set RUBY_BOX=1 environment variable to use Ruby::Box.");
    }

    entry = rb_class_new_instance_pass_kw(0, NULL, rb_cBoxEntry);
    box = get_box_struct_internal(entry);

    box->box_object = box_value;
    box->box_id = box_generate_id();
    rb_define_singleton_method(box->load_path, "resolve_feature_path", rb_resolve_feature_path, 1);

    // Set the Ruby::Box object unique/consistent from any boxes to have just single
    // constant table from any view of every (including main) box.
    // If a code in the box adds a constant, the constant will be visible even from root/main.
    RCLASS_SET_PRIME_CLASSEXT_WRITABLE(box_value, 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_BOX(rb_cObject, box);
    RCLASS_SET_CONST_TBL(box_value, RCLASSEXT_CONST_TBL(object_classext), true);

    rb_ivar_set(box_value, id_box_entry, entry);

    return box_value;
}

Class Attribute Details

Namespace.enabled? ⇒ `Boolean` (readonly)

Returns true if Box is enabled.

[ GitHub ]

# File 'box.c', line 363


static VALUE
rb_box_s_getenabled(VALUE recv)
{
    return RBOOL(rb_box_available());
}

Class Method Details

Namespace.current ⇒ `Box`, ...

Returns the current box. Returns nil if Ruby Box is not enabled.

[ GitHub ]

# File 'box.c', line 376


static VALUE
rb_box_s_current(VALUE recv)
{
    const rb_box_t *box;

    if (!rb_box_available())
        return Qnil;

    box = rb_vm_current_box(GET_EC());
    VM_ASSERT(box && box->box_object);
    return box->box_object;
}

.main

This method is for internal use only.

[ GitHub ]

# File 'box.c', line 886


static VALUE
rb_box_s_main(VALUE recv)
{
    return main_box->box_object;
}

.root

This method is for internal use only.

[ GitHub ]

# File 'box.c', line 879


static VALUE
rb_box_s_root(VALUE recv)
{
    return root_box->box_object;
}

Instance Attribute Details

#main? ⇒ `Boolean` (readonly)

This method is for internal use only.

[ GitHub ]

# File 'box.c', line 901


static VALUE
rb_box_main_p(VALUE box_value)
{
    const rb_box_t *box = (const rb_box_t *)rb_get_box_t(box_value);
    return RBOOL(BOX_MAIN_P(box));
}

#root? ⇒ `Boolean` (readonly)

This method is for internal use only.

[ GitHub ]

# File 'box.c', line 893


static VALUE
rb_box_root_p(VALUE box_value)
{
    const rb_box_t *box = (const rb_box_t *)rb_get_box_t(box_value);
    return RBOOL(BOX_ROOT_P(box));
}

Instance Method Details

#eval(str)

[ GitHub ]

# File 'box.c', line 769


static VALUE
rb_box_eval(VALUE box_value, VALUE str)
{
    const rb_iseq_t *iseq;
    const rb_box_t *box;

    StringValue(str);

    iseq = rb_iseq_compile_iseq(str, rb_str_new_cstr("eval"));
    VM_ASSERT(iseq);

    box = (const rb_box_t *)rb_get_box_t(box_value);

    return rb_iseq_eval(iseq, box);
}

#inspect

[ GitHub ]

# File 'box.c', line 818


static VALUE
rb_box_inspect(VALUE obj)
{
    rb_box_t *box;
    VALUE r;
    if (obj == Qfalse) {
        r = rb_str_new_cstr("#<Namespace:root>");
        return r;
    }
    box = rb_get_box_t(obj);
    r = rb_str_new_cstr("#<Namespace:");
    rb_str_concat(r, rb_funcall(LONG2NUM(box->box_id), rb_intern("to_s"), 0));
    if (BOX_ROOT_P(box)) {
        rb_str_cat_cstr(r, ",root");
    }
    if (BOX_USER_P(box)) {
        rb_str_cat_cstr(r, ",user");
    }
    if (BOX_MAIN_P(box)) {
        rb_str_cat_cstr(r, ",main");
    }
    else if (BOX_OPTIONAL_P(box)) {
        rb_str_cat_cstr(r, ",optional");
    }
    rb_str_cat_cstr(r, ">");
    return r;
}

#load(*args)

And it requires calling dlclose before deleting it.

[ GitHub ]

# File 'box.c', line 695


static VALUE
rb_box_load(int argc, VALUE *argv, VALUE box)
{
    VALUE fname, wrap;
    rb_scan_args(argc, argv, "11", &fname, &wrap);

    rb_vm_frame_flag_set_box_require(GET_EC());

    VALUE args = rb_ary_new_from_args(2, fname, wrap);
    return rb_load_entrypoint(args);
}

#load_path ⇒ Array

Returns box local load path.

[ GitHub ]

# File 'box.c', line 395


static VALUE
rb_box_load_path(VALUE box)
{
    VM_ASSERT(BOX_OBJ_P(box));
    return rb_get_box_t(box)->load_path;
}

#require(fname)

[ GitHub ]

# File 'box.c', line 707


static VALUE
rb_box_require(VALUE box, VALUE fname)
{
    rb_vm_frame_flag_set_box_require(GET_EC());

    return rb_require_string(fname);
}

#require_relative(fname)

[ GitHub ]

# File 'box.c', line 715


static VALUE
rb_box_require_relative(VALUE box, VALUE fname)
{
    rb_vm_frame_flag_set_box_require(GET_EC());

    return rb_require_relative_entrypoint(fname);
}

Class: Ruby::Box

Overview

Class Attribute Summary

Class Method Summary

::Module - Inherited

Instance Attribute Summary

::Module - Inherited

Instance Method Summary

::Module - Inherited

Constructor Details

Namespace.new ⇒ Box

Class Attribute Details

Namespace.enabled? ⇒ Boolean (readonly)

Class Method Details

Namespace.current ⇒ Box, ...

.main

.root

Instance Attribute Details

#main? ⇒ Boolean (readonly)

#root? ⇒ Boolean (readonly)

Instance Method Details

#eval(str)

#inspect

#load(*args)

#load_path ⇒ Array

#require(fname)

#require_relative(fname)

`::Module` - Inherited

`::Module` - Inherited

`::Module` - Inherited

Namespace.new ⇒ `Box`

Namespace.enabled? ⇒ `Boolean` (readonly)

Namespace.current ⇒ `Box`, ...

#main? ⇒ `Boolean` (readonly)

#root? ⇒ `Boolean` (readonly)