Added new IgnoreList class

Tests now work with stupid versions of JUnit, like 3.x

git-svn-id: http://svn.dmdirc.com/trunk@2674 00569f92-eb28-0410-84fd-f71c24880f

src/com/dmdirc/IgnoreList.java

@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) 2006-2007 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc;
+
+import com.dmdirc.parser.RegexStringList;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Wraps around a RegexStringList to allow "simple" expressions to be used
+ * instead of more complex regular expressions.
+ * 
+ * @author chris
+ */
+public class IgnoreList extends RegexStringList {
+    
+    /**
+     * Retrieves a list of regular expressions in this ignore list.
+     * 
+     * @return All expressions in this ignore list
+     */
+    public List<String> getRegexList() {
+        return new ArrayList<String>(ignoreInfo);
+    }
+    
+    /**
+     * Retrieves a list of simple expressions in this ignore list.
+     * 
+     * @return All expressions in this ignore list, converted to simple expressions
+     * @throws UnsupportedOperationException if an expression can't be converted
+     */
+    public List<String> getSimpleList() throws UnsupportedOperationException {
+        final List<String> res = new ArrayList<String>();
+        
+        for (String regex : ignoreInfo) {
+            res.add(regexToSimple(regex));
+        }
+        
+        return res;
+    }    
+    
+    /**
+     * Converts a regular expression into a simple expression.
+     * 
+     * @param regex The regular expression to be converted
+     * @return A simple expression corresponding to the regex
+     * @throws UnsupportedOperationException if the regex cannot be converted
+     */
+    protected String regexToSimple(final String regex) throws UnsupportedOperationException {
+        final StringBuilder res = new StringBuilder(regex.length());
+        boolean escaped = false;
+        boolean inchar = false;
+        
+        for (char part : regex.toCharArray()) {
+            if (inchar) {
+                inchar = false;
+                
+                if (part == '*') {
+                    res.append(part);
+                    continue;
+                } else {
+                    res.append('?');
+                }
+            }
+            
+            if (escaped) {
+                if (part == '?' || part == '*') {
+                    throw new UnsupportedOperationException("Cannot convert to" +
+                            " simple expression: ? or * is escaped.");
+                }
+                
+                res.append(part);
+                escaped = false;
+            }  else if (part == '\\') {
+                escaped = true;
+            } else if (part == '.') {
+                inchar = true;
+            } else if (part == '.' || part == '^' || part == '$' || part == '['
+            || part == ']' || part == '\\' || part == '(' || part == ')'
+            || part == '{' || part == '}' || part == '|' || part == '+') {
+                throw new UnsupportedOperationException("Cannot convert to"
+                        + " simple expression: unescaped special char: " + part);
+            } else {
+                res.append(part);
+            }
+        }
+        
+        if (escaped) {
+            throw new UnsupportedOperationException("Cannot convert to "
+                    + "simple expression: trailing backslash");
+        } else if (inchar) {
+            res.append('?');
+        }
+        
+        return res.toString();
+    }
+    
+    /**
+     * Converts a simple expression to a regular expression.
+     * 
+     * @param regex The simple expression to be converted
+     * @return A corresponding regular expression
+     */
+    @SuppressWarnings("fallthrough")
+    protected String simpleToRegex(final String regex) {
+        final StringBuilder res = new StringBuilder(regex.length());
+        
+        for (char part : regex.toCharArray()) {
+            switch (part) {
+            case '.': case '^': case '$': case '[': case ']': case '\\':
+            case '(': case ')': case '{': case '}': case '|': case '+':
+                res.append('\\');
+                res.append(part);
+                break;
+            case '?':
+                res.append('.');
+                break;
+            case '*':
+                res.append('.');                
+            default:
+                res.append(part);
+                break;
+            }
+        }
+        
+        return res.toString();
+    }
+
+}

src/com/dmdirc/parser/IRCParser.java

