@qooxdoo/framework 7.0.0-beta.6 → 7.0.0

package/source/class/qx/log/appender/Formatter.js

@@ -1,26 +1,25 @@
 qx.Class.define("qx.log.appender.Formatter", {
   extend: qx.core.Object,
-  
+
   properties: {
     /** How to format time in an entry; offset since start (backwards compatible) or as actual date/time */
     formatTimeAs: {
       init: "offset",
-      check: [ "offset", "datetime" ]
+      check: ["offset", "datetime"]
     }
   },
 
   members: {
-
     /**
      * Formats a numeric time offset to 6 characters.
-     * 
+     *
      * @param offset
      *          {Integer} Current offset value
      * @param length
      *          {Integer?6} Refine the length
      * @return {String} Padded string
      */
-    formatOffset: function(offset, length) {
+    formatOffset(offset, length) {
       var str = offset.toString();
       var diff = (length || 6) - str.length;
       var pad = "";
@@ -31,45 +30,50 @@ qx.Class.define("qx.log.appender.Formatter", {
 
       return pad + str;
     },
-    
+
     /**
      * Formats the time part of an entry
-     * 
+     *
      * @param entry {Map} the entry to output
      * @return {String} formatted time, as an offset or date time depending on `formatTimeAs` property
      */
-    formatEntryTime: function(entry) {
+    formatEntryTime(entry) {
       if (this.getFormatTimeAs() == "offset") {
         return this.formatOffset(entry.offset, 6);
       }
       if (!qx.log.appender.Formatter.__DATETIME_FORMAT) {
-        qx.log.appender.Formatter.__DATETIME_FORMAT = new qx.util.format.DateFormat("YYYY-MM-dd HH:mm:ss");
+        qx.log.appender.Formatter.__DATETIME_FORMAT =
+          new qx.util.format.DateFormat("YYYY-MM-dd HH:mm:ss");
       }
       return qx.log.appender.Formatter.__DATETIME_FORMAT.format(entry.time);
     },
-    
+
     /**
      * Normalises the entry into an object with clazz, object, hash.
-     * 
+     *
      * @param entry {Map} the entry to output
      * @return {Map} result, containing:
      *  clazz {Class?} the class of the object
      *  object {Object?} the object
-     *  hash {String?} the hash code 
+     *  hash {String?} the hash code
      */
-    normalizeEntryClass: function(entry) {
+    normalizeEntryClass(entry) {
       var result = {
-          clazz: null,
-          object: null,
-          hash: null
+        clazz: null,
+        object: null,
+        hash: null
       };
-      
+
       if (entry.object) {
         result.hash = entry.object;
         if (entry.clazz) {
           result.clazz = entry.clazz;
         } else {
-          var obj = entry.win.qx.core.ObjectRegistry.fromHashCode(entry.object, true);
+          var obj = entry.win.qx.core.ObjectRegistry.fromHashCode(
+            entry.object,
+            true
+          );
+
           if (obj) {
             result.clazz = obj.constructor;
             result.object = obj;
@@ -78,17 +82,17 @@ qx.Class.define("qx.log.appender.Formatter", {
       } else if (entry.clazz) {
         result.clazz = entry.clazz;
       }
-      
+
       return result;
     },
-    
+
     /**
      * Formats the object part of an entry
-     * 
+     *
      * @param entry {Map} the entry to output
      * @return {String} formatted object, with class and hash code if possible
      */
-    formatEntryObjectAndClass: function(entry) {
+    formatEntryObjectAndClass(entry) {
       var breakdown = this.normalizeEntryClass(entry);
       var result = "";
       if (breakdown.clazz) {
@@ -100,14 +104,14 @@ qx.Class.define("qx.log.appender.Formatter", {
       result += ":";
       return result;
     },
-    
+
     /**
      * Formats the items part of an entry
-     * 
+     *
      * @param entry {Map} the entry to output
      * @return {String} formatted items
      */
-    formatEntryItems: function(entry) {
+    formatEntryItems(entry) {
       var output = [];
       var items = entry.items;
 
@@ -134,19 +138,21 @@ qx.Class.define("qx.log.appender.Formatter", {
           output.push(msg);
         }
       }
-      
+
       return output.join(" ");
     },
 
     /**
      * Converts a single log entry to plain text
-     * 
+     *
      * @param entry {Map} The entry to process
      * @return {String} the formatted log entry
      */
-    toText: function(entry) {
-      var output = this.formatEntryTime(entry) + " " +
-            this.formatEntryObjectAndClass(entry);
+    toText(entry) {
+      var output =
+        this.formatEntryTime(entry) +
+        " " +
+        this.formatEntryObjectAndClass(entry);
       var str = this.formatEntryItems(entry);
       if (str) {
         output += " " + str;
@@ -156,18 +162,18 @@ qx.Class.define("qx.log.appender.Formatter", {
     },
 
     /**
-     * Converts a single log entry to an array of plain text.  
-     * 
-     * This use of arrays is an outdated performance improvement, and as there is no 
-     * specification of what is in each of the elements of the array, there is no value 
+     * Converts a single log entry to an array of plain text.
+     *
+     * This use of arrays is an outdated performance improvement, and as there is no
+     * specification of what is in each of the elements of the array, there is no value
      * in preserving this.  This method is deprecated because it will be removed in 7.0
      * and only toText will remain.  Note that toTextArray is not used anywhere in Qooxdoo.
-     * 
+     *
      * @param entry {Map} The entry to process
      * @return {Array} Argument list ready message array.
      * @deprecated {6.0} See toText instead
      */
-    toTextArray: function(entry) {
+    toTextArray(entry) {
       var output = [];
 
       output.push(this.formatEntryTime(entry));
@@ -176,18 +182,22 @@ qx.Class.define("qx.log.appender.Formatter", {
 
       return output;
     },
-    
+
     /**
      * Converts a single log entry to HTML
-     * 
+     *
      * @signature function(entry)
      * @param entry {Map} The entry to process
      */
-    toHtml: function(entry) {
+    toHtml(entry) {
       var output = [];
       var item, msg, sub, list;
 
-      output.push("<span class='offset'>", this.formatEntryTime(entry), "</span> ");
+      output.push(
+        "<span class='offset'>",
+        this.formatEntryTime(entry),
+        "</span> "
+      );
 
       var breakdown = this.normalizeEntryClass(entry);
       var result = "";
@@ -195,13 +205,30 @@ qx.Class.define("qx.log.appender.Formatter", {
         result += breakdown.clazz.classname;
       }
       if (breakdown.object) {
-        output.push("<span class='object' title='Object instance with hash code: " + 
-            breakdown.object.toHashCode() + "'>", breakdown.classname, "[", breakdown.object, "]</span>: ");
+        output.push(
+          "<span class='object' title='Object instance with hash code: " +
+            breakdown.object.toHashCode() +
+            "'>",
+          breakdown.classname,
+          "[",
+          breakdown.object,
+          "]</span>: "
+        );
       } else if (breakdown.hash) {
-        output.push("<span class='object' title='Object instance with hash code: " + 
-            breakdown.hash + "'>", breakdown.classname, "[", breakdown.hash, "]</span>: ");
+        output.push(
+          "<span class='object' title='Object instance with hash code: " +
+            breakdown.hash +
+            "'>",
+          breakdown.classname,
+          "[",
+          breakdown.hash,
+          "]</span>: "
+        );
       } else if (breakdown.clazz) {
-        output.push("<span class='object'>" + breakdown.clazz.classname, "</span>: ");
+        output.push(
+          "<span class='object'>" + breakdown.clazz.classname,
+          "</span>: "
+        );
       }
 
       var items = entry.items;
@@ -215,12 +242,27 @@ qx.Class.define("qx.log.appender.Formatter", {
           for (var j = 0, jl = msg.length; j < jl; j++) {
             sub = msg[j];
             if (typeof sub === "string") {
-              list.push("<span>" + qx.log.appender.Formatter.escapeHTML(sub) + "</span>");
+              list.push(
+                "<span>" + qx.log.appender.Formatter.escapeHTML(sub) + "</span>"
+              );
             } else if (sub.key) {
-              list.push("<span class='type-key'>" + sub.key + "</span>:<span class='type-" + sub.type + "'>"
-                  + qx.log.appender.Formatter.escapeHTML(sub.text) + "</span>");
+              list.push(
+                "<span class='type-key'>" +
+                  sub.key +
+                  "</span>:<span class='type-" +
+                  sub.type +
+                  "'>" +
+                  qx.log.appender.Formatter.escapeHTML(sub.text) +
+                  "</span>"
+              );
             } else {
-              list.push("<span class='type-" + sub.type + "'>" + qx.log.appender.Formatter.escapeHTML(sub.text) + "</span>");
+              list.push(
+                "<span class='type-" +
+                  sub.type +
+                  "'>" +
+                  qx.log.appender.Formatter.escapeHTML(sub.text) +
+                  "</span>"
+              );
             }
           }
 
@@ -234,7 +276,13 @@ qx.Class.define("qx.log.appender.Formatter", {
 
           output.push("</span>");
         } else {
-          output.push("<span class='type-" + item.type + "'>" + qx.log.appender.Formatter.escapeHTML(msg) + "</span> ");
+          output.push(
+            "<span class='type-" +
+              item.type +
+              "'>" +
+              qx.log.appender.Formatter.escapeHTML(msg) +
+              "</span> "
+          );
         }
       }
 
@@ -245,55 +293,58 @@ qx.Class.define("qx.log.appender.Formatter", {
       return wrapper;
     }
   },
-  
-  
+
   statics: {
     /** @type {qx.util.format.DateFormat} format for datetimes */
     __DATETIME_FORMAT: null,
-    
+
     /** @type {qx.log.appender.Formatter} the default instance */
     __defaultFormatter: null,
-    
+
     /**
      * Returns the default formatter
-     * 
+     *
      * @return {qx.log.appender.Formatter}
      */
-    getFormatter: function() {
+    getFormatter() {
       if (!qx.log.appender.Formatter.__defaultFormatter) {
-        qx.log.appender.Formatter.__defaultFormatter = new qx.log.appender.Formatter();
+        qx.log.appender.Formatter.__defaultFormatter =
+          new qx.log.appender.Formatter();
       }
       return qx.log.appender.Formatter.__defaultFormatter;
     },
-    
+
     /**
      * Sets the default formatter
-     * 
+     *
      * @param instance {qx.log.appender.Formatter}
      */
-    setFormatter: function(instance) {
+    setFormatter(instance) {
       qx.log.appender.Formatter.__defaultFormatter = instance;
     },
 
     /**
      * Escapes the HTML in the given value
-     * 
+     *
      * @param value
      *          {String} value to escape
      * @return {String} escaped value
      */
-    escapeHTML: function(value) {
-      return String(value).replace(/[<>&"']/g, qx.log.appender.Formatter.__escapeHTMLReplace);
+    escapeHTML(value) {
+      return String(value).replace(
+        /[<>&"']/g,
+        qx.log.appender.Formatter.__escapeHTMLReplace
+      );
     },
 
     /**
      * Internal replacement helper for HTML escape.
-     * 
+     *
      * @param ch
      *          {String} Single item to replace.
      * @return {String} Replaced item
      */
-    __escapeHTMLReplace: function(ch) {
+    __escapeHTMLReplace(ch) {
       var map = {
         "<": "&lt;",
         ">": "&gt;",
@@ -305,4 +356,4 @@ qx.Class.define("qx.log.appender.Formatter", {
       return map[ch] || "?";
     }
   }
-});
+});

package/source/class/qx/log/appender/Native.js

@@ -33,23 +33,20 @@
  * @require(qx.log.appender.Formatter)
  * @require(qx.bom.client.Html)
  */
-qx.Bootstrap.define("qx.log.appender.Native",
-{
+qx.Bootstrap.define("qx.log.appender.Native", {
   /*
   *****************************************************************************
      STATICS
   *****************************************************************************
   */
 
-  statics :
-  {
+  statics: {
     /**
      * Processes a single log entry
      *
      * @param entry {Map} The entry to process
      */
-    process : function(entry)
-    {
+    process(entry) {
       if (qx.core.Environment.get("html.console")) {
         // Firefox 4's Web Console doesn't support "debug"
         var level = console[entry.level] ? entry.level : "log";
@@ -62,16 +59,13 @@ qx.Bootstrap.define("qx.log.appender.Native",
     }
   },
 
-
-
-
   /*
   *****************************************************************************
      DEFER
   *****************************************************************************
   */
 
-  defer : function(statics) {
+  defer(statics) {
     qx.log.Logger.register(statics);
   }
 });

package/source/class/qx/log/appender/NodeConsole.js

@@ -25,17 +25,15 @@
  * @ignore(process.*)
  */
 qx.Class.define("qx.log.appender.NodeConsole", {
-
-  statics:
-  {
+  statics: {
     /**
      * process.stdout
      */
-    __OUT : null,
+    __OUT: null,
     /**
      * process.stderr
      */
-    __ERR : null,
+    __ERR: null,
 
     /**
      * Whether to use color codes
@@ -46,11 +44,11 @@ qx.Class.define("qx.log.appender.NodeConsole", {
      * Which ANSI color codes to use for which log level
      */
     __colorCodes: {
-      debug: '\u001b[38;5;3m', // yellow
+      debug: "\u001b[38;5;3m", // yellow
       info: "\u001b[38;5;12m", // light blue
-      warn: '\u001b[38;5;9m',  // light right
-      error: '\u001b[38;5;1m', // red
-      reset: '\u001b[0m'
+      warn: "\u001b[38;5;9m", // light right
+      error: "\u001b[38;5;1m", // red
+      reset: "\u001b[0m"
     },
 
     /**
@@ -69,15 +67,15 @@ qx.Class.define("qx.log.appender.NodeConsole", {
      * @param logMessage {String} Message to be logged
      * @param level {String} Log level. One of "debug", "info", "warn", "error"
      */
-    log : function(logMessage, level)
-    {
+    log(logMessage, level) {
       if (this.__useColors && this.__colorCodes[level]) {
-        logMessage = this.__colorCodes[level] + logMessage + this.__colorCodes.reset;
+        logMessage =
+          this.__colorCodes[level] + logMessage + this.__colorCodes.reset;
       }
       if (level === "error") {
-        this.__ERR.write(logMessage+'\n');
+        this.__ERR.write(logMessage + "\n");
       } else {
-        this.__OUT.write(logMessage+'\n');
+        this.__OUT.write(logMessage + "\n");
       }
     },
 
@@ -86,8 +84,7 @@ qx.Class.define("qx.log.appender.NodeConsole", {
      *
      * @param logMessage {String} Message to be logged
      */
-    debug : function(logMessage)
-    {
+    debug(logMessage) {
       this.log(logMessage, "debug");
     },
 
@@ -96,8 +93,7 @@ qx.Class.define("qx.log.appender.NodeConsole", {
      *
      * @param logMessage {String} Message to be logged
      */
-    info : function(logMessage)
-    {
+    info(logMessage) {
       this.log(logMessage, "info");
     },
 
@@ -106,8 +102,7 @@ qx.Class.define("qx.log.appender.NodeConsole", {
      *
      * @param logMessage {String} Message to be logged
      */
-    warn : function(logMessage)
-    {
+    warn(logMessage) {
       this.log(logMessage, "warn");
     },
 
@@ -116,8 +111,7 @@ qx.Class.define("qx.log.appender.NodeConsole", {
      *
      * @param logMessage {String} Message to be logged
      */
-    error : function(logMessage)
-    {
+    error(logMessage) {
       this.log(logMessage, "error");
     },
 
@@ -126,13 +120,12 @@ qx.Class.define("qx.log.appender.NodeConsole", {
      *
      * @param entry {Map} Log entry object
      */
-    process : function(entry)
-    {
+    process(entry) {
       let level = entry.level || "info";
       for (let prop of Object.keys(entry)) {
         if (prop === "items") {
           let items = entry[prop];
-          for (var p=0; p<items.length; p++) {
+          for (var p = 0; p < items.length; p++) {
             let item = items[p];
             this[level](item.text);
           }
@@ -144,9 +137,8 @@ qx.Class.define("qx.log.appender.NodeConsole", {
   /**
    * @ignore(process.*)
    */
-  defer : function(statics)
-  {
-    if (typeof(process) !== "undefined") {
+  defer(statics) {
+    if (typeof process !== "undefined") {
       statics.__OUT = process.stdout;
       statics.__ERR = process.stderr;
       qx.log.Logger.register(statics);

package/source/class/qx/log/appender/PhoneGap.js

@@ -39,22 +39,19 @@
  * @ignore(debug.*)
  */
 /* global debug */
-qx.Class.define("qx.log.appender.PhoneGap",
-{
+qx.Class.define("qx.log.appender.PhoneGap", {
   /*
   *****************************************************************************
      STATICS
   *****************************************************************************
   */
 
-  statics :
-  {
+  statics: {
     /**
      * Processes a single log entry
      * @param entry {Map} The entry to process
      */
-    process : function(entry)
-    {
+    process(entry) {
       var formatter = qx.log.appender.Formatter.getFormatter();
       var args = formatter.toText(entry);
       var level = entry.level;
@@ -68,19 +65,14 @@ qx.Class.define("qx.log.appender.PhoneGap",
     }
   },
 
-
-
-
   /*
   *****************************************************************************
      DEFER
   *****************************************************************************
   */
 
-  defer : function(statics)
-  {
-    function register()
-    {
+  defer(statics) {
+    function register() {
       if (window.debug) {
         qx.log.Logger.register(statics);
       } else {

package/source/class/qx/log/appender/RhinoConsole.js

@@ -24,17 +24,15 @@
  */
 /* global java */
 qx.Class.define("qx.log.appender.RhinoConsole", {
-
-  statics:
-  {
+  statics: {
     /**
      * java.lang.System.out
      */
-    __OUT : null,
+    __OUT: null,
     /**
      * java.lang.System.err
      */
-    __ERR : null,
+    __ERR: null,
 
     /**
      * Writes a message to the shell. Errors will be sent to STDERR, everything
@@ -43,8 +41,7 @@ qx.Class.define("qx.log.appender.RhinoConsole", {
      * @param logMessage {String} Message to be logged
      * @param level {String} Log level. One of "debug", "info", "warn", "error"
      */
-    log : function(logMessage, level)
-    {
+    log(logMessage, level) {
       if (level == "error") {
         this.__ERR.println(logMessage);
       } else {
@@ -57,8 +54,7 @@ qx.Class.define("qx.log.appender.RhinoConsole", {
      *
      * @param logMessage {String} Message to be logged
      */
-    debug : function(logMessage)
-    {
+    debug(logMessage) {
       this.log(logMessage, "debug");
     },
 
@@ -67,8 +63,7 @@ qx.Class.define("qx.log.appender.RhinoConsole", {
      *
      * @param logMessage {String} Message to be logged
      */
-    info : function(logMessage)
-    {
+    info(logMessage) {
       this.log(logMessage, "info");
     },
 
@@ -77,8 +72,7 @@ qx.Class.define("qx.log.appender.RhinoConsole", {
      *
      * @param logMessage {String} Message to be logged
      */
-    warn : function(logMessage)
-    {
+    warn(logMessage) {
       this.log(logMessage, "warn");
     },
 
@@ -87,8 +81,7 @@ qx.Class.define("qx.log.appender.RhinoConsole", {
      *
      * @param logMessage {String} Message to be logged
      */
-    error : function(logMessage)
-    {
+    error(logMessage) {
       this.log(logMessage, "error");
     },
 
@@ -97,28 +90,24 @@ qx.Class.define("qx.log.appender.RhinoConsole", {
      *
      * @param entry {Map} Log entry object
      */
-    process : function(entry)
-    {
+    process(entry) {
       var level = entry.level || "info";
       for (var prop in entry) {
         if (prop == "items") {
           var items = entry[prop];
-          for (var p=0, l=items.length; p<l; p++) {
+          for (var p = 0, l = items.length; p < l; p++) {
             var item = items[p];
             this[level](item.text);
           }
         }
       }
     }
-
   },
 
-  defer : function()
-  {
-    if (typeof(java) !== "undefined" && typeof(java.lang) !== "undefined") {
+  defer() {
+    if (typeof java !== "undefined" && typeof java.lang !== "undefined") {
       qx.log.appender.RhinoConsole.__OUT = java.lang.System.out;
       qx.log.appender.RhinoConsole.__ERR = java.lang.System.err;
     }
   }
-
 });