← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/xulrunner-1.9/intrepid

« back to all changes in this revision

Viewing changes to mozilla/testing/mochitest/MochiKit/Logging.js

  • Committer: Bazaar Package Importer
  • Author(s): Alexander Sack, Alexander Sack, Fabien Tassin
  • Date: 2008-02-13 11:47:21 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20080213114721-7om0mgzngvuk9czv
Tags: 1.9~b3+nobinonly-0ubuntu1
https://launchpad.net/bugs/37507
* release FIREFOX_3_0b3_RELEASE

[ Alexander Sack ]
* submit patch that ships xpcshell to bugzilla
  - rename debian/patches/ship_xpcshell.patch =>
           debian/patches/bz410617_att295212_ship_xpcshell.patch
  - update debian/patches/series
* fix tooltip in epiphany: previously displayed out of screen bounds
  (LP: #37507)
  - add debian/patches/bz233371_att297343_fix_outofscreen_embed_tooltip.patch
  - update debian/patches/series
* use default upstream gcc tweaks for improved performance - especially of the
  javascript engine
  - update debian/rules
* update global extension/plugin patch to apply cleanly against latest code
  - update debian/patches/bzXXX_gre_extension_plugin_support.patch
* fix pyxpcom build failure introduced by recent commit
  - add debian/patches/bzXXX_fix_pyxpcom_build_failure.patch
  - update debian/patches/series
* add distro independent global install locations for extensions,
  /usr/lib/mozilla/extensions and /usr/share/mozilla/extensions
  - update debian/xulrunner-1.9.dirs
* support embedded tarball layout when either there is a *.tar.bz2 in orig tarball
  or if DEBIAN_MOZCLIENT_EMBEDDED is not unset (you will need this to produce embedded
  tarballs during |get-orig-source|
  - update debian/rules
* bump minimum libnss3-dev build requirements to >= 3.12.0~1.9b3
  - update debian/control
* bump minimum libnspr4-dev build requirements to >= 4.7.0~1.9b3
  - update debian/control

[ Fabien Tassin ]
* Drop patches applied upstream
  - drop debian/patches/bz410617_att295212_ship_xpcshell.patch
  - drop debian/patches/bz404634_att294921.patch
  - drop debian/patches/bz386610_python2.5_ftbfs_amd64.patch
  - drop debian/patches/bz373918_att295042.patch
  - drop debian/patches/bz408062_unstable_pc.patch
  - drop debian/patches/bz384304_fix_recursive_symlinks.patch
  - update debian/patches/series
* Refresh diverged patches:
  - update debian/patches/bzXXX_pc_honour_system_nspr_nss.patch
  - update debian/patches/rename_venkman_addon.patch
  - update debian/patches/bz344818_cairo_xrender.patch
* Install links for all .so libs in the -dev package
  - update debian/patches/dont_install_so_in_dev.patch
* Bump gtk requirement to 2.12 as per Mozilla bug 412432
  - update debian/control
* Add #DEBHELPER# token to postinst/prerm scripts
  - update debian/xulrunner-1.9.{postinst,prerm}
* Install previously missed libdbusservice.so
  - update debian/xulrunner-1.9.install
* Update venkman patch to also rename locales
  - update debian/patches/rename_venkman_addon.patch
* Bump requirement for system cairo to >= 1.5.8 as we now need
  the newly added cairo_path_extents()
  - update debian/rules
* Include mozilla-devscripts file using -include so ifneq could be omitted
  - update debian/rules
* Fix missing .so symlinks regression
  - update debian/patches/dont_install_so_in_dev.patch

Show diffs side-by-side

added added

removed removed

Lines of Context:
mozilla/testing/mochitest/MochiKit/Logging.js
1
 
/***
2
 
 
3
 
MochiKit.Logging 1.4
4
 
 
5
 
See <http://mochikit.com/> for documentation, downloads, license, etc.
6
 
 
7
 
(c) 2005 Bob Ippolito.  All rights Reserved.
8
 
 
9
 
***/
10
 
 
11
 
if (typeof(dojo) != 'undefined') {
12
 
    dojo.provide('MochiKit.Logging');
13
 
    dojo.require('MochiKit.Base');
14
 
}
15
 
 
16
 
if (typeof(JSAN) != 'undefined') {
17
 
    JSAN.use("MochiKit.Base", []);
18
 
}
19
 
 
20
 
try {
21
 
    if (typeof(MochiKit.Base) == 'undefined') {
22
 
        throw "";
23
 
    }
24
 
} catch (e) {
25
 
    throw "MochiKit.Logging depends on MochiKit.Base!";
26
 
}
27
 
 
28
 
if (typeof(MochiKit.Logging) == 'undefined') {
29
 
    MochiKit.Logging = {};
30
 
}
31
 
 
32
 
MochiKit.Logging.NAME = "MochiKit.Logging";
33
 
MochiKit.Logging.VERSION = "1.4";
34
 
MochiKit.Logging.__repr__ = function () {
35
 
    return "[" + this.NAME + " " + this.VERSION + "]";
36
 
};
37
 
 
38
 
MochiKit.Logging.toString = function () {
39
 
    return this.__repr__();
40
 
};
41
 
 
42
 
 
43
 
MochiKit.Logging.EXPORT = [
44
 
    "LogLevel",
45
 
    "LogMessage",
46
 
    "Logger",
47
 
    "alertListener",
48
 
    "logger",
49
 
    "log",
50
 
    "logError",
51
 
    "logDebug",
52
 
    "logFatal",
53
 
    "logWarning"
54
 
];
55
 
 
56
 
 
57
 
MochiKit.Logging.EXPORT_OK = [
58
 
    "logLevelAtLeast",
59
 
    "isLogMessage",
60
 
    "compareLogMessage"
61
 
];
62
 
 
63
 
 
64
 
/** @id MochiKit.Logging.LogMessage */
65
 
MochiKit.Logging.LogMessage = function (num, level, info) {
66
 
    this.num = num;
67
 
    this.level = level;
68
 
    this.info = info;
69
 
    this.timestamp = new Date();
70
 
};
71
 
 
72
 
MochiKit.Logging.LogMessage.prototype = {
73
 
     /** @id MochiKit.Logging.LogMessage.prototype.repr */
74
 
    repr: function () {
75
 
        var m = MochiKit.Base;
76
 
        return 'LogMessage(' + 
77
 
            m.map(
78
 
                m.repr,
79
 
                [this.num, this.level, this.info]
80
 
            ).join(', ') + ')';
81
 
    },
82
 
    /** @id MochiKit.Logging.LogMessage.prototype.toString */
83
 
    toString: MochiKit.Base.forwardCall("repr")
84
 
};
85
 
 
86
 
MochiKit.Base.update(MochiKit.Logging, {
87
 
    /** @id MochiKit.Logging.logLevelAtLeast */
88
 
    logLevelAtLeast: function (minLevel) {
89
 
        var self = MochiKit.Logging;
90
 
        if (typeof(minLevel) == 'string') {
91
 
            minLevel = self.LogLevel[minLevel];
92
 
        }
93
 
        return function (msg) {
94
 
            var msgLevel = msg.level;
95
 
            if (typeof(msgLevel) == 'string') {
96
 
                msgLevel = self.LogLevel[msgLevel];
97
 
            }
98
 
            return msgLevel >= minLevel;
99
 
        };
100
 
    },
101
 
 
102
 
    /** @id MochiKit.Logging.isLogMessage */
103
 
    isLogMessage: function (/* ... */) {
104
 
        var LogMessage = MochiKit.Logging.LogMessage;
105
 
        for (var i = 0; i < arguments.length; i++) {
106
 
            if (!(arguments[i] instanceof LogMessage)) {
107
 
                return false;
108
 
            }
109
 
        }
110
 
        return true;
111
 
    },
112
 
 
113
 
    /** @id MochiKit.Logging.compareLogMessage */
114
 
    compareLogMessage: function (a, b) {
115
 
        return MochiKit.Base.compare([a.level, a.info], [b.level, b.info]);
116
 
    },
117
 
 
118
 
    /** @id MochiKit.Logging.alertListener */
119
 
    alertListener: function (msg) {
120
 
        alert(
121
 
            "num: " + msg.num +
122
 
            "\nlevel: " +  msg.level +
123
 
            "\ninfo: " + msg.info.join(" ")
124
 
        );
125
 
    }
126
 
 
127
 
});
128
 
 
129
 
/** @id MochiKit.Logging.Logger */
130
 
MochiKit.Logging.Logger = function (/* optional */maxSize) {
131
 
    this.counter = 0;
132
 
    if (typeof(maxSize) == 'undefined' || maxSize === null) {
133
 
        maxSize = -1;
134
 
    }
135
 
    this.maxSize = maxSize;
136
 
    this._messages = [];
137
 
    this.listeners = {};
138
 
    this.useNativeConsole = false;
139
 
};
140
 
 
141
 
MochiKit.Logging.Logger.prototype = {
142
 
    /** @id MochiKit.Logging.Logger.prototype.clear */
143
 
    clear: function () {
144
 
        this._messages.splice(0, this._messages.length);
145
 
    },
146
 
 
147
 
    /** @id MochiKit.Logging.Logger.prototype.logToConsole */
148
 
    logToConsole: function (msg) {
149
 
        if (typeof(window) != "undefined" && window.console
150
 
                && window.console.log) {
151
 
            // Safari and FireBug 0.4
152
 
            // Percent replacement is a workaround for cute Safari crashing bug 
153
 
            window.console.log(msg.replace(/%/g, '\uFF05'));
154
 
        } else if (typeof(opera) != "undefined" && opera.postError) {
155
 
            // Opera
156
 
            opera.postError(msg);
157
 
        } else if (typeof(printfire) == "function") {
158
 
            // FireBug 0.3 and earlier
159
 
            printfire(msg);
160
 
        } else if (typeof(Debug) != "undefined" && Debug.writeln) {
161
 
            // IE Web Development Helper (?)
162
 
            // http://www.nikhilk.net/Entry.aspx?id=93
163
 
            Debug.writeln(msg);
164
 
        } else if (typeof(debug) != "undefined" && debug.trace) {
165
 
            // Atlas framework (?)
166
 
            // http://www.nikhilk.net/Entry.aspx?id=93
167
 
            debug.trace(msg);
168
 
        }
169
 
    },
170
 
    
171
 
    /** @id MochiKit.Logging.Logger.prototype.dispatchListeners */
172
 
    dispatchListeners: function (msg) {
173
 
        for (var k in this.listeners) {
174
 
            var pair = this.listeners[k];
175
 
            if (pair.ident != k || (pair[0] && !pair[0](msg))) {
176
 
                continue;
177
 
            }
178
 
            pair[1](msg);
179
 
        }
180
 
    },
181
 
 
182
 
    /** @id MochiKit.Logging.Logger.prototype.addListener */
183
 
    addListener: function (ident, filter, listener) {
184
 
        if (typeof(filter) == 'string') {
185
 
            filter = MochiKit.Logging.logLevelAtLeast(filter);
186
 
        }
187
 
        var entry = [filter, listener];
188
 
        entry.ident = ident;
189
 
        this.listeners[ident] = entry;
190
 
    },
191
 
 
192
 
    /** @id MochiKit.Logging.Logger.prototype.removeListener */
193
 
    removeListener: function (ident) {
194
 
        delete this.listeners[ident];
195
 
    },
196
 
 
197
 
    /** @id MochiKit.Logging.Logger.prototype.baseLog */
198
 
    baseLog: function (level, message/*, ...*/) {
199
 
        var msg = new MochiKit.Logging.LogMessage(
200
 
            this.counter,
201
 
            level,
202
 
            MochiKit.Base.extend(null, arguments, 1)
203
 
        );
204
 
        this._messages.push(msg);
205
 
        this.dispatchListeners(msg);
206
 
        if (this.useNativeConsole) {
207
 
            this.logToConsole(msg.level + ": " + msg.info.join(" "));
208
 
        }
209
 
        this.counter += 1;
210
 
        while (this.maxSize >= 0 && this._messages.length > this.maxSize) {
211
 
            this._messages.shift();
212
 
        }
213
 
    },
214
 
 
215
 
    /** @id MochiKit.Logging.Logger.prototype.getMessages */
216
 
    getMessages: function (howMany) {
217
 
        var firstMsg = 0;
218
 
        if (!(typeof(howMany) == 'undefined' || howMany === null)) {
219
 
            firstMsg = Math.max(0, this._messages.length - howMany);
220
 
        }
221
 
        return this._messages.slice(firstMsg);
222
 
    },
223
 
 
224
 
    /** @id MochiKit.Logging.Logger.prototype.getMessageText */
225
 
    getMessageText: function (howMany) {
226
 
        if (typeof(howMany) == 'undefined' || howMany === null) {
227
 
            howMany = 30;
228
 
        }
229
 
        var messages = this.getMessages(howMany);
230
 
        if (messages.length) {
231
 
            var lst = map(function (m) {
232
 
                return '\n  [' + m.num + '] ' + m.level + ': ' + m.info.join(' '); 
233
 
            }, messages);
234
 
            lst.unshift('LAST ' + messages.length + ' MESSAGES:');
235
 
            return lst.join('');
236
 
        }
237
 
        return '';
238
 
    },
239
 
 
240
 
    /** @id MochiKit.Logging.Logger.prototype.debuggingBookmarklet */
241
 
    debuggingBookmarklet: function (inline) {
242
 
        if (typeof(MochiKit.LoggingPane) == "undefined") {
243
 
            alert(this.getMessageText());
244
 
        } else {
245
 
            MochiKit.LoggingPane.createLoggingPane(inline || false);
246
 
        }
247
 
    }
248
 
};
249
 
 
250
 
MochiKit.Logging.__new__ = function () {
251
 
    this.LogLevel = {
252
 
        ERROR: 40,
253
 
        FATAL: 50,
254
 
        WARNING: 30,
255
 
        INFO: 20,
256
 
        DEBUG: 10
257
 
    };
258
 
 
259
 
    var m = MochiKit.Base;
260
 
    m.registerComparator("LogMessage",
261
 
        this.isLogMessage,
262
 
        this.compareLogMessage
263
 
    );
264
 
 
265
 
    var partial = m.partial;
266
 
 
267
 
    var Logger = this.Logger;
268
 
    var baseLog = Logger.prototype.baseLog;
269
 
    m.update(this.Logger.prototype, {
270
 
        debug: partial(baseLog, 'DEBUG'),
271
 
        log: partial(baseLog, 'INFO'),
272
 
        error: partial(baseLog, 'ERROR'),
273
 
        fatal: partial(baseLog, 'FATAL'),
274
 
        warning: partial(baseLog, 'WARNING')
275
 
    });
276
 
 
277
 
    // indirectly find logger so it can be replaced
278
 
    var self = this;
279
 
    var connectLog = function (name) {
280
 
        return function () {
281
 
            self.logger[name].apply(self.logger, arguments);
282
 
        };
283
 
    };
284
 
 
285
 
    /** @id MochiKit.Logging.log */
286
 
    this.log = connectLog('log');
287
 
    /** @id MochiKit.Logging.logError */
288
 
    this.logError = connectLog('error');
289
 
    /** @id MochiKit.Logging.logDebug */
290
 
    this.logDebug = connectLog('debug');
291
 
    /** @id MochiKit.Logging.logFatal */
292
 
    this.logFatal = connectLog('fatal');
293
 
    /** @id MochiKit.Logging.logWarning */
294
 
    this.logWarning = connectLog('warning');
295
 
    this.logger = new Logger();
296
 
    this.logger.useNativeConsole = true;
297
 
 
298
 
    this.EXPORT_TAGS = {
299
 
        ":common": this.EXPORT,
300
 
        ":all": m.concat(this.EXPORT, this.EXPORT_OK)
301
 
    };
302
 
 
303
 
    m.nameFunctions(this);
304
 
 
305
 
};
306
 
 
307
 
if (typeof(printfire) == "undefined" &&
308
 
        typeof(document) != "undefined" && document.createEvent &&
309
 
        typeof(dispatchEvent) != "undefined") {
310
 
    // FireBug really should be less lame about this global function
311
 
    printfire  = function () {
312
 
        printfire.args = arguments;
313
 
        var ev = document.createEvent("Events");
314
 
        ev.initEvent("printfire", false, true);
315
 
        dispatchEvent(ev);
316
 
    };
317
 
}
318
 
 
319
 
MochiKit.Logging.__new__();
320
 
 
321
 
MochiKit.Base._exportSymbols(this, MochiKit.Logging);