@@ -389,6 +389,13 @@ public final class IRCParser implements Runnable {
 	 * @return a reference to the ignorelist
 	 */
 	public RegexStringList getIgnoreList() { return myIgnoreList; }
+
+	/**
+	 * Replaces the current ignorelist with a new one.
+	 *
+	 * @param ignoreList Replacement ignorelist
+	 */
+	public void setIgnoreList(final RegexStringList ignoreList) { myIgnoreList = ignoreList; }
 	
 	//---------------------------------------------------------------------------
 	// Start Callbacks

src/com/dmdirc/parser/RegexStringList.java

@@ -25,6 +25,7 @@
 package com.dmdirc.parser;
 
 import java.util.ArrayList;
+import java.util.List;
 
 /**
  * IRC Parser Ignore list.
@@ -35,7 +36,7 @@ import java.util.ArrayList;
 public class RegexStringList {
 	
 	/** Arraylist storing ignore patterns */
-	private final ArrayList<String> ignoreInfo = new ArrayList<String>();
+	protected final List<String> ignoreInfo = new ArrayList<String>();
 	
 	/**
 	 * Add a new ignore pattern to the ignore list.

test/com/dmdirc/IgnoreListTest.java

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2006-2007 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc;
+
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+
+public class IgnoreListTest extends junit.framework.TestCase {
+    
+    private final String[][] tests = {
+        {"a@b.c", "a@b\\.c"},
+        {"*chris*", ".*chris.*"},
+        {"c???s", "c...s"},
+        {"c*?*", "c.*..*"},
+    };  
+    
+    private final IgnoreList il = new IgnoreList();
+
+    @Test
+    public void testToRegex() {
+        for (String[] test : tests) {
+            final String convert1 = il.simpleToRegex(test[0]);
+            assertEquals(test[1], convert1);
+        }
+    }
+    
+    @Test
+    public void testToSimple() {
+        for (String[] test : tests) {
+            final String convert2 = il.regexToSimple(test[1]);
+            assertEquals(test[0], convert2);
+        }
+    }    
+    
+}

test/com/dmdirc/ServerTest.java

@@ -28,7 +28,7 @@ import static org.junit.Assert.*;
 public class ServerTest extends junit.framework.TestCase {
 
     @Test
-    public void getNetworkFromServerName() {
+    public void testGetNetworkFromServerName() {
         final String[][] tests = {
             {"foo.com", "foo.com"},
             {"bar.foo.com", "foo.com"},

test/com/dmdirc/actions/ActionModelTest.java

@@ -23,6 +23,7 @@
 package com.dmdirc.actions;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import org.junit.Test;
 import static org.junit.Assert.*;
@@ -56,7 +57,7 @@ public class ActionModelTest extends junit.framework.TestCase {
 
         model.setTriggers(triggers);
 
-        assertEquals(triggers, model.getTriggers());
+        assertEquals(Arrays.asList(triggers), Arrays.asList(model.getTriggers()));
     }
 
     @Test
@@ -84,7 +85,7 @@ public class ActionModelTest extends junit.framework.TestCase {
 
         model.setResponse(newResponse);
 
-        assertEquals(newResponse, model.getResponse());
+        assertEquals(Arrays.asList(newResponse), Arrays.asList(model.getResponse()));
     }
 
     @Test

test/com/dmdirc/actions/ConditionTreeTest.java

@@ -28,7 +28,7 @@ import static org.junit.Assert.*;
 public class ConditionTreeTest extends junit.framework.TestCase {
 
     @Test
-    public void parseString() {
+    public void testParseString() {
         String[][] testCases = {
             {"1", "1"},
             {"50", "50"},
@@ -62,7 +62,7 @@ public class ConditionTreeTest extends junit.framework.TestCase {
     }
     
     @Test
-    public void evaluate() {
+    public void testEvaluate() {
         System.out.println();
         
         final String target = "((0&1&2)|3)&(!4)";
@@ -116,7 +116,7 @@ public class ConditionTreeTest extends junit.framework.TestCase {
     }
     
     @Test
-    public void getNumArgs() {
+    public void testGetNumArgs() {
         final String target = "((0&1&2)|3)&(!4)";
         final ConditionTree tree = ConditionTree.parseString(target);
         assertNotNull(tree);        
@@ -125,7 +125,7 @@ public class ConditionTreeTest extends junit.framework.TestCase {
     }
     
     @Test
-    public void createConjunction() {
+    public void testCreateConjunction() {
         final String expected = "(((0&1)&2)&3)";
         final ConditionTree tree = ConditionTree.createConjunction(4);
         
@@ -134,7 +134,7 @@ public class ConditionTreeTest extends junit.framework.TestCase {
     }
     
     @Test
-    public void createDisjunction() {
+    public void testCreateDisjunction() {
         final String expected = "(((0|1)|2)|3)";
         final ConditionTree tree = ConditionTree.createDisjunction(4);