platform/lang-impl/src/com/intellij/diagnostic/logging/LogConsolePreferences.java

   1 /*
   2  * Copyright (c) 2000-2006 JetBrains s.r.o. All Rights Reserved.
   3  */
   4
   5 package com.intellij.diagnostic.logging;
   6
   7 import com.intellij.execution.process.ProcessOutputTypes;
   8 import com.intellij.execution.ui.ConsoleViewContentType;
   9 import com.intellij.openapi.components.ServiceManager;
  10 import com.intellij.openapi.components.State;
  11 import com.intellij.openapi.components.Storage;
  12 import com.intellij.openapi.diagnostic.Logger;
  13 import com.intellij.openapi.project.Project;
  14 import com.intellij.openapi.util.DefaultJDOMExternalizer;
  15 import com.intellij.openapi.util.InvalidDataException;
  16 import com.intellij.openapi.util.Key;
  17 import com.intellij.openapi.util.WriteExternalException;
  18 import com.intellij.util.StringBuilderSpinAllocator;
  19 import org.jdom.Element;
  20 import org.jetbrains.annotations.NonNls;
  21 import org.jetbrains.annotations.NotNull;
  22 import org.jetbrains.annotations.Nullable;
  23
  24 import java.util.*;
  25 import java.util.regex.Pattern;
  26
  27 /**
  28  * User: anna
  29  * Date: 06-Feb-2006
  30  */
  31 @State(
  32   name = "LogFilters",
  33   storages = {@Storage(
  34     id = "LogFilters",
  35     file = "$WORKSPACE_FILE$")})
  36 @SuppressWarnings({"AssignmentToStaticFieldFromInstanceMethod"})
  37 public class LogConsolePreferences extends LogFilterRegistrar {
  38   private final SortedMap<LogFilter, Boolean> myRegisteredLogFilters = new TreeMap<LogFilter, Boolean>(new Comparator<LogFilter>() {
  39     public int compare(final LogFilter o1, final LogFilter o2) {
  40       return -1;
  41     }
  42   });
  43   @NonNls private static final String FILTER = "filter";
  44   @NonNls private static final String IS_ACTIVE = "is_active";
  45
  46   public boolean FILTER_ERRORS = false;
  47   public boolean FILTER_WARNINGS = false;
  48   public boolean FILTER_INFO = true;
  49   public String CUSTOM_FILTER = null;
  50   @NonNls public static final String ERROR = "ERROR";
  51   @NonNls public static final String WARNING = "WARNING";
  52   @NonNls private static final String WARN = "WARN";
  53   @NonNls public static final String INFO = "INFO";
  54   @NonNls public static final String CUSTOM = "CUSTOM";
  55
  56   public final static Pattern ERROR_PATTERN = Pattern.compile(".*" + ERROR + ".*");
  57   public final static Pattern WARNING_PATTERN = Pattern.compile(".*" + WARNING + ".*");
  58   public final static Pattern WARN_PATTERN = Pattern.compile(".*" + WARN + ".*");
  59   public final static Pattern INFO_PATTERN = Pattern.compile(".*" + INFO + ".*");
  60
  61   private static Pattern ourCustomPattern = null;
  62
  63   @NonNls public final static Pattern EXCEPTION_PATTERN = Pattern.compile(".*at .*");
  64
  65   private final List<FilterListener> myListeners = new ArrayList<FilterListener>();
  66   private static final Logger LOG = Logger.getInstance("#" + LogConsolePreferences.class.getName());
  67
  68   public static LogConsolePreferences getInstance(Project project) {
  69     return ServiceManager.getService(project, LogConsolePreferences.class);
  70   }
  71
  72   public void updateCustomFilter(String customFilter) {
  73     CUSTOM_FILTER = customFilter;
  74     ourCustomPattern = null;
  75     fireStateChanged();
  76   }
  77
  78   @Nullable
  79   private Pattern getCustomPattern() {
  80     if (ourCustomPattern == null && CUSTOM_FILTER != null) {
  81       final StringBuilder buf = StringBuilderSpinAllocator.alloc();
  82       try {
  83         for (int i = 0; i < CUSTOM_FILTER.length(); i++) {
  84           final char c = CUSTOM_FILTER.charAt(i);
  85           if (Character.isLetterOrDigit(c)) {
  86             buf.append(Character.toUpperCase(c));
  87           }
  88           else {
  89             buf.append("\\").append(c);
  90           }
  91         }
  92         ourCustomPattern = Pattern.compile(".*" + buf + ".*");
  93       }
  94       finally {
  95         StringBuilderSpinAllocator.dispose(buf);
  96       }
  97     }
  98     return ourCustomPattern;
  99   }
 100
 101   public boolean isApplicable(@NotNull String text, String prevType, boolean checkStandartFilters) {
 102     if (CUSTOM_FILTER != null) {
 103       final Pattern pattern = getCustomPattern();
 104       if (pattern != null && !pattern.matcher(text.toUpperCase()).matches()) return false;
 105     }
 106     for (LogFilter filter : myRegisteredLogFilters.keySet()) {
 107       if (myRegisteredLogFilters.get(filter).booleanValue() && !filter.isAcceptable(text)) return false;
 108     }
 109     if (checkStandartFilters) {
 110       final String type = getType(text);
 111       boolean selfTyped = false;
 112       if (type != null) {
 113         if (!isApplicable(type)) return false;
 114         selfTyped = true;
 115       }
 116       return selfTyped || prevType == null || isApplicable(prevType);
 117     }
 118     return true;
 119   }
 120
 121   private boolean isApplicable(final String type) {
 122     if (type.equals(ERROR)) {
 123       return !FILTER_ERRORS;
 124     }
 125     if (type.equals(WARNING)) {
 126       return !FILTER_WARNINGS;
 127     }
 128     if (type.equals(INFO)) {
 129       return !FILTER_INFO;
 130     }
 131     return true;
 132   }
 133
 134   public static ConsoleViewContentType getContentType(String type) {
 135     if (type.equals(ERROR)) return ConsoleViewContentType.ERROR_OUTPUT;
 136     return ConsoleViewContentType.NORMAL_OUTPUT;
 137   }
 138
 139   @Nullable
 140   public static String getType(@NotNull String text) {
 141     if (ERROR_PATTERN.matcher(text.toUpperCase()).matches()) return ERROR;
 142     if (WARNING_PATTERN.matcher(text.toUpperCase()).matches() || WARN_PATTERN.matcher(text.toUpperCase()).matches()) return WARNING;
 143     if (INFO_PATTERN.matcher(text.toUpperCase()).matches()) return INFO;
 144     return null;
 145   }
 146
 147   public static Key getProcessOutputTypes(String type) {
 148     if (type.equals(ERROR)) return ProcessOutputTypes.STDERR;
 149     if (type.equals(WARNING) || type.equals(INFO)) return ProcessOutputTypes.STDOUT;
 150     return null;
 151   }
 152
 153   public Element getState() {
 154     @NonNls Element element = new Element("LogFilters");
 155     try {
 156       for (LogFilter filter : myRegisteredLogFilters.keySet()) {
 157         Element filterElement = new Element(FILTER);
 158         filterElement.setAttribute(IS_ACTIVE, myRegisteredLogFilters.get(filter).toString());
 159         filter.writeExternal(filterElement);
 160         element.addContent(filterElement);
 161       }
 162       DefaultJDOMExternalizer.writeExternal(this, element);
 163     }
 164     catch (WriteExternalException e) {
 165       LOG.error(e);
 166     }
 167     return element;
 168   }
 169
 170   public void loadState(final Element object) {
 171     try {
 172       final List children = object.getChildren(FILTER);
 173       for (Object child : children) {
 174         Element filterElement = (Element)child;
 175         final LogFilter filter = new LogFilter();
 176         filter.readExternal(filterElement);
 177         setFilterSelected(filter, Boolean.parseBoolean(filterElement.getAttributeValue(IS_ACTIVE)));
 178       }
 179       DefaultJDOMExternalizer.readExternal(this, object);
 180     }
 181     catch (InvalidDataException e) {
 182       LOG.error(e);
 183     }
 184   }
 185
 186   public void registerFilter(LogFilter filter) {
 187     myRegisteredLogFilters.put(filter, Boolean.FALSE);
 188   }
 189
 190   public List<LogFilter> getRegisteredLogFilters() {
 191     return new ArrayList<LogFilter>(myRegisteredLogFilters.keySet());
 192   }
 193
 194   public boolean isFilterSelected(LogFilter filter) {
 195     final Boolean isSelected = myRegisteredLogFilters.get(filter);
 196     if (isSelected != null) {
 197       return isSelected.booleanValue();
 198     }
 199     if (filter instanceof IndependentLogFilter) {
 200       return ((IndependentLogFilter)filter).isSelected();
 201     }
 202     return false;
 203   }
 204
 205   public void setFilterSelected(LogFilter filter, boolean state) {
 206     if (filter instanceof IndependentLogFilter) {
 207       ((IndependentLogFilter)filter).selectFilter();
 208     }
 209     else if (myRegisteredLogFilters.containsKey(filter)) {
 210       myRegisteredLogFilters.put(filter, state);
 211     }
 212     fireStateChanged(filter);
 213   }
 214
 215   public void selectOnlyFilter(LogFilter filter) {
 216     for (LogFilter logFilter : myRegisteredLogFilters.keySet()) {
 217       myRegisteredLogFilters.put(logFilter, false);
 218     }
 219     setFilterSelected(filter, true);
 220   }
 221
 222   private void fireStateChanged(final LogFilter filter) {
 223     for (FilterListener listener : myListeners) {
 224       listener.onFilterStateChange(filter);
 225     }
 226   }
 227
 228   private void fireStateChanged() {
 229     for (FilterListener listener : myListeners) {
 230       listener.onTextFilterChange();
 231     }
 232   }
 233
 234   public void addFilterListener(FilterListener l) {
 235     myListeners.add(l);
 236   }
 237
 238   public void removeFilterListener(FilterListener l) {
 239     myListeners.remove(l);
 240   }
 241
 242   public interface FilterListener {
 243     void onFilterStateChange(LogFilter filter);
 244
 245     void onTextFilterChange();
 246   }
 247 }