1
0
Fork 0
easejs/lib/interface.js

366 lines
9.8 KiB
JavaScript
Raw Normal View History

2010-12-01 19:27:40 -05:00
/**
* Contains interface module
*
2013-12-20 00:49:06 -05:00
* Copyright (C) 2010, 2011, 2012, 2013 Mike Gerwitz
2010-12-01 19:27:40 -05:00
*
* This file is part of ease.js.
*
* ease.js is free software: you can redistribute it and/or modify it under the
* terms of the GNU General Public License as published by the Free Software
* Foundation, either version 3 of the License, or (at your option) any later
* version.
2010-12-01 19:27:40 -05:00
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
2010-12-01 19:27:40 -05:00
*
* You should have received a copy of the GNU General Public License along with
* this program. If not, see <http://www.gnu.org/licenses/>.
2010-12-01 19:27:40 -05:00
*
* @author Mike Gerwitz
*/
var util = require( __dirname + '/util' ),
MethodWrapperFactory = require( __dirname + '/MethodWrapperFactory' ),
wrappers = require( __dirname + '/MethodWrappers' ).standard,
member_builder = require( __dirname + '/MemberBuilder' )(
MethodWrapperFactory( wrappers.wrapNew ),
MethodWrapperFactory( wrappers.wrapOverride ),
Added `proxy' keyword support The concept of proxy methods will become an important, core concept in ease.js that will provide strong benefits for creating decorators and proxies, removing boilerplate code and providing useful metadata to the system. Consider the following example: Class( 'Foo', { // ... 'public performOperation': function( bar ) { this._doSomethingWith( bar ); return this; }, } ); Class( 'FooDecorator', { 'private _foo': null, // ... 'public performOperation': function( bar ) { return this._foo.performOperation( bar ); }, } ); In the above example, `FooDecorator` is a decorator for `Foo`. Assume that the `getValueOf()` method is undecorated and simply needs to be proxied to its component --- an instance of `Foo`. (It is not uncommon that a decorator, proxy, or related class will alter certain functionality while leaving much of it unchanged.) In order to do so, we can use this generic, boilerplate code return this.obj.func.apply( this.obj, arguments ); which would need to be repeated again and again for *each method that needs to be proxied*. We also have another problem --- `Foo.getValueOf()` returns *itself*, which `FooDecorator` *also* returns. This breaks encapsulation, so we instead need to return ourself: 'public performOperation': function( bar ) { this._foo.performOperation( bar ); return this; }, Our boilerplate code then becomes: var ret = this.obj.func.apply( this.obj, arguments ); return ( ret === this.obj ) ? this : ret; Alternatively, we could use the `proxy' keyword: Class( 'FooDecorator2', { 'private _foo': null, // ... 'public proxy performOperation': '_foo', } ); `FooDecorator2.getValueOf()` and `FooDecorator.getValueOf()` both perform the exact same task --- proxy the entire call to another object and return its result, unless the result is the component, in which case the decorator itself is returned. Proxies, as of this commit, accomplish the following: - All arguments are forwarded to the destination - The return value is forwarded to the caller - If the destination returns a reference to itself, it will be replaced with a reference to the caller's context (`this`). - If the call is expected to fail, either because the destination is not an object or because the requested method is not a function, a useful error will be immediately thrown (rather than the potentially cryptic one that would otherwise result, requiring analysis of the stack trace). N.B. As of this commit, static proxies do not yet function properly.
2012-05-02 13:26:47 -04:00
MethodWrapperFactory( wrappers.wrapProxy ),
require( __dirname + '/MemberBuilderValidator' )()
),
Class = require( __dirname + '/class' )
;
2010-12-01 19:27:40 -05:00
/**
* This module may be invoked in order to provide a more natural looking
* interface definition
*
* Only new interfaces may be created using this method. They cannot be
* extended. To extend an existing interface, call its extend() method, or use
* the extend() method of this module.
*
* @param {string|Object} namedef optional name or definition
* @param {Object=} def interface definition if first arg is name
*
* @return {Function|Object} new interface or staging object
*/
module.exports = function( namedef, def )
{
var type = ( typeof namedef ),
result = null
2011-03-04 00:24:42 -05:00
;
2011-03-04 00:24:42 -05:00
switch ( type )
{
2011-03-04 00:24:42 -05:00
// anonymous interface
case 'object':
result = createAnonymousInterface.apply( null, arguments );
2011-03-04 00:24:42 -05:00
break;
// named class
case 'string':
result = createNamedInterface.apply( null, arguments );
2011-03-04 00:24:42 -05:00
break;
default:
// we don't know what to do!
throw TypeError(
"Expecting anonymous interface definition or named " +
"interface definition"
);
}
return result;
};
2010-12-01 19:27:40 -05:00
/**
* Creates an interface
*
* @return {Function} extended interface
2010-12-01 19:27:40 -05:00
*/
module.exports.extend = function()
2010-12-01 19:27:40 -05:00
{
return extend.apply( this, arguments );
};
2010-12-01 19:27:40 -05:00
2011-03-03 23:59:37 -05:00
/**
* Determines whether the provided object is an interface created through
* ease.js
*
* @param {Object} obj object to test
*
* @return {boolean} true if interface (created through ease.js), otherwise
* false
*/
module.exports.isInterface = function( obj )
{
obj = obj || {};
return ( obj.prototype instanceof Interface )
? true
: false
;
};
2010-12-01 19:27:40 -05:00
/**
* Default interface implementation
*
* @return {undefined}
*/
function Interface() {}
/**
* Creates a new anonymous Interface from the given interface definition
*
* @param {Object} def interface definition
*
* @return {Function} new anonymous interface
*/
function createAnonymousInterface( def )
{
// ensure we have the proper number of arguments (if they passed in
// too many, it may signify that they don't know what they're doing,
// and likely they're not getting the result they're looking for)
if ( arguments.length > 1 )
{
throw Error(
"Expecting one argument for Interface definition; " +
arguments.length + " given."
);
}
return extend( def );
}
/**
* Creates a new named interface from the given interface definition
*
* @param {string} name interface name
* @param {Object} def interface definition
*
* @return {Function} new named interface
*/
function createNamedInterface( name, def )
{
// if too many arguments were provided, it's likely that they're
// expecting some result that they're not going to get
if ( arguments.length > 2 )
{
throw Error(
"Expecting two arguments for definition of named Interface '" +
name + "'; " + arguments.length + " given."
);
}
// the definition must be an object
if ( typeof def !== 'object' )
{
throw TypeError(
"Unexpected value for definition of named Interface '" +
name + "'; object expected"
);
}
// add the name to the definition
def.__name = name;
return extend( def );
}
2010-12-29 22:40:23 -05:00
var extend = ( function( extending )
2010-12-01 19:27:40 -05:00
{
2010-12-29 22:40:23 -05:00
return function extend()
{
// ensure we'll be permitted to instantiate interfaces for the base
extending = true;
2010-12-01 19:27:40 -05:00
2010-12-29 22:40:23 -05:00
var args = Array.prototype.slice.call( arguments ),
props = args.pop() || {},
base = args.pop() || Interface,
prototype = new base(),
iname = '',
members = member_builder.initMembers(
prototype, prototype, prototype
)
;
2010-12-28 21:56:55 -05:00
// grab the name, if one was provided
if ( iname = props.__name )
{
// we no longer need it
delete props.__name;
}
2010-12-29 22:40:23 -05:00
// sanity check
inheritCheck( prototype );
var new_interface = createInterface( iname );
2010-12-29 22:40:23 -05:00
try
{
util.propParse( props, {
assumeAbstract: true,
property: function()
{
// should never get to this point because of assumeAbstract
throw TypeError( 'Unexpected internal error' );
},
getset: function()
{
// should never get to this point because of assumeAbstract
throw TypeError( 'Unexpected internal error' );
},
method: function( name, value, is_abstract, keywords )
{
// all members must be public
if ( keywords[ 'protected' ] || keywords[ 'private' ] )
{
throw TypeError(
iname + " member " + name + " must be public"
);
}
member_builder.buildMethod(
members, null, name, value, keywords
);
},
} );
}
catch ( e )
{
// alter the message to include our name
e.message = "Failed to define interface " +
( ( iname ) ? iname : '(anonymous)' ) + ": " + e.message
;
// re-throw
throw e;
}
2010-12-29 22:40:23 -05:00
attachExtend( new_interface );
attachStringMethod( new_interface, iname );
2010-12-29 22:40:23 -05:00
new_interface.prototype = prototype;
new_interface.constructor = new_interface;
// freeze the interface (preventing additions), if supported
util.freeze( new_interface );
2010-12-29 22:40:23 -05:00
// we're done; let's not allow interfaces to be instantiated anymore
extending = false;
2010-12-01 19:27:40 -05:00
2010-12-29 22:40:23 -05:00
return new_interface;
};
2010-12-01 19:27:40 -05:00
2010-12-29 22:40:23 -05:00
/**
* Creates a new interface constructor function
*
* @param {string=} iname interface name
*
2010-12-29 22:40:23 -05:00
* @return {function()}
*/
function createInterface( iname )
2010-12-29 22:40:23 -05:00
{
return function()
{
// allows us to extend the interface without throwing an exception
// (since the prototype requires an instance)
if ( !extending )
{
// only called if someone tries to create a new instance of an
// interface
throw Error(
"Interface " + ( ( iname ) ? ( iname + ' ' ) : '' ) +
" cannot be instantiated"
);
2010-12-29 22:40:23 -05:00
}
};
}
} )( false );
2010-12-01 19:27:40 -05:00
2010-12-28 21:56:55 -05:00
/**
* Assures that the parent object is a valid object to inherit from
*
* This method allows inheriting from any object (note that it will likely cause
* errors if not an interface), but will place restrictions on objects like
* Classes that do not make sense to inherit from. This will provide a more
* friendly error, with suggestions on how to resolve the issue, rather than a
* cryptic error resulting from inheritance problems.
*
* This method will throw an exception if there is a violation.
*
* @param {Object} prototype prototype to check for inheritance flaws
*
* @return {undefined}
*/
function inheritCheck( prototype )
{
// if we're inheriting from another interface, then we're good
if ( !( prototype instanceof Interface ) )
2010-12-28 21:56:55 -05:00
{
throw new TypeError( "Interfaces may only extend other interfaces" );
2010-12-28 21:56:55 -05:00
}
}
2010-12-01 23:27:31 -05:00
/**
* Attaches extend method to the given function (interface)
*
* @param {Function} func function (interface) to attach method to
*
* @return {undefined}
*/
2010-12-28 22:08:30 -05:00
function attachExtend( func )
2010-12-01 23:27:31 -05:00
{
/**
* Shorthand for extending interfaces
*
* This method can be invoked on the object, rather than having to call
* Interface.extend( this ).
*
* @param {Object} props properties to add to extended interface
*
* @return {Object} extended interface
*/
util.defineSecureProp( func, 'extend', function( props )
{
return extend( this, props );
});
}
/**
* Provides more sane/useful output when interface is converted to a string
*
* @param {Object} func interface
* @param {string=} iname interface name
*
* @return {undefined}
*/
function attachStringMethod( func, iname )
{
func.toString = ( iname )
? function() { return '[object Interface <' + iname + '>]'; }
: function() { return '[object Interface]'; }
;
}