Mootools Extends mutator, calling this.parent from functions in nested objects - class

Question

Here's a simple example of how the Extends mutator can be used:
var firstClass = new Class({
aMethod: function(){
console.log('firstClass method');
}
});
var secondClass = new Class({
Extends:firstClass,
aMethod: function(){
this.parent();
console.log('secondClass method');
},
initialize: function(){
this.aMethod();
}
});
var instance = new secondClass();
//Output:
// firstClass method
// secondClass method
I would like to achieve the same behavior, but with class constructors like this:
var firstClass = new Class({
methods: {
aMethod: function(){
console.log('firstClass method');
}
}
});
var secondClass = new Class({
Extends:firstClass,
methods: {
aMethod: function(){
this.parent();
console.log('secondClass method');
}
},
initialize: function(){
this.methods.aMethod.call(this);
}
});
var instance = new secondClass();
//Output:
// Error: The method "initialize" has no parent.
instance.methods.aMethod.call(this);
//Output:
// TypeError: this.parent is not a function
My Mootools Fu is unfortunately not very strong, so I'm kind of at a loss. Is this possible with the way Extends currently works? If it's not then I'd like to work on implementing a solution to do this, however I'd need some pointers to get me started in the right direction (make a custom Mutator? modify the Core source? something else?). Any suggestions or ideas on how to proceed would be appreciated.
Update
I came up with a way to do this using pattern based mutators (Github). Mark's code needs to be included for the following to work:
(function(){
/* Utility functions */
Object.extend({
containsMethods:function(obj){
if(typeOf(obj) != 'object') return false;
return Object.getLength(Object.filter(obj, function(item){return typeOf(item) == 'function';})) > 0;
},
containsObjects:function(obj){
if(typeOf(obj) != 'object') return false;
return Object.getLength(Object.filter(obj, function(item){return typeOf(item) == 'object';})) > 0;
}
});
var getInheritance = function(obj, key){
var temp = {};
if(obj){
if(obj.inheritance !== undefined){
temp[key] = obj.inheritance;
}
delete obj.inheritance;
}
return temp;
}
/* Recursive function to turn specially keyed object literals in the constructor into class instances with inheritance */
var classify = function(obj, inherit, key, imap){
if(typeOf(obj) != 'object'){return obj;}
if(key == undefined){
key = '';
}
var inheritance = 'extends';
if(imap != null){
imap = Object.append(imap, getInheritance(obj, key));
imap = Object.append(imap, getInheritance(inherit, key));
if(imap[key] != undefined){
inheritance = imap[key];
}
}
var i = 'extends';
for(var k in inherit){
if(!inherit.hasOwnProperty(k)) {continue;}
i = 'extends';
if(imap != null){
if(typeOf(inherit[k]) == 'object'){
imap = Object.append(imap, getInheritance(inherit[k], k));
}
if(typeOf(obj[k]) == 'object'){
imap = Object.append(imap, getInheritance(obj[k], k));
}
if(imap[k] != undefined){
i = imap[k];
}
}
/* Needed to clean up properties when inheritance == false */
if(inherit[k] === undefined){
delete inherit[k];
}
if(typeOf(inherit[k]) == 'object' && i === false && !Object.keys(obj).contains(k)){
obj[k] = undefined;
continue;
}
if(obj[k] && typeOf(obj[k]) == 'object' && i !== false){
obj[k] = classify(obj[k], inherit[k], k, imap);
}
}
if(Object.containsMethods(obj)){
var constructor = {};
if(inherit != undefined && inheritance !== false){
if(inheritance == 'implements'){
constructor.Implements = (inherit.$constructor ? inherit.$constructor : new Class(inherit));
}else {
constructor.Extends = (inherit.$constructor ? inherit.$constructor : new Class(inherit));
}
}
obj = new (new Class(Object.append(constructor, obj)));
}else {
if(!Object.containsMethods(inherit)){
obj = Object.append({}, inherit, obj);
}
}
return obj;
};
/* Mutator */
Class.defineMutator(/^_(\w+)_/, function(params, key){
var old_key = key;
var key = key.replace(/_/g, "");
var c = null;
var imap = null;
if(this.$constructor){
imap = this.$constructor.imap = (this.$constructor.imap || {});
}
if(this.prototype[key] != undefined){
c = classify.call(this, params, this.prototype[key], '', imap);
}else {
c = classify.call(this, params, undefined, '', imap);
}
this.prototype[key] = c;
delete this[old_key];
});
})();
The mutator pattern is simply a key name surrounded with single underscores (ex: _methods_). The nested objects in the class constructor can contain any combination of properties and methods or other nested objects. Each individual object can have a property with the key 'inheritance' that takes the following values: 'implements', 'extends' or false. Implements and extends correspond to the behavior of the Implements and Extends Mootools class mutators. Extends is the default, and is the method used when nothing is supplied for the inheritance property. A value of false will keep the given object (and any objects nested within it) from being inherited altogether.
The entire code including examples can be found here