<cfscript>
|
function GetAncestors(cd) {
|
var ancestors = ArrayNew(1);
|
if ( StructKeyExists( cd, 'extends' ) )
|
ancestors = GetAncestors( cd.extends ) ;
|
|
ArrayAppend( ancestors, cd ) ;
|
|
return ancestors ;
|
|
}
|
|
/**
|
* Gets ancestors (interfaces) from given interface metadata
|
* It only get direct ancestors.
|
*
|
* @param cd Meta data of the interface whose ancestors are to be obtained.
|
* @returns ancestors - Array of meta data of direct ancestors
|
*/
|
function GetInterfaceAncestors(cd) {
|
var ancestors = ArrayNew(1);
|
|
if (not IsStruct(cd))
|
return ancestors;
|
|
if (StructKeyExists(cd,'extends')) {
|
for (intf in cd.extends)
|
{
|
ArrayAppend(ancestors,cd.extends[#intf#]);
|
}
|
}
|
return ancestors;
|
}
|
|
/**
|
* Checks if given metadata belongs to interface or component
|
*
|
* @param cd Metadata of component or interface
|
* @return true if it is an interface else false
|
*/
|
function IsInterface(cd) {
|
if (IsStruct(cd) and StructKeyExists(cd,'type') and cd.type eq "interface")
|
return true;
|
return false;
|
}
|
|
/**
|
* Gets array of only direct imlpemented interfaces.
|
|
* @param cd Metadata of the Component
|
* @return Array of metadata (Struct) of direct implemented interfaces
|
*/
|
function GetImplementedInterfaces(cd) {
|
var interfaces = ArrayNew(1);
|
|
if (not IsStruct(cd))
|
return interfaces;
|
|
if (StructKeyExists(cd,'implements')) {
|
for (itf in cd.implements) {
|
ArrayAppend(interfaces,cd.implements[#itf#]);
|
}
|
}
|
|
return interfaces;
|
}
|
|
function GetMethods(ancestors) {
|
|
var methods = StructNew() ;
|
var curAncestor = "";
|
var curMethod = "";
|
|
for ( i=1; i lte ArrayLen(ancestors); i=i+1 ) {
|
curAncestor = ancestors[i] ;
|
|
if ( StructKeyExists( curAncestor, 'functions' ) )
|
for ( j=1; j lte ArrayLen( curAncestor.functions ); j=j+1 ) {
|
curMethod = StructNew() ;
|
curMethod.metadata = curAncestor.functions[j] ;
|
curMethod.implementedIn = curAncestor.name ;
|
if ( i eq ArrayLen(ancestors) // don't exclude any method 1)from this
|
or not StructKeyExists( curMethod.metadata, 'access' ) // 2)that does not have 'access' attribute
|
or curMethod.metadata.access neq 'private' ) { // 3)that does not have access='private'
|
methods[curmethod.metadata.name] = curMethod ;
|
}
|
}
|
|
}
|
return methods ;
|
}
|
|
/**
|
* Gets methods of given interface metadata and its parents. Gets methods recursively
|
|
* @param cd - Metadata of an interface
|
* @param methods - Struct of methods obtained so far.
|
* @param originalInterface - A flag indicating if this method is being called for
|
* the original interface for which are obtaining methods.
|
* For recursive calls, this flag is set to false.
|
* @return Struct. Key is method name. Value is a Struct contining metadata of the method,
|
* and name of the interface where it is defined
|
*
|
*/
|
function GetInterfaceMethods(cd, methods, originalInterface) {
|
var curMethod = "";
|
|
if (not IsStruct(cd))
|
return methods;
|
|
if (StructKeyExists(cd,'extends')) {
|
for (intf in cd.extends)
|
{
|
methods = GetInterfaceMethods(cd.extends[#intf#],methods,false);
|
}
|
}
|
|
if ( StructKeyExists( cd, 'functions' ) ) {
|
for ( j=1; j lte ArrayLen( cd.functions ); j=j+1 ) {
|
curMethod = StructNew() ;
|
curMethod.metadata = cd.functions[j] ;
|
curMethod.implementedIn = cd.name ;
|
if ( originalInterface // don't exclude any method 1)from this
|
or not StructKeyExists( curMethod.metadata, 'access' ) // 2)that does not have 'access' attribute
|
or curMethod.metadata.access neq 'private' ) { // 3)that does not have access='private'
|
methods[curmethod.metadata.name] = curMethod ;
|
}
|
}//of for (j = 1; j lte ArrayLen(currAncestorchain); j = j+1)
|
}
|
|
return methods;
|
}
|
|
function GetProperties(ancestors) {
|
|
var properties = StructNew();
|
var curAncestor = "";
|
var curProperty = "";
|
|
for ( i=1; i lte ArrayLen(ancestors); i=i+1 ) {
|
curAncestor = ancestors[i] ;
|
|
if ( StructKeyExists( curAncestor, 'properties' ) )
|
for ( j=1; j lte ArrayLen( curAncestor.properties ); j=j+1 ) {
|
curProperty = StructNew() ;
|
curProperty.metadata = curAncestor.properties[j] ;
|
curProperty.implementedIn = curAncestor.name ;
|
properties[curProperty.metadata.name] = curProperty ;
|
}
|
|
}
|
return properties ;
|
|
}
|
|
function GetFullComponentName( name ) {
|
var package = "";
|
if ( Find( '.', name ) )
|
return name ;
|
else {
|
package = ListDeleteAt( cd.name, ListLen( cd.name, '.' ), '.' ) ;
|
return ListAppend( package, name, '.' ) ;
|
}
|
}
|
|
function GetShortComponentName( name ) {
|
var package ="";
|
var referencePackage = "";
|
if ( Find( '.', name ) ) {
|
package = ListDeleteAt( name, ListLen( name, '.' ), '.' ) ;
|
referencePackage = ListDeleteAt( cd.name, ListLen( cd.name, '.' ), '.' ) ;
|
if ( package eq referencePackage )
|
return ListLast( name, '.' ) ;
|
else
|
return name ;
|
} else
|
return name ;
|
|
}
|
|
function GetURLToViewer( fullName, anchor ) {
|
var url = '#getpageContext().getRequest().getContextPath()#/CFIDE/componentutils/cfcexplorer.cfc?method=getcfcinhtml&name=' & fullName ;
|
if ( anchor neq '' )
|
url = url & '&##' & anchor ;
|
return url ;
|
}
|
|
function GetLinkForType( type, captionType ) {
|
var caption = "";
|
|
if ( ListFindNoCase( 'string,numeric,boolean,date,any,binary,UUID,variableName,query,array,struct,object', type ) )
|
return type ;
|
else {
|
caption = GetShortComponentName( type ) ;
|
type = GetFullComponentName( type ) ;
|
if ( captionType eq "LONG" )
|
caption = type ;
|
if ( type eq cd.name )
|
return caption ;
|
else
|
return "<a href=""" & GetURLToViewer( type, '' ) & """>" & caption & "</a>" ;
|
}
|
}
|
|
function GetLinkForMethod( methodName, componentName ) {
|
return "<a href=""" &
|
GetURLToViewer( GetFullComponentName(componentName), 'method_' & methodName ) &
|
""">" & methodName & "</a>" ;
|
}
|
|
// returns path with forward slashes without a trailing slash
|
function GetNormalizedPath( path ) {
|
path = Replace( path, '\', '/', 'ALL' ) ;
|
if ( Right( path, 1 ) eq '/' )
|
path = RemoveChars( path, Len(path), 1 ) ;
|
return path ;
|
}
|
|
// returns true if root is longer (closer to the path) than
|
// the closestRoot and if path is under the root
|
function IsResolvable( path, root, closestRoot ) {
|
return ( Len(root) gt Len(closestRoot )
|
and Find( root, path, 1 ) eq 1 ) ;
|
}
|
|
// returns full component name;
|
// when calling this function path must be resolvable
|
function ResolveName( path, root, mapping ) {
|
var name = RemoveChars( path, 1, Len(root) ) ; // remove root
|
name = Left( name, Len(name) - 4 ) ; // remove '.cfc'
|
name = mapping & name ; // prepend mapping
|
|
// remove leading slash
|
if ( Left( name, 1 ) eq '/' )
|
name = RemoveChars( name, 1, 1) ;
|
|
// convert slashes to dots and return
|
return Replace( name, '/', '.', 'ALL' ) ;
|
}
|
</cfscript>
|
