Make IRCStringConverter use an enum sensibly

Fixes CLIENT-135

Change-Id: I5f326523ff031c0996996f0efad6c8e5d7278c7f
Reviewed-on: http://gerrit.dmdirc.com/1859
Automatic-Compile: DMDirc Local Commits <dmdirc@googlemail.com>
Reviewed-by: Greg Holmes <greg@dmdirc.com>

src/com/dmdirc/parser/irc/IRCEncoding.java

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2006-2011 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.parser.irc;
+
+/**
+ * An enumeration of the supported types of encoding for an IRC connection.
+ *
+ * @since 0.6.6
+ */
+public enum IRCEncoding {
+
+    /** The ASCII encoding. */
+    ASCII(0),
+    /** "Strict" RFC1459. */
+    STRICT_RFC1459(3),
+    /** Standard RFC1459. */
+    RFC1459(4);
+
+    /** The limit used for this encoding. */
+    private final int limit;
+
+    /**
+     * Creates a new instance of IRCEncoding with the specified limit.
+     *
+     * @param limit The limit used for this encoding.
+     */
+    private IRCEncoding(final int limit) {
+        this.limit = limit;
+    }
+
+    /**
+     * Retrieves the "limit" of this encoding. That is, the number of characters
+     * after the uppercase ASCII 'Z' which should be treated
+     * "case-insensitively". A limit of 3 will cause the '[', '\' and ']'
+     * characters to be treated as equal to '{', '|' and '}', respectively.
+     *
+     * @return The limit of this encoding
+     */
+    public int getLimit() {
+        return limit;
+    }
+}

src/com/dmdirc/parser/irc/IRCParser.java

@@ -712,8 +712,7 @@ public class IRCParser implements SecureParser, EncodingParser, Runnable {
         stopPingTimer();
 
         currentSocketState = SocketState.CLOSED;
-        // Char Mapping
-        updateCharArrays((byte) 4);
+        setEncoding(IRCEncoding.RFC1459);
     }
 
     /**
@@ -1201,21 +1200,18 @@ public class IRCParser implements SecureParser, EncodingParser, Runnable {
     @Override
     public IRCStringConverter getStringConverter() {
         if (stringConverter == null) {
-            stringConverter = new IRCStringConverter((byte) 4);
+            stringConverter = new IRCStringConverter(IRCEncoding.RFC1459);
         }
         return stringConverter;
     }
 
     /**
-     * Update the character arrays.
+     * Sets the encoding that this parser's string converter should use.
      *
-     * @param limit Number of post-alphabetical characters to convert
-     *              0 = ascii encoding
-     *              3 = strict-rfc1459 encoding
-     *              4 = rfc1459 encoding
+     * @param encoding The encoding to use
      */
