The Tor Browser: testing/mochitest/MochiKit/Logging.js@6474c204b198 (annotated)

testing/mochitest/MochiKit/Logging.js@6474c204b198 (annotated)

testing/mochitest/MochiKit/Logging.js

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /***
 MochiKit.Logging 1.4
 See <http://mochikit.com/> for documentation, downloads, license, etc.
 (c) 2005 Bob Ippolito.  All rights Reserved.
 ***/
 if (typeof(dojo) != 'undefined') {
     dojo.provide('MochiKit.Logging');
     dojo.require('MochiKit.Base');
 }
 if (typeof(JSAN) != 'undefined') {
     JSAN.use("MochiKit.Base", []);
 }
 try {
     if (typeof(MochiKit.Base) == 'undefined') {
         throw "";
     }
 } catch (e) {
     throw "MochiKit.Logging depends on MochiKit.Base!";
 }
 if (typeof(MochiKit.Logging) == 'undefined') {
     MochiKit.Logging = {};
 }
 MochiKit.Logging.NAME = "MochiKit.Logging";
 MochiKit.Logging.VERSION = "1.4";
 MochiKit.Logging.__repr__ = function () {
     return "[" + this.NAME + " " + this.VERSION + "]";
 };
 MochiKit.Logging.toString = function () {
     return this.__repr__();
 };
 MochiKit.Logging.EXPORT = [
     "LogLevel",
     "LogMessage",
     "Logger",
     "alertListener",
     "logger",
     "log",
     "logError",
     "logDebug",
     "logFatal",
     "logWarning"
 ];
 MochiKit.Logging.EXPORT_OK = [
     "logLevelAtLeast",
     "isLogMessage",
     "compareLogMessage"
 ];
 /** @id MochiKit.Logging.LogMessage */
 MochiKit.Logging.LogMessage = function (num, level, info) {
     this.num = num;
     this.level = level;
     this.info = info;
     this.timestamp = new Date();
 };
 MochiKit.Logging.LogMessage.prototype = {
      /** @id MochiKit.Logging.LogMessage.prototype.repr */
     repr: function () {
         var m = MochiKit.Base;
         return 'LogMessage(' +
             m.map(
                 m.repr,
                 [this.num, this.level, this.info]
             ).join(', ') + ')';
     },
     /** @id MochiKit.Logging.LogMessage.prototype.toString */
     toString: MochiKit.Base.forwardCall("repr")
 };
 MochiKit.Base.update(MochiKit.Logging, {
     /** @id MochiKit.Logging.logLevelAtLeast */
     logLevelAtLeast: function (minLevel) {
         var self = MochiKit.Logging;
         if (typeof(minLevel) == 'string') {
             minLevel = self.LogLevel[minLevel];
         }
         return function (msg) {
             var msgLevel = msg.level;
             if (typeof(msgLevel) == 'string') {
                 msgLevel = self.LogLevel[msgLevel];
             }
             return msgLevel >= minLevel;
         };
     },
     /** @id MochiKit.Logging.isLogMessage */
     isLogMessage: function (/* ... */) {
         var LogMessage = MochiKit.Logging.LogMessage;
         for (var i = 0; i < arguments.length; i++) {
             if (!(arguments[i] instanceof LogMessage)) {
                 return false;
             }
         }
         return true;
     },
     /** @id MochiKit.Logging.compareLogMessage */
     compareLogMessage: function (a, b) {
         return MochiKit.Base.compare([a.level, a.info], [b.level, b.info]);
     },
     /** @id MochiKit.Logging.alertListener */
     alertListener: function (msg) {
         alert(
             "num: " + msg.num +
             "\nlevel: " +  msg.level +
             "\ninfo: " + msg.info.join(" ")
         );
     }
 });
 /** @id MochiKit.Logging.Logger */
 MochiKit.Logging.Logger = function (/* optional */maxSize) {
     this.counter = 0;
     if (typeof(maxSize) == 'undefined' || maxSize === null) {
         maxSize = -1;
     }
     this.maxSize = maxSize;
     this._messages = [];
     this.listeners = {};
     this.useNativeConsole = false;
 };
 MochiKit.Logging.Logger.prototype = {
     /** @id MochiKit.Logging.Logger.prototype.clear */
     clear: function () {
         this._messages.splice(0, this._messages.length);
     },
     /** @id MochiKit.Logging.Logger.prototype.logToConsole */
     logToConsole: function (msg) {
         if (typeof(window) != "undefined" && window.console
                 && window.console.log) {
             // Safari and FireBug 0.4
             // Percent replacement is a workaround for cute Safari crashing bug
             window.console.log(msg.replace(/%/g, '\uFF05'));
         } else if (typeof(opera) != "undefined" && opera.postError) {
             // Opera
             opera.postError(msg);
         } else if (typeof(printfire) == "function") {
             // FireBug 0.3 and earlier
             printfire(msg);
         } else if (typeof(Debug) != "undefined" && Debug.writeln) {
             // IE Web Development Helper (?)
             // http://www.nikhilk.net/Entry.aspx?id=93
             Debug.writeln(msg);
         } else if (typeof(debug) != "undefined" && debug.trace) {
             // Atlas framework (?)
             // http://www.nikhilk.net/Entry.aspx?id=93
             debug.trace(msg);
         }
     },
     /** @id MochiKit.Logging.Logger.prototype.dispatchListeners */
     dispatchListeners: function (msg) {
         for (var k in this.listeners) {
             var pair = this.listeners[k];
             if (pair.ident != k || (pair[0] && !pair[0](msg))) {
                 continue;
             }
             pair[1](msg);
         }
     },
     /** @id MochiKit.Logging.Logger.prototype.addListener */
     addListener: function (ident, filter, listener) {
         if (typeof(filter) == 'string') {
             filter = MochiKit.Logging.logLevelAtLeast(filter);
         }
         var entry = [filter, listener];
         entry.ident = ident;
         this.listeners[ident] = entry;
     },
     /** @id MochiKit.Logging.Logger.prototype.removeListener */
     removeListener: function (ident) {
         delete this.listeners[ident];
     },
     /** @id MochiKit.Logging.Logger.prototype.baseLog */
     baseLog: function (level, message/*, ...*/) {
         var msg = new MochiKit.Logging.LogMessage(
             this.counter,
             level,
             MochiKit.Base.extend(null, arguments, 1)
         );
         this._messages.push(msg);
         this.dispatchListeners(msg);
         if (this.useNativeConsole) {
             this.logToConsole(msg.level + ": " + msg.info.join(" "));
         }
         this.counter += 1;
         while (this.maxSize >= 0 && this._messages.length > this.maxSize) {
             this._messages.shift();
         }
     },
     /** @id MochiKit.Logging.Logger.prototype.getMessages */
     getMessages: function (howMany) {
         var firstMsg = 0;
         if (!(typeof(howMany) == 'undefined' || howMany === null)) {
             firstMsg = Math.max(0, this._messages.length - howMany);
         }
         return this._messages.slice(firstMsg);
     },
     /** @id MochiKit.Logging.Logger.prototype.getMessageText */
     getMessageText: function (howMany) {
         if (typeof(howMany) == 'undefined' || howMany === null) {
             howMany = 30;
         }
         var messages = this.getMessages(howMany);
         if (messages.length) {
             var lst = map(function (m) {
                 return '\n  [' + m.num + '] ' + m.level + ': ' + m.info.join(' ');
             }, messages);
             lst.unshift('LAST ' + messages.length + ' MESSAGES:');
             return lst.join('');
         }
         return '';
     },
     /** @id MochiKit.Logging.Logger.prototype.debuggingBookmarklet */
     debuggingBookmarklet: function (inline) {
         if (typeof(MochiKit.LoggingPane) == "undefined") {
             alert(this.getMessageText());
         } else {
             MochiKit.LoggingPane.createLoggingPane(inline || false);
         }
     }
 };
 MochiKit.Logging.__new__ = function () {
     this.LogLevel = {
         ERROR: 40,
         FATAL: 50,
         WARNING: 30,
         INFO: 20,
         DEBUG: 10
     };
     var m = MochiKit.Base;
     m.registerComparator("LogMessage",
         this.isLogMessage,
         this.compareLogMessage
     );
     var partial = m.partial;
     var Logger = this.Logger;
     var baseLog = Logger.prototype.baseLog;
     m.update(this.Logger.prototype, {
         debug: partial(baseLog, 'DEBUG'),
         log: partial(baseLog, 'INFO'),
         error: partial(baseLog, 'ERROR'),
         fatal: partial(baseLog, 'FATAL'),
         warning: partial(baseLog, 'WARNING')
     });
     // indirectly find logger so it can be replaced
     var self = this;
     var connectLog = function (name) {
         return function () {
             self.logger[name].apply(self.logger, arguments);
         };
     };
     /** @id MochiKit.Logging.log */
     this.log = connectLog('log');
     /** @id MochiKit.Logging.logError */
     this.logError = connectLog('error');
     /** @id MochiKit.Logging.logDebug */
     this.logDebug = connectLog('debug');
     /** @id MochiKit.Logging.logFatal */
     this.logFatal = connectLog('fatal');
     /** @id MochiKit.Logging.logWarning */
     this.logWarning = connectLog('warning');
     this.logger = new Logger();
     this.logger.useNativeConsole = true;
     this.EXPORT_TAGS = {
         ":common": this.EXPORT,
         ":all": m.concat(this.EXPORT, this.EXPORT_OK)
     };
     m.nameFunctions(this);
 };
 if (typeof(printfire) == "undefined" &&
         typeof(document) != "undefined" && document.createEvent &&
         typeof(dispatchEvent) != "undefined") {
     // FireBug really should be less lame about this global function
     printfire  = function () {
         printfire.args = arguments;
         var ev = document.createEvent("Events");
         ev.initEvent("printfire", false, true);
         dispatchEvent(ev);
     };
 }
 MochiKit.Logging.__new__();
 MochiKit.Base._exportSymbols(this, MochiKit.Logging);