adding support for composite keywords

Author: ceki

goscp

@@ -0,0 +1,3 @@
+TARGET=cgulcu@hqchnesoa07:/srv/jboss-eap-4.3.0.GA_CP05/jboss-as/server/nesoa-04-esb-01/lib/
+
+scp logback-core/target/logback-core-0.9.27-SNAPSHOT.jar logback-classic/target/logback-classic-0.9.27-SNAPSHOT.jar logback-access/target/logback-access-0.9.27-SNAPSHOT.jar   $TARGET

logback-classic/src/main/java/ch/qos/logback/classic/pattern/DateConverter.java

@@ -29,6 +29,7 @@ public class DateConverter extends ClassicConverter {
 
   public void start() {
 
+
     String datePattern = getFirstOption();
     if (datePattern == null) {
       datePattern = CoreConstants.ISO8601_PATTERN;

logback-classic/src/test/java/ch/qos/logback/classic/turbo/ReconfigureOnChangeTest.java

@@ -179,7 +179,7 @@ void verify(long expectedReconfigurations) {
     // we can't have the test succeed under JDK 1.5, punt and require 1.6+
     if (Env.isJDK6OrHigher()) {
       assertTrue(failMsg,
-          (effectiveResets * 1.3) >= (expectedReconfigurations * 1.0));
+          (effectiveResets * 1.4) >= (expectedReconfigurations * 1.0));
     }
   }
 

logback-core/src/main/java/ch/qos/logback/core/OutputStreamAppender.java

@@ -210,8 +210,9 @@ protected void subAppend(E event) {
       if (event instanceof DeferredProcessingAware) {
         ((DeferredProcessingAware) event).prepareForDeferredProcessing();
       }
-      // the synchronized prevents the OutputStream from being closed while we
-      // are writing
+      // the synchronization prevents the OutputStream from being closed while we
+      // are writing. It also prevents multiple thread from entering the same
+      // converter. Converters assume that they are in a synchronized block.
       synchronized (lock) {
         writeOut(event);
       }

logback-core/src/main/java/ch/qos/logback/core/html/HTMLLayoutBase.java

@@ -83,7 +83,7 @@ public void start() {
       Parser<E> p = new Parser<E>(pattern);
       p.setContext(getContext());
       Node t = p.parse();
-      this.head = p.compile(t, getEffectiveConverterMap());
+      this.head = p.compile(t, getEffectiveConverterMap(), Parser.DEFAULT_COMPOSITE_CONVERTER_MAP);
       ConverterUtil.startConverters(this.head);
     } catch (ScanException ex) {
       addError("Incorrect pattern found", ex);

logback-core/src/main/java/ch/qos/logback/core/pattern/CompositeConverter.java

@@ -1,6 +1,6 @@
 /**
  * Logback: the reliable, generic, fast and flexible logging framework.
- * Copyright (C) 1999-2009, QOS.ch. All rights reserved.
+ * Copyright (C) 1999-2010, QOS.ch. All rights reserved.
  *
  * This program and the accompanying materials are dual-licensed under
  * either the terms of the Eclipse Public License v1.0 as published by
@@ -13,24 +13,22 @@
  */
 package ch.qos.logback.core.pattern;
 
-public class CompositeConverter<E> extends FormattingConverter<E> {
+abstract public class CompositeConverter<E> extends DynamicConverter<E> {
 
-  StringBuilder buf = new StringBuilder();
   Converter<E> childConverter;
 
   public String convert(E event) {
-    if (buf.capacity() > MAX_CAPACITY) {
-      buf = new StringBuilder(INITIAL_BUF_SIZE);
-    } else {
-      buf.setLength(0);
-    }
+    StringBuilder buf = new StringBuilder();
 
     for (Converter<E> c = childConverter; c != null; c = c.next) {
       c.write(buf, event);
     }
-    return buf.toString();
+    String intermediary = buf.toString();
+    return transform(intermediary);
   }
 
+  abstract String transform(String in);
+
   public void setChildConverter(Converter<E> child) {
     childConverter = child;
   }

logback-core/src/main/java/ch/qos/logback/core/pattern/ConverterUtil.java

@@ -17,25 +17,28 @@ public class ConverterUtil {
 
   /**
    * Start converters in the chain of converters.
+   *
    * @param head
    */
   public static void startConverters(Converter head) {
     Converter c = head;
     while (c != null) {
-      if (c instanceof DynamicConverter) {
-        DynamicConverter dc = (DynamicConverter) c;
-        dc.start();
-      } else if(c instanceof CompositeConverter){
+      // CompositeConverter is a subclass of  DynamicConverter
+      if (c instanceof CompositeConverter) {
         CompositeConverter cc = (CompositeConverter) c;
         Converter childConverter = cc.childConverter;
         startConverters(childConverter);
+        cc.start();
+      } else if (c instanceof DynamicConverter) {
+        DynamicConverter dc = (DynamicConverter) c;
+        dc.start();
       }
       c = c.getNext();
     }
   }
 
-  
-  public static<E> Converter<E> findTail(Converter<E> head) {
+
+  public static <E> Converter<E> findTail(Converter<E> head) {
     Converter<E> p = head;
     while (p != null) {
       Converter<E> next = p.getNext();

logback-core/src/main/java/ch/qos/logback/core/pattern/DynamicConverter.java

@@ -21,7 +21,7 @@ abstract public class DynamicConverter<E> extends FormattingConverter<E>
     implements LifeCycle {
 
   // Contains a list of option Strings.
-  private List optionList;
+  private List<String> optionList;
 
   /**
    * Is this component active?
@@ -46,7 +46,7 @@ public boolean isStarted() {
     return started;
   }
 
-  public void setOptionList(List optionList) {
+  public void setOptionList(List<String> optionList) {
     this.optionList = optionList;
   }
 
@@ -60,11 +60,11 @@ public String getFirstOption() {
     if (optionList == null || optionList.size() == 0) {
       return null;
     } else {
-      return (String) optionList.get(0);
+      return optionList.get(0);
     }
   }
 
-  protected List getOptionList() {
+  protected List<String> getOptionList() {
     return optionList;
   }
 }

logback-core/src/main/java/ch/qos/logback/core/pattern/IdentityCompositeConverter.java

@@ -0,0 +1,22 @@
+/**
+ * Logback: the reliable, generic, fast and flexible logging framework.
+ * Copyright (C) 1999-2010, QOS.ch. All rights reserved.
+ *
+ * This program and the accompanying materials are dual-licensed under
+ * either the terms of the Eclipse Public License v1.0 as published by
+ * the Eclipse Foundation
+ *
+ *   or (per the licensee's choosing)
+ *
+ * under the terms of the GNU Lesser General Public License version 2.1
+ * as published by the Free Software Foundation.
+ */
+package ch.qos.logback.core.pattern;
+
+public class IdentityCompositeConverter<E> extends CompositeConverter<E> {
+
+  @Override
+  String transform(String in) {
+    return in;
+  }
+}

logback-core/src/main/java/ch/qos/logback/core/pattern/PatternLayoutBase.java

@@ -81,7 +81,7 @@ public void start() {
         p.setContext(getContext());
       }
       Node t = p.parse();
-      this.head = p.compile(t, getEffectiveConverterMap());
+      this.head = p.compile(t, getEffectiveConverterMap(), Parser.DEFAULT_COMPOSITE_CONVERTER_MAP);
       if (postCompileProcessor != null) {
         postCompileProcessor.process(head);
       }

logback-core/src/main/java/ch/qos/logback/core/pattern/ReplacingCompositeConverter.java

@@ -0,0 +1,31 @@
+/**
+ * Logback: the reliable, generic, fast and flexible logging framework.
+ * Copyright (C) 1999-2010, QOS.ch. All rights reserved.
+ *
+ * This program and the accompanying materials are dual-licensed under
+ * either the terms of the Eclipse Public License v1.0 as published by
+ * the Eclipse Foundation
+ *
+ *   or (per the licensee's choosing)
+ *
+ * under the terms of the GNU Lesser General Public License version 2.1
+ * as published by the Free Software Foundation.
+ */
+package ch.qos.logback.core.pattern;
+
+import java.util.List;
+
+public class ReplacingCompositeConverter<E> extends CompositeConverter<E> {
+
+  String regex;
+  String by;
+
+  public void start() {
+     final List<String> optionList = getOptionList();
+     regex = optionList.get(0);
+  }
+  @Override
+  String transform(String in) {
+    return null;  //To change body of implemented methods use File | Settings | File Templates.
+  }
+}

logback-core/src/main/java/ch/qos/logback/core/pattern/parser/Compiler.java

@@ -15,10 +15,7 @@
 
 import java.util.Map;
 
-import ch.qos.logback.core.pattern.CompositeConverter;
-import ch.qos.logback.core.pattern.Converter;
-import ch.qos.logback.core.pattern.DynamicConverter;
-import ch.qos.logback.core.pattern.LiteralConverter;
+import ch.qos.logback.core.pattern.*;
 import ch.qos.logback.core.spi.ContextAwareBase;
 import ch.qos.logback.core.status.ErrorStatus;
 import ch.qos.logback.core.util.OptionHelper;
@@ -29,46 +26,49 @@ class Compiler<E> extends ContextAwareBase {
   Converter<E> tail;
   final Node top;
   final Map converterMap;
+  final Map compositeConverterMap;
 
-  Compiler(final Node top, final Map converterMap) {
+  Compiler(final Node top, final Map converterMap, Map compositeConverterMap) {
     this.top = top;
     this.converterMap = converterMap;
+    this.compositeConverterMap = compositeConverterMap;
   }
 
   Converter<E> compile() {
     head = tail = null;
     for (Node n = top; n != null; n = n.next) {
       switch (n.type) {
-      case Node.LITERAL:
-        addToList(new LiteralConverter<E>((String) n.getValue()));
-        break;
-      case Node.COMPOSITE:
-        CompositeNode cn = (CompositeNode) n;
-        CompositeConverter<E> compositeConverter = new CompositeConverter<E>();
-        compositeConverter.setFormattingInfo(cn.getFormatInfo());
-        Compiler<E> childCompiler = new Compiler<E>(cn.getChildNode(),
-            converterMap);
-        childCompiler.setContext(context);
-        Converter<E> childConverter = childCompiler.compile();
-        compositeConverter.setChildConverter(childConverter);
-        addToList(compositeConverter);
-        break;
-      case Node.KEYWORD:
-        KeywordNode kn = (KeywordNode) n;
-        DynamicConverter<E> dynaConverter = createConverter(kn);
-        if (dynaConverter != null) {
-          dynaConverter.setFormattingInfo(kn.getFormatInfo());
-          dynaConverter.setOptionList(kn.getOptions());
-          addToList(dynaConverter);
-        } else {
-          // if the appropriate dynaconverter cannot be found, then replace
-          // it with a dummy LiteralConverter indicating an error.
-          Converter<E> errConveter = new LiteralConverter<E>("%PARSER_ERROR["
-              + kn.getValue()+"]");
-          addStatus(new ErrorStatus("[" + kn.getValue()
-              + "] is not a valid conversion word", this));
-          addToList(errConveter);
-        }
+        case Node.LITERAL:
+          addToList(new LiteralConverter<E>((String) n.getValue()));
+          break;
+        case Node.COMPOSITE_KEYWORD:
+          CompositeNode cn = (CompositeNode) n;
+          CompositeConverter<E> compositeConverter = createCompiteConverter(cn);
+          compositeConverter.setFormattingInfo(cn.getFormatInfo());
+          compositeConverter.setOptionList(cn.getOptions());
+          Compiler<E> childCompiler = new Compiler<E>(cn.getChildNode(),
+                  converterMap, compositeConverterMap);
+          childCompiler.setContext(context);
+          Converter<E> childConverter = childCompiler.compile();
+          compositeConverter.setChildConverter(childConverter);
+          addToList(compositeConverter);
+          break;
+        case Node.SIMPLE_KEYWORD:
+          SimpleKeywordNode kn = (SimpleKeywordNode) n;
+          DynamicConverter<E> dynaConverter = createConverter(kn);
+          if (dynaConverter != null) {
+            dynaConverter.setFormattingInfo(kn.getFormatInfo());
+            dynaConverter.setOptionList(kn.getOptions());
+            addToList(dynaConverter);
+          } else {
+            // if the appropriate dynaconverter cannot be found, then replace
+            // it with a dummy LiteralConverter indicating an error.
+            Converter<E> errConveter = new LiteralConverter<E>("%PARSER_ERROR["
+                    + kn.getValue() + "]");
+            addStatus(new ErrorStatus("[" + kn.getValue()
+                    + "] is not a valid conversion word", this));
+            addToList(errConveter);
+          }
 
       }
     }
@@ -87,31 +87,60 @@ private void addToList(Converter<E> c) {
   /**
    * Attempt to create a converter using the information found in
    * 'converterMap'.
-   * 
+   *
    * @param kn
    * @return
    */
   @SuppressWarnings("unchecked")
-  DynamicConverter<E> createConverter(KeywordNode kn) {
+  DynamicConverter<E> createConverter(SimpleKeywordNode kn) {
     String keyword = (String) kn.getValue();
     String converterClassStr = (String) converterMap.get(keyword);
 
     if (converterClassStr != null) {
       try {
         return (DynamicConverter) OptionHelper.instantiateByClassName(
-            converterClassStr, DynamicConverter.class, context);
+                converterClassStr, DynamicConverter.class, context);
       } catch (Exception e) {
         addError("Failed to instantiate converter class [" + converterClassStr
-            + "]", e);
+                + "]", e);
         return null;
       }
     } else {
       addError("There is no conversion class registered for conversion word ["
-          + keyword + "]");
+              + keyword + "]");
       return null;
     }
   }
 
+  /**
+   * Attempt to create a converter using the information found in
+   * 'compositeConverterMap'.
+   *
+   * @param cn
+   * @return
+   */
+  @SuppressWarnings("unchecked")
+  CompositeConverter<E> createCompiteConverter(CompositeNode cn) {
+    String keyword = (String) cn.getValue();
+    String converterClassStr = (String) compositeConverterMap.get(keyword);
+
+    if (converterClassStr != null) {
+      try {
+        return (CompositeConverter) OptionHelper.instantiateByClassName(
+                converterClassStr, CompositeConverter.class, context);
+      } catch (Exception e) {
+        addError("Failed to instantiate converter class [" + converterClassStr
+                + "]", e);
+        return null;
+      }
+    } else {
+      addError("There is no conversion class registered for composite conversion word ["
+              + keyword + "]");
+      return null;
+    }
+  }
+
+
   // public void setStatusManager(StatusManager statusManager) {
   // this.statusManager = statusManager;
   // }

logback-core/src/main/java/ch/qos/logback/core/pattern/parser/CompositeNode.java

@@ -13,11 +13,12 @@
  */
 package ch.qos.logback.core.pattern.parser;
 
-public class CompositeNode extends FormattingNode {
+public class CompositeNode extends SimpleKeywordNode {
 	Node childNode;
 
-	CompositeNode() {
-		super(Node.COMPOSITE);
+	CompositeNode(String keyword) {
+		super(Node.COMPOSITE_KEYWORD, keyword);
+
 	}
 
 	public Node getChildNode() {

logback-core/src/main/java/ch/qos/logback/core/pattern/parser/Node.java

@@ -15,8 +15,8 @@
 
 public class Node {
 	static final int LITERAL = 0;
-	static final int KEYWORD = 1;
-	static final int COMPOSITE = 2;
+	static final int SIMPLE_KEYWORD = 1;
+	static final int COMPOSITE_KEYWORD = 2;
 
 	final int type;
 	final Object value;