GNU
/
easejs
1
0
Fork 0
Code Releases Activity

Merge branch 'master' into doc/master

closure/master
Mike Gerwitz 2011-03-15 00:31:45 -04:00
parent 7c4efe5f2a 5fe08a18ac
commit 8175f60cf4
2 changed files with 45 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

101
lib/class.js
View File

@ -27,37 +27,6 @@ var util = require( './util' ),
propobj = require( './propobj' )
;
/**
* Stores class metadata internally (ensures data is encapsulated)
*
* The data in this object is hashed a class id.
*
* @type {Object.<number, { implemented: Array.<string> }>}
*/
var class_meta = {};
/**
* Stores class instance visibility object
*
* An entry in this table exists for each instance, with the instance id (iid)
* as the key. For each instance, there is always a base. The base will contain
* a proxy to the public members on the instance itself. The base will also
* contain all protected members.
*
* Atop the base object is a private member object, with the base as its
* prototype. There exists a private member object for the instance itself and
* one for each supertype. This is stored by the class id (cid) as the key. This
* permits the private member object associated with the class of the method
* call to be bound to that method. For example, if a parent method is called,
* that call must be invoked in the context of the parent, so the private
* members of the parent must be made available.
*
* The resulting structure looks something like this:
* class_instance = { iid: { cid: {} } }
*
* @type {Object.<number, Object<number, Object>>}
*/
var class_instance = {};
/*
* IE contains a nasty enumeration "bug" (poor implementation) that makes
@ -217,7 +186,7 @@ module.exports.isInstanceOf = function( type, instance )
// if no metadata is available, then our remaining checks cannot be
// performed
if ( !instance.__cid || !( meta = getMeta( instance.__cid ) ) )
if ( !instance.__cid || !( meta = getMeta( instance ) ) )
{
return false;
}
@ -450,7 +419,7 @@ var extend = ( function( extending )
members = member_builder.initMembers( prototype ),
abstract_methods =
util.clone( getMeta( base.__cid ).abstractMethods )
util.clone( getMeta( base ).abstractMethods )
|| { __length: 0 }
;
@ -543,7 +512,7 @@ var extend = ( function( extending )
} );
// reference to the parent prototype (for more experienced users)
prototype.parent = base.prototype;
prototype.___$$parent$$ = base.prototype;
// set up the new class
var new_class = createCtor( cname, abstract_methods, members );
@ -556,15 +525,15 @@ var extend = ( function( extending )
// important: call after setting prototype
setupProps( new_class, abstract_methods, class_id );
// create internal metadata for the new class
var meta = createMeta( new_class, base );
meta.abstractMethods = abstract_methods;
meta.name = cname;
// lock down the new class (if supported) to ensure that we can't add
// members at runtime
util.freeze( new_class );
// create internal metadata for the new class
var meta = createMeta( new_class, base.prototype.__cid );
meta.abstractMethods = abstract_methods;
meta.name = cname;
// we're done with the extension process
extending = false;
@ -724,7 +693,7 @@ var implement = function()
// create a new class with the implemented abstract methods
var class_new = module.exports.extend( base, dest );
getMeta( class_new.__cid ).implemented = implemented;
getMeta( class_new ).implemented = implemented;
return class_new;
}
@ -756,6 +725,21 @@ function setupProps( func, abstract_methods, class_id )
* This will be passed to all methods when invoked, permitting them to access
* the private and protected members while keeping them encapsulated.
*
* For each instance, there is always a base. The base will contain a proxy to
* the public members on the instance itself. The base will also contain all
* protected members.
*
* Atop the base object is a private member object, with the base as its
* prototype. There exists a private member object for the instance itself and
* one for each supertype. This is stored by the class id (cid) as the key. This
* permits the private member object associated with the class of the method
* call to be bound to that method. For example, if a parent method is called,
* that call must be invoked in the context of the parent, so the private
* members of the parent must be made available.
*
* The resulting structure looks something like this:
* class_instance = { iid: { cid: {} } }
*
* @param {number} iid instance id
* @param {Object} instance instance to initialize
*
@ -767,7 +751,7 @@ function initInstance( iid, instance )
prot.prototype = instance;
// add the visibility objects to the data object for this class instance
class_instance[ iid ] = new prot();
instance.___$$vis$$ = new prot();
}
@ -801,7 +785,7 @@ function attachPropInit( prototype, properties, members, cid )
// first initialize the parent's properties, so that ours will overwrite
// them
var parent_init = prototype.parent.__initProps;
var parent_init = prototype.___$$parent$$.__initProps;
if ( parent_init instanceof Function )
{
// call the parent prop_init, letting it know that it's been
@ -813,12 +797,12 @@ function attachPropInit( prototype, properties, members, cid )
// this will return our property proxy, if supported by our environment,
// otherwise just a normal object with everything merged in
var inst_props = propobj.createPropProxy(
this, class_instance[ iid ], properties[ 'public' ]
this, this.___$$vis$$, properties[ 'public' ]
);
// if we're inheriting, perform a setup that doesn't include everything
// that we don't want (e.g. private properties)
class_instance[ iid ][ cid ] = propobj.setup(
this.___$$vis$$[ cid ] = propobj.setup(
inst_props, properties, members
);
});
@ -952,29 +936,34 @@ function attachInstanceOf( instance )
/**
* Initializes class metadata for the given class
*
* @param {Class} func class to initialize metadata for
* @param {Class} func class to initialize metadata for
* @param {Class} cparent class parent
*
* @return {undefined}
*/
function createMeta( func, parent_id )
function createMeta( func, cparent )
{
var id = func.__cid,
parent_meta = ( ( parent_id ) ? getMeta( parent_id ) : undefined );
parent_meta = ( ( cparent.__cid ) ? getMeta( cparent ) : undefined );
// copy the parent prototype's metadata if it exists (inherit metadata)
if ( parent_meta )
{
class_meta[ id ] = util.clone( parent_meta, true );
func.___$$meta$$ = util.clone( parent_meta, true );
}
else
{
// create empty
class_meta[ id ] = {
func.___$$meta$$ = {
implemented: [],
};
}
return class_meta[ id ];
// store the metadata in the prototype as well (inconsiderable overhead;
// it's just a reference)
func.prototype.___$$meta$$ = func.___$$meta$$;
return func.___$$meta$$;
}
@ -984,13 +973,13 @@ function createMeta( func, parent_id )
* Since a reference is returned (rather than a copy), the returned object can
* be modified to alter the metadata.
*
* @param {number} id id of class to retrieve metadata for
* @param {Class} cls class from which to retrieve metadata
*
* @return {Object}
*/
function getMeta( id )
function getMeta( cls )
{
return class_meta[ id ] || {};
return cls.___$$meta$$ || {};
}
@ -1007,15 +996,15 @@ function getMeta( id )
* overridden by the subtype to continue to use the private members of the
* supertype.
*
* @param {function()} method method to look up instance object for
* @param {number} cid class id
* @param {function()} inst instance that the method is being called from
* @param {number} cid class id
*
* @return {Object,null} instance object if found, otherwise null
*/
function getMethodInstance( inst, cid )
{
var iid = inst.__iid,
data = class_instance[ iid ];
data = inst.___$$vis$$;
return ( iid && data )
? data[ cid ]

18
test/test-class-parent.js
View File

@ -60,11 +60,6 @@ var common = require( './common' ),
{
return this.__super( arg );
},
callParentAlt: function()
{
return this.parent.myMethod2.apply( this, arguments );
},
}),
foo = new Foo(),
@ -109,19 +104,6 @@ assert.equal(
"Arguments should be passed to super method via _super argument list"
);
assert.deepEqual(
SubFoo.prototype.parent,
Foo.prototype,
"Parent property should represent parent prototype"
);
sub_foo.callParentAlt( arg = 'moo' );
assert.equal(
method2Arg,
arg,
"The parent property may also be used to invoke parent methods"
);
assert.throws( function()
{
Foo.extend(