Made CaseMapping an interface

Author: mbax

src/main/java/org/kitteh/irc/client/library/feature/CaseMapping.java

@@ -24,63 +24,49 @@
 package org.kitteh.irc.client.library.feature;
 
 import org.jspecify.annotations.NonNull;
+import org.jspecify.annotations.NullMarked;
 import org.jspecify.annotations.Nullable;
 import org.kitteh.irc.client.library.util.Sanity;
 
 import java.util.HashMap;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Optional;
 
 /**
  * ISUPPORT CASEMAPPING.
  */
-public enum CaseMapping {
+@NullMarked
+public interface CaseMapping {
+    record Ranged(char upperbound) implements CaseMapping {
+        @Override
+        public String toLowerCase(String input) {
+            Sanity.nullCheck(input, "Input");
+            char[] arr = input.toCharArray();
+            for (int i = 0; i < arr.length; i++) {
+                char c = arr[i];
+                if ((c >= 'A') && (c <= this.upperbound)) {
+                    arr[i] += (char) 32;
+                }
+            }
+            return new String(arr);
+        }
+    }
+
     /**
      * A-Z become a-z
      */
-    ASCII('Z'),
+    CaseMapping.Ranged ASCII = new CaseMapping.Ranged('Z');
     /**
      * A-Z become a-z, []^ become {}~
      */
-    RFC1459('^'),
+    CaseMapping.Ranged RFC1459 = new CaseMapping.Ranged('^');
     /**
      * A-Z become a-z, [] become {}
      */
-    STRICT_RFC1459(']');
-
-    private static final Map<String, CaseMapping> nameMap = new HashMap<>();
-
-    static {
-        for (CaseMapping caseMapping : CaseMapping.values()) {
-            CaseMapping.nameMap.put(caseMapping.name().replace('_', '-'), caseMapping);
-        }
-    }
-
-    /**
-     * Gets a CaseMapping by name. Case insensitive.
-     *
-     * @param name the name of the CaseMapping to get
-     * @return the matching CaseMapping if one exists
-     */
-    public static @NonNull Optional<CaseMapping> getByName(@Nullable String name) {
-        return (name == null) ? Optional.empty() : Optional.ofNullable(CaseMapping.nameMap.get(name.toUpperCase()));
-    }
-
-    private final char upperbound;
-
-    CaseMapping(char upperbound) {
-        this.upperbound = upperbound;
-    }
+    CaseMapping.Ranged STRICT_RFC1459 = new CaseMapping.Ranged(']');
 
-    /**
-     * Gets if two given strings are equal, case insensitive, using this
-     * case mapping.
-     *
-     * @param one one string
-     * @param two two string, red string, blue string
-     * @return true if equal ignoring case using this case mapping
-     */
-    public boolean areEqualIgnoringCase(@NonNull String one, @NonNull String two) {
+    default boolean areEqualIgnoringCase(String one,String two) {
         return this.toLowerCase(one).equals(this.toLowerCase(two));
     }
 
@@ -91,15 +77,23 @@ public boolean areEqualIgnoringCase(@NonNull String one, @NonNull String two) {
      * @return lowercased string
      * @throws IllegalArgumentException if input is null
      */
-    public @NonNull String toLowerCase(@NonNull String input) {
-        Sanity.nullCheck(input, "Input");
-        char[] arr = input.toCharArray();
-        for (int i = 0; i < arr.length; i++) {
-            char c = arr[i];
-            if ((c >= 'A') && (c <= this.upperbound)) {
-                arr[i] += (char) 32;
-            }
+    String toLowerCase(String input);
+
+    /**
+     * Gets a CaseMapping by name, case-insensitive.
+     *
+     * @param name the name of the CaseMapping to get
+     * @return the matching CaseMapping if one exists
+     */
+    static @NonNull Optional<CaseMapping> getByName(@Nullable String name) {
+        if (name == null) {
+            return Optional.empty();
         }
-        return new String(arr);
+        return Optional.ofNullable(switch (name.toUpperCase(Locale.ROOT)) {
+            case "ASCII" -> ASCII;
+            case "RFC1459" -> RFC1459;
+            case "STRICT-RFC1459" -> STRICT_RFC1459;
+            default -> null;
+        });
     }
 }

src/test/java/org/kitteh/irc/client/library/CaseMappingTest.java

@@ -5,40 +5,36 @@
 import org.kitteh.irc.client.library.feature.CaseMapping;
 import org.kitteh.irc.client.library.util.Pair;
 
-import java.util.EnumMap;
+import java.lang.reflect.Modifier;
+import java.util.Arrays;
+import java.util.HashMap;
 import java.util.Map;
-import java.util.Optional;
 
 /**
  * Tests case mappings.
  */
 public class CaseMappingTest {
-    /**
-     * Verifies all casemapping enums match names.
-     */
-    @Test
-    public void verifyMatch() {
-        for (CaseMapping caseMapping : CaseMapping.values()) {
-            Optional<CaseMapping> acquired = CaseMapping.getByName(caseMapping.name().replace('_', '-'));
-            Assertions.assertTrue(acquired.isPresent(), "Failed to acquire mapping for " + caseMapping.name());
-            Assertions.assertEquals(caseMapping, acquired.get());
-        }
-        Assertions.assertEquals(Optional.empty(), CaseMapping.getByName(null));
-    }
-
     /**
      * Tests casemapping lowercasing.
      */
     @Test
     public void lowerCase() {
-        Map<CaseMapping, Pair<String, String>> test = new EnumMap<>(CaseMapping.class);
+        Map<CaseMapping, Pair<String, String>> test = new HashMap<>();
         test.put(CaseMapping.ASCII, new Pair<>("abcdwxyzABCDWXYZ!@#$%^&*(){}[];':,.<>", "abcdwxyzabcdwxyz!@#$%^&*(){}[];':,.<>"));
         test.put(CaseMapping.RFC1459, new Pair<>("abcdwxyzABCDWXYZ!@#$%^&*(){}[];':,.<>", "abcdwxyzabcdwxyz!@#$%~&*(){}{};':,.<>"));
         test.put(CaseMapping.STRICT_RFC1459, new Pair<>("abcdwxyzABCDWXYZ!@#$%^&*(){}[];':,.<>", "abcdwxyzabcdwxyz!@#$%^&*(){}{};':,.<>"));
 
-        for (CaseMapping caseMapping : CaseMapping.values()) {
-            Assertions.assertTrue(test.containsKey(caseMapping), "Missing CaseMapping " + caseMapping.name());
-        }
+        Arrays.stream(CaseMapping.class.getDeclaredFields())
+                .filter(field -> Modifier.isPublic(field.getModifiers()) && CaseMapping.class.isAssignableFrom(field.getType()))
+                .forEach(field -> {
+                            try {
+                                Assertions.assertTrue(test.containsKey((CaseMapping) field.get(null)), "Missing CaseMapping " + field.getName());
+                            } catch (IllegalAccessException e) {
+                                throw new RuntimeException(e);
+                            }
+                        }
+                );
+
         for (Map.Entry<CaseMapping, Pair<String, String>> entry : test.entrySet()) {
             Assertions.assertEquals(entry.getKey().toLowerCase(entry.getValue().getLeft()), entry.getValue().getRight(), "Incorrect lowercasing");
             Assertions.assertTrue(entry.getKey().areEqualIgnoringCase(entry.getValue().getLeft(), entry.getValue().getRight()), "Incorrect equalsIgnoreCase");

src/test/java/org/kitteh/irc/client/library/defaults/feature/ISupportManagerTest.java

@@ -38,7 +38,7 @@ public void testParam() {
     @Test
     public void casemapping() {
         DefaultISupportManager manager = this.getManager();
-        ISupportParameter param = manager.createParameter(ISupportParameter.CaseMapping.NAME + '=' + CaseMapping.RFC1459.name());
+        ISupportParameter param = manager.createParameter(ISupportParameter.CaseMapping.NAME + "=RFC1459");
         Assertions.assertTrue(ISupportParameter.CaseMapping.class.isAssignableFrom(param.getClass()));
         Assertions.assertEquals(CaseMapping.RFC1459, ((ISupportParameter.CaseMapping) param).getCaseMapping());
     }