Add more option specifications per series, and nullify the 'series' and 'axis' warnin...
[dygraphs.git] / stacktrace.js
CommitLineData
00639fab
DV
1// Domain Public by Eric Wendelin http://eriwen.com/ (2008)
2// Luke Smith http://lucassmith.name/ (2008)
3// Loic Dachary <loic@dachary.org> (2008)
4// Johan Euphrosine <proppy@aminche.com> (2008)
5// Oyvind Sean Kinsey http://kinsey.no/blog (2010)
6// Victor Homyakov <victor-homyakov@users.sourceforge.net> (2010)
7
8/**
9 * Main function giving a function stack trace with a forced or passed in Error
10 *
11 * @cfg {Error} e The error to create a stacktrace from (optional)
12 * @cfg {Boolean} guess If we should try to resolve the names of anonymous functions
13 * @return {Array} of Strings with functions, lines, files, and arguments where possible
14 */
15function printStackTrace(options) {
16 options = options || {guess: true};
17 var ex = options.e || null, guess = !!options.guess;
18 var p = new printStackTrace.implementation(), result = p.run(ex);
19 return (guess) ? p.guessAnonymousFunctions(result) : result;
20}
21
22printStackTrace.implementation = function() {
23};
24
25printStackTrace.implementation.prototype = {
26 /**
27 * @param {Error} ex The error to create a stacktrace from (optional)
28 * @param {String} mode Forced mode (optional, mostly for unit tests)
29 */
30 run: function(ex, mode) {
31 ex = ex || this.createException();
32 // examine exception properties w/o debugger
33 //for (var prop in ex) {alert("Ex['" + prop + "']=" + ex[prop]);}
34 mode = mode || this.mode(ex);
35 if (mode === 'other') {
36 return this.other(arguments.callee);
37 } else {
38 return this[mode](ex);
39 }
40 },
41
42 createException: function() {
43 try {
44 this.undef();
45 } catch (e) {
46 return e;
47 }
48 },
49
50 /**
51 * Mode could differ for different exception, e.g.
52 * exceptions in Chrome may or may not have arguments or stack.
53 *
54 * @return {String} mode of operation for the exception
55 */
56 mode: function(e) {
57 if (e['arguments'] && e.stack) {
58 return 'chrome';
59 } else if (typeof e.message === 'string' && typeof window !== 'undefined' && window.opera) {
60 // e.message.indexOf("Backtrace:") > -1 -> opera
61 // !e.stacktrace -> opera
62 if (!e.stacktrace) {
63 return 'opera9'; // use e.message
64 }
65 // 'opera#sourceloc' in e -> opera9, opera10a
66 if (e.message.indexOf('\n') > -1 && e.message.split('\n').length > e.stacktrace.split('\n').length) {
67 return 'opera9'; // use e.message
68 }
69 // e.stacktrace && !e.stack -> opera10a
70 if (!e.stack) {
71 return 'opera10a'; // use e.stacktrace
72 }
73 // e.stacktrace && e.stack -> opera10b
74 if (e.stacktrace.indexOf("called from line") < 0) {
75 return 'opera10b'; // use e.stacktrace, format differs from 'opera10a'
76 }
77 // e.stacktrace && e.stack -> opera11
78 return 'opera11'; // use e.stacktrace, format differs from 'opera10a', 'opera10b'
79 } else if (e.stack) {
80 return 'firefox';
81 }
82 return 'other';
83 },
84
85 /**
86 * Given a context, function name, and callback function, overwrite it so that it calls
87 * printStackTrace() first with a callback and then runs the rest of the body.
88 *
89 * @param {Object} context of execution (e.g. window)
90 * @param {String} functionName to instrument
91 * @param {Function} function to call with a stack trace on invocation
92 */
93 instrumentFunction: function(context, functionName, callback) {
94 context = context || window;
95 var original = context[functionName];
96 context[functionName] = function instrumented() {
97 callback.call(this, printStackTrace().slice(4));
98 return context[functionName]._instrumented.apply(this, arguments);
99 };
100 context[functionName]._instrumented = original;
101 },
102
103 /**
104 * Given a context and function name of a function that has been
105 * instrumented, revert the function to it's original (non-instrumented)
106 * state.
107 *
108 * @param {Object} context of execution (e.g. window)
109 * @param {String} functionName to de-instrument
110 */
111 deinstrumentFunction: function(context, functionName) {
112 if (context[functionName].constructor === Function &&
113 context[functionName]._instrumented &&
114 context[functionName]._instrumented.constructor === Function) {
115 context[functionName] = context[functionName]._instrumented;
116 }
117 },
118
119 /**
120 * Given an Error object, return a formatted Array based on Chrome's stack string.
121 *
122 * @param e - Error object to inspect
123 * @return Array<String> of function calls, files and line numbers
124 */
125 chrome: function(e) {
126 var stack = (e.stack + '\n').replace(/^\S[^\(]+?[\n$]/gm, '').
127 replace(/^\s+at\s+/gm, '').
128 replace(/^([^\(]+?)([\n$])/gm, '{anonymous}()@$1$2').
129 replace(/^Object.<anonymous>\s*\(([^\)]+)\)/gm, '{anonymous}()@$1').split('\n');
130 stack.pop();
131 return stack;
132 },
133
134 /**
135 * Given an Error object, return a formatted Array based on Firefox's stack string.
136 *
137 * @param e - Error object to inspect
138 * @return Array<String> of function calls, files and line numbers
139 */
140 firefox: function(e) {
141 return e.stack.replace(/(?:\n@:0)?\s+$/m, '').replace(/^\(/gm, '{anonymous}(').split('\n');
142 },
143
144 opera11: function(e) {
145 // "Error thrown at line 42, column 12 in <anonymous function>() in file://localhost/G:/js/stacktrace.js:\n"
146 // "Error thrown at line 42, column 12 in <anonymous function: createException>() in file://localhost/G:/js/stacktrace.js:\n"
147 // "called from line 7, column 4 in bar(n) in file://localhost/G:/js/test/functional/testcase1.html:\n"
148 // "called from line 15, column 3 in file://localhost/G:/js/test/functional/testcase1.html:\n"
149 var ANON = '{anonymous}', lineRE = /^.*line (\d+), column (\d+)(?: in (.+))? in (\S+):$/;
150 var lines = e.stacktrace.split('\n'), result = [];
151
152 for (var i = 0, len = lines.length; i < len; i += 2) {
153 var match = lineRE.exec(lines[i]);
154 if (match) {
155 var location = match[4] + ':' + match[1] + ':' + match[2];
156 var fnName = match[3] || "global code";
157 fnName = fnName.replace(/<anonymous function: (\S+)>/, "$1").replace(/<anonymous function>/, ANON);
158 result.push(fnName + '@' + location + ' -- ' + lines[i + 1].replace(/^\s+/, ''));
159 }
160 }
161
162 return result;
163 },
164
165 opera10b: function(e) {
166 // "<anonymous function: run>([arguments not available])@file://localhost/G:/js/stacktrace.js:27\n" +
167 // "printStackTrace([arguments not available])@file://localhost/G:/js/stacktrace.js:18\n" +
168 // "@file://localhost/G:/js/test/functional/testcase1.html:15"
169 var ANON = '{anonymous}', lineRE = /^(.*)@(.+):(\d+)$/;
170 var lines = e.stacktrace.split('\n'), result = [];
171
172 for (var i = 0, len = lines.length; i < len; i++) {
173 var match = lineRE.exec(lines[i]);
174 if (match) {
175 var fnName = match[1]? (match[1] + '()') : "global code";
176 result.push(fnName + '@' + match[2] + ':' + match[3]);
177 }
178 }
179
180 return result;
181 },
182
183 /**
184 * Given an Error object, return a formatted Array based on Opera 10's stacktrace string.
185 *
186 * @param e - Error object to inspect
187 * @return Array<String> of function calls, files and line numbers
188 */
189 opera10a: function(e) {
190 // " Line 27 of linked script file://localhost/G:/js/stacktrace.js\n"
191 // " Line 11 of inline#1 script in file://localhost/G:/js/test/functional/testcase1.html: In function foo\n"
192 var ANON = '{anonymous}', lineRE = /Line (\d+).*script (?:in )?(\S+)(?:: In function (\S+))?$/i;
193 var lines = e.stacktrace.split('\n'), result = [];
194
195 for (var i = 0, len = lines.length; i < len; i += 2) {
196 var match = lineRE.exec(lines[i]);
197 if (match) {
198 var fnName = match[3] || ANON;
199 result.push(fnName + '()@' + match[2] + ':' + match[1] + ' -- ' + lines[i + 1].replace(/^\s+/, ''));
200 }
201 }
202
203 return result;
204 },
205
206 // Opera 7.x-9.2x only!
207 opera9: function(e) {
208 // " Line 43 of linked script file://localhost/G:/js/stacktrace.js\n"
209 // " Line 7 of inline#1 script in file://localhost/G:/js/test/functional/testcase1.html\n"
210 var ANON = '{anonymous}', lineRE = /Line (\d+).*script (?:in )?(\S+)/i;
211 var lines = e.message.split('\n'), result = [];
212
213 for (var i = 2, len = lines.length; i < len; i += 2) {
214 var match = lineRE.exec(lines[i]);
215 if (match) {
216 result.push(ANON + '()@' + match[2] + ':' + match[1] + ' -- ' + lines[i + 1].replace(/^\s+/, ''));
217 }
218 }
219
220 return result;
221 },
222
223 // Safari, IE, and others
224 other: function(curr) {
225 var ANON = '{anonymous}', fnRE = /function\s*([\w\-$]+)?\s*\(/i, stack = [], fn, args, maxStackSize = 10;
226 while (curr && stack.length < maxStackSize) {
227 fn = fnRE.test(curr.toString()) ? RegExp.$1 || ANON : ANON;
228 args = Array.prototype.slice.call(curr['arguments'] || []);
229 stack[stack.length] = fn + '(' + this.stringifyArguments(args) + ')';
230 curr = curr.caller;
231 }
232 return stack;
233 },
234
235 /**
236 * Given arguments array as a String, subsituting type names for non-string types.
237 *
238 * @param {Arguments} object
239 * @return {Array} of Strings with stringified arguments
240 */
241 stringifyArguments: function(args) {
242 var result = [];
243 var slice = Array.prototype.slice;
244 for (var i = 0; i < args.length; ++i) {
245 var arg = args[i];
246 if (arg === undefined) {
247 result[i] = 'undefined';
248 } else if (arg === null) {
249 result[i] = 'null';
250 } else if (arg.constructor) {
251 if (arg.constructor === Array) {
252 if (arg.length < 3) {
253 result[i] = '[' + this.stringifyArguments(arg) + ']';
254 } else {
255 result[i] = '[' + this.stringifyArguments(slice.call(arg, 0, 1)) + '...' + this.stringifyArguments(slice.call(arg, -1)) + ']';
256 }
257 } else if (arg.constructor === Object) {
258 result[i] = '#object';
259 } else if (arg.constructor === Function) {
260 result[i] = '#function';
261 } else if (arg.constructor === String) {
262 result[i] = '"' + arg + '"';
263 } else if (arg.constructor === Number) {
264 result[i] = arg;
265 }
266 }
267 }
268 return result.join(',');
269 },
270
271 sourceCache: {},
272
273 /**
274 * @return the text from a given URL
275 */
276 ajax: function(url) {
277 var req = this.createXMLHTTPObject();
278 if (req) {
279 try {
280 req.open('GET', url, false);
281 req.send(null);
282 return req.responseText;
283 } catch (e) {
284 }
285 }
286 return '';
287 },
288
289 /**
290 * Try XHR methods in order and store XHR factory.
291 *
292 * @return <Function> XHR function or equivalent
293 */
294 createXMLHTTPObject: function() {
295 var xmlhttp, XMLHttpFactories = [
296 function() {
297 return new XMLHttpRequest();
298 }, function() {
299 return new ActiveXObject('Msxml2.XMLHTTP');
300 }, function() {
301 return new ActiveXObject('Msxml3.XMLHTTP');
302 }, function() {
303 return new ActiveXObject('Microsoft.XMLHTTP');
304 }
305 ];
306 for (var i = 0; i < XMLHttpFactories.length; i++) {
307 try {
308 xmlhttp = XMLHttpFactories[i]();
309 // Use memoization to cache the factory
310 this.createXMLHTTPObject = XMLHttpFactories[i];
311 return xmlhttp;
312 } catch (e) {
313 }
314 }
315 },
316
317 /**
318 * Given a URL, check if it is in the same domain (so we can get the source
319 * via Ajax).
320 *
321 * @param url <String> source url
322 * @return False if we need a cross-domain request
323 */
324 isSameDomain: function(url) {
325 return url.indexOf(location.hostname) !== -1;
326 },
327
328 /**
329 * Get source code from given URL if in the same domain.
330 *
331 * @param url <String> JS source URL
332 * @return <Array> Array of source code lines
333 */
334 getSource: function(url) {
335 // TODO reuse source from script tags?
336 if (!(url in this.sourceCache)) {
337 this.sourceCache[url] = this.ajax(url).split('\n');
338 }
339 return this.sourceCache[url];
340 },
341
342 guessAnonymousFunctions: function(stack) {
343 for (var i = 0; i < stack.length; ++i) {
344 var reStack = /\{anonymous\}\(.*\)@(.*)/,
345 reRef = /^(.*?)(?::(\d+))(?::(\d+))?(?: -- .+)?$/,
346 frame = stack[i], ref = reStack.exec(frame);
347
348 if (ref) {
349 var m = reRef.exec(ref[1]), file = m[1],
350 lineno = m[2], charno = m[3] || 0;
351 if (file && this.isSameDomain(file) && lineno) {
352 var functionName = this.guessAnonymousFunction(file, lineno, charno);
353 stack[i] = frame.replace('{anonymous}', functionName);
354 }
355 }
356 }
357 return stack;
358 },
359
360 guessAnonymousFunction: function(url, lineNo, charNo) {
361 var ret;
362 try {
363 ret = this.findFunctionName(this.getSource(url), lineNo);
364 } catch (e) {
365 ret = 'getSource failed with url: ' + url + ', exception: ' + e.toString();
366 }
367 return ret;
368 },
369
370 findFunctionName: function(source, lineNo) {
371 // FIXME findFunctionName fails for compressed source
372 // (more than one function on the same line)
373 // TODO use captured args
374 // function {name}({args}) m[1]=name m[2]=args
375 var reFunctionDeclaration = /function\s+([^(]*?)\s*\(([^)]*)\)/;
376 // {name} = function ({args}) TODO args capture
377 // /['"]?([0-9A-Za-z_]+)['"]?\s*[:=]\s*function(?:[^(]*)/
378 var reFunctionExpression = /['"]?([0-9A-Za-z_]+)['"]?\s*[:=]\s*function\b/;
379 // {name} = eval()
380 var reFunctionEvaluation = /['"]?([0-9A-Za-z_]+)['"]?\s*[:=]\s*(?:eval|new Function)\b/;
381 // Walk backwards in the source lines until we find
382 // the line which matches one of the patterns above
383 var code = "", line, maxLines = Math.min(lineNo, 20), m, commentPos;
384 for (var i = 0; i < maxLines; ++i) {
385 // lineNo is 1-based, source[] is 0-based
386 line = source[lineNo - i - 1];
387 commentPos = line.indexOf('//');
388 if (commentPos >= 0) {
389 line = line.substr(0, commentPos);
390 }
391 // TODO check other types of comments? Commented code may lead to false positive
392 if (line) {
393 code = line + code;
394 m = reFunctionExpression.exec(code);
395 if (m && m[1]) {
396 return m[1];
397 }
398 m = reFunctionDeclaration.exec(code);
399 if (m && m[1]) {
400 //return m[1] + "(" + (m[2] || "") + ")";
401 return m[1];
402 }
403 m = reFunctionEvaluation.exec(code);
404 if (m && m[1]) {
405 return m[1];
406 }
407 }
408 }
409 return '(?)';
410 }
411};