[Sean Ng] iP

.gitignore

@@ -15,3 +15,5 @@ bin/
 
 /text-ui-test/ACTUAL.txt
 text-ui-test/EXPECTED-UNIX.TXT
+
+data/

README.md

@@ -1,4 +1,4 @@
-# Duke project template
+# duke.Duke project template
 
 This is a project template for a greenfield Java project. It's named after the Java mascot _Duke_. Given below are instructions on how to use it.
 
@@ -13,7 +13,7 @@ Prerequisites: JDK 11, update Intellij to the most recent version.
    1. If there are any further prompts, accept the defaults.
 1. Configure the project to use **JDK 11** (not other versions) as explained in [here](https://www.jetbrains.com/help/idea/sdk.html#set-up-jdk).<br>
    In the same dialog, set the **Project language level** field to the `SDK default` option.
-3. After that, locate the `src/main/java/Duke.java` file, right-click it, and choose `Run Duke.main()` (if the code editor is showing compile errors, try restarting the IDE). If the setup is correct, you should see something like the below as the output:
+3. After that, locate the `src/main/java/duke.Duke.java` file, right-click it, and choose `Run duke.Duke.main()` (if the code editor is showing compile errors, try restarting the IDE). If the setup is correct, you should see something like the below as the output:
    ```
    Hello from
     ____        _        

src/main/java/META-INF/MANIFEST.MF

@@ -0,0 +1,3 @@
+Manifest-Version: 1.0
+Main-Class: duke.Duke
+

src/main/java/duke/Duke.java

@@ -0,0 +1,49 @@
+package duke;
+
+import duke.command.Command;
+
+/**
+ * Main driver class for task organisation bot Duke.
+ */
+public class Duke {
+
+    private Storage storage;
+    private TaskList tasks;
+    private Ui ui;
+
+    /**
+     * Creates a new Duke.
+     */
+    public Duke() {
+        ui = new Ui();
+        storage = new Storage();
+        try {
+            tasks = new TaskList(storage.load());
+        } catch (Exception e) {
+            ui.showLoadingError();
+            tasks = new TaskList();
+        }
+    }
+
+    /**
+     * Listen for user input and respond until "bye" command is issued.
+     */
+    public void run() {
+        this.ui.greet();
+        boolean isExit = false;
+        while (!isExit) {
+            try {
+                String fullCommand = ui.readCommand();
+                Command c = Parser.parse(fullCommand);
+                c.execute(tasks, ui, storage);
+                isExit = c.isExit();
+            } catch (DukeException e) {
+                ui.showError(e.getMessage());
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        new Duke().run();
+    }
+}

src/main/java/duke/DukeException.java

@@ -0,0 +1,16 @@
+package duke;
+
+/**
+ * Custom exception class for Duke.
+ */
+public class DukeException extends Exception {
+
+    /**
+     * Creates a new DukeException
+     *
+     * @param errorMessage Error message explaining the reason for generating the DukeException.
+     */
+    public DukeException(String errorMessage) {
+        super(errorMessage);
+    }
+}

src/main/java/duke/Parser.java

@@ -0,0 +1,100 @@
+package duke;
+
+import duke.command.*;
+
+import java.time.LocalDate;
+import java.time.format.DateTimeParseException;
+
+/**
+ * Class that parses user input and returns the corresponding command.
+ */
+public class Parser {
+
+    /**
+     * Main method that takes in raw user input and returns the corresponding command.
+     *
+     * @param fullCommand The raw string input by the user.
+     * @return The command corresponding to the user's input.
+     * @throws DukeException If user's input is invalid (does not correspond to any command or invalid parameters).
+     */
+    public static Command parse(String fullCommand) throws DukeException {
+        String[] input = fullCommand.split(" ", 2); //return [commandWord, restOfCommand]
+        String commandWord = input[0];
+
+        switch(commandWord) {
+        case ListCommand.COMMAND_WORD:
+            return new ListCommand();
+        case MarkCommand.COMMAND_WORD: {
+            int index = -1;
+            try {
+                index = Integer.valueOf(input[1]) - 1;
+                return new MarkCommand(index);
+            } catch (NumberFormatException e) {
+                throw new DukeException("Invalid parameter(s). Usage: mark [taskNumber]");
+            } catch (IndexOutOfBoundsException e) {
+                throw new DukeException("Invalid parameter(s). duke.task.Task " + (index + 1) + " does not exist");
+            }
+        }
+        case UnmarkCommand.COMMAND_WORD: {
+            int index = -1;
+            try {
+                index = Integer.valueOf(input[1]) - 1;
+                return new UnmarkCommand(index);
+            } catch (NumberFormatException e) {
+                throw new DukeException("Invalid parameter(s). Usage: mark [taskNumber]");
+            } catch (IndexOutOfBoundsException e) {
+                throw new DukeException("Invalid parameter(s). duke.task.Task " + (index + 1) + " does not exist");
+            }
+        }
+        case TodoCommand.COMMAND_WORD:
+            try {
+                String description = input[1];
+                return new TodoCommand(description);
+            } catch (IndexOutOfBoundsException e) {
+                throw new DukeException("Invalid parameter(s). Usage: todo [description]");
+            }
+        case DeadlineCommand.COMMAND_WORD:
+            try {
+                String[] args = input[1].split(" /by ", 2);
+                String description = args[0];
+                LocalDate deadline = LocalDate.parse(args[1]);
+                return new DeadlineCommand(description, deadline);
+            } catch (DateTimeParseException e) {
+                throw new DukeException("Please specify your date in the format \"yyyy-mm-dd\"");
+            } catch (IndexOutOfBoundsException e) {
+                throw new DukeException("Invalid parameter(s). Usage: deadline [description] /by [time]");
+            }
+        case EventCommand.COMMAND_WORD:
+            try {
+                String[] args = input[1].split(" /at ", 2);
+                String description = args[0];
+                String at = args[1];
+                return new EventCommand(description, at);
+            } catch (IndexOutOfBoundsException e) {
+                throw new DukeException("Invalid parameter(s). Usage: event [description] /at [time]");
+            }
+        case DeleteCommand.COMMAND_WORD: {
+            int index = -1;
+            try {
+                index = Integer.parseInt(input[1]) - 1;
+                return new DeleteCommand(index);
+            } catch (NumberFormatException e) {
+                throw new DukeException("Invalid parameter(s). Usage: delete [taskNumber]");
+            } catch (IndexOutOfBoundsException e) {
+                throw new DukeException("Invalid parameter(s). duke.task.Task " + (index + 1) + " does not exist");
+            }
+        }
+        case FindCommand.COMMAND_WORD:
+            try {
+                String keyword = input[1];
+                return new FindCommand(keyword);
+            } catch (IndexOutOfBoundsException e) {
+                throw new DukeException("Invalid parameters. Usage: find [keyword]");
+            }
+        case ByeCommand.COMMAND_WORD:
+            return new ByeCommand();
+        default:
+            throw new DukeException("Unknown command");
+        }
+    }
+}

src/main/java/duke/Storage.java

@@ -0,0 +1,49 @@
+package duke;
+
+import java.io.*;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+/**
+ * Responsible for writing and loading the list of tasks to and from the user's memory.
+ */
+public class Storage {
+
+    static final String PROJECT_ROOT = System.getProperty("user.dir");
+
+    /**
+     * Writes the list of tasks to {PROJECT_ROOT}/data/duke.txt
+     *
+     * @param tasks The list of tasks to be written.
+     */
+    public void save(TaskList tasks) {
+        try {
+            String path  = Path.of(PROJECT_ROOT, "data", "duke.txt").toString();
+            FileOutputStream fos = new FileOutputStream(path);
+            ObjectOutputStream oos = new ObjectOutputStream(fos);
+            oos.writeObject(tasks);
+        } catch (IOException e) {
+            System.out.println(e);
+        }
+    }
+
+    /**
+     * Loads the list of tasks from {{PROJECT_ROOT}/data/duke.txt}
+     *
+     * @return The saved list of tasks.
+     */
+    public TaskList load() {
+        Path dataFolder = Path.of(PROJECT_ROOT, "data");
+        if (!Files.exists(dataFolder)) { //initialize data directory if not present
+            new File(dataFolder.toString()).mkdir();
+        }
+        try {
+            String path = Path.of(PROJECT_ROOT, "data", "duke.txt").toString();
+            FileInputStream fis = new FileInputStream(path);
+            ObjectInputStream ois = new ObjectInputStream(fis);
+            return (TaskList) ois.readObject();
+        } catch (IOException | ClassNotFoundException e) { //if duke.txt does not exist or is weird
+            return new TaskList();
+        }
+    }
+}

src/main/java/duke/TaskList.java

@@ -0,0 +1,106 @@
+package duke;
+
+import duke.task.Task;
+
+import java.io.Serializable;
+import java.sql.Array;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+/**
+ * Represents the list of user's tasks.
+ */
+public class TaskList implements Serializable {
+
+    private ArrayList<Task> tasks;
+
+    /**
+     * Creates a new empty list of tasks.
+     */
+    public TaskList() {
+        this.tasks = new ArrayList<>();
+    }
+
+    /**
+     * Initialize based on the list of tasks saved in the user's memory.
+     *
+     * @param tasks The saved list of tasks.
+     */
+    public TaskList(TaskList tasks) {
+        this.tasks = new ArrayList<>(tasks.tasks);
+    }
+
+    /**
+     * Marks the task corresponding to the index as completed.
+     *
+     * @param index The index of the task to be marked completed.
+     * @return The completed task.
+     */
+    public Task mark(int index) {
+        Task task = this.tasks.get(index);
+        task.mark();
+        return task;
+    }
+
+    /**
+     * Unmarks the task corresponding to the index as completed.
+     *
+     * @param index The index of the task to be unmarked completed.
+     * @return The incomplete task.
+     */
+    public Task unmark(int index) {
+        Task task = this.tasks.get(index);
+        task.unmark();
+        return task;
+    }
+
+    /**
+     * Adds a task to the list of tasks.
+     *
+     * @param task The task to be added.
+     */
+    public void addTask(Task task) {
+        tasks.add(task);
+    }
+
+    /**
+     * Deletes a task from the list of tasks based on the index.
+     *
+     * @param index The index of the task to be deleted.
+     * @return The deleted task.
+     */
+    public Task deleteTask(int index) {
+        Task task = tasks.get(index);
+        tasks.remove(index);
+        return task;
+    }
+
+    /**
+     * Counts the number of tasks in the list.
+     *
+     * @return The number of tasks.
+     */
+    public int count() {
+        return this.tasks.size();
+    }
+
+    @Override
+    public String toString() {
+        List<String> taskStrings = IntStream.range(0, tasks.size())
+                .mapToObj(i -> (i + 1) + ". " + tasks.get(i).toString())
+                .collect(Collectors.toList());
+        return String.join("\n", taskStrings);
+    }
+
+    public boolean isEmpty() {
+        return this.tasks.size() == 0;
+    }
+
+    public TaskList findTasks(String keyword) {
+        TaskList tl = new TaskList(this);
+        tl.tasks.removeIf(task -> !task.descriptionContains(keyword));
+        return tl;
+    }
+}