var diatom = function diatom(name, parameter) {
/*;
@meta-configuration:
{
"name:required": "string",
"parameter": "...string"
}
@end-meta-configuration
*/
if (falzy(name) || typeof name != "string") {
throw new Error("invalid name");
}
/*;
@note:
We want to ensure that the class created conforms to the conventional
class namespace structure.
@end-note
*/
if (!CLASS_NAME_PATTERN.test(name)) {
throw new Error("name does not conform to conventional class name structure");
}
parameter = shft(arguments);
/*;
@note:
These are standard conventional default parameter.
@end-note
*/
if (arid(parameter)) {
parameter = ["option", "callback"];
}
name = llamalize(name, true);
try {
var blueprint = komento(template, { "name": name, "parameter": parameter.join(",") });
blueprint = new Function("return " + blueprint)();
burne(CLASS, blueprint);
burne(DIATOMIC, blueprint);
return blueprint;
} catch (error) {
throw new Error("function not created properly, " + error.stack);
}
};
var symbiote = function symbiote(child, parent) {
/*;
@meta-configuration:
{
"child:required": "function",
"parent:required": [
"function",
"string",
Array,
"..."
]
}
@end-meta-configuration
*/
if (typeof child != "function") {
throw new Error("invalid child");
}
var tree = wauker(child);
if (arguments.length > 1) {
parent = leveld(shft(arguments)).
filter(function (parent) {return protype(parent, FUNCTION, STRING);}).
map(function (parent) {
if (typeof parent == "function") {
return parent;
} else {
return xtrak(tree, parent).pop();
}
}).
filter(truly);
} else {
parent = shft(tree);
}
/*
@note:
If there are no given parent then it will get the inheritance
tree of the child and construct the initializer using that inheritance tree.
This is to ensure that we are using symbiosis properly.
@end-note
*/
if (arid(parent)) {
parent = shft(tree);
}
/*;
@note:
This will collect all non-symbiosis initialize method.
@end-note
*/
var initializer = [child].concat(parent).
map(function (blueprint) {
var initialize = wichevr(blueprint[INITIALIZE],
blueprint.prototype.initialize,
blueprint.prototype.constructor);
if (!mrkd(SYMBIOSIS, initialize, true)) {
//: @note: Cache the initialize method.
blueprint[INITIALIZE] = initialize;
//: @note: Mark the initialize method what class it belongs.
initialize[BLUEPRINT] = fname(blueprint);
return initialize;
}
}).
filter(truly).
reverse();
child.prototype.initialize = function initialize() {var _this = this;
var parameter = raze(arguments);
return initializer.reduce(function (result, initialize) {
try {
return initialize.apply(_this, parameter);
} catch (error) {
throw new Error("failed initialize, " + initialize[BLUEPRINT] + ", " + error.stack);
}
}, this);
};
burne(SYMBIOSIS, child.prototype.initialize);
return child;
};