refactored pattern layout

lib/layouts.js

@@ -170,42 +170,19 @@ function patternLayout (pattern, tokens) {
   
   pattern = pattern || TTCC_CONVERSION_PATTERN;
 
-  return function(loggingEvent) {
+  function categoryName(loggingEvent, specifier) {
-    var formattedString = "";
-    var result;
-    var searchString = pattern;
-    
-    while ((result = regex.exec(searchString))) {
-      var matchedString = result[0];
-      var padding = result[1];
-      var truncation = result[2];
-      var conversionCharacter = result[3];
-      var specifier = result[5];
-      var text = result[6];
-      
-      // Check if the pattern matched was just normal text
-      if (text) {
-        formattedString += "" + text;
-      } else {
-        // Create a raw replacement string based on the conversion
-        // character and specifier
-        var replacement = "";
-        switch(conversionCharacter) {
-        case "c":
     var loggerName = loggingEvent.categoryName;
     if (specifier) {
       var precision = parseInt(specifier, 10);
-            var loggerNameBits = loggingEvent.categoryName.split(".");
+      var loggerNameBits = loggerName.split(".");
-            if (precision >= loggerNameBits.length) {
+      if (precision < loggerNameBits.length) {
-              replacement = loggerName;
+        loggerName = loggerNameBits.slice(loggerNameBits.length - precision).join(".");
-            } else {
-              replacement = loggerNameBits.slice(loggerNameBits.length - precision).join(".");
       }
-          } else {
-            replacement = loggerName;
     }
-          break;
+    return loggerName;
-        case "d":
+  }
+
+  function formatAsDate(loggingEvent, specifier) {
     var format = dateFormat.ISO8601_FORMAT;
     if (specifier) {
       format = specifier;
@@ -219,70 +196,126 @@ function patternLayout (pattern, tokens) {
       }
     }
     // Format the date
-          replacement = dateFormat.asString(format, loggingEvent.startTime);
+    return dateFormat.asString(format, loggingEvent.startTime);
-          break;
+  }
-        case "m":
+
-          replacement = formatLogData(loggingEvent.data);
+  function formatMessage(loggingEvent) {
-          break;
+    return formatLogData(loggingEvent.data);
-        case "n":
+  }
-          replacement = eol;
+  
-          break;
+  function endOfLine() {
-        case "p":
+    return eol;
-          replacement = loggingEvent.level.toString();
+  }
-          break;
+
-        case "r":
+  function logLevel(loggingEvent) {
-          replacement = "" + loggingEvent.startTime.toLocaleTimeString();
+    return loggingEvent.level.toString();
-          break;
+  }
-        case "[":
+
-          replacement = colorizeStart(colours[loggingEvent.level.toString()]);
+  function startTime(loggingEvent) {
-          break;
+    return "" + loggingEvent.startTime.toLocaleTimeString();
-        case "]":
+  }
-          replacement = colorizeEnd(colours[loggingEvent.level.toString()]);
+
-          break;
+  function startColour(loggingEvent) {
-        case "%":
+    return colorizeStart(colours[loggingEvent.level.toString()]);
-          replacement = "%";
+  }
-          break;
+
-        case "x":
+  function endColour(loggingEvent) {
-          if(typeof(tokens[specifier]) !== 'undefined') {
+    return colorizeEnd(colours[loggingEvent.level.toString()]);
-            if(typeof(tokens[specifier]) === 'function') {
+  }
-              replacement = tokens[specifier]();
+
-            } else {
+  function percent() {
-              replacement = tokens[specifier];
+    return '%';
   }
+
+  function userDefined(loggingEvent, specifier) {
+    if (typeof(tokens[specifier]) !== 'undefined') {
+      if (typeof(tokens[specifier]) === 'function') {
+        return tokens[specifier](loggingEvent);
       } else {
-            replacement = matchedString;
+        return tokens[specifier];
       }
-          break;
-        default:
-          replacement = matchedString;
-          break;
     }
-        // Format the replacement according to any padding or
+    return null;
-        // truncation specified
+  }
 
-        var len;
+  var replacers = {
+    'c': categoryName,
+    'd': formatAsDate,
+    'm': formatMessage,
+    'n': endOfLine,
+    'p': logLevel,
+    'r': startTime,
+    '[': startColour,
+    ']': endColour,
+    '%': percent,
+    'x': userDefined
+  };
+
+  function replaceToken(conversionCharacter, loggingEvent, specifier) {
+    var replacer = replacers[conversionCharacter];
+    if (replacer) {
+      return replacer(loggingEvent, specifier);
+    }
+    return null;
+  }
 
-        // First, truncation
+  function truncate(truncation, toTruncate) {
+    var len;
     if (truncation) {
       len = parseInt(truncation.substr(1), 10);
-          replacement = replacement.substring(0, len);
+      return toTruncate.substring(0, len);
+    }
+
+    return toTruncate;
   }
-        // Next, padding
+
+  function pad(padding, toPad) {
+    var len;
     if (padding) {
       if (padding.charAt(0) == "-") {
         len = parseInt(padding.substr(1), 10);
         // Right pad with spaces
-            while (replacement.length < len) {
+        while (toPad.length < len) {
-              replacement += " ";
+          toPad += " ";
         }
       } else {
         len = parseInt(padding, 10);
         // Left pad with spaces
-            while (replacement.length < len) {
+        while (toPad.length < len) {
-              replacement = " " + replacement;
+          toPad = " " + toPad;
         }
       }
     }
+    return toPad;
+  }
+  
+  return function(loggingEvent) {
+    var formattedString = "";
+    var result;
+    var searchString = pattern;
+    
+    while ((result = regex.exec(searchString))) {
+      var matchedString = result[0];
+      var padding = result[1];
+      var truncation = result[2];
+      var conversionCharacter = result[3];
+      var specifier = result[5];
+      var text = result[6];
+      
+      // Check if the pattern matched was just normal text
+      if (text) {
+        formattedString += "" + text;
+      } else {
+        // Create a raw replacement string based on the conversion
+        // character and specifier
+        var replacement = 
+          replaceToken(conversionCharacter, loggingEvent, specifier) || 
+          matchedString;
+
+        // Format the replacement according to any padding or
+        // truncation specified
+        replacement = truncate(truncation, replacement);
+        replacement = pad(padding, replacement);
         formattedString += replacement;
       }
       searchString = searchString.substr(result.index + result[0].length);