Ah, thanks! I had missed forwardCall completely. Got to say that I
like the MochiKit API:s more and more. Most of the basic stuff missing
in JavaScript is there. Documented and with a nice API. Great!
I'll prepare a proper patch later on, but below you'll find the functions
I'm using to prepare stack traces for logging. Basically, since most
function objects are anonymous, it is necessary to propagate the
names from the prototype objects into the function objects
themselves. Has it's drawbacks and problems, for sure, but works
quite well for me. :-)
To integrate with MochiKit, some bookkeeping for signalling and
bind stuff might be desired. Anyway, that is what I'm currently
doing (outside of MochiKit right now, though).
/**
* Registers a class. This assigns class name and method name
* identifiers to each function in the class and class prototype.
*
* @param clsthe class constructor function
* @param className the name of the class
*/
FunctionUtil.registerClass = function(cls, className) {
if (className == null) {
className = (cls.name != null) ? cls.name : cls.className;
}
if (className == null) {
className = ObjectUtil.indexOf(window, cls);
}
cls.className = className;
for (var name in cls) {
var obj = cls[name];
if (typeof(obj) == function) {
obj.className = className;
obj.methodName = name;
}
}
for (var name in cls.prototype) {
var obj = cls.prototype[name];
if (typeof(obj) == function) {
obj.className = className;
obj.methodName = name;
}
}
}
/**
* Returns the stack trace for the currently executing function. The
* stack trace is an array of function or method names ordered with
* the top of the stack at the lowest index. The maximum function
* call depth searched by this method is 20.
*
* @return the stack trace array
*/
FunctionUtil.getStackTrace = function() {
var func = this.getStackTrace.caller;
var res = [];
var oldFuncs = [];
var name;
while (func != null) {
if (func.stackTrace instanceof Array) {
return res.concat(func.stackTrace);
} else if (func.stackTrace != false) {
res.push(this.getName(func));
}
if (ArrayUtil.indexOf(oldFuncs, func) = 0) {
res.push(...recursion...);
return res;
}
oldFuncs.push(func);
if (oldFuncs.length = 20) {
res.push(...);
return res;
}
func = func.caller;
}
return res;
}
/**
* Injects a stack trace for the currently executing function. This
* method is useful for creating a fake stack trace in callback
* functions and similar. A null value can be used to clear any
* previously created stack trace.
*
* @param stackTrace the stack trace array,
* false to skip function, or
* null to reset to default
*/
FunctionUtil.setStackTrace = function(stackTrace) {
var func = this.setStackTrace.caller;
if (func != null) {
func.stackTrace = stackTrace;
}
}
/**
* Returns the name of a function. If the function is registered in
* a class, the full method name (with class prefix) will be
* returned.
*
* @param func the function object
*
* @return the function name, or
* null if not available
*/
FunctionUtil.getName = function(func) {
if (func != null func.name != null func.name != ) {
return func.name;
} else if (func != null func.className != null) {
return func.className + . + func.methodName;
} else if (func != null func.methodName != null) {
return func.methodName;
} else {
return null;
}
}
/Per
On Nov 21, 2007 12:19 AM, Bob Ippolito [EMAIL PROTECTED] wrote:
On 11/18/07, Per Cederberg [EMAIL PROTECTED] wrote:
#1. Is there a way to do late binding with MochiKit.Base.bind? I.e.
allowing function names to be resolved when the returned function is
called, rather than when bind() is called. See example below:
obj = {
a: function() { return a; },
}
var test = MochiKit.Base.bind(a, obj);
test() == a
obj.a = function() { return b; }
test() == b (currently MochiKit returns a here)
It is easy enough to modify the MochiKit.Base.bind(), but it would of
course break semantic backwards compability a bit.
I gave it a shot and it definitely breaks backwards compatibility in a
way that the tests fail. I won't be doing this, but you can do this
with forwardCall.
obj = {a: function () { return a; }}
[object Object]
test = bind(forwardCall(a), obj)
function () {...}
test()
a
obj.a = function () { return b; }
function () {...}
test()
b
#3. With a few quick hacks to set class and function names on object
functions I've been able to implement JavaScript stack traces. And
combined with logging, this has
