[Refact] - Add a CommandParser and improve SLAP

Author: joel-lim

src/main/java/duke/commands/Command.java

@@ -1,22 +1,63 @@
 package duke.commands;
 
-import duke.ui.Ui;
-import duke.tasks.TaskList;
+import duke.parsers.CommandParser;
 import duke.storage.Storage;
+import duke.tasks.TaskList;
+import duke.ui.Ui;
+
+import java.io.IOException;
+
 import duke.exceptions.DukeException;
 
 /**
  * Represents a command that can be run by Duke.
  */
-public interface Command {
+public abstract class Command {
+    protected CommandParser commandParser;
+
+    /**
+     * Creates a Command object.
+     * 
+     * @param commandParser CommandParser to help parse arguments.
+     */
+    public Command(CommandParser commandParser) {
+        this.commandParser = commandParser;
+    }
+
+    /**
+     * Saves the TaskList to Storage.
+     * 
+     * @param storage The storage medium.
+     * @param tasks The in-memory list of tasks.
+     */
+    protected void save(Storage storage, TaskList tasks) throws DukeException {
+        try {
+            storage.save(tasks.getAllTasks());
+        } catch (IOException e) {
+            throw new DukeException("Error when saving to disk!");
+        }
+    }
+
+    /**
+     * Separates a given string by a the first occurrence of a delimiter.
+     * 
+     * @param str       String to be split.
+     * @param delimiter Delimiter that divides the string.
+     * @return Array of the two halves of the given string split by the delimiter,
+     *         or array of the original string if delimiter is not present.
+     */
+    protected String[] split(String str, String delimiter) {
+        return commandParser.splitByDelimiter(str, delimiter);
+    }
+
     /**
-     * Parses the given argument string and executes the Command.
+     * Executes the given command based on the argument string.
      * 
-     * @param arg   Arguments for the command (may be empty).
-     * @param tasks List of Tasks.
-     * @param ui    User interface for Duke.
+     * @param arg     Argument string for the command (may be empty).
+     * @param tasks   List of Tasks.
+     * @param ui      User interface for Duke.
      * @param storage Storage for Duke.
      * @throws DukeException If inputs are invalid.
      */
-    void execute(String arg, TaskList tasks, Ui ui, Storage storage) throws DukeException;
+    abstract void execute(String arg, TaskList tasks, Ui ui, Storage storage) throws DukeException;
 }

src/main/java/duke/commands/CommandHandler.java

@@ -2,50 +2,52 @@
 
 import java.util.HashMap;
 
-import javafx.util.Pair;
-
 import duke.ui.Ui;
 import duke.tasks.TaskList;
 import duke.storage.Storage;
-import duke.parsers.DateTimeParser;
+import duke.parsers.CommandParser;
 import duke.exceptions.DukeException;
 
 /**
- * Parses user-entered strings and executes them as Commands.
- * Remains active until user deactivates with "bye"
+ * Parses user-entered strings and executes them as Commands. Remains active
+ * until user deactivates with "bye"
  */
 public class CommandHandler {
     private TaskList tasks;
     private Ui ui;
     private Storage storage;
     private HashMap<String, Command> commands;
+    private CommandParser commandParser;
     private boolean isActive;
 
     /**
      * Creates a CommandHandler.
-     * @param tasks List of tasks.
-     * @param ui User interface.
+     * 
+     * @param tasks   List of tasks.
+     * @param ui      User interface.
      * @param storage Persistent storage.
      */
     public CommandHandler(TaskList tasks, Ui ui, Storage storage) {
         this.tasks = tasks;
         this.ui = ui;
         this.storage = storage;
         this.commands = new HashMap<>();
+        this.commandParser = new CommandParser();
         isActive = true;
 
-        // Create parsers
-        DateTimeParser dtParser = new DateTimeParser();
-
         // Register commands
-        commands.put("list", new ListAll());
-        commands.put("done", new MarkTaskAsDone());
-        commands.put("todo", new CreateTodo());
-        commands.put("deadline", new CreateDeadline(dtParser));
-        commands.put("event", new CreateEvent(dtParser));
-        commands.put("delete", new DeleteTask());
-        commands.put("find", new FindTasks());
-        commands.put("reschedule", new RescheduleTask(dtParser));
+        commands.put("list", new ListAll(commandParser));
+        commands.put("done", new MarkTaskAsDone(commandParser));
+        commands.put("todo", new CreateTodo(commandParser));
+        commands.put("deadline", new CreateDeadline(commandParser));
+        commands.put("event", new CreateEvent(commandParser));
+        commands.put("delete", new DeleteTask(commandParser));
+        commands.put("find", new FindTasks(commandParser));
+        commands.put("reschedule", new RescheduleTask(commandParser));
+    }
+
+    public boolean isActive() {
+        return isActive;
     }
 
     /**
@@ -61,28 +63,16 @@ public void handleCommand(String command) {
         }
 
         // Extract out command word and arguments
-        Pair<String, String> commandAndArg = getCommandAndArg(command);
-        String commandWord = commandAndArg.getKey();
-        String arg = commandAndArg.getValue();
+        String[] commandAndArg = commandParser.splitByDelimiter(command, " ");
+        String commandWord = commandAndArg[0].toLowerCase().strip();
 
         // Execute command
-        executeCommand(commandWord, arg);
-    }
-
-    public boolean isActive() {
-        return isActive;
-    }
-
-    private Pair<String, String> getCommandAndArg(String str) {
-        int spaceIndex = str.indexOf(" ");
-        if (spaceIndex == -1) {
-            // No spaces found, so must be single-word command
-            return new Pair<String, String>(str.toLowerCase(), "");
+        if (commandAndArg.length < 2) {
+            // No args provided
+            executeCommand(commandWord, "");
         } else {
-            // Split string into command word and arguments
-            String commandWord = str.substring(0, spaceIndex).toLowerCase();
-            String arg = str.substring(spaceIndex + 1);
-            return new Pair<String, String>(commandWord, arg);
+            // Use provided args
+            executeCommand(commandWord, commandAndArg[1]);
         }
     }
 

src/main/java/duke/commands/CreateDeadline.java

@@ -1,50 +1,48 @@
 package duke.commands;
 
-import java.io.IOException;
+import java.time.LocalDateTime;
 
 import duke.ui.Ui;
 import duke.tasks.Task;
 import duke.tasks.TaskList;
 import duke.tasks.Deadline;
 import duke.storage.Storage;
-import duke.parsers.DateTimeParser;
+import duke.parsers.CommandParser;
 import duke.exceptions.DukeException;
 
 /**
  * Creates a Deadline Task and adds it to the TaskList.
  */
-class CreateDeadline extends TimedCommand {
+class CreateDeadline extends Command {
 
-    public CreateDeadline(DateTimeParser dtParser) {
-        super(dtParser);
+    public CreateDeadline(CommandParser commandParser) {
+        super(commandParser);
     }
 
     public void execute(String arg, TaskList tasks, Ui ui, Storage storage) throws DukeException {
-        // Perform parsing of arguments
-        String[] args = arg.split("/by");
-        if (args.length < 2) {
-            throw new DukeException("Usage: deadline [task name] /by [datetime]");
-        }
-
-        String taskName = args[0].strip();
-        String dateTime = args[1].strip();
-        if (taskName.length() == 0 || dateTime.length() == 0) {
-            throw new DukeException("Usage: deadline [task name] /by [datetime]");
-        }
+        // Obtain command arguments from argument string
+        String[] args = split(arg, "/by");
+        String taskName = getTaskName(args);
+        LocalDateTime dateTime = getDateTime(args);
 
-        // Create parsed Deadline
-        Task newTask = new Deadline(taskName, dtParser.parse(dateTime));
+        Task newTask = new Deadline(taskName, dateTime);
         tasks.add(newTask);
 
-        // Save new Deadline to disk
-        try {
-            storage.save(tasks.getAllTasks());
-        } catch (IOException e) {
-            throw new DukeException("Error when saving to disk!");
-        }
+        save(storage, tasks);
 
-        // Display reply
         ui.showReply(String.format("Got it. I've added this task:\n  %s\nNow you have %d tasks in the list.", newTask,
                 tasks.size()));
     }
-}
+
+    private String getTaskName(String[] args) throws DukeException {
+        String taskName = args[0].strip();
+        if (args.length < 2 || taskName.length() == 0) {
+            throw new DukeException("Usage: deadline [task name] /by [due date]");
+        }
+        return taskName;
+    }
+
+    private LocalDateTime getDateTime(String[] args) throws DukeException {
+        return commandParser.parse(args[1].strip());
+    }
+}

src/main/java/duke/commands/CreateEvent.java

@@ -1,50 +1,56 @@
 package duke.commands;
 
-import java.io.IOException;
+import java.time.LocalDateTime;
 
 import duke.ui.Ui;
 import duke.tasks.Task;
 import duke.tasks.TaskList;
 import duke.tasks.Event;
 import duke.storage.Storage;
-import duke.parsers.DateTimeParser;
+import duke.parsers.CommandParser;
 import duke.exceptions.DukeException;
 
 /**
  * Creates an Event Task and adds it to the TaskList.
  */
-class CreateEvent extends TimedCommand {
+class CreateEvent extends Command {
 
-    public CreateEvent(DateTimeParser dtParser) {
-        super(dtParser);
+    public CreateEvent(CommandParser commandParser) {
+        super(commandParser);
     }
 
     public void execute(String arg, TaskList tasks, Ui ui, Storage storage) throws DukeException {
-        // Perform parsing of arguments
-        String[] args = arg.split("/at");
-        if (args.length < 2) {
-            throw new DukeException("Usage: event [task name] /at [start datetime] to [end datetime]");
-        }
+        // Obtain command arguments from argument string
+        String[] args = split(arg, "/at");
+        String taskName = getTaskName(args);
+        LocalDateTime[] dateTimes = getDateTimes(args);
 
-        String taskName = args[0].strip();
-        String[] dateTimes = args[1].strip().split("to");
-        if (taskName.length() == 0 || dateTimes.length < 2) {
-            throw new DukeException("Usage: event [task name] /at [start datetime] to [end datetime]");
-        }
-
-        // Create parsed Event
-        Task newTask = new Event(taskName, dtParser.parse(dateTimes[0].strip()), dtParser.parse(dateTimes[1].strip()));
+        Task newTask = new Event(taskName, dateTimes[0], dateTimes[1]);
         tasks.add(newTask);
 
-        // Save new Event to disk
-        try {
-            storage.save(tasks.getAllTasks());
-        } catch (IOException e) {
-            throw new DukeException("Error when saving to disk!");
-        }
+        save(storage, tasks);
 
-        // Display reply
         ui.showReply(String.format("Got it. I've added this task:\n  %s\nNow you have %d tasks in the list.", newTask,
                 tasks.size()));
     }
-}
+
+    private String getTaskName(String[] args) throws DukeException {
+        String taskName = args[0].strip();
+        if (args.length < 2 || taskName.length() == 0) {
+            throw new DukeException("Usage: event [task name] /at [start datetime] to [end datetime]");
+        }
+        return taskName;
+    }
+
+    private LocalDateTime[] getDateTimes(String[] args) throws DukeException {
+        String[] dateTimeStrings = split(args[1].strip(), "to");
+        if (dateTimeStrings.length < 2) {
+            throw new DukeException("Usage: event [task name] /at [start datetime] to [end datetime]");
+        }
+        LocalDateTime[] dateTimes = new LocalDateTime[2];
+        for (int i = 0; i < 2; i++) {
+            dateTimes[i] = commandParser.parse(dateTimeStrings[i].strip());
+        }
+        return dateTimes;
+    }
+}

src/main/java/duke/commands/CreateTodo.java

@@ -1,36 +1,39 @@
 package duke.commands;
 
-import java.io.IOException;
-
 import duke.ui.Ui;
 import duke.tasks.Task;
 import duke.tasks.Todo;
 import duke.tasks.TaskList;
 import duke.storage.Storage;
+import duke.parsers.CommandParser;
 import duke.exceptions.DukeException;
 
 /**
  * Creates a Todo Task and adds it to the TaskList.
  */
-class CreateTodo implements Command {
+class CreateTodo extends Command {
+
+    public CreateTodo(CommandParser commandParser) {
+        super(commandParser);
+    }
+
     public void execute(String arg, TaskList tasks, Ui ui, Storage storage) throws DukeException {
-        if (arg.length() == 0) {
-            throw new DukeException("Usage: todo [task name]");
-        }
+        String taskName = getTaskName(arg);
 
-        // Create new Task
-        Task newTask = new Todo(arg);
+        Task newTask = new Todo(taskName);
         tasks.add(newTask);
 
-        // Save new Todo to disk
-        try {
-            storage.save(tasks.getAllTasks());
-        } catch (IOException e) {
-            throw new DukeException("Error when saving to disk!");
-        }
+        save(storage, tasks);
 
-        // Display reply
         ui.showReply(String.format("Got it. I've added this task:\n  %s\nNow you have %d tasks in the list.", newTask,
                 tasks.size()));
     }
-}
+
+    private String getTaskName(String arg) throws DukeException {
+        String taskName = arg.strip();
+        if (arg.length() == 0) {
+            throw new DukeException("Usage: todo [task name]");
+        }
+        return taskName;
+    }
+}