Centralize command dispatch map

Replace the command switch with an immutable command-to-handler map
to simplify routing and make command registration easier to maintain.

Bump the CLI project version and codecmedia dependency to 1.1.1
to align with the updated release.

Author: TamKungZ

pom.xml

@@ -7,7 +7,7 @@
 
   <groupId>me.tamkungz.codecmedia</groupId>
   <artifactId>codecmedia-cli</artifactId>
-  <version>1.1.0</version>
+  <version>1.1.1</version>
   <packaging>jar</packaging>
 
   <name>CodecMedia CLI</name>
@@ -90,7 +90,7 @@
     <dependency>
       <groupId>me.tamkungz.codecmedia</groupId>
       <artifactId>codecmedia</artifactId>
-      <version>1.1.0</version>
+      <version>1.1.1</version>
     </dependency>
 
     <dependency>

src/main/java/me/tamkungz/codecmedia/CodecMediaCli.java

@@ -2,6 +2,8 @@
 
 import java.io.PrintStream;
 import java.nio.file.Path;
+import java.util.Collections;
+import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.Locale;
 import java.util.Map;
@@ -37,6 +39,13 @@
  */
 public final class CodecMediaCli {
 
+    @FunctionalInterface
+    private interface CommandHandler {
+        int handle(CodecMediaEngine engine, String[] args, PrintStream out) throws CodecMediaException;
+    }
+
+    private static final Map<String, CommandHandler> COMMANDS = createCommands();
+
     private CodecMediaCli() {
     }
 
@@ -83,21 +92,13 @@ static int run(String[] args, PrintStream out, PrintStream err) {
             String command = args[0].toLowerCase(Locale.ROOT);
             CodecMediaEngine engine = CodecMedia.createDefault();
 
-            return switch (command) {
-                case "get" -> handleGet(engine, args, out);
-                case "probe" -> handleProbe(engine, args, out);
-                case "validate" -> handleValidate(engine, args, out);
-                case "convert" -> handleConvert(engine, args, out);
-                case "extract-audio" -> handleExtractAudio(engine, args, out);
-                case "play" -> handlePlay(engine, args, out);
-                case "read-metadata" -> handleReadMetadata(engine, args, out);
-                case "write-metadata" -> handleWriteMetadata(engine, args, out);
-                default -> {
-                    err.println("Unknown command: " + command);
-                    printUsage(err);
-                    yield 2;
-                }
-            };
+            CommandHandler handler = COMMANDS.get(command);
+            if (handler == null) {
+                err.println("Unknown command: " + command);
+                printUsage(err);
+                return 2;
+            }
+            return handler.handle(engine, args, out);
         } catch (IllegalArgumentException ex) {
             err.println("Invalid arguments: " + ex.getMessage());
             return 2;
@@ -110,6 +111,19 @@ static int run(String[] args, PrintStream out, PrintStream err) {
         }
     }
 
+    private static Map<String, CommandHandler> createCommands() {
+        Map<String, CommandHandler> handlers = new HashMap<>();
+        handlers.put("get", CodecMediaCli::handleGet);
+        handlers.put("probe", CodecMediaCli::handleProbe);
+        handlers.put("validate", CodecMediaCli::handleValidate);
+        handlers.put("convert", CodecMediaCli::handleConvert);
+        handlers.put("extract-audio", CodecMediaCli::handleExtractAudio);
+        handlers.put("play", CodecMediaCli::handlePlay);
+        handlers.put("read-metadata", CodecMediaCli::handleReadMetadata);
+        handlers.put("write-metadata", CodecMediaCli::handleWriteMetadata);
+        return Collections.unmodifiableMap(handlers);
+    }
+
     /**
      * Handles the {@code get} command.
      *
@@ -543,4 +557,4 @@ private static void printUsage(PrintStream out) {
         out.println("  read-metadata <input>");
         out.println("  write-metadata <input> --entry <key=value> [--entry <key=value> ...]");
     }
-}
+}

src/test/java/me/tamkungz/codecmedia/CodecMediaCliTest.java

@@ -0,0 +1,100 @@
+package me.tamkungz.codecmedia;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+import java.nio.charset.StandardCharsets;
+
+import org.junit.jupiter.api.Test;
+
+class CodecMediaCliTest {
+
+    @Test
+    void shouldPrintUsageWhenNoArgs() {
+        RunResult result = runCli(new String[0]);
+
+        assertEquals(0, result.code());
+        assertTrue(result.out().contains("CodecMedia CLI"));
+        assertTrue(result.out().contains("Usage:"));
+    }
+
+    @Test
+    void shouldReturnCode2ForUnknownCommand() {
+        RunResult result = runCli(new String[] {"unknown-cmd"});
+
+        assertEquals(2, result.code());
+        assertTrue(result.err().contains("Unknown command: unknown-cmd"));
+    }
+
+    @Test
+    void shouldReturnCode2WhenValidateMaxBytesValueMissing() {
+        RunResult result = runCli(new String[] {"validate", "file.mp3", "--max-bytes"});
+
+        assertEquals(2, result.code());
+        assertTrue(result.err().contains("--max-bytes requires a numeric value"));
+    }
+
+    @Test
+    void shouldReturnCode2WhenValidateMaxBytesNotNumeric() {
+        RunResult result = runCli(new String[] {"validate", "file.mp3", "--max-bytes", "abc"});
+
+        assertEquals(2, result.code());
+        assertTrue(result.err().contains("--max-bytes must be a long integer: abc"));
+    }
+
+    @Test
+    void shouldReturnCode2WhenConvertTargetFormatMissing() {
+        RunResult result = runCli(new String[] {"convert", "input.media", "output"});
+
+        assertEquals(2, result.code());
+        assertTrue(result.err().contains("Target format missing"));
+    }
+
+    @Test
+    void shouldReturnCode2WhenExtractAudioHasUnknownOption() {
+        RunResult result = runCli(new String[] {"extract-audio", "input.mp4", "out", "--bad-option"});
+
+        assertEquals(2, result.code());
+        assertTrue(result.err().contains("Unknown option for extract-audio: --bad-option"));
+    }
+
+    @Test
+    void shouldReturnCode2WhenWriteMetadataEntryMalformed() {
+        RunResult result = runCli(new String[] {"write-metadata", "in.mp3", "--entry", "bad"});
+
+        assertEquals(2, result.code());
+        assertTrue(result.err().contains("Invalid --entry value: bad"));
+    }
+
+    @Test
+    void shouldReturnCode2WhenWriteMetadataEntryValueMissing() {
+        RunResult result = runCli(new String[] {"write-metadata", "in.mp3", "--entry"});
+
+        assertEquals(2, result.code());
+        assertTrue(result.err().contains("Usage: write-metadata"));
+    }
+
+    @Test
+    void shouldReturnCode2WhenPlayHasUnknownOption() {
+        RunResult result = runCli(new String[] {"play", "song.mp3", "--nope"});
+
+        assertEquals(2, result.code());
+        assertTrue(result.err().contains("Unknown option for play: --nope"));
+    }
+
+    private static RunResult runCli(String[] args) {
+        ByteArrayOutputStream outBuffer = new ByteArrayOutputStream();
+        ByteArrayOutputStream errBuffer = new ByteArrayOutputStream();
+        int code = CodecMediaCli.run(args, new PrintStream(outBuffer), new PrintStream(errBuffer));
+        return new RunResult(
+                code,
+                outBuffer.toString(StandardCharsets.UTF_8),
+                errBuffer.toString(StandardCharsets.UTF_8)
+        );
+    }
+
+    private record RunResult(int code, String out, String err) {
+    }
+}