Merge pull request #1 from sgarza/master

[rbdr/cologne] / lib / cobalt.js

diff --git a/lib/cobalt.js b/lib/cobalt.js
index 17e694864606a70694840543ae9ab1ffa2f61c3e..b5dd94cb7be3dfe5e59c96eb553b28df4cb78099 100644 (file)
--- a/lib/cobalt.js
+++ b/lib/cobalt.js
@@ -1,298 +1,320 @@
-(function (global) {
-  var Module, Class;
-
-  // Load up dependencies
-  if (typeof require === 'function') {
-    var Ne = require('neon');
-    Module = Ne.Module;
-    Class = Ne.Class;
-    var Microtime = require('microtime');
-  } else {
-    Module = global.Module;
-    Class = global.Class;
+// Load up dependencies
+if (typeof require === 'function') {
+  require('neon');
+  var colors = require('colors');
+  var Microtime = require('microtime');
+}
+
+Cobalt = Module("Cobalt");
+Module(Cobalt, 'Logger')({});
+Module(Cobalt, 'Formatter')({});
+
+// Load up loggers + formatters
+if (typeof require === 'function') {
+  // Formatters
+  require('./formatters/token.js');
+  require('./formatters/simple.js');
+
+  // Loggers
+  require('./loggers/console.js');
+  require('./loggers/socket.js');
+  require('./loggers/file.js');
+}
+
+Cobalt.now = function () {
+  if (typeof performance !== 'undefined' && performance.timing) {
+    return performance.timing.navigationStart + performance.now();

   }
 
   }
 

-  var Cobalt = {};
-  Module(Cobalt, 'Logger')({});
-  Module(Cobalt, 'Formatter')({});
-
-  // Load up loggers + formatters
-  if (typeof require === 'function') {
-    // Formatters
-    Cobalt.Formatter.Token = require('./formatters/token.js').Token;
-
-    // Loggers
-    Cobalt.Logger.JsConsole = require('./loggers/console.js').JsConsole;
-    Cobalt.Logger.Socket = require('./loggers/socket.js').Socket;
+  if (typeof Microtime !== 'undefined') {
+    return Microtime.nowDouble() * 1000;

   }
 
   }
 

-  Cobalt.now = function () {
-    if (typeof performance !== 'undefined' && performance.timing) {
-      return performance.timing.navigationStart + performance.now();
-    }
+  return Date.now();
+}

 
 

-    if (typeof Microtime !== 'undefined') {
-      return Microtime.nowDouble() * 1000;
+// Stringify with circular dereference.
+Cobalt.stringify = function (object) {
+  var cache = [], stringified;
+  stringified = JSON.stringify(object, function (key, value) {
+    if (typeof value === 'object' && value !== null) {
+      if (cache.indexOf(value) !== -1) {
+        return "[Circular]";
+      }
+      cache.push(value);

     }
     }

-
-    return Date.now();
-  }
-
-  // Stringify with circular dereference.
-  Cobalt.stringify = function (object) {
-    var cache = [], stringified;
-    stringified = JSON.stringify(object, function (key, value) {
-      if (typeof value === 'object' && value !== null) {
-        if (cache.indexOf(value) !== -1) {
-          return "[Circular]";
+    return value;
+  });
+  cache = null;
+
+  return stringified;
+}
+
+Class(Cobalt, 'Console')({
+  prototype : {
+    from : "Generic Cobalt Logger",
+    version : "0.1.0",
+    currentIndent : 0,
+    indentSize : 2,
+    loggers : [],
+    separatorLength : 120,
+    currentColor : "black",
+
+    // Initialize instance of cobalt console
+    // and extend configuration.
+    init : function (config) {
+      var co = this,
+          property;
+
+      if (config) {
+        for (property in config) {
+          co[property] = config[property];

         }
         }

-        cache.push(value);

       }
       }

-      return value;
-    });
-    cache = null;
+    },
+
+    addLogger : function (logger) {
+      this.loggers.push(logger);
+    },
+
+    removeLogger : function (logger) {
+      var index;
+
+      index = this.loggers.indexOf(logger);
+      this.loggers.splice(index, 1);
+    },
+
+    // Builds a Cobalt Log Object
+    buildLog : function (item, level) {
+      var co = this, oldItem, logObject = {};
+
+      if (typeof item === "undefined" || item === null || !item._cobaltLog) {
+        logObject.message = item;
+        logObject._cobaltLog = true;
+        logObject._from = co.from;
+        logObject._level = level || 6;
+        logObject._levelString = co._levelString(logObject._level);
+        logObject._version = co.version;
+        logObject._timestamp = co.now();
+        logObject._indentLevel = co.currentIndent;
+        logObject._color = co.currentColor;
+        logObject._separator = false;
+        return logObject;
+      }

 
 

-    return stringified;
-  }
+      if (item._cobaltLog) {
+        item._level = level || item._level || 6;
+        item._levelString = co._levelString(item._level);
+      }

 
 

-  Cobalt.Console = Class(Cobalt, 'Console')({
-    prototype : {
-      from : "Generic Cobalt Logger",
-      version : "0.1.0",
-      currentIndent : 0,
-      indentSize : 2,
-      loggers : [],
-      separatorLength : 120,
-      currentColor : "black",
-
-      // Initialize instance of cobalt console
-      // and extend configuration.
-      init : function (config) {
-        var co = this,
-            property;
-
-        if (config) {
-          for (property in config) {
-            co[property] = config[property];
-          }
-        }
-      },
-
-      addLogger : function (logger) {
-        this.loggers.push(logger);
-      },
-
-      removeLogger : function (logger) {
-        var index;
-
-        index = this.loggers.indexOf(logger);
-        this.loggers.splice(index, 1);
-      },
-
-      // Builds a Cobalt Log Object
-      buildLog : function (item, level) {
-        var co = this, oldItem;
-
-        if (!item._cobaltLog) {
-          if (typeof item !== "object") {
-            item = {message : item.toString() };
-          } else {
-            item.message = Cobalt.stringify(item);
-          }
-
-          item._cobaltLog = true;
-          item._from = co.from;
-          item._level = item._level || level || 7;
-          item._levelString = co._levelString(item._level);
-          item._version = co.version;
-          item._timestamp = co.now();
-          item._indentLevel = co.currentIndent;
-          item._color = co.currentColor;
-        }
+      return item;
+    },

 
 

-        return item;
-      },
-
-      buildSeparator : function (type) {
-        var co = this;
-        return {
-          _cobaltLog : true,
-          _separator : true,
-          _version : co.version,
-          _timestamp : co.now(),
-          _separatorType : type,
-          _indentLevel : co.currentIndent,
-          _color : co.currentColor
-        }
-      },
-
-      _log : function (severity) {
-        var co = this,
-            logString,
-            logObjectArray = [],
-            i, j;
-
-        for (i = 1; i < arguments.length; i++) {
-          if (typeof arguments[i] === 'undefined') {
-            logObjectArray.push(co.buildLog("undefined", severity));
-          } else {
-            logObjectArray.push(co.buildLog(arguments[i], severity));
-          }
+    extendLog : function (extendingObject) {
+      var co = this, logObject,
+          property;
+
+      logObject = co.buildLog(undefined, 6);
+      extendingObject = extendingObject || {};
+
+      for (property in extendingObject) {
+        if (extendingObject.hasOwnProperty(property)) {
+          logObject[property] = extendingObject[property];

         }
         }

+      }

 
 

-        for (j = 0; j < co.loggers.length; j++) {
-          co.loggers[j].log.apply(co.loggers[j], logObjectArray);
+      return logObject;
+    },
+
+    buildSeparator : function (type) {
+      var co = this;
+      return {
+        _cobaltLog : true,
+        _separator : true,
+        _version : co.version,
+        _timestamp : co.now(),
+        _separatorType : type,
+        _indentLevel : co.currentIndent,
+        _color : co.currentColor
+      }
+    },
+
+    _log : function (severity) {
+      var co = this,
+          logString,
+          logObjectArray = [],
+          i, j;
+
+      for (i = 1; i < arguments.length; i++) {
+        if (typeof arguments[i] === 'undefined') {
+          logObjectArray.push(co.buildLog("undefined", severity));
+        } else if (arguments[i] === null) {
+          logObjectArray.push(co.buildLog("null", severity));
+        } else {
+          logObjectArray.push(co.buildLog(arguments[i], severity));

         }
         }

-      },
+      }

 
 

-      log : function () {
-        this._log.apply(this, [7].concat([].splice.call(arguments, 0)));
-      },
+      for (j = 0; j < co.loggers.length; j++) {
+        co.loggers[j].log.apply(co.loggers[j], logObjectArray);
+      }
+    },

 
 

-      info : function () {
-        this._log.apply(this, [6].concat([].splice.call(arguments, 0)));
-      },
+    log : function () {
+      this._log.apply(this, [6].concat(Array.prototype.slice.call(arguments)));
+    },

 
 

-      notice : function () {
-        this._log.apply(this, [5].concat([].splice.call(arguments, 0)));
-      },
+    debug : function () {
+      this._log.apply(this, [7].concat(Array.prototype.slice.call(arguments)));
+    },

 
 

-      warn : function () {
-        this._log.apply(this, [4].concat([].splice.call(arguments, 0)));
-      },
+    info : function () {
+      this._log.apply(this, [6].concat(Array.prototype.slice.call(arguments)));
+    },

 
 

-      error : function () {
-        this._log.apply(this, [3].concat([].splice.call(arguments, 0)));
-      },
+    notice : function () {
+      this._log.apply(this, [5].concat(Array.prototype.slice.call(arguments)));
+    },

 
 

-      separator : function (type) {
-        var co = this;
+    warn : function () {
+      this._log.apply(this, [4].concat(Array.prototype.slice.call(arguments)));
+    },

 
 

-        co._log(7, co.buildSeparator(type));
-      },
+    error : function () {
+      this._log.apply(this, [3].concat(Array.prototype.slice.call(arguments)));
+    },

 
 

-      space : function (lines) {
-        var co = this,
-            i;
+    dir : function () {
+    },

 
 

-        if (typeof lines === "undefined") {
-          lines = 1;
-        }
+    time : function () {
+    },

 
 

-        for (i = 0; i < lines; i++) {
-          co.log(' ');
-        }
+    timeEnd : function () {
+    },

 
 

-        return co;
-      },
+    groupCollapsed : function () {
+    },

 
 

-      indent : function (callback) {
-        var co = this;
+    groupEnd : function () {
+    },

 
 

-        if (typeof callback === "function") {
-          co.currentIndent = co.currentIndent + co.indentSize;
-          callback();
-          co.currentIndent = co.currentIndent - co.indentSize;
-        } else {
-          co.currentIndent = co.currentIndent + co.indentSize;
-        }
+    separator : function (type) {
+      var co = this;

 
 

-        return co;
-      },
+      co._log(7, co.buildSeparator(type));
+    },

 
 

-      outdent : function (callback) {
-        var co = this;
+    space : function (lines) {
+      var co = this,
+          i;

 
 

-        if (typeof callback === "function") {
-          co.currentIndent = co.currentIndent - co.indentSize;
-          if (co.currentIndent < 0) {
-            co.currentIndent = 0;
-          }
+      if (typeof lines === "undefined") {
+        lines = 1;
+      }

 
 

-          callback();
+      for (i = 0; i < lines; i++) {
+        co.log(' ');
+      }

 
 

-          co.currentIndent = co.currentIndent + co.indentSize;
-        } else {
-          co.currentIndent = co.currentIndent - co.indentSize;
-          if (co.currentIndent < 0) {
-            co.currentIndent = 0;
-          }
-        }
+      return co;
+    },

 
 

-        return co;
-      },
+    indent : function (callback) {
+      var co = this;

 
 

-      color : function (color, callback) {
-        var co = this,
-            oldColor = co.currentColor;
+      if (typeof callback === "function") {
+        co.currentIndent = co.currentIndent + co.indentSize;
+        callback();
+        co.currentIndent = co.currentIndent - co.indentSize;
+      } else {
+        co.currentIndent = co.currentIndent + co.indentSize;
+      }

 
 

-        if (typeof callback === "function") {
-          co.currentColor = color;
-          callback();
-          co.currentColor = oldColor;
-        } else {
-          co.currentColor = color;
-        }
+      return co;
+    },

 
 

-        return co;
-      },
+    outdent : function (callback) {
+      var co = this;

 
 

-      // Returns the current time in microseconds.
-      now : function () {
-        if (typeof performance !== 'undefined' && performance.timing) {
-          return performance.timing.navigationStart + performance.now();
+      if (typeof callback === "function") {
+        co.currentIndent = co.currentIndent - co.indentSize;
+        if (co.currentIndent < 0) {
+          co.currentIndent = 0;

         }
 
         }
 

-        if (typeof Microtime !== 'undefined') {
-          return Microtime.nowDouble() * 1000;
-        }
+        callback();

 
 

-        return Date.now();
-      },
-
-      _levelString : function (level) {
-        switch(level) {
-          case 0:
-            return "PANIC";
-            break;
-          case 1:
-            return "ALERT"
-            break;
-          case 2:
-            return "CRIT"
-            break;
-          case 3:
-            return "ERROR"
-            break;
-          case 4:
-            return "WARN"
-            break;
-          case 5:
-            return "NOTICE"
-            break;
-          case 6:
-            return "INFO"
-            break;
-          case 7:
-            return "DEBUG"
-            break;
+        co.currentIndent = co.currentIndent + co.indentSize;
+      } else {
+        co.currentIndent = co.currentIndent - co.indentSize;
+        if (co.currentIndent < 0) {
+          co.currentIndent = 0;

         }
       }
         }
       }

-    }
-  });

 
 

-  if (Cobalt.Console.__objectSpy) {
-    Cobalt.Console.__objectSpy.destroy();
-  }
+      return co;
+    },
+
+    color : function (color, callback) {
+      var co = this,
+          oldColor = co.currentColor;
+
+      if (typeof callback === "function") {
+        co.currentColor = color;
+        callback();
+        co.currentColor = oldColor;
+      } else {
+        co.currentColor = color;
+      }
+
+      return co;
+    },

 
 

-  if (typeof require === 'function') {
-    global.Formatter = Cobalt.Formatter;
-    global.Logger = Cobalt.Logger;
-    global.Console = Cobalt.Console;
-    global.now = Cobalt.now;
-    global.stringify = Cobalt.stringify;
-  } else {
-    global.Cobalt = Cobalt;
+    // Returns the current time in microseconds.
+    now : function () {
+      if (typeof performance !== 'undefined' && performance.timing) {
+        return performance.timing.navigationStart + performance.now();
+      }
+
+      if (typeof Microtime !== 'undefined') {
+        return Microtime.nowDouble() * 1000;
+      }
+
+      return Date.now();
+    },
+
+    _levelString : function (level) {
+      switch(level) {
+        case 0:
+          return "PANIC";
+          break;
+        case 1:
+          return "ALERT"
+          break;
+        case 2:
+          return "CRIT"
+          break;
+        case 3:
+          return "ERROR"
+          break;
+        case 4:
+          return "WARN"
+          break;
+        case 5:
+          return "NOTICE"
+          break;
+        case 6:
+          return "INFO"
+          break;
+        case 7:
+          return "DEBUG"
+          break;
+      }
+    }

   }
   }

+});

 
 

-}(typeof window !== 'undefined' ? window : (typeof module.exports !== 'undefined' ? module.exports : self)));
+if (Cobalt.Console.__objectSpy) {
+  Cobalt.Console.__objectSpy.destroy();
+}