-    protected void updateCharArrays(final byte limit) {
-        stringConverter = new IRCStringConverter(limit);
+    protected void setEncoding(final IRCEncoding encoding) {
+        stringConverter = new IRCStringConverter(encoding);
     }
 
     /**

src/com/dmdirc/parser/irc/IRCStringConverter.java

@@ -19,49 +19,40 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
-
 package com.dmdirc.parser.irc;
 
 import com.dmdirc.parser.interfaces.StringConverter;
 
 /**
  * IRC String Converter.
- *
- * @author Shane Mc Cormack
  */
 public class IRCStringConverter implements StringConverter {
 
-    /** Characters to use when converting tolowercase. */
+    /** Characters to use when converting to lowercase. */
     private final char[] lowercase;
-    /** Characters to use when converting touppercase. */
+    /** Characters to use when converting to uppercase. */
     private final char[] uppercase;
-    /** limit. */
-    private final byte limit;
+    /** Encoding to use. */
+    private final IRCEncoding encoding;
 
     /**
      * Create a new IRCStringConverter with rfc1459 encoding.
      */
     public IRCStringConverter() {
-        this((byte) 4);
+        this(IRCEncoding.RFC1459);
     }
 
     /**
      * Create a new IRCStringConverter.
-     * @param limit Number of post-alphabetical characters to convert
-     *              0 = ascii encoding
-     *              3 = strict-rfc1459 encoding
-     *              4 = rfc1459 encoding
+     *
+     * @param encoding The encoding to use.
      */
-    public IRCStringConverter(final byte limit) {
-        // If limit is out side the boundries, use rfc1459
-        if (limit > 4 || limit < 0) {
-            this.limit = (byte) 4;
-        } else {
-            this.limit = limit;
-        }
+    public IRCStringConverter(final IRCEncoding encoding) {
+        this.encoding = encoding;
 
         lowercase = new char[127];
         uppercase = new char[127];
+
         // Normal Chars
         for (char i = 0; i < lowercase.length; ++i) {
             lowercase[i] = i;
@@ -69,23 +60,26 @@ public class IRCStringConverter implements StringConverter {
         }
 
         // Replace the uppercase chars with lowercase
-        for (char i = 65; i <= (90 + this.limit); ++i) {
+        for (char i = 65; i <= (90 + encoding.getLimit()); ++i) {
             lowercase[i] = (char) (i + 32);
             uppercase[i + 32] = i;
         }
     }
 
     /**
-     * Get last used chararray limit.
+     * Retrieves the encoding used by this converter.
      *
-     * @return last used chararray limit
+     * @return This converter's current encoding
      */
-    protected int getLimit() { return limit; }
+    public IRCEncoding getEncoding() {
+        return encoding;
+    }
 
     /** {@inheritDoc} */
-        @Override
+    @Override
     public String toLowerCase(final String input) {
         final char[] result = input.toCharArray();
+
         for (int i = 0; i < input.length(); ++i) {
             if (result[i] >= 0 && result[i] < lowercase.length) {
                 result[i] = lowercase[result[i]];
@@ -93,13 +87,15 @@ public class IRCStringConverter implements StringConverter {
                 result[i] = result[i];
             }
         }
+
         return new String(result);
     }
 
     /** {@inheritDoc} */
-        @Override
+    @Override
     public String toUpperCase(final String input) {
         final char[] result = input.toCharArray();
+
         for (int i = 0; i < input.length(); ++i) {
             if (result[i] >= 0 && result[i] < uppercase.length) {
                 result[i] = uppercase[result[i]];
@@ -107,29 +103,40 @@ public class IRCStringConverter implements StringConverter {
                 result[i] = result[i];
             }
         }
+
         return new String(result);
     }
 
     /** {@inheritDoc} */
-        @Override
+    @Override
     public boolean equalsIgnoreCase(final String first, final String second) {
-        if (first == null && second == null) { return true; }
-        if (first == null || second == null) { return false; }
-        boolean result = (first.length() == second.length());
+        if (first == null && second == null) {
+            return true;
+        }
+
+        if (first == null || second == null) {
+            return false;
+        }
+
+        boolean result = first.length() == second.length();
+
         if (result) {
             final char[] firstChar = first.toCharArray();
             final char[] secondChar = second.toCharArray();
+
             for (int i = 0; i < first.length(); ++i) {
                 if (firstChar[i] < lowercase.length && secondChar[i] < lowercase.length) {
-                    result = (lowercase[firstChar[i]] == lowercase[secondChar[i]]);
+                    result = lowercase[firstChar[i]] == lowercase[secondChar[i]];
                 } else {
                     result = firstChar[i] == secondChar[i];
                 }
-                if (!result) { break; }
+
+                if (!result) {
+                    break;
+                }
             }
         }
 
         return result;
     }
-
 }

src/com/dmdirc/parser/irc/Process004005.java

@@ -32,6 +32,7 @@ import java.util.regex.Pattern;
  * Process ISUPPORT lines.
  */
 public class Process004005 extends IRCProcessor {
+
     /**
      * Process ISUPPORT lines.
      *
@@ -40,80 +41,99 @@ public class Process004005 extends IRCProcessor {
      */
     @Override
     public void process(final String sParam, final String[] token) {
-        if (sParam.equals("002")) {
+        if ("002".equals(sParam)) {
             final Pattern pattern = Pattern.compile("running(?: version)? (.*)$");
             final Matcher matcher = pattern.matcher(myParser.getLastLine());
             if (matcher.find()) {
                 myParser.h005Info.put("002IRCD", matcher.group(1));
             }
-        } else if (sParam.equals("003")) {
+        } else if ("003".equals(sParam)) {
             myParser.h005Info.put("003IRCD", token[token.length - 1]);
-        } else if (sParam.equals("004")) {
+        } else if ("004".equals(sParam)) {
             // 004
             final boolean multiParam = token.length > 4;
             int i = multiParam ? 4 : 1;
             final String[] bits = multiParam ? token : token[3].split(" ");
 
             myParser.h005Info.put("004IRCD", bits[i++]);
-            // some IRCDs put a timestamp where the usermodes should be
-            // (issues 4140. 4181 and 4183) so check to see if this is numeric
-            // only, and if so, skip it.
-            if (bits[i].matches("^\\d+$")) { i++; }
+
+            if (bits[i].matches("^\\d+$")) {
+                // some IRCDs put a timestamp where the usermodes should be
+                // (issues 4140. 4181 and 4183) so check to see if this is
+                // numeric only, and if so, skip it.
+                i++;
+            }
+
             myParser.h005Info.put("USERMODES", bits[i++]);
             myParser.h005Info.put("USERCHANMODES", bits[i++]);
-            if (bits.length > i) { myParser.h005Info.put("USERCHANPARAMMODES", bits[i++]); } // INSPIRCD includes an extra param
+
+            if (bits.length > i) {
+                // INSPIRCD includes an extra param
+                myParser.h005Info.put("USERCHANPARAMMODES", bits[i++]);
+            }
+
             myParser.parseUserModes();
-        } else if (sParam.equals("005")) {
-            // 005
+        } else if ("005".equals(sParam)) {
             for (int i = 3; i < token.length; i++) {
                 final String[] bits = token[i].split("=", 2);
-                if (bits[0].isEmpty()) { continue; }
-                final boolean isNegation = (bits[0].charAt(0) == '-');
-                final String sKey = (isNegation) ? bits[0].substring(1).toUpperCase() : bits[0].toUpperCase();
-                final String sValue = (bits.length == 2) ? bits[1] : "";
-                callDebugInfo(IRCParser.DEBUG_INFO, "%s => %s", sKey, sValue);
+
+                if (bits[0].isEmpty()) {
+                    continue;
+                }
+
+                final boolean isNegation = bits[0].charAt(0) == '-';
+                final String key = (isNegation ? bits[0].substring(1) : bits[0]).toUpperCase();
+                final String value = bits.length == 2 ? bits[1] : "";
+
+                callDebugInfo(IRCParser.DEBUG_INFO, "%s => %s", key, value);
+
                 if (isNegation) {
-                    myParser.h005Info.remove(sKey);
+                    myParser.h005Info.remove(key);
                 } else {
-                    myParser.h005Info.put(sKey, sValue);
+                    myParser.h005Info.put(key, value);
                 }
-                if (sKey.equals("NETWORK") && !isNegation) {
-                    myParser.networkName = sValue;
+
+                if ("NETWORK".equals(key) && !isNegation) {
+                    myParser.networkName = value;
                     callGotNetwork();
-                } else if (sKey.equals("CASEMAPPING") && !isNegation) {
-                    byte limit = (byte) 4;
-                    if (sValue.equalsIgnoreCase("strict-rfc1459")) {
-                        limit = (byte) 3;
-                    } else if (sValue.equalsIgnoreCase("ascii")) {
-                        limit = (byte) 0;
-                    } else if (!sValue.equalsIgnoreCase("rfc1459")) {
-                        myParser.callErrorInfo(new ParserError(ParserError.ERROR_WARNING, "Unknown casemapping: '" + sValue + "' - assuming rfc1459", myParser.getLastLine()));
+                } else if ("CASEMAPPING".equals(key) && !isNegation) {
+                    IRCEncoding encoding = IRCEncoding.RFC1459;
+
+                    try {
+                        encoding = IRCEncoding.valueOf(value.toUpperCase().replace('-', '_'));
+                    } catch (IllegalArgumentException ex) {
+                        myParser.callErrorInfo(new ParserError(
+                                ParserError.ERROR_WARNING,
+                                "Unknown casemapping: '" + value + "' - assuming rfc1459",
+                                myParser.getLastLine()));
                     }
-                    final boolean limitChanged = (myParser.getStringConverter().getLimit() != limit);
-                    myParser.updateCharArrays(limit);
-                    if (limitChanged && myParser.knownClients() == 1) {
+
+                    final boolean encodingChanged = myParser.getStringConverter().getEncoding() != encoding;
+                    myParser.setEncoding(encoding);
+
+                    if (encodingChanged && myParser.knownClients() == 1) {
                         // This means that the casemapping is not rfc1459
                         // We have only added ourselves so far (from 001)
                         // We can fix the hashtable easily.
                         myParser.removeClient(myParser.getLocalClient());
                         myParser.addClient(myParser.getLocalClient());
                     }
-                } else if (sKey.equals("CHANTYPES")) {
+                } else if ("CHANTYPES".equals(key)) {
                     myParser.parseChanPrefix();
-                } else if (sKey.equals("PREFIX")) {
+                } else if ("PREFIX".equals(key)) {
                     myParser.parsePrefixModes();
-                } else if (sKey.equals("CHANMODES")) {
+                } else if ("CHANMODES".equals(key)) {
                     myParser.parseChanModes();
-                } else if (sKey.equals("NAMESX") || sKey.equals("UHNAMES")) {
-                    myParser.sendString("PROTOCTL " + sKey);
-                } else if (sKey.equals("LISTMODE")) {
+                } else if ("NAMESX".equals(key) || "UHNAMES".equals(key)) {
+                    myParser.sendString("PROTOCTL " + key);
+                } else if ("LISTMODE".equals(key)) {
                     // Support for potential future decent mode listing in the protocol
                     //
                     // See my proposal: http://shanemcc.co.uk/irc/#listmode
                     // Add listmode handler
                     String[] handles = new String[2];
-                    handles[0] = sValue; // List mode item
-                    final String endValue = "" + (Integer.parseInt(sValue) + 1);
+                    handles[0] = value; // List mode item
+                    final String endValue = "" + (Integer.parseInt(value) + 1);
                     myParser.h005Info.put("LISTMODEEND", endValue);
                     handles[1] = endValue; // List mode end
                     // Add listmode handlers
@@ -156,6 +176,8 @@ public class Process004005 extends IRCProcessor {
      * @param parser IRCParser That owns this IRCProcessor
      * @param manager ProcessingManager that is in charge of this IRCProcessor
      */
-    protected Process004005(final IRCParser parser, final ProcessingManager manager) { super(parser, manager); }
+    protected Process004005(final IRCParser parser, final ProcessingManager manager) {
+        super(parser, manager);
+    }
 
 }

test/com/dmdirc/parser/irc/IRCStringConverterTest.java

@@ -29,13 +29,13 @@ public class IRCStringConverterTest {
     @Test
     public void testCaseConversion() {
         final IRCParser asciiParser = new IRCParser();
-        asciiParser.updateCharArrays((byte) 0);
+        asciiParser.setEncoding(IRCEncoding.ASCII);
 
         final IRCParser rfcParser = new IRCParser();
-        rfcParser.updateCharArrays((byte) 4);
+        rfcParser.setEncoding(IRCEncoding.RFC1459);
 
         final IRCParser strictParser = new IRCParser();
-        strictParser.updateCharArrays((byte) 3);
+        strictParser.setEncoding(IRCEncoding.STRICT_RFC1459);
 
         final String[][] testcases = {
             {"12345", "12345", "12345", "12345"},
@@ -66,28 +66,21 @@ public class IRCStringConverterTest {
             assertEquals(testcase[0], strictU);
         }
     }
-    
-    @Test
-    public void testLimit() {
-        final IRCStringConverter ircsc = new IRCStringConverter((byte) 100);
-        
-        assertEquals(4, ircsc.getLimit());
-    }
 
     @Test
     public void testDefaultLimit() {
         final IRCStringConverter ircsc = new IRCStringConverter();
 
-        assertEquals(4, ircsc.getLimit());
+        assertEquals(IRCEncoding.RFC1459, ircsc.getEncoding());
     }
-    
+
     @Test
     public void testEqualsNull() {
-        final IRCStringConverter ircsc = new IRCStringConverter((byte) 100);
-        
+        final IRCStringConverter ircsc = new IRCStringConverter(IRCEncoding.ASCII);
+
         assertTrue(ircsc.equalsIgnoreCase(null, null));
         assertFalse(ircsc.equalsIgnoreCase("null", null));
         assertFalse(ircsc.equalsIgnoreCase(null, "null"));
-    }    
+    }
 
 }

test/com/dmdirc/parser/irc/Process004005Test.java

@@ -31,45 +31,45 @@ import static org.junit.Assert.*;
 import static org.mockito.Mockito.*;
 
 public class Process004005Test {
-    
-    private TestParser doCaseMappingTest(final String target, final int expected) {
+
+    private TestParser doCaseMappingTest(final String target, final IRCEncoding expected) {
         final TestParser parser = new TestParser();
         parser.injectConnectionStrings();
         parser.injectLine(":server 005 nick CASEMAPPING=" + target
                     + " :are supported by this server");
-        
-        assertEquals(expected, parser.getStringConverter().getLimit());
-        
+
+        assertEquals(expected, parser.getStringConverter().getEncoding());
+
         return parser;
     }
-    
+
     @Test
     public void testCaseMappingASCII() {
-        doCaseMappingTest("ascii", 0);
-        doCaseMappingTest("ASCII", 0);
+        doCaseMappingTest("ascii", IRCEncoding.ASCII);
+        doCaseMappingTest("ASCII", IRCEncoding.ASCII);
     }
-    
+
     @Test
     public void testCaseMappingRFC() {
-        doCaseMappingTest("rfc1459", 4);
-        doCaseMappingTest("RFC1459", 4);
+        doCaseMappingTest("rfc1459", IRCEncoding.RFC1459);
+        doCaseMappingTest("RFC1459", IRCEncoding.RFC1459);
     }
-    
+
     @Test
     public void testCaseMappingStrict() {
-        doCaseMappingTest("strict-rfc1459", 3);
-        doCaseMappingTest("strict-RFC1459", 3);        
+        doCaseMappingTest("strict-rfc1459", IRCEncoding.STRICT_RFC1459);
+        doCaseMappingTest("strict-RFC1459", IRCEncoding.STRICT_RFC1459);
     }
-    
+
     @Test
     public void testCaseMappingUnknown() {
-        final TestParser tp = doCaseMappingTest("rfc1459", 4);
+        final TestParser tp = doCaseMappingTest("rfc1459", IRCEncoding.RFC1459);
         final ErrorInfoListener info = mock(ErrorInfoListener.class);
-        
+
         tp.getCallbackManager().addCallback(ErrorInfoListener.class, info);
-        
+
         tp.injectLine(":server 005 nick CASEMAPPING=unknown :are supported by this server");
-        
+
         verify(info).onErrorInfo(same(tp), (Date) anyObject(), (ParserError) anyObject());
